@epic-web/workshop-utils 6.70.0 → 6.71.1

package/dist/process-manager.server.d.ts

@@ -7,10 +7,18 @@ type DevProcessesMap = Map<string, {
     process: ChildProcess;
     port: number;
 }>;
-type SidecarProcessesMap = Map<string, {
+type SidecarOutputLine = {
+    type: 'stdout' | 'stderr';
+    content: string;
+    timestamp: number;
+};
+type SidecarProcessEntry = {
     color: (typeof colors)[number];
     process: ChildProcess;
-}>;
+    command: string;
+    output: Array<SidecarOutputLine>;
+};
+type SidecarProcessesMap = Map<string, SidecarProcessEntry>;
 type OutputLine = {
     type: 'stdout' | 'stderr';
     content: string;
@@ -78,6 +86,8 @@ export declare function getProcesses(): {
 };
 export declare function startSidecarProcesses(processes: Record<string, string>): void;
 export declare function startSidecarProcess(name: string, command: string): void;
+export declare function getSidecarLogs(name: string, lineCount?: number): string;
+export declare function restartSidecarProcess(name: string): Promise<boolean>;
 export declare function stopSidecarProcesses(): void;
 export declare function closeProcess(key: string): Promise<void>;
 export declare function stopPort(port: string | number): Promise<void>;

package/dist/process-manager.server.js

@@ -274,14 +274,21 @@ export function startSidecarProcesses(processes) {
         startSidecarProcess(name, command);
     }
 }
+// Maximum number of log entries to keep per sidecar process
+const MAX_SIDECAR_LOG_ENTRIES = 1000;
 export function startSidecarProcess(name, command) {
     if (isDeployed)
         throw new Error('cannot run sidecar processes in deployed mode');
     // if the process is already running, don't start it again
-    if (sidecarProcesses.has(name)) {
+    const existingEntry = sidecarProcesses.get(name);
+    if (existingEntry && existingEntry.process.exitCode === null) {
         console.log(`Sidecar process ${name} is already running`);
         return;
     }
+    // If there's an old exited entry, clean it up first
+    if (existingEntry) {
+        sidecarProcesses.delete(name);
+    }
     const color = getNextAvailableColor();
     // Spawn the command using shell to handle complex commands properly
     const workshopRoot = getEnv().EPICSHOP_CONTEXT_CWD;
@@ -295,23 +302,38 @@ export function startSidecarProcess(name, command) {
         },
     });
     const prefix = chalk[color](`[${name}]`);
+    const output = [];
+    function addOutputLine(type, content) {
+        output.push({ type, content, timestamp: Date.now() });
+        // Keep only the last MAX_SIDECAR_LOG_ENTRIES entries
+        if (output.length > MAX_SIDECAR_LOG_ENTRIES) {
+            output.shift();
+        }
+    }
     function handleStdOutData(data) {
-        console.log(data
-            .toString('utf-8')
+        const content = data.toString('utf-8');
+        addOutputLine('stdout', content);
+        console.log(content
             .split('\n')
             .map((line) => `${prefix} ${line}`)
             .join('\n'));
     }
     sidecarProcess.stdout?.on('data', handleStdOutData);
     function handleStdErrData(data) {
-        console.error(data
-            .toString('utf-8')
+        const content = data.toString('utf-8');
+        addOutputLine('stderr', content);
+        console.error(content
             .split('\n')
             .map((line) => `${prefix} ${line}`)
             .join('\n'));
     }
     sidecarProcess.stderr?.on('data', handleStdErrData);
-    sidecarProcesses.set(name, { color, process: sidecarProcess });
+    sidecarProcesses.set(name, {
+        color,
+        process: sidecarProcess,
+        command,
+        output,
+    });
     sidecarProcess.on('exit', (code, signal) => {
         sidecarProcess.stdout?.off('data', handleStdOutData);
         sidecarProcess.stderr?.off('data', handleStdErrData);
@@ -321,20 +343,73 @@ export function startSidecarProcess(name, command) {
         else {
             console.log(`${prefix} exited with code ${code}${signal ? ` (signal: ${signal})` : ''}`);
         }
-        sidecarProcesses.delete(name);
+        // Don't delete the entry so we can still access logs after exit
+        // Just mark it as not running by keeping the process reference
     });
     sidecarProcess.on('error', (error) => {
         console.error(`${prefix} failed to start: ${error.message}`);
-        sidecarProcesses.delete(name);
+        addOutputLine('stderr', `Failed to start: ${error.message}`);
     });
     console.log(`${prefix} started`);
 }
+export function getSidecarLogs(name, lineCount = 50) {
+    const entry = sidecarProcesses.get(name);
+    if (!entry)
+        return '';
+    // Get the last N lines of output
+    const logs = entry.output.slice(-lineCount);
+    return logs.map((line) => line.content).join('');
+}
+export async function restartSidecarProcess(name) {
+    if (isDeployed)
+        throw new Error('cannot restart sidecar processes in deployed mode');
+    const entry = sidecarProcesses.get(name);
+    if (!entry) {
+        console.log(`Sidecar process ${name} not found`);
+        return false;
+    }
+    const { command, process: proc, output: oldOutput } = entry;
+    // Remove the entry immediately to prevent concurrent restarts
+    sidecarProcesses.delete(name);
+    // Kill the existing process if it's still running
+    if (proc.exitCode === null) {
+        console.log(`Stopping sidecar process: ${name}`);
+        proc.kill();
+        // Wait for the process to exit
+        await new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                // Force kill if it doesn't exit in time
+                proc.kill('SIGKILL');
+                resolve();
+            }, 5000);
+            proc.once('exit', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+    }
+    // Start a new process with the same command
+    startSidecarProcess(name, command);
+    // Preserve logs from the old process by prepending them to the new array
+    // We must modify the existing array (not replace it) because event handlers
+    // have already captured it in their closure
+    const newEntry = sidecarProcesses.get(name);
+    if (newEntry) {
+        // Prepend old logs to the existing array that handlers are writing to
+        newEntry.output.unshift(...oldOutput);
+        // Trim to max entries if needed
+        if (newEntry.output.length > MAX_SIDECAR_LOG_ENTRIES) {
+            newEntry.output.splice(0, newEntry.output.length - MAX_SIDECAR_LOG_ENTRIES);
+        }
+    }
+    return true;
+}
 export function stopSidecarProcesses() {
     if (isDeployed)
         throw new Error('cannot stop sidecar processes in deployed mode');
-    for (const [name, proc] of sidecarProcesses.entries()) {
+    for (const [name, entry] of sidecarProcesses.entries()) {
         console.log(`Stopping sidecar process: ${name}`);
-        proc.process.kill();
+        entry.process.kill();
     }
     sidecarProcesses.clear();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epic-web/workshop-utils",
-  "version": "6.70.0",
+  "version": "6.71.1",
   "publishConfig": {
     "access": "public"
   },