@playcraft/cli 0.1.58-beta → 0.1.60-beta

package/dist/workspace-runtime/batch/processes.js

@@ -2,6 +2,8 @@ import { execFile, spawn } from 'node:child_process';
 import { readFile } from 'node:fs/promises';
 import { promisify } from 'node:util';
 import { setTimeout as delay } from 'node:timers/promises';
+import { startLauncherProcess, stopLauncherProcess } from '../codex/launcher-client.js';
+import { launcherSocket } from '../workspaces/developer-command.js';
 export async function processBirth(pid) {
     if (process.platform !== 'linux') {
         return promisify(execFile)('ps', ['-p', String(pid), '-o', 'lstart='], { timeout: 2000 }).then(value => value.stdout.trim() || undefined, () => undefined);
@@ -23,12 +25,27 @@ export function groupExited(pid) {
         return error.code === 'ESRCH';
     }
 }
+/** A missing local process cannot replace the launcher's proof for a development-user group. */
+export function processHasExited(record) {
+    return record.stopped || (!record.launcher && groupExited(record.pid));
+}
 /**
  * Stops one run's process group. A mismatched birth means the pid was reused, which is not proof
  * that the original writers exited, so the caller must not report writersStopped.
  */
 export async function stopProcessGroup(record) {
-    if (record.stopped || groupExited(record.pid))
+    if (record.stopped)
+        return true;
+    if (record.launcher) {
+        try {
+            await stopLauncherProcess(record.launcher);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    if (groupExited(record.pid))
         return true;
     if (record.birth && await processBirth(record.pid) !== record.birth)
         return false;
@@ -46,27 +63,82 @@ export async function stopProcessGroup(record) {
     }
     return groupExited(record.pid);
 }
-export async function runProcessGroup(cwd, command, role, onStart) {
-    const child = spawn('bash', ['-lc', command], {
+export async function runProcessGroup(cwd, command, role, onStart, options) {
+    const socketPath = options && launcherSocket(options.state);
+    if (options && options.state.config.workspaceMode === 'multi' &&
+        options.state.config.environment !== 'local' && !socketPath)
+        throw new Error('development_launcher_unavailable');
+    let launched;
+    let tracked;
+    if (socketPath) {
+        // Persist uncertainty before sending start: a lost acknowledgement is not a rejected launch.
+        tracked = { pid: 0, role, stopped: false, launcher: {
+                socketPath, processId: options.processId, runtimeEpoch: options.state.runtimeEpoch, instanceId: '',
+            } };
+        await onStart(tracked);
+        try {
+            launched = await startLauncherProcess({
+                socketPath, processId: options.processId, runtimeEpoch: options.state.runtimeEpoch,
+                argv: ['/usr/bin/bash', '-lc', `{ ${command}; } </dev/null 2>&1`], cwd, env: {},
+            });
+        }
+        catch (error) {
+            if (error.launchRejected) {
+                tracked.stopped = true;
+                await onStart(tracked);
+            }
+            throw error;
+        }
+    }
+    launched?.stdin?.end();
+    const child = launched ? undefined : spawn('bash', ['-lc', command], {
         cwd, detached: true, stdio: ['ignore', 'pipe', 'pipe'],
         env: { PATH: process.env.PATH, HOME: cwd, GIT_TERMINAL_PROMPT: '0' },
     });
-    const pid = child.pid;
+    const pid = launched?.pid ?? child?.pid;
     if (!pid)
         throw new Error('batch_process_not_started');
     let output = '';
-    const collect = (chunk) => { output = (output + String(chunk)).slice(-64 * 1024); };
-    child.stdout?.on('data', collect);
-    child.stderr?.on('data', collect);
+    const collect = (chunk) => {
+        output = (output + String(chunk)).slice(-64 * 1024);
+        options?.onOutput?.(chunk);
+    };
+    (launched?.stdout ?? child?.stdout)?.on('data', collect);
+    (launched?.stderr ?? child?.stderr)?.on('data', collect);
     // Subscribe before any await. A short command can exit during processBirth or onStart,
     // and a late listener never sees that close event.
     const finished = new Promise((resolve) => {
-        child.once('error', () => resolve(null));
-        child.once('close', resolve);
+        if (launched)
+            launched.onExit(code => resolve(code ?? null));
+        else {
+            child.once('error', () => resolve(null));
+            child.once('close', resolve);
+        }
     });
-    const tracked = { pid, birth: await processBirth(pid), stopped: false, role };
-    await onStart(tracked);
-    const code = await finished;
-    tracked.stopped = groupExited(pid);
-    return { code, output, process: tracked };
+    tracked = { pid, birth: await processBirth(pid), stopped: false, role,
+        ...(launched ? { launcher: launched.identity } : {}) };
+    try {
+        await onStart(tracked);
+        const code = await finished;
+        if (launched) {
+            try {
+                await launched.stop();
+                tracked.stopped = true;
+            }
+            catch (error) {
+                collect(`\n[install] ${error instanceof Error ? error.message : String(error)}\n`);
+                // Keep the directory occupied until the launcher confirms stop.
+            }
+        }
+        else
+            tracked.stopped = groupExited(pid);
+        return { code, output, process: tracked };
+    }
+    catch (error) {
+        if (launched)
+            await launched.stop().catch(() => undefined);
+        else
+            await stopProcessGroup(tracked);
+        throw error;
+    }
 }

package/dist/workspace-runtime/batch/writer-proof.js

@@ -1,12 +1,12 @@
 import { setTimeout as delay } from 'node:timers/promises';
-import { groupExited, stopProcessGroup } from './processes.js';
+import { processHasExited, stopProcessGroup } from './processes.js';
 /** An interrupt acknowledgement is not proof that the native turn and its writers have stopped. */
 export async function stopMemberWriters(state, record) {
     if (!record)
         return true;
     let stopped = true;
     for (const process of record.processes) {
-        if (process.stopped || groupExited(process.pid))
+        if (processHasExited(process))
             process.stopped = true;
         else
             process.stopped = await stopProcessGroup(process);