-
+
);
}
diff --git a/src/env.js b/src/env.js
index 6ca7f3e..2a31a5d 100644
--- a/src/env.js
+++ b/src/env.js
@@ -11,6 +11,16 @@ export const env = createEnv({
NODE_ENV: z
.enum(["development", "test", "production"])
.default("development"),
+ // Repository Configuration
+ REPO_URL: z.string().url().optional(),
+ REPO_BRANCH: z.string().default("main"),
+ SCRIPTS_DIRECTORY: z.string().default("scripts"),
+ ALLOWED_SCRIPT_EXTENSIONS: z.string().default(".sh,.py,.js,.ts,.bash"),
+ // Security
+ MAX_SCRIPT_EXECUTION_TIME: z.string().default("300000"), // 5 minutes in ms
+ ALLOWED_SCRIPT_PATHS: z.string().default("scripts/"),
+ // WebSocket Configuration
+ WEBSOCKET_PORT: z.string().default("3001"),
},
/**
@@ -29,6 +39,16 @@ export const env = createEnv({
runtimeEnv: {
DATABASE_URL: process.env.DATABASE_URL,
NODE_ENV: process.env.NODE_ENV,
+ // Repository Configuration
+ REPO_URL: process.env.REPO_URL,
+ REPO_BRANCH: process.env.REPO_BRANCH,
+ SCRIPTS_DIRECTORY: process.env.SCRIPTS_DIRECTORY,
+ ALLOWED_SCRIPT_EXTENSIONS: process.env.ALLOWED_SCRIPT_EXTENSIONS,
+ // Security
+ MAX_SCRIPT_EXECUTION_TIME: process.env.MAX_SCRIPT_EXECUTION_TIME,
+ ALLOWED_SCRIPT_PATHS: process.env.ALLOWED_SCRIPT_PATHS,
+ // WebSocket Configuration
+ WEBSOCKET_PORT: process.env.WEBSOCKET_PORT,
// NEXT_PUBLIC_CLIENTVAR: process.env.NEXT_PUBLIC_CLIENTVAR,
},
/**
diff --git a/src/server/api/root.ts b/src/server/api/root.ts
index b341fc4..b1d29c8 100644
--- a/src/server/api/root.ts
+++ b/src/server/api/root.ts
@@ -1,4 +1,4 @@
-import { postRouter } from "~/server/api/routers/post";
+import { scriptsRouter } from "~/server/api/routers/scripts";
import { createCallerFactory, createTRPCRouter } from "~/server/api/trpc";
/**
@@ -7,7 +7,7 @@ import { createCallerFactory, createTRPCRouter } from "~/server/api/trpc";
* All routers added in /api/routers should be manually added here.
*/
export const appRouter = createTRPCRouter({
- post: postRouter,
+ scripts: scriptsRouter,
});
// export type definition of API
diff --git a/src/server/api/routers/scripts.ts b/src/server/api/routers/scripts.ts
new file mode 100644
index 0000000..3716f2f
--- /dev/null
+++ b/src/server/api/routers/scripts.ts
@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { createTRPCRouter, publicProcedure } from "~/server/api/trpc";
+import { scriptManager } from "~/server/lib/scripts";
+import { gitManager } from "~/server/lib/git";
+
+export const scriptsRouter = createTRPCRouter({
+ // Get all available scripts
+ getScripts: publicProcedure
+ .query(async () => {
+ const scripts = await scriptManager.getScripts();
+ return {
+ scripts,
+ directoryInfo: scriptManager.getScriptsDirectoryInfo()
+ };
+ }),
+
+ // Get repository status
+ getRepoStatus: publicProcedure
+ .query(async () => {
+ const status = await gitManager.getStatus();
+ return status;
+ }),
+
+ // Update repository
+ updateRepo: publicProcedure
+ .mutation(async () => {
+ const result = await gitManager.pullUpdates();
+ return result;
+ }),
+
+ // Get script content
+ getScriptContent: publicProcedure
+ .input(z.object({ scriptPath: z.string() }))
+ .query(async ({ input }) => {
+ try {
+ const content = await scriptManager.getScriptContent(input.scriptPath);
+ return { success: true, content };
+ } catch (error) {
+ return {
+ success: false,
+ error: error instanceof Error ? error.message : 'Unknown error'
+ };
+ }
+ }),
+
+ // Validate script path
+ validateScript: publicProcedure
+ .input(z.object({ scriptPath: z.string() }))
+ .query(async ({ input }) => {
+ const validation = scriptManager.validateScriptPath(input.scriptPath);
+ return validation;
+ }),
+
+ // Get directory information
+ getDirectoryInfo: publicProcedure
+ .query(async () => {
+ return scriptManager.getScriptsDirectoryInfo();
+ })
+});
diff --git a/src/server/api/websocket/handler.ts b/src/server/api/websocket/handler.ts
new file mode 100644
index 0000000..b899f60
--- /dev/null
+++ b/src/server/api/websocket/handler.ts
@@ -0,0 +1,215 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import { IncomingMessage } from 'http';
+import { scriptManager } from '~/server/lib/scripts';
+import { env } from '~/env.js';
+
+interface ScriptExecutionMessage {
+ type: 'start' | 'output' | 'error' | 'end';
+ data: string;
+ timestamp: number;
+}
+
+export class ScriptExecutionHandler {
+ private wss: WebSocketServer;
+ private activeExecutions: Map = new Map();
+
+ constructor(server: any) {
+ this.wss = new WebSocketServer({
+ server,
+ path: '/ws/script-execution'
+ });
+
+ this.wss.on('connection', this.handleConnection.bind(this));
+ }
+
+ private handleConnection(ws: WebSocket, request: IncomingMessage) {
+ console.log('New WebSocket connection for script execution');
+
+ ws.on('message', (data) => {
+ try {
+ const message = JSON.parse(data.toString());
+ this.handleMessage(ws, message);
+ } catch (error) {
+ console.error('Error parsing WebSocket message:', error);
+ this.sendMessage(ws, {
+ type: 'error',
+ data: 'Invalid message format',
+ timestamp: Date.now()
+ });
+ }
+ });
+
+ ws.on('close', () => {
+ console.log('WebSocket connection closed');
+ // Clean up any active executions for this connection
+ this.cleanupActiveExecutions(ws);
+ });
+
+ ws.on('error', (error) => {
+ console.error('WebSocket error:', error);
+ this.cleanupActiveExecutions(ws);
+ });
+ }
+
+ private async handleMessage(ws: WebSocket, message: any) {
+ const { action, scriptPath, executionId } = message;
+
+ switch (action) {
+ case 'start':
+ if (scriptPath && executionId) {
+ await this.startScriptExecution(ws, scriptPath, executionId);
+ } else {
+ this.sendMessage(ws, {
+ type: 'error',
+ data: 'Missing scriptPath or executionId',
+ timestamp: Date.now()
+ });
+ }
+ break;
+
+ case 'stop':
+ if (executionId) {
+ this.stopScriptExecution(executionId);
+ }
+ break;
+
+ default:
+ this.sendMessage(ws, {
+ type: 'error',
+ data: 'Unknown action',
+ timestamp: Date.now()
+ });
+ }
+ }
+
+ private async startScriptExecution(ws: WebSocket, scriptPath: string, executionId: string) {
+ try {
+ // Validate script path
+ const validation = scriptManager.validateScriptPath(scriptPath);
+ if (!validation.valid) {
+ this.sendMessage(ws, {
+ type: 'error',
+ data: validation.message || 'Invalid script path',
+ timestamp: Date.now()
+ });
+ return;
+ }
+
+ // Check if execution is already running
+ if (this.activeExecutions.has(executionId)) {
+ this.sendMessage(ws, {
+ type: 'error',
+ data: 'Script execution already running',
+ timestamp: Date.now()
+ });
+ return;
+ }
+
+ // Start script execution
+ const process = await scriptManager.executeScript(scriptPath);
+
+ // Store the execution
+ this.activeExecutions.set(executionId, { process, ws });
+
+ // Send start message
+ this.sendMessage(ws, {
+ type: 'start',
+ data: `Starting execution of ${scriptPath}`,
+ timestamp: Date.now()
+ });
+
+ // Handle stdout
+ process.stdout?.on('data', (data: Buffer) => {
+ this.sendMessage(ws, {
+ type: 'output',
+ data: data.toString(),
+ timestamp: Date.now()
+ });
+ });
+
+ // Handle stderr
+ process.stderr?.on('data', (data: Buffer) => {
+ this.sendMessage(ws, {
+ type: 'error',
+ data: data.toString(),
+ timestamp: Date.now()
+ });
+ });
+
+ // Handle process exit
+ process.on('exit', (code: number | null, signal: string | null) => {
+ this.sendMessage(ws, {
+ type: 'end',
+ data: `Script execution finished with code: ${code}, signal: ${signal}`,
+ timestamp: Date.now()
+ });
+
+ // Clean up
+ this.activeExecutions.delete(executionId);
+ });
+
+ // Handle process error
+ process.on('error', (error: Error) => {
+ this.sendMessage(ws, {
+ type: 'error',
+ data: `Process error: ${error.message}`,
+ timestamp: Date.now()
+ });
+
+ // Clean up
+ this.activeExecutions.delete(executionId);
+ });
+
+ } catch (error) {
+ this.sendMessage(ws, {
+ type: 'error',
+ data: `Failed to start script: ${error instanceof Error ? error.message : 'Unknown error'}`,
+ timestamp: Date.now()
+ });
+ }
+ }
+
+ private stopScriptExecution(executionId: string) {
+ const execution = this.activeExecutions.get(executionId);
+ if (execution) {
+ execution.process.kill('SIGTERM');
+ this.activeExecutions.delete(executionId);
+
+ this.sendMessage(execution.ws, {
+ type: 'end',
+ data: 'Script execution stopped by user',
+ timestamp: Date.now()
+ });
+ }
+ }
+
+ private sendMessage(ws: WebSocket, message: ScriptExecutionMessage) {
+ if (ws.readyState === WebSocket.OPEN) {
+ ws.send(JSON.stringify(message));
+ }
+ }
+
+ private cleanupActiveExecutions(ws: WebSocket) {
+ for (const [executionId, execution] of this.activeExecutions.entries()) {
+ if (execution.ws === ws) {
+ execution.process.kill('SIGTERM');
+ this.activeExecutions.delete(executionId);
+ }
+ }
+ }
+
+ // Get active executions count
+ getActiveExecutionsCount(): number {
+ return this.activeExecutions.size;
+ }
+
+ // Get active executions info
+ getActiveExecutions(): string[] {
+ return Array.from(this.activeExecutions.keys());
+ }
+}
+
+// Export function to create handler
+export function createScriptExecutionHandler(server: any): ScriptExecutionHandler {
+ return new ScriptExecutionHandler(server);
+}
diff --git a/src/server/lib/git.ts b/src/server/lib/git.ts
new file mode 100644
index 0000000..4df9cdb
--- /dev/null
+++ b/src/server/lib/git.ts
@@ -0,0 +1,177 @@
+import { simpleGit, SimpleGit } from 'simple-git';
+import { env } from '~/env.js';
+import { join } from 'path';
+
+export class GitManager {
+ private git: SimpleGit;
+ private repoPath: string;
+ private scriptsDir: string;
+
+ constructor() {
+ this.repoPath = process.cwd();
+ this.scriptsDir = join(this.repoPath, env.SCRIPTS_DIRECTORY);
+ this.git = simpleGit(this.repoPath);
+ }
+
+ /**
+ * Check if the repository is behind the remote
+ */
+ async isBehindRemote(): Promise {
+ try {
+ if (!env.REPO_URL) {
+ return false; // No remote configured
+ }
+
+ // Fetch latest changes without merging
+ await this.git.fetch();
+
+ // Check if local branch is behind remote
+ const status = await this.git.status();
+ const behind = status.behind > 0;
+
+ return behind;
+ } catch (error) {
+ console.error('Error checking repo status:', error);
+ return false;
+ }
+ }
+
+ /**
+ * Pull updates from remote repository
+ */
+ async pullUpdates(): Promise<{ success: boolean; message: string }> {
+ try {
+ if (!env.REPO_URL) {
+ return { success: false, message: 'No remote repository configured' };
+ }
+
+ // Check if we're in a git repository
+ const isRepo = await this.git.checkIsRepo();
+ if (!isRepo) {
+ // Clone the repository if it doesn't exist
+ return await this.cloneRepository();
+ }
+
+ // Pull latest changes
+ const result = await this.git.pull(env.REPO_BRANCH);
+
+ return {
+ success: true,
+ message: `Successfully pulled updates. ${result.summary.changes} changes, ${result.summary.insertions} insertions, ${result.summary.deletions} deletions`
+ };
+ } catch (error) {
+ console.error('Error pulling updates:', error);
+ return {
+ success: false,
+ message: `Failed to pull updates: ${error instanceof Error ? error.message : 'Unknown error'}`
+ };
+ }
+ }
+
+ /**
+ * Clone the repository if it doesn't exist
+ */
+ private async cloneRepository(): Promise<{ success: boolean; message: string }> {
+ try {
+ if (!env.REPO_URL) {
+ return { success: false, message: 'No repository URL configured' };
+ }
+
+ console.log(`Cloning repository from ${env.REPO_URL}...`);
+
+ // Clone the repository
+ await this.git.clone(env.REPO_URL, this.repoPath, {
+ '--branch': env.REPO_BRANCH,
+ '--single-branch': true,
+ '--depth': 1
+ });
+
+ return {
+ success: true,
+ message: `Successfully cloned repository from ${env.REPO_URL}`
+ };
+ } catch (error) {
+ console.error('Error cloning repository:', error);
+ return {
+ success: false,
+ message: `Failed to clone repository: ${error instanceof Error ? error.message : 'Unknown error'}`
+ };
+ }
+ }
+
+ /**
+ * Initialize repository on startup if needed
+ */
+ async initializeRepository(): Promise {
+ try {
+ if (!env.REPO_URL) {
+ console.log('No remote repository configured, skipping initialization');
+ return;
+ }
+
+ const isRepo = await this.git.checkIsRepo();
+ if (!isRepo) {
+ console.log('Repository not found, cloning...');
+ const result = await this.cloneRepository();
+ if (result.success) {
+ console.log('Repository initialized successfully');
+ } else {
+ console.error('Failed to initialize repository:', result.message);
+ }
+ } else {
+ console.log('Repository already exists, checking for updates...');
+ const behind = await this.isBehindRemote();
+ if (behind) {
+ console.log('Repository is behind remote, pulling updates...');
+ const result = await this.pullUpdates();
+ if (result.success) {
+ console.log('Repository updated successfully');
+ } else {
+ console.error('Failed to update repository:', result.message);
+ }
+ } else {
+ console.log('Repository is up to date');
+ }
+ }
+ } catch (error) {
+ console.error('Error initializing repository:', error);
+ }
+ }
+
+ /**
+ * Get repository status information
+ */
+ async getStatus(): Promise<{
+ isRepo: boolean;
+ isBehind: boolean;
+ lastCommit?: string;
+ branch?: string;
+ }> {
+ try {
+ const isRepo = await this.git.checkIsRepo();
+ if (!isRepo) {
+ return { isRepo: false, isBehind: false };
+ }
+
+ const isBehind = await this.isBehindRemote();
+ const log = await this.git.log({ maxCount: 1 });
+ const status = await this.git.status();
+
+ return {
+ isRepo: true,
+ isBehind,
+ lastCommit: log.latest?.hash,
+ branch: status.current
+ };
+ } catch (error) {
+ console.error('Error getting repository status:', error);
+ return { isRepo: false, isBehind: false };
+ }
+ }
+}
+
+// Export singleton instance
+export const gitManager = new GitManager();
+
+// Initialize repository on module load
+gitManager.initializeRepository().catch(console.error);
diff --git a/src/server/lib/scripts.ts b/src/server/lib/scripts.ts
new file mode 100644
index 0000000..dbe0733
--- /dev/null
+++ b/src/server/lib/scripts.ts
@@ -0,0 +1,212 @@
+import { readdir, stat, access } from 'fs/promises';
+import { join, resolve, extname } from 'path';
+import { env } from '~/env.js';
+import { spawn, ChildProcess } from 'child_process';
+
+export interface ScriptInfo {
+ name: string;
+ path: string;
+ extension: string;
+ size: number;
+ lastModified: Date;
+ executable: boolean;
+}
+
+export class ScriptManager {
+ private scriptsDir: string;
+ private allowedExtensions: string[];
+ private allowedPaths: string[];
+ private maxExecutionTime: number;
+
+ constructor() {
+ this.scriptsDir = join(process.cwd(), env.SCRIPTS_DIRECTORY);
+ this.allowedExtensions = env.ALLOWED_SCRIPT_EXTENSIONS.split(',').map(ext => ext.trim());
+ this.allowedPaths = env.ALLOWED_SCRIPT_PATHS.split(',').map(path => path.trim());
+ this.maxExecutionTime = parseInt(env.MAX_SCRIPT_EXECUTION_TIME, 10);
+ }
+
+ /**
+ * Get all available scripts in the scripts directory
+ */
+ async getScripts(): Promise {
+ try {
+ const files = await readdir(this.scriptsDir);
+ const scripts: ScriptInfo[] = [];
+
+ for (const file of files) {
+ const filePath = join(this.scriptsDir, file);
+ const stats = await stat(filePath);
+
+ if (stats.isFile()) {
+ const extension = extname(file);
+
+ // Check if file extension is allowed
+ if (this.allowedExtensions.includes(extension)) {
+ // Check if file is executable
+ const executable = await this.isExecutable(filePath);
+
+ scripts.push({
+ name: file,
+ path: filePath,
+ extension,
+ size: stats.size,
+ lastModified: stats.mtime,
+ executable
+ });
+ }
+ }
+ }
+
+ return scripts.sort((a, b) => a.name.localeCompare(b.name));
+ } catch (error) {
+ console.error('Error reading scripts directory:', error);
+ return [];
+ }
+ }
+
+ /**
+ * Check if a file is executable
+ */
+ private async isExecutable(filePath: string): Promise {
+ try {
+ await access(filePath, 0o111); // Check execute permission
+ return true;
+ } catch {
+ return false;
+ }
+ }
+
+ /**
+ * Validate if a script path is allowed to be executed
+ */
+ validateScriptPath(scriptPath: string): { valid: boolean; message?: string } {
+ const resolvedPath = resolve(scriptPath);
+ const scriptsDirResolved = resolve(this.scriptsDir);
+
+ // Check if the script is within the allowed directory
+ if (!resolvedPath.startsWith(scriptsDirResolved)) {
+ return {
+ valid: false,
+ message: 'Script path is not within the allowed scripts directory'
+ };
+ }
+
+ // Check if the script path matches any allowed path pattern
+ const relativePath = resolvedPath.replace(scriptsDirResolved, '').replace(/\\/g, '/');
+ const isAllowed = this.allowedPaths.some(allowedPath =>
+ relativePath.startsWith(allowedPath.replace(/\\/g, '/'))
+ );
+
+ if (!isAllowed) {
+ return {
+ valid: false,
+ message: 'Script path is not in the allowed paths list'
+ };
+ }
+
+ // Check file extension
+ const extension = extname(scriptPath);
+ if (!this.allowedExtensions.includes(extension)) {
+ return {
+ valid: false,
+ message: `File extension '${extension}' is not allowed. Allowed extensions: ${this.allowedExtensions.join(', ')}`
+ };
+ }
+
+ return { valid: true };
+ }
+
+ /**
+ * Execute a script and return a child process
+ */
+ async executeScript(scriptPath: string): Promise {
+ const validation = this.validateScriptPath(scriptPath);
+ if (!validation.valid) {
+ throw new Error(validation.message);
+ }
+
+ // Determine the command to run based on file extension
+ const extension = extname(scriptPath);
+ let command: string;
+ let args: string[] = [];
+
+ switch (extension) {
+ case '.sh':
+ case '.bash':
+ command = 'bash';
+ args = [scriptPath];
+ break;
+ case '.py':
+ command = 'python';
+ args = [scriptPath];
+ break;
+ case '.js':
+ command = 'node';
+ args = [scriptPath];
+ break;
+ case '.ts':
+ command = 'npx';
+ args = ['ts-node', scriptPath];
+ break;
+ default:
+ // Try to execute directly (for files with shebang)
+ command = scriptPath;
+ args = [];
+ }
+
+ // Spawn the process
+ const childProcess = spawn(command, args, {
+ cwd: this.scriptsDir,
+ stdio: ['pipe', 'pipe', 'pipe'],
+ shell: true
+ });
+
+ // Set up timeout
+ const timeout = setTimeout(() => {
+ if (!childProcess.killed) {
+ childProcess.kill('SIGTERM');
+ console.log(`Script execution timed out after ${this.maxExecutionTime}ms`);
+ }
+ }, this.maxExecutionTime);
+
+ // Clean up timeout when process exits
+ childProcess.on('exit', () => {
+ clearTimeout(timeout);
+ });
+
+ return childProcess;
+ }
+
+ /**
+ * Get script content for display
+ */
+ async getScriptContent(scriptPath: string): Promise {
+ const validation = this.validateScriptPath(scriptPath);
+ if (!validation.valid) {
+ throw new Error(validation.message);
+ }
+
+ const { readFile } = await import('fs/promises');
+ return await readFile(scriptPath, 'utf-8');
+ }
+
+ /**
+ * Get scripts directory information
+ */
+ getScriptsDirectoryInfo(): {
+ path: string;
+ allowedExtensions: string[];
+ allowedPaths: string[];
+ maxExecutionTime: number;
+ } {
+ return {
+ path: this.scriptsDir,
+ allowedExtensions: this.allowedExtensions,
+ allowedPaths: this.allowedPaths,
+ maxExecutionTime: this.maxExecutionTime
+ };
+ }
+}
+
+// Export singleton instance
+export const scriptManager = new ScriptManager();
PVE Scripts local
+
+ {/* Header */}
+
+
+
-
+ {/* Repository Status */}
+ + đ PVE Scripts Local Management +
++ Manage and execute Proxmox helper scripts locally with live output streaming +
+
+
+ {/* Running Script Terminal */}
+ {runningScript && (
+
+
+ )}
+
+ {/* Scripts List */}
+