@playcraft/cli 0.1.10 → 0.1.12

package/dist/utils/agent-api-client.js

@@ -1,5 +1,5 @@
 import { readFileSync, existsSync } from 'fs';
-import { join } from 'path';
+import { dirname, join } from 'path';
 import { homedir } from 'os';
 import { loadGlobalConfig } from '../config.js';
 import { DEFAULT_PLAYCRAFT_CLOUD_BASE } from '../commands/login.js';
@@ -18,8 +18,8 @@ function isPatToken(token) {
  * or from the CLI after `playcraft login`.
  *
  * 凭证解析优先级：
- *   API URL : PLAYCRAFT_API_URL → .playcraft.json → ~/.playcraft/config.json → DEFAULT_PLAYCRAFT_CLOUD_BASE
- *   Token   : PLAYCRAFT_SANDBOX_TOKEN → .playcraft.json token → ~/.playcraft/config.json token (PAT)
+ *   API URL : PLAYCRAFT_API_URL → sandbox global .playcraft.json → project .playcraft.json → ~/.playcraft/config.json → DEFAULT_PLAYCRAFT_CLOUD_BASE
+ *   Token   : PLAYCRAFT_SANDBOX_TOKEN → sandbox global .playcraft.json → project .playcraft.json → ~/.playcraft/config.json token (PAT)
  *
  * 鉴权 header 自动选择：
  *   - 沙箱 JWT (非 PAT) → X-Sandbox-Token: <token>（后端 @SandboxToken 路由的沙箱分支）
@@ -28,7 +28,7 @@ function isPatToken(token) {
 export class AgentApiClient {
     apiUrl;
     token;
-    isPat;
+    credentialFile;
     playcraftEnv;
     constructor() {
         const localConfig = AgentApiClient.loadLocalConfig();
@@ -39,7 +39,7 @@ export class AgentApiClient {
             globalConfig.backendUrl ||
             globalConfig.url ||
             DEFAULT_PLAYCRAFT_CLOUD_BASE).replace(/\/+$/, '');
-        // Token: 沙箱 token 环境变量 → 本地 .playcraft.json → 全局 login 配置（PAT）
+        // Token: 环境变量 → 沙箱全局配置 → 项目配置 → 用户登录配置
         const token = process.env.PLAYCRAFT_SANDBOX_TOKEN ||
             localConfig.token ||
             globalConfig.token ||
@@ -50,14 +50,22 @@ export class AgentApiClient {
         }
         this.apiUrl = apiUrl;
         this.token = token;
-        this.isPat = isPatToken(token);
+        this.credentialFile = localConfig.credentialFile;
         this.playcraftEnv = (process.env.PLAYCRAFT_ENV || localConfig.env || '').trim();
     }
     /** 根据 token 类型构造鉴权 headers */
     authHeaders() {
-        const headers = this.isPat
-            ? { Authorization: `Bearer ${this.token}` }
-            : { 'X-Sandbox-Token': this.token };
+        let token = this.token;
+        // Polling commands can outlive a credential: read the atomically refreshed file per request.
+        if (this.credentialFile && !process.env.PLAYCRAFT_SANDBOX_TOKEN) {
+            try {
+                token = JSON.parse(readFileSync(this.credentialFile, 'utf8')).token || token;
+            }
+            catch { /* Keep the last credential if a local file is temporarily unavailable. */ }
+        }
+        const headers = isPatToken(token)
+            ? { Authorization: `Bearer ${token}` }
+            : { 'X-Sandbox-Token': token };
         if (this.playcraftEnv) {
             headers['playcraft-env'] = this.playcraftEnv;
         }
@@ -196,15 +204,22 @@ export class AgentApiClient {
      * 与全局 login 配置（~/.playcraft/config.json）不同，前者专用于沙箱 token。
      */
     static loadLocalConfig() {
+        const ancestors = [];
+        for (let directory = process.cwd();; directory = dirname(directory)) {
+            ancestors.push(join(directory, '.playcraft.json'));
+            if (dirname(directory) === directory)
+                break;
+        }
         const searchPaths = [
-            join(process.cwd(), '.playcraft.json'),
+            process.env.PLAYCRAFT_SANDBOX_CONFIG_PATH || '/workspaces/.playcraft.json',
+            ...ancestors,
             '/project/.playcraft.json',
             join(homedir(), '.playcraft.json'),
         ];
         for (const p of searchPaths) {
             if (existsSync(p)) {
                 try {
-                    return JSON.parse(readFileSync(p, 'utf-8'));
+                    return { ...JSON.parse(readFileSync(p, 'utf-8')), credentialFile: p };
                 }
                 catch {
                     continue;

package/dist/workspace-runtime/codex/app-server.js

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { startLauncherProcess } from './launcher-client.js';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -7,6 +7,9 @@ import { writePlaycraftCodexConfig } from './config-toml.js';
 import { createJsonRpcStdioClient } from './jsonrpc-stdio.js';
 import { projectNativeThread } from '@playcraft/common/cloud-workspace/runtime';
 import { collectedEvent, NativePreparationError } from './native-adapter.js';
+import { exportTranscript } from './transcripts.js';
+import { readProjectSkillsLockFile } from '@playcraft/common/project-skills';
+import { freezeWorkspaceSkills } from '../workspaces/skills.js';
 function asRecord(value) {
     return value && typeof value === 'object' && !Array.isArray(value)
         ? value
@@ -61,6 +64,8 @@ export function createCodexAppServerAdapter(options) {
     let readyFlag = false;
     let closed = false;
     let startPromise;
+    let skillsRestartFailed = false;
+    let preparationQueue = Promise.resolve();
     let live;
     const exitListeners = new Set();
     const collected = new Set();
@@ -68,7 +73,35 @@ export function createCodexAppServerAdapter(options) {
         for (const listener of collected)
             listener(event);
     }
+    async function withPreparation(action) {
+        const previous = preparationQueue;
+        let release;
+        preparationQueue = new Promise(resolve => { release = resolve; });
+        await previous;
+        try {
+            return await action();
+        }
+        finally {
+            release();
+        }
+    }
+    function transcriptHome() {
+        if (!launcherSocket)
+            return { homeDir };
+        return {
+            homeDir,
+            launcher: {
+                socketPath: launcherSocket,
+                runtimeEpoch: executionEpoch,
+                cwd: options.config.workspaceMode === 'multi' ? '/home/playcraft-dev' : options.config.workspaceRoot,
+            },
+        };
+    }
     async function ensureStarted() {
+        if (closed)
+            throw new Error('codex_not_started');
+        if (skillsRestartFailed)
+            throw new NativePreparationError('workspace_skills_unavailable');
         if (readyFlag && rpc)
             return;
         startPromise ??= start();
@@ -85,9 +118,100 @@ export function createCodexAppServerAdapter(options) {
                 ? reason : 'model_credential_unavailable');
         }
     }
+    async function lockedThreadConfig(cwd) {
+        const modelConfig = await threadConfig(cwd);
+        // Single-workspace legacy runners retain their prior behaviour until explicitly adopted.
+        if (await readProjectSkillsLockFile(cwd) === null) {
+            if (options.config.workspaceMode === 'multi')
+                throw new NativePreparationError('workspace_skills_unavailable');
+            return { params: modelConfig, skillsHash: undefined, discoveryHash: undefined };
+        }
+        try {
+            const frozen = await freezeWorkspaceSkills(cwd, join(options.config.stateDir, 'skill-artifacts'), options.loadSkillArtifact ? entry => options.loadSkillArtifact(cwd, entry) : undefined);
+            if (!rpc)
+                throw new Error('codex_not_started');
+            const found = await rpc.request('skills/list', { cwds: [cwd], forceReload: true }, 30_000);
+            const listing = found.data.find(item => item.cwd === cwd);
+            if (!listing || listing.errors.length)
+                throw new Error('workspace_skills_unavailable');
+            // Native scanning is used only to disable paths. Availability comes exclusively from the lock.
+            const config = { ...('config' in modelConfig ? modelConfig.config : {}),
+                'skills.include_instructions': false,
+                'skills.config': listing.skills.map(skill => ({ path: skill.path, enabled: false })) };
+            const developerInstructions = [
+                `Available workspace skills are fixed by lock ${frozen.declarationHash}.`,
+                'Use only the following locked skills. Read its SKILL.md when a skill applies, and resolve supporting files relative to that file. Disabled and unlisted skill directories are not available.',
+                ...frozen.skills.map(skill => JSON.stringify(skill)),
+                ...(frozen.skills.length ? [] : ['(No workspace skills are enabled.)']),
+            ].join('\n');
+            const discoveryHash = createHash('sha256').update(JSON.stringify(listing.skills.map(skill => skill.path).sort())).digest('hex');
+            return { params: { ...modelConfig, config, developerInstructions }, skillsHash: frozen.lockHash, discoveryHash };
+        }
+        catch {
+            throw new NativePreparationError('workspace_skills_unavailable');
+        }
+    }
+    async function restartForSkills(threadId) {
+        if ([...threads.values()].some(thread => thread.turnActive) || approvals.size)
+            throw new NativePreparationError('skills_reload_pending');
+        const previous = live;
+        if (previous)
+            previous.superseded = true;
+        readyFlag = false;
+        await previous?.rpc.close();
+        await previous?.child.stop();
+        if (closed)
+            throw new Error('codex_not_started');
+        rpc = undefined;
+        startPromise = undefined;
+        for (const thread of threads.values()) {
+            thread.loaded = false;
+            thread.needsRecreate = !thread.hasNativeHistory;
+        }
+        // A controlled idle restart retains the runtime epoch and all durable thread identities.
+        try {
+            startPromise = start();
+            await startPromise;
+            if (closed)
+                throw new Error('codex_not_started');
+            if (!live)
+                throw new NativePreparationError('workspace_skills_unavailable');
+            await options.onSkillProcessRestart?.({ pid: live.pid, startedAt: live.startedAt });
+            if (closed)
+                throw new Error('codex_not_started');
+            // Other workspaces resume lazily, so a damaged unrelated lock cannot block this workspace.
+            const thread = threads.get(threadId);
+            if (thread?.hasNativeHistory && thread.cwd)
+                await resumePreparedThread(threadId, thread, await lockedThreadConfig(thread.cwd));
+        }
+        catch {
+            readyFlag = false;
+            skillsRestartFailed = true;
+            if (live) {
+                live.superseded = true;
+                await live.rpc.close();
+                await live.child.stop();
+            }
+            throw new NativePreparationError('workspace_skills_unavailable');
+        }
+    }
+    async function resumePreparedThread(threadId, thread, prepared) {
+        const resumed = await rpc.request('thread/resume', {
+            threadId, cwd: thread.cwd, ...prepared.params,
+        }, 30_000);
+        if (resumed.thread?.id !== threadId)
+            throw new NativePreparationError('workspace_skills_unavailable');
+        thread.loaded = true;
+        thread.skillsHash = prepared.skillsHash;
+        thread.discoveryHash = prepared.discoveryHash;
+    }
     async function start() {
+        if (closed)
+            throw new Error('codex_not_started');
         await options.modelBroker?.start();
         const token = options.modelBroker ? 'workspace-broker-managed' : await readToken(options);
+        if (closed)
+            throw new Error('codex_not_started');
         const bin = options.command || process.env.PLAYCRAFT_CODEX_BIN || (launcherSocket ? '/usr/local/bin/codex' : 'codex');
         const { command, prefix } = spawnCommand(bin);
         const args = [...prefix, ...(options.args ?? ['app-server'])];
@@ -118,6 +242,8 @@ export function createCodexAppServerAdapter(options) {
         }
         else {
             await writePlaycraftCodexConfig({ homeDir, modelProxyUrl: options.config.modelProxyUrl, model });
+            if (closed)
+                throw new Error('codex_not_started');
             const local = spawn(command, args, {
                 cwd: options.config.workspaceRoot,
                 env: { ...process.env, ...options.env, CODEX_HOME: homeDir, OPENAI_API_KEY: token, PLAYCRAFT_SKIP_UPDATE_CHECK: '1' },
@@ -134,11 +260,25 @@ export function createCodexAppServerAdapter(options) {
                 },
             };
         }
+        if (closed) {
+            await child.stop();
+            throw new Error('codex_not_started');
+        }
         child.stderr?.on('data', (chunk) => {
             process.stderr.write(chunk);
         });
         rpc = createJsonRpcStdioClient(child);
         rpc.onNotification((method, params) => {
+            if (method === 'turn/completed') {
+                const record = asRecord(params), turnId = asRecord(record.turn).id;
+                const thread = typeof record.threadId === 'string' ? threads.get(record.threadId)
+                    : [...threads.values()].find(item => item.lastTurnId === turnId);
+                if (thread) {
+                    thread.turnActive = false;
+                    if (typeof turnId === 'string')
+                        thread.lastCompletedTurnId = turnId;
+                }
+            }
             emitCollected(collectedEvent('notification', method, params));
         });
         rpc.onServerRequest((id, method, params) => {
@@ -169,7 +309,8 @@ export function createCodexAppServerAdapter(options) {
                 readyFlag = false;
                 // Retain the old handle until its entire execution group is confirmed stopped.
                 rpc = undefined;
-                emitCollected(collectedEvent('process_exit', 'process.exited', { pid: current.pid }));
+                if (!current.superseded)
+                    emitCollected(collectedEvent('process_exit', 'process.exited', { pid: current.pid }));
             }
             if (!current.superseded && !closed) {
                 for (const listener of exitListeners)
@@ -184,6 +325,8 @@ export function createCodexAppServerAdapter(options) {
                     version: options.config.cliVersion,
                 },
             });
+            if (closed)
+                throw new Error('codex_not_started');
             rpc.notify('initialized', {});
             readyFlag = true;
         }
@@ -224,6 +367,7 @@ export function createCodexAppServerAdapter(options) {
             if (previous)
                 await previous.child.stop();
             executionEpoch += 1;
+            skillsRestartFailed = false;
             if (closed)
                 throw new Error('codex_not_started');
             try {
@@ -240,21 +384,38 @@ export function createCodexAppServerAdapter(options) {
             return { pid: next.pid, startedAt: next.startedAt };
         },
         async canContinueThread(input) {
-            await ensureStarted();
-            if (!rpc)
-                return false;
-            try {
-                const result = await rpc.request('thread/resume', { threadId: input.threadId, cwd: input.cwd,
-                    ...await threadConfig(input.cwd ?? '') }, 30_000);
-                const resumedId = result.thread?.id ?? result.threadId;
-                if (resumedId !== input.threadId)
+            return withPreparation(async () => {
+                await ensureStarted();
+                if (!rpc)
                     return false;
-                threads.set(input.threadId, { sessionId: input.sessionId });
-                return true;
-            }
-            catch {
-                return false;
-            }
+                try {
+                    const prepared = await lockedThreadConfig(input.cwd ?? '');
+                    const existing = threads.get(input.threadId);
+                    if (existing && existing.sessionId !== input.sessionId)
+                        return false;
+                    if (existing?.needsRecreate)
+                        return false;
+                    if (existing?.loaded) {
+                        if (existing.skillsHash !== prepared.skillsHash || existing.discoveryHash !== prepared.discoveryHash) {
+                            if (!existing.hasNativeHistory)
+                                return false;
+                            await restartForSkills(input.threadId);
+                        }
+                        return threads.get(input.threadId)?.sessionId === input.sessionId;
+                    }
+                    const result = await rpc.request('thread/resume', { threadId: input.threadId, cwd: input.cwd,
+                        ...prepared.params }, 30_000);
+                    const resumedId = result.thread?.id ?? result.threadId;
+                    if (resumedId !== input.threadId)
+                        return false;
+                    threads.set(input.threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
+                        discoveryHash: prepared.discoveryHash, hasNativeHistory: true, loaded: true });
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            });
         },
         async readThread(input) {
             try {
@@ -272,6 +433,9 @@ export function createCodexAppServerAdapter(options) {
                 return undefined;
             }
         },
+        exportThread(input) {
+            return exportTranscript(transcriptHome(), input.threadId);
+        },
         async captureNativeCheckpoint(input) {
             const thread = threads.get(input.threadId);
             if (!thread || thread.sessionId !== input.sessionId)
@@ -284,44 +448,80 @@ export function createCodexAppServerAdapter(options) {
             await ensureStarted();
         },
         async startThread(input) {
-            await ensureStarted();
-            if (!rpc)
-                throw new Error('codex_not_started');
-            const result = await rpc.request('thread/start', {
-                cwd: input.cwd,
-                model,
-                ...await threadConfig(input.cwd),
+            return withPreparation(async () => {
+                await ensureStarted();
+                if (!rpc)
+                    throw new Error('codex_not_started');
+                const prepared = await lockedThreadConfig(input.cwd);
+                const result = await rpc.request('thread/start', {
+                    cwd: input.cwd,
+                    model,
+                    ...prepared.params,
+                });
+                const threadId = result.thread?.id;
+                if (!threadId)
+                    throw new Error('native_receipt_lost');
+                threads.set(threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
+                    discoveryHash: prepared.discoveryHash, hasNativeHistory: false, loaded: true });
+                return { threadId };
             });
-            const threadId = result.thread?.id;
-            if (!threadId)
-                throw new Error('native_receipt_lost');
-            threads.set(threadId, { sessionId: input.sessionId });
-            return { threadId };
         },
         async startTurn(input) {
-            await ensureStarted();
-            if (!rpc)
-                throw new Error('codex_not_started');
-            if (threads.get(input.threadId)?.sessionId !== input.sessionId) {
-                return { outcome: 'failed', error: 'unknown_thread' };
-            }
-            const requestId = rpc.reserveRequest();
-            await input.persistReservation({ nativeRequestId: String(requestId) });
-            if (input.simulateLostReceipt)
-                return { outcome: 'uncertain', threadId: input.threadId };
-            try {
-                const started = await rpc.sendReserved(requestId, 'turn/start', { threadId: input.threadId, input: [{ type: 'text', text: input.text }] }, turnTimeoutMs);
-                const turnId = started.turn?.id;
-                if (!turnId)
-                    return { outcome: 'uncertain', threadId: input.threadId };
+            return withPreparation(async () => {
+                await ensureStarted();
+                if (!rpc)
+                    throw new Error('codex_not_started');
+                if (threads.get(input.threadId)?.sessionId !== input.sessionId) {
+                    return { outcome: 'failed', error: 'unknown_thread' };
+                }
                 const thread = threads.get(input.threadId);
-                if (thread)
-                    thread.lastTurnId = turnId;
-                return { outcome: 'accepted', threadId: input.threadId, turnId };
-            }
-            catch {
-                return { outcome: 'uncertain', threadId: input.threadId };
-            }
+                if (thread.needsRecreate)
+                    return { outcome: 'failed', error: 'workspace_skills_changed' };
+                if (thread.skillsHash && thread.cwd) {
+                    try {
+                        const prepared = await lockedThreadConfig(thread.cwd);
+                        // Codex does not persist an empty thread rollout until its first turn.
+                        if (!thread.hasNativeHistory) {
+                            if (prepared.skillsHash !== thread.skillsHash || prepared.discoveryHash !== thread.discoveryHash)
+                                return { outcome: 'failed', error: 'workspace_skills_changed' };
+                        }
+                        else if (prepared.skillsHash !== thread.skillsHash || prepared.discoveryHash !== thread.discoveryHash) {
+                            await restartForSkills(input.threadId);
+                        }
+                        if (!thread.loaded)
+                            await resumePreparedThread(input.threadId, thread, prepared);
+                        thread.skillsHash = prepared.skillsHash;
+                        thread.discoveryHash = prepared.discoveryHash;
+                    }
+                    catch (error) {
+                        return { outcome: 'failed', error: error instanceof NativePreparationError ? error.message : 'workspace_skills_unavailable' };
+                    }
+                }
+                const requestId = rpc.reserveRequest();
+                await input.persistReservation({ nativeRequestId: String(requestId) });
+                if (input.simulateLostReceipt)
+                    return { outcome: 'uncertain', threadId: input.threadId };
+                try {
+                    thread.turnActive = true;
+                    const started = await rpc.sendReserved(requestId, 'turn/start', { threadId: input.threadId, input: [
+                            { type: 'text', text: input.text },
+                            ...(input.images ?? []).map((path) => ({ type: 'localImage', path })),
+                        ] }, turnTimeoutMs);
+                    const turnId = started.turn?.id;
+                    if (!turnId)
+                        return { outcome: 'uncertain', threadId: input.threadId };
+                    const acceptedThread = threads.get(input.threadId);
+                    if (acceptedThread) {
+                        acceptedThread.lastTurnId = turnId;
+                        acceptedThread.hasNativeHistory = true;
+                        acceptedThread.turnActive = acceptedThread.lastCompletedTurnId !== turnId;
+                    }
+                    return { outcome: 'accepted', threadId: input.threadId, turnId };
+                }
+                catch {
+                    return { outcome: 'uncertain', threadId: input.threadId };
+                }
+            });
         },
         async interrupt(input) {
             await ensureStarted();

package/dist/workspace-runtime/codex/transcripts.js

@@ -0,0 +1,94 @@
+import { randomUUID } from 'node:crypto';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { startLauncherProcess } from './launcher-client.js';
+export const TRANSCRIPT_MAX_BYTES = 64 * 1024 * 1024;
+const THREAD_ID = /^[A-Za-z0-9_-]{1,128}$/;
+const TRANSCRIPT_PATH = /^sessions\/\d{4}\/\d{2}\/\d{2}\/rollout-[A-Za-z0-9_.-]{1,200}\.jsonl$/;
+const COMMAND_TIMEOUT_MS = 60_000;
+/**
+ * Reads the transcript Codex keeps for one thread. Codex appends to it while a turn runs, so a
+ * trailing partial line is dropped; what is returned always parses line by line.
+ */
+export async function exportTranscript(home, threadId) {
+    if (!THREAD_ID.test(threadId))
+        return undefined;
+    const found = home.launcher
+        ? await exportAsDeveloper(home.homeDir, home.launcher, threadId)
+        : await exportDirect(home.homeDir, threadId);
+    if (!found || !transcriptPathFor(found.path, threadId))
+        return undefined;
+    const end = found.body.lastIndexOf(0x0a);
+    if (end < 0)
+        return undefined;
+    return { path: found.path, body: found.body.subarray(0, end + 1) };
+}
+function transcriptPathFor(path, threadId) {
+    return TRANSCRIPT_PATH.test(path) && path.endsWith(`-${threadId}.jsonl`);
+}
+async function exportDirect(homeDir, threadId) {
+    const suffix = `-${threadId}.jsonl`;
+    for (const year of await names(join(homeDir, 'sessions'))) {
+        for (const month of await names(join(homeDir, 'sessions', year))) {
+            for (const day of await names(join(homeDir, 'sessions', year, month))) {
+                const directory = join('sessions', year, month, day);
+                const match = (await names(join(homeDir, directory))).find((name) => name.endsWith(suffix));
+                if (!match)
+                    continue;
+                const path = `${directory}/${match}`;
+                const absolute = join(homeDir, path);
+                if ((await stat(absolute)).size > TRANSCRIPT_MAX_BYTES)
+                    return undefined;
+                return { path, body: await readFile(absolute) };
+            }
+        }
+    }
+    return undefined;
+}
+async function exportAsDeveloper(homeDir, launcher, threadId) {
+    const limitKib = TRANSCRIPT_MAX_BYTES / 1024;
+    const outcome = await runAsDeveloper(launcher, [
+        `home=${quote(homeDir)}`,
+        `f=$(find "$home/sessions" -mindepth 4 -maxdepth 4 -type f -name ${quote(`rollout-*-${threadId}.jsonl`)} -size -${limitKib}k 2>/dev/null | head -n 1)`,
+        '[ -n "$f" ] || exit 3',
+        'printf \'%s\\n\' "${f#"$home"/}"',
+        'base64 -w 0 "$f"',
+    ].join('; '));
+    if (outcome.code !== 0)
+        return undefined;
+    const text = outcome.stdout.toString('utf8');
+    const newline = text.indexOf('\n');
+    if (newline < 0)
+        return undefined;
+    return { path: text.slice(0, newline), body: Buffer.from(text.slice(newline + 1).trim(), 'base64') };
+}
+async function runAsDeveloper(launcher, command) {
+    const child = await startLauncherProcess({
+        socketPath: launcher.socketPath,
+        processId: `transcript-${randomUUID()}`,
+        runtimeEpoch: launcher.runtimeEpoch,
+        argv: ['/usr/bin/bash', '-c', `{ ${command}; } </dev/null 2>/dev/null`],
+        cwd: launcher.cwd,
+        env: {},
+    });
+    child.stdin?.end();
+    const chunks = [];
+    child.stdout?.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+    const code = await new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            void child.stop().catch(() => undefined);
+            resolve(null);
+        }, COMMAND_TIMEOUT_MS);
+        child.onExit((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        });
+    });
+    return { code, stdout: Buffer.concat(chunks) };
+}
+async function names(directory) {
+    return readdir(directory).then((entries) => entries.sort(), () => []);
+}
+function quote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}

package/dist/workspace-runtime/previews/publish.js

@@ -33,6 +33,12 @@ export async function previewWorkspaceRoot(state, operation) {
     if (!operation.workspaceId || !/^[A-Za-z0-9_-]+$/.test(operation.operationId)) {
         throw new PreviewFailure('invalid_preview_publish');
     }
+    if (operation.sessionId !== undefined) {
+        const session = state.journal.getSession(operation.sessionId);
+        if (!session || (state.config.workspaceMode === 'multi' && session.workspaceId !== operation.workspaceId)) {
+            throw new PreviewFailure('session_workspace_mismatch');
+        }
+    }
     return workspaceRoot(state, operation.workspaceId);
 }
 /** Tracks a background publish so tests and shutdown can wait for it. */
@@ -55,6 +61,9 @@ export async function recoverInterruptedPreviews(journal) {
 }
 export async function runPreviewPublish(state, operation, root) {
     const workspaceId = operation.workspaceId;
+    const scope = operation.sessionId === undefined
+        ? {}
+        : { sessionId: operation.sessionId, clientRequestId: operation.clientRequestId };
     const outputDir = join(root, OUTPUT_FOLDER, operation.operationId);
     const output = { log: '' };
     try {
@@ -73,6 +82,7 @@ export async function runPreviewPublish(state, operation, root) {
         const source = await sourceRevision(root);
         const reserved = previewReservationSchema.parse(await postControl(state, '/runtime/internal/preview-reservations', {
             workspaceId,
+            ...scope,
             operationId: operation.operationId,
             contentDigest,
             contentMd5,
@@ -81,6 +91,8 @@ export async function runPreviewPublish(state, operation, root) {
             dirty: source.dirty,
             cliVersion: state.config.cliVersion,
         }));
+        if (reserved.sessionId !== operation.sessionId)
+            throw new PreviewFailure('preview_scope_mismatch');
         if (!reserved.alreadyUploaded) {
             const uploaded = await fetch(reserved.uploadUrl, {
                 method: 'PUT',
@@ -99,11 +111,16 @@ export async function runPreviewPublish(state, operation, root) {
         }
         const published = previewPublishResultSchema.parse(await postControl(state, '/runtime/internal/preview-completions', {
             workspaceId,
+            ...scope,
             operationId: operation.operationId,
             artifactId: reserved.artifactId,
             expectedPublishRevision: reserved.expectedPublishRevision,
             logTail: tail(output.log),
         }));
+        if (published.sessionId !== operation.sessionId || published.previewId !== reserved.previewId ||
+            published.artifactId !== reserved.artifactId) {
+            throw new PreviewFailure('preview_scope_mismatch');
+        }
         if (published.status === 'conflict')
             throw new PreviewFailure('publish_conflict');
         return published;
@@ -113,6 +130,7 @@ export async function runPreviewPublish(state, operation, root) {
         if (code !== 'publish_conflict') {
             await postControl(state, '/runtime/internal/preview-failures', {
                 workspaceId,
+                ...scope,
                 operationId: operation.operationId,
                 error: code,
                 logTail: tail(output.log || (error instanceof Error ? error.message : '')),