@playcraft/cli 0.1.47-beta → 0.1.49-beta

package/dist/commands/tools-batch.js

@@ -35,12 +35,22 @@ const messages = {
     },
 };
 const language = () => /^zh/i.test(process.env.PLAYCRAFT_LANG ?? process.env.LANG ?? '') ? messages.zh : messages.en;
+const modelConfigIdPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Model bound by the runtime to the conversation that is creating the batch. */
+export function sessionModelConfigId(env = process.env) {
+    const value = env.PLAYCRAFT_MODEL_CONFIG_ID?.trim();
+    return value && modelConfigIdPattern.test(value) ? value : undefined;
+}
+function bindSessionModel(body) {
+    const modelConfigId = sessionModelConfigId();
+    return modelConfigId ? { ...body, modelConfigId } : body;
+}
 export async function createBatchDraft(path, client = new AgentApiClient()) {
-    const draft = batchCreateSchema.parse(JSON.parse(await readFile(path, 'utf8')));
+    const draft = batchCreateSchema.parse(bindSessionModel(JSON.parse(await readFile(path, 'utf8'))));
     return client.post('/create-batch', draft);
 }
 export async function createPromptBatch(input, client = new AgentApiClient()) {
-    return client.post('/create-batch', batchPromptCreateSchema.parse(input));
+    return client.post('/create-batch', batchPromptCreateSchema.parse(bindSessionModel(input)));
 }
 export function registerBatchCommands(tools) {
     const t = language();

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

@@ -1,6 +1,7 @@
 import { setTimeout as delay } from 'node:timers/promises';
 import { sandboxBatchMemberStopSchema } from '@playcraft/common/cloud-workspace/runtime';
 import { groupExited, stopProcessGroup } from './processes.js';
+import { settleObservedGenerate } from './generate.js';
 import { memberStatus, readMember, serializeRun, writeMember, writeStopMarker } from './records.js';
 async function prove(record) {
     let stopped = true;
@@ -26,6 +27,11 @@ export async function readBatchMemberStatus(state, runId) {
     const record = await readMember(state, runId);
     if (!record)
         return undefined;
+    if (record.phase === 'generate' && record.state === 'running') {
+        const settled = await settleObservedGenerate(state, record);
+        if (settled.state !== 'running')
+            return memberStatus(settled);
+    }
     const processes = record.processes.map(process => ({ ...process, stopped: process.stopped || groupExited(process.pid) }));
     const live = processes.some(process => !process.stopped);
     let next = { ...record, processes };

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

@@ -1,26 +1,23 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { lstat, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { lstat, open } from 'node:fs/promises';
 import { join } from 'node:path';
-import { hashOperationPayload, sandboxBatchMemberDeliverSchema } from '@playcraft/common/cloud-workspace/runtime';
-import { findExternalLocalReferences } from '../previews/single-file.js';
+import { hashOperationPayload, sandboxBatchMemberDeliverSchema, } from '@playcraft/common/cloud-workspace/runtime';
 import { workspaceRoot } from '../workspaces/registry.js';
-import { requireBatchContentChanges } from './content-changes.js';
-import { gitRead, gitWrite } from './git.js';
 import { groupExited, runProcessGroup, stopProcessGroup } from './processes.js';
-import { filesystemObjectStore, memberStatus, readMember, readStopMarker, serializeRun, writeMember, } from './records.js';
+import { memberStatus, readMember, readStopMarker, serializeRun, writeMember, } from './records.js';
+/** Base build writes dist/index.html. Channel packaging stays on export playable (`--mode full`). */
 function buildCommand() {
-    return process.env.PLAYCRAFT_BATCH_BUILD_COMMAND
-        ?? 'playcraft build --mode full --platform playcraft --format html --output dist/index.html .';
+    return (process.env.PLAYCRAFT_BATCH_BUILD_COMMAND ?? 'CI=1 playcraft build --mode base --output dist .');
 }
-async function saveExact(root) {
-    await gitWrite(root, ['add', '-A', '.']);
-    const privatePaths = await gitRead(root, ['ls-files', '--', '.playcraft.json', 'playcraft.config.json', ':(glob)**/.playcraft.json', ':(glob)**/playcraft.config.json']);
-    if (privatePaths.trim())
-        throw new Error('batch_private_path');
-    const clean = await gitWrite(root, ['diff', '--cached', '--quiet']).then(() => true, () => false);
-    if (!clean)
-        await gitWrite(root, ['commit', '-m', 'Save batch member']);
-    return (await gitRead(root, ['rev-parse', 'HEAD'])).trim();
+async function readBuiltHtml(root) {
+    const htmlPath = join(root, 'dist', 'index.html');
+    const info = await lstat(htmlPath).catch(() => undefined);
+    if (!info?.isFile() || info.isSymbolicLink())
+        throw new Error('batch_build_failed');
+    const handle = await open(htmlPath, constants.O_RDONLY | constants.O_NOFOLLOW).catch(() => {
+        throw new Error('batch_build_failed');
+    });
+    await handle.close();
 }
 async function prove(record) {
     let stopped = true;
@@ -35,8 +32,11 @@ async function prove(record) {
     }
     return stopped;
 }
-export async function deliverBatchMember(state, body, options) {
-    if (!body || typeof body !== 'object' || !('occupancyId' in body) || !body.occupancyId)
+export async function deliverBatchMember(state, body) {
+    if (!body ||
+        typeof body !== 'object' ||
+        !('occupancyId' in body) ||
+        !body.occupancyId)
         throw new Error('occupancy_required');
     const parsed = sandboxBatchMemberDeliverSchema.safeParse(body);
     if (!parsed.success)
@@ -47,109 +47,127 @@ export async function deliverBatchMember(state, body, options) {
         const existing = await readMember(state, command.runId);
         if (existing && command.ownerFence < existing.ownerFence)
             throw new Error('stale_owner');
-        if (existing?.state === 'completed' && existing.phase === 'deliver' && existing.evidence && existing.commandHash?.deliver === hash && existing.ownerFence === command.ownerFence) {
+        if (existing?.state === 'completed' &&
+            existing.phase === 'deliver' &&
+            existing.evidence &&
+            existing.commandHash?.deliver === hash &&
+            existing.ownerFence === command.ownerFence) {
             return memberStatus(existing);
         }
-        if (await readStopMarker(state, command.runId) && existing?.state === 'completed' && existing.evidence)
+        if ((await readStopMarker(state, command.runId)) &&
+            existing?.state === 'completed' &&
+            existing.evidence)
             return memberStatus(existing);
         if (await readStopMarker(state, command.runId))
             return memberStatus(await markStopped(state, command, existing));
-        if (existing && existing.ownerFence === command.ownerFence && existing.commandHash?.deliver && existing.commandHash.deliver !== hash && existing.state === 'completed') {
+        if (existing &&
+            existing.ownerFence === command.ownerFence &&
+            existing.commandHash?.deliver &&
+            existing.commandHash.deliver !== hash &&
+            existing.state === 'completed') {
             throw new Error('batch_command_conflict');
         }
         const root = await workspaceRoot(state, command.workspaceId, command.directoryName);
         let record = await writeMember(state, {
-            runId: command.runId, ownerFence: command.ownerFence, occupancyId: command.occupancyId, workspaceId: command.workspaceId,
-            directoryName: command.directoryName, phase: 'deliver', state: 'running', writersStopped: false, holding: true, stopRequested: false,
-            processes: existing?.processes ?? [], sessionId: existing?.sessionId, operationId: existing?.operationId, commandHash: { ...existing?.commandHash, deliver: hash },
-            snapshotDigest: existing?.snapshotDigest, branchName: existing?.branchName, updatedAt: new Date().toISOString(),
-            sourceCommit: existing?.sourceCommit ?? state.journal.getWorkspace(command.workspaceId)?.directories?.find(directory => directory.directoryName === command.directoryName)?.sourceCommit,
+            runId: command.runId,
+            ownerFence: command.ownerFence,
+            occupancyId: command.occupancyId,
+            workspaceId: command.workspaceId,
+            directoryName: command.directoryName,
+            phase: 'deliver',
+            state: 'running',
+            writersStopped: false,
+            holding: true,
+            stopRequested: false,
+            processes: existing?.processes ?? [],
+            sessionId: existing?.sessionId,
+            operationId: existing?.operationId,
+            commandHash: { ...existing?.commandHash, deliver: hash },
+            snapshotDigest: existing?.snapshotDigest,
+            branchName: existing?.branchName,
+            updatedAt: new Date().toISOString(),
+            sourceCommit: existing?.sourceCommit ??
+                state.journal
+                    .getWorkspace(command.workspaceId)
+                    ?.directories?.find((directory) => directory.directoryName === command.directoryName)
+                    ?.sourceCommit,
             beforeTree: existing?.beforeTree,
         });
-        const buildRoot = join(state.config.stateDir, 'batch-builds', `${command.runId}-${randomUUID()}`);
         try {
-            const savedCommit = command.fromCommit ?? await saveExact(root);
-            if (command.fromCommit)
-                await gitRead(root, ['cat-file', '-e', `${command.fromCommit}^{commit}`]);
-            await requireBatchContentChanges(root, record.sourceCommit ?? '', savedCommit);
             if (await readStopMarker(state, command.runId))
                 return memberStatus(await markStopped(state, command, record));
-            let pushedCommit;
-            if (command.pushRemote) {
-                const branch = existing?.branchName ?? (await gitRead(root, ['symbolic-ref', '--short', 'HEAD'])).trim();
-                try {
-                    await gitWrite(root, ['push', '--porcelain', 'origin', `${savedCommit}:refs/heads/${branch}`]);
-                }
-                catch {
-                    throw new Error('batch_push_failed');
-                }
-                const remote = (await gitWrite(root, ['ls-remote', 'origin', `refs/heads/${branch}`])).slice(0, savedCommit.length);
-                if (remote !== savedCommit)
-                    throw new Error('batch_push_failed');
-                pushedCommit = savedCommit;
-            }
-            await mkdir(join(buildRoot, '..'), { recursive: true });
-            await gitWrite(join(buildRoot, '..'), ['clone', '--local', '--no-hardlinks', '--no-checkout', '--', root, buildRoot]);
-            await gitWrite(buildRoot, ['checkout', '--detach', savedCommit]);
-            const built = await runProcessGroup(buildRoot, buildCommand(), 'build', async (process) => {
+            const built = await runProcessGroup(root, buildCommand(), 'build', async (process) => {
                 record = await writeMember(state, { ...record, processes: [...record.processes, process] });
             });
-            record = await writeMember(state, { ...record, processes: record.processes.map(process => process.pid === built.process.pid ? built.process : process) });
+            record = await writeMember(state, {
+                ...record,
+                processes: record.processes.map((process) => process.pid === built.process.pid ? built.process : process),
+            });
             if (await readStopMarker(state, command.runId))
                 return memberStatus(await markStopped(state, command, record));
             if (built.code !== 0)
                 throw new Error('batch_build_failed');
-            const htmlPath = join(buildRoot, 'dist', 'index.html');
-            if (!(await lstat(htmlPath).catch(() => undefined))?.isFile())
-                throw new Error('batch_build_failed');
-            const entries = await readdir(join(buildRoot, 'dist'));
-            if (!entries.includes('index.html'))
-                throw new Error('batch_build_failed');
-            const bodyBytes = await readFile(htmlPath);
-            if (findExternalLocalReferences(bodyBytes.toString()).length)
-                throw new Error('batch_verify_failed');
-            const buildDigest = createHash('sha256').update(bodyBytes).digest('hex');
-            const previewRef = `workspaces/${command.workspaceId}/batches/members/${command.runId}/${buildDigest}.html`;
-            const store = options?.objectStore ?? filesystemObjectStore(state);
-            await store.put(previewRef, bodyBytes);
-            const published = await store.get(previewRef);
-            if (createHash('sha256').update(published).digest('hex') !== buildDigest)
-                throw new Error('batch_verify_failed');
-            await mkdir(join(root, 'dist'), { recursive: true });
-            await writeFile(join(root, 'dist', 'index.html'), published);
-            if (createHash('sha256').update(await readFile(join(root, 'dist', 'index.html'))).digest('hex') !== buildDigest)
-                throw new Error('batch_verify_failed');
+            await readBuiltHtml(root);
             const writersStopped = await prove(record);
             if (!writersStopped)
-                return memberStatus(await writeMember(state, { ...record, state: 'stopping', writersStopped: false, holding: true, headCommit: savedCommit }));
+                return memberStatus(await writeMember(state, {
+                    ...record,
+                    state: 'stopping',
+                    writersStopped: false,
+                    holding: true,
+                }));
             if (await readStopMarker(state, command.runId))
-                return memberStatus(await markStopped(state, command, { ...record, headCommit: savedCommit }));
+                return memberStatus(await markStopped(state, command, record));
             record = await writeMember(state, {
-                ...record, state: 'completed', writersStopped: true, holding: false, headCommit: savedCommit, error: undefined,
-                evidence: { savedCommit, ...(pushedCommit ? { pushedCommit } : {}), buildDigest, verified: true, previewRef },
+                ...record,
+                state: 'completed',
+                writersStopped: true,
+                holding: false,
+                error: undefined,
+                evidence: { verified: true },
             });
             return memberStatus(record);
         }
         catch (error) {
-            const code = error instanceof Error && /^[a-z0-9_]+$/.test(error.message) ? error.message : 'batch_deliver_failed';
+            const code = error instanceof Error && /^[a-z0-9_]+$/.test(error.message)
+                ? error.message
+                : 'batch_deliver_failed';
             const writersStopped = await prove(record);
-            record = await writeMember(state, { ...record, state: writersStopped ? 'failed' : 'stopping', writersStopped, holding: !writersStopped, error: code });
+            record = await writeMember(state, {
+                ...record,
+                state: writersStopped ? 'failed' : 'stopping',
+                writersStopped,
+                holding: !writersStopped,
+                error: code,
+            });
             return memberStatus(record);
         }
-        finally {
-            await rm(buildRoot, { recursive: true, force: true });
-        }
     });
 }
 async function markStopped(state, command, existing) {
     if (existing)
         await prove(existing);
     return writeMember(state, {
-        runId: command.runId, ownerFence: command.ownerFence, occupancyId: existing?.occupancyId ?? command.occupancyId,
-        workspaceId: command.workspaceId, directoryName: command.directoryName, phase: 'deliver', state: 'stopped', writersStopped: true,
-        holding: false, stopRequested: true, processes: existing?.processes ?? [], sessionId: existing?.sessionId, operationId: existing?.operationId,
-        headCommit: existing?.headCommit, evidence: existing?.evidence, commandHash: existing?.commandHash, snapshotDigest: existing?.snapshotDigest,
-        branchName: existing?.branchName, updatedAt: new Date().toISOString(),
-        sourceCommit: existing?.sourceCommit, beforeTree: existing?.beforeTree,
+        runId: command.runId,
+        ownerFence: command.ownerFence,
+        occupancyId: existing?.occupancyId ?? command.occupancyId,
+        workspaceId: command.workspaceId,
+        directoryName: command.directoryName,
+        phase: 'deliver',
+        state: 'stopped',
+        writersStopped: true,
+        holding: false,
+        stopRequested: true,
+        processes: existing?.processes ?? [],
+        sessionId: existing?.sessionId,
+        operationId: existing?.operationId,
+        headCommit: existing?.headCommit,
+        evidence: existing?.evidence,
+        commandHash: existing?.commandHash,
+        snapshotDigest: existing?.snapshotDigest,
+        branchName: existing?.branchName,
+        updatedAt: new Date().toISOString(),
+        sourceCommit: existing?.sourceCommit,
+        beforeTree: existing?.beforeTree,
     });
 }

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

@@ -80,7 +80,8 @@ export async function generateBatchMember(state, body) {
         await mkdir(tempDir, { recursive: true, mode: 0o700 });
         const policy = memberExecutionPolicy(root, tempDir);
         await bindMemberPolicy(state, sessionId, policy);
-        const turnPayload = { text: command.prompt, permissionMode: 'auto', ...(command.model && /^[0-9a-f-]{36}$/i.test(command.model) ? { modelConfigId: command.model } : {}) };
+        const modelConfigId = command.model && /^[0-9a-f-]{36}$/i.test(command.model) ? command.model : undefined;
+        const turnPayload = { text: command.prompt, permissionMode: 'auto', ...(modelConfigId ? { modelConfigId } : {}) };
         const turnKey = operation(state, { kind: 'session.turn', clientRequestId: `batch-turn:${command.runId}`, sessionId, workspaceId: command.workspaceId, directoryName: command.directoryName, payload: turnPayload });
         const prior = state.journal.getOperation(turnKey.scopeKey);
         if (prior && prior.payloadHash !== turnKey.record.payloadHash)
@@ -114,9 +115,9 @@ export async function generateBatchMember(state, body) {
         });
         try {
             if (!state.journal.getSession(sessionId)) {
-                const created = operation(state, { kind: 'session.create', clientRequestId: `batch-create:${command.runId}`, sessionId, workspaceId: command.workspaceId, directoryName: command.directoryName, payload: { permissionMode: 'auto' } });
+                const created = operation(state, { kind: 'session.create', clientRequestId: `batch-create:${command.runId}`, sessionId, workspaceId: command.workspaceId, directoryName: command.directoryName, payload: { permissionMode: 'auto', ...(modelConfigId ? { modelConfigId } : {}) } });
                 if (!state.journal.getOperation(created.scopeKey))
-                    await executeOperation(state, created.scopeKey, created.record, { permissionMode: 'auto' });
+                    await executeOperation(state, created.scopeKey, created.record, { permissionMode: 'auto', ...(modelConfigId ? { modelConfigId } : {}) });
             }
             if (await readStopMarker(state, command.runId))
                 return memberStatus(await stoppedRecord(state, command, record));
@@ -179,6 +180,11 @@ async function finishGenerate(state, record, started, root, early) {
             return stoppedRecord(state, record, record);
         return completeGeneration(state, { ...record, operationId: started.operationId }, root);
     }
+    if (!terminal) {
+        return writeMember(state, {
+            ...record, state: 'running', writersStopped: false, holding: true, operationId: started.operationId, error: undefined,
+        });
+    }
     const writersStopped = await proveStopped(record);
     return writeMember(state, {
         ...record, state: writersStopped ? (terminal === 'interrupted' ? 'stopped' : 'failed') : 'unknown',
@@ -186,6 +192,23 @@ async function finishGenerate(state, record, started, root, early) {
         error: writersStopped ? (terminal === 'interrupted' ? undefined : 'batch_turn_failed') : 'native_receipt_lost',
     });
 }
+/** A later status read finishes a generate turn that was still running when dispatch returned. */
+export async function settleObservedGenerate(state, record) {
+    if (record.phase !== 'generate' || record.state !== 'running' || record.stopRequested)
+        return record;
+    const session = record.sessionId ? state.journal.getSession(record.sessionId) : undefined;
+    if (!session || session.turnBlock === 'uncertain' || session.turnStatus === 'starting' || session.turnStatus === 'running')
+        return record;
+    const terminal = session.turnStatus === 'completed' ? 'completed'
+        : session.turnStatus === 'failed' ? 'failed'
+            : session.turnStatus === 'interrupted' ? 'interrupted'
+                : session.turnStatus === 'waiting_for_user' ? 'needs_user'
+                    : undefined;
+    if (!terminal)
+        return record;
+    const root = await workspaceRoot(state, record.workspaceId, record.directoryName);
+    return finishGenerate(state, record, { operationId: record.operationId, status: 'accepted' }, root, () => terminal);
+}
 async function reconcileGenerate(state, record) {
     const session = record.sessionId ? state.journal.getSession(record.sessionId) : undefined;
     if (record.state === 'unknown' && session?.turnStatus === 'completed') {