@playcraft/cli 0.1.57-beta → 0.1.59-beta

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

@@ -1,4 +1,4 @@
-import { readFileSync, mkdirSync, writeFileSync, renameSync } from 'node:fs';
+import { readFileSync, readdirSync, mkdirSync, writeFileSync, renameSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { dirname, join } from 'node:path';
 const memory = new WeakMap();
@@ -29,38 +29,87 @@ function parsePolicy(raw) {
         return undefined;
     return value;
 }
-export async function bindMemberPolicy(state, sessionId, policy) {
+export async function bindMemberPolicy(state, sessionId, policy, owner) {
     const path = policyPath(state, sessionId);
     mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
     const temporary = `${path}.${randomUUID()}.tmp`;
-    writeFileSync(temporary, JSON.stringify(policy), { mode: 0o600 });
+    const binding = { ...owner, policy };
+    writeFileSync(temporary, JSON.stringify(binding), { mode: 0o600 });
     renameSync(temporary, path);
     const map = memory.get(state) ?? new Map();
-    map.set(sessionId, policy);
+    map.set(sessionId, binding);
     memory.set(state, map);
 }
-/** Synchronous: the shared session adapter reapplies this on every thread start and resume. */
+function readBinding(raw) {
+    const value = JSON.parse(raw);
+    if (!('policy' in value)) {
+        const policy = parsePolicy(raw);
+        return policy ? { policy } : undefined;
+    }
+    const policy = parsePolicy(JSON.stringify(value.policy));
+    return policy && typeof value.runId === 'string' && /^[0-9a-f-]{36}$/i.test(value.runId)
+        && Number.isInteger(value.ownerFence) && value.ownerFence >= 0 ? { ...value, policy } : undefined;
+}
+function memberRecord(state, runId, sessionId) {
+    if (typeof runId !== 'string' || !/^[0-9a-f-]{36}$/i.test(runId))
+        throw new Error('member_policy_record_invalid');
+    const record = JSON.parse(readFileSync(join(state.config.stateDir, 'batch-members', `${runId}.json`), 'utf8'));
+    if (record.runId !== runId || record.sessionId !== sessionId || !Number.isInteger(record.ownerFence)
+        || typeof record.holding !== 'boolean' || typeof record.writersStopped !== 'boolean')
+        throw new Error('member_policy_record_invalid');
+    return record;
+}
+function sessionMembers(state, sessionId) {
+    return readdirSync(join(state.config.stateDir, 'batch-members')).filter(name => name.endsWith('.json'))
+        .map(name => JSON.parse(readFileSync(join(state.config.stateDir, 'batch-members', name), 'utf8')))
+        .filter(record => record.sessionId === sessionId)
+        .map(record => memberRecord(state, record.runId, sessionId));
+}
+/** Re-read the owning Run on every lookup; a cached policy is never proof of an active member. */
 export function trustedMemberPolicy(state, sessionId) {
-    const cached = memory.get(state)?.get(sessionId);
-    if (cached)
-        return cached;
     try {
-        const parsed = parsePolicy(readFileSync(policyPath(state, sessionId), 'utf8'));
-        if (!parsed) {
-            return {
-                cwd: state.config.workspaceRoot,
-                approvalPolicy: 'never',
-                sandboxPolicy: { type: 'readOnly', networkAccess: false },
-            };
+        let binding = memory.get(state)?.get(sessionId);
+        if (!binding) {
+            let raw;
+            try {
+                raw = readFileSync(policyPath(state, sessionId), 'utf8');
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    return undefined;
+                throw error;
+            }
+            binding = readBinding(raw);
+            if (!binding)
+                throw new Error('member_policy_invalid');
+            const map = memory.get(state) ?? new Map();
+            map.set(sessionId, binding);
+            memory.set(state, map);
         }
-        const map = memory.get(state) ?? new Map();
-        map.set(sessionId, parsed);
-        memory.set(state, map);
-        return parsed;
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
+        if (binding.runId) {
+            const record = memberRecord(state, binding.runId, sessionId);
+            if (record.holding || !record.writersStopped) {
+                if (record.ownerFence !== binding.ownerFence)
+                    throw new Error('member_policy_owner_mismatch');
+                return binding.policy;
+            }
+            if (sessionMembers(state, sessionId).some(member => member.holding || !member.writersStopped))
+                throw new Error('member_policy_owner_mismatch');
+            return undefined;
+        }
+        // Profiles written before Run ownership was recorded still use durable member facts.
+        const records = sessionMembers(state, sessionId);
+        if (!records.length)
+            throw new Error('member_policy_record_missing');
+        const active = records.filter(record => record.holding || !record.writersStopped);
+        if (!active.length)
             return undefined;
+        if (active.length !== 1 || binding.policy.sandboxPolicy.type !== 'workspaceWrite'
+            || !binding.policy.sandboxPolicy.writableRoots.includes(join(state.config.stateDir, 'batch-temp', active[0].runId)))
+            throw new Error('member_policy_owner_mismatch');
+        return binding.policy;
+    }
+    catch {
         return {
             cwd: state.config.workspaceRoot,
             approvalPolicy: 'never',

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

@@ -3,12 +3,15 @@ import { lstat, mkdir, readFile, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { sandboxBatchMemberPrepareSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { claimBatchDirectory, withDirectoryOwner } from '../server/directory-access.js';
+import { writeWorkspaceCliContext } from '../workspaces/cli-context.js';
 import { registerWorkspaceDirectory } from '../workspaces/directories.js';
 import { workspaceContainerRoot } from '../workspaces/registry.js';
 import { dependencyInstallCommand, planInstall } from '../workspaces/dependencies.js';
 import { copyCredentialHelpers, gitRead, gitWrite } from './git.js';
 import { restoreArchive } from './source-capture.js';
 import { groupExited, runProcessGroup } from './processes.js';
+import { stopMemberWriters } from './writer-proof.js';
 import { filesystemObjectStore, memberStatus, readMember, readSnapshot, readStopMarker, serializeRun, sourceCacheDir, writeMember, } from './records.js';
 const BRANCH = /^remix\/draft-[a-f0-9]{16}$/;
 function hashCommand(value) {
@@ -143,111 +146,123 @@ export async function prepareBatchMember(state, body, options) {
         if (existing?.processes.some((process) => process.role === 'install' && !process.stopped && !groupExited(process.pid)))
             return memberStatus(existing);
         const snapshot = command.snapshot;
-        if ((await readSnapshot(state, snapshot.batchId))?.digest === snapshot.digest) {
-            /* The local snapshot record is an accelerator; the command snapshot remains authoritative. */
-        }
-        let record = await writeMember(state, {
-            runId: command.runId,
-            ownerFence: command.ownerFence,
-            occupancyId: command.occupancyId,
-            workspaceId: command.workspaceId,
-            directoryName: command.directoryName,
-            phase: 'prepare',
-            state: 'running',
-            writersStopped: false,
-            holding: true,
-            stopRequested: false,
-            processes: existing?.processes ?? [],
-            commandHash: { ...existing?.commandHash, prepare: hash },
-            snapshotDigest: snapshot.digest,
-            branchName: command.branchName,
-            sourceCommit: snapshot.commitHash,
-            beforeTree: existing?.beforeTree,
-            updatedAt: new Date().toISOString(),
-        });
-        let staging;
-        try {
-            const parent = await workspaceContainerRoot(state, command.workspaceId);
-            const root = join(parent, command.directoryName);
-            staging = join(parent, `.batch-member-${randomUUID()}`);
-            const binding = state.journal.getWorkspace(command.workspaceId);
-            if (!binding)
-                throw new Error('workspace_not_registered');
-            const repositoryUrl = binding.repositoryUrl ?? undefined;
-            const sourceRoot = join(parent, snapshot.sourceDirectoryName);
-            if (!(await lstat(root).catch(() => undefined))) {
-                await mkdir(parent, { recursive: true });
-                if (command.resumeFromCommit)
-                    await resumeBranch(repositoryUrl, command.branchName, command.resumeFromCommit, staging, sourceRoot);
-                else
-                    await materialize(state, snapshot, staging, options?.objectStore ?? filesystemObjectStore(state), sourceRoot);
-                const commit = command.resumeFromCommit ?? snapshot.commitHash;
-                await checkoutBranch(staging, command.branchName, commit, repositoryUrl);
-                const { rename } = await import('node:fs/promises');
-                await rename(staging, root);
+        await claimBatchDirectory(state, command);
+        return withDirectoryOwner(state, command, `run:${command.runId}`, async () => {
+            if ((await readSnapshot(state, snapshot.batchId))?.digest === snapshot.digest) {
+                /* The local snapshot record is an accelerator; the command snapshot remains authoritative. */
             }
-            await registerWorkspaceDirectory(state, {
+            let record = await writeMember(state, {
+                runId: command.runId,
+                ownerFence: command.ownerFence,
+                occupancyId: command.occupancyId,
                 workspaceId: command.workspaceId,
                 directoryName: command.directoryName,
-                remixId: command.remixId,
+                phase: 'prepare',
+                state: 'running',
+                writersStopped: false,
+                holding: true,
+                stopRequested: false,
+                processes: existing?.processes ?? [],
+                commandHash: { ...existing?.commandHash, prepare: hash },
+                snapshotDigest: snapshot.digest,
                 branchName: command.branchName,
-                sourceCommit: command.resumeFromCommit ?? snapshot.commitHash,
-            }, state.acceptedLeaseFence);
-            const plan = await planInstall(root);
-            if (plan.kind === 'install') {
-                // Keep control-user installs script-free. pnpm validates the frozen manifest and lock.
-                const frozen = `${dependencyInstallCommand(state, { frozenLockfile: true })} --ignore-scripts`;
-                const installCommand = process.env.PLAYCRAFT_BATCH_INSTALL_COMMAND ?? (plan.hasLockfile
-                    ? frozen
-                    : `${dependencyInstallCommand(state)} --lockfile-only --ignore-scripts && ${frozen}`);
-                const installed = await runProcessGroup(root, installCommand, 'install', async (process) => {
+                sourceCommit: snapshot.commitHash,
+                beforeTree: existing?.beforeTree,
+                updatedAt: new Date().toISOString(),
+            });
+            let staging;
+            try {
+                const parent = await workspaceContainerRoot(state, command.workspaceId);
+                const root = join(parent, command.directoryName);
+                staging = join(parent, `.batch-member-${randomUUID()}`);
+                const binding = state.journal.getWorkspace(command.workspaceId);
+                if (!binding)
+                    throw new Error('workspace_not_registered');
+                const repositoryUrl = binding.repositoryUrl ?? undefined;
+                const sourceRoot = join(parent, snapshot.sourceDirectoryName);
+                if (!(await lstat(root).catch(() => undefined))) {
+                    await mkdir(parent, { recursive: true });
+                    if (command.resumeFromCommit)
+                        await resumeBranch(repositoryUrl, command.branchName, command.resumeFromCommit, staging, sourceRoot);
+                    else
+                        await materialize(state, snapshot, staging, options?.objectStore ?? filesystemObjectStore(state), sourceRoot);
+                    const commit = command.resumeFromCommit ?? snapshot.commitHash;
+                    await checkoutBranch(staging, command.branchName, commit, repositoryUrl);
+                    const { rename } = await import('node:fs/promises');
+                    await rename(staging, root);
+                }
+                await registerWorkspaceDirectory(state, {
+                    workspaceId: command.workspaceId,
+                    directoryName: command.directoryName,
+                    remixId: command.remixId,
+                    branchName: command.branchName,
+                    sourceCommit: command.resumeFromCommit ?? snapshot.commitHash,
+                }, state.acceptedLeaseFence);
+                // Workspace-level registration writes this for `basic` only. A batch member is a workspace
+                // directory in its own right: without the hint `generatedWorkspace()` returns nothing and the
+                // agent's deliverables are never captured as artifacts.
+                await writeWorkspaceCliContext(root, command.workspaceId);
+                const plan = await planInstall(root);
+                if (plan.kind === 'install') {
+                    // Keep control-user installs script-free. pnpm validates the frozen manifest and lock.
+                    const frozen = `${dependencyInstallCommand(state, { frozenLockfile: true })} --ignore-scripts`;
+                    const installCommand = process.env.PLAYCRAFT_BATCH_INSTALL_COMMAND ?? (plan.hasLockfile
+                        ? frozen
+                        : `${dependencyInstallCommand(state)} --lockfile-only --ignore-scripts && ${frozen}`);
+                    const installed = await runProcessGroup(root, installCommand, 'install', async (process) => {
+                        record = await writeMember(state, {
+                            ...record,
+                            processes: [...record.processes, process],
+                        });
+                    });
                     record = await writeMember(state, {
                         ...record,
-                        processes: [...record.processes, process],
+                        processes: record.processes.map((process) => process.pid === installed.process.pid
+                            ? { ...installed.process, role: 'install' }
+                            : process),
                     });
+                    if (await readStopMarker(state, command.runId))
+                        return memberStatus(await sealStopped(state, command, record));
+                    if (installed.code !== 0)
+                        throw new Error('batch_install_failed');
+                }
+                const writersStopped = await stopMemberWriters(state, record);
+                if (!writersStopped)
+                    return memberStatus(await writeMember(state, { ...record, state: 'stopping', writersStopped: false, holding: true }));
+                const head = (await gitRead(root, ['rev-parse', 'HEAD'])).trim();
+                record = await writeMember(state, {
+                    ...record,
+                    state: 'completed',
+                    writersStopped: true,
+                    holding: true,
+                    headCommit: head,
+                    error: undefined,
                 });
+                return memberStatus(record);
+            }
+            catch (error) {
+                const code = error instanceof Error && /^[a-z0-9_]+$/.test(error.message)
+                    ? error.message
+                    : 'batch_prepare_failed';
+                const writersStopped = await stopMemberWriters(state, record);
                 record = await writeMember(state, {
                     ...record,
-                    processes: record.processes.map((process) => process.pid === installed.process.pid
-                        ? { ...installed.process, role: 'install' }
-                        : process),
+                    state: writersStopped ? 'failed' : 'stopping',
+                    writersStopped,
+                    holding: !writersStopped,
+                    error: code,
                 });
-                if (await readStopMarker(state, command.runId))
-                    return memberStatus(await sealStopped(state, command, record));
-                if (installed.code !== 0)
-                    throw new Error('batch_install_failed');
+                return memberStatus(record);
             }
-            const head = (await gitRead(root, ['rev-parse', 'HEAD'])).trim();
-            record = await writeMember(state, {
-                ...record,
-                state: 'completed',
-                writersStopped: true,
-                holding: true,
-                headCommit: head,
-                error: undefined,
-            });
-            return memberStatus(record);
-        }
-        catch (error) {
-            const code = error instanceof Error && /^[a-z0-9_]+$/.test(error.message)
-                ? error.message
-                : 'batch_prepare_failed';
-            record = await writeMember(state, {
-                ...record,
-                state: 'failed',
-                writersStopped: true,
-                holding: false,
-                error: code,
-            });
-            return memberStatus(record);
-        }
-        finally {
-            if (staging)
-                await rm(staging, { recursive: true, force: true });
-        }
+            finally {
+                if (staging)
+                    await rm(staging, { recursive: true, force: true });
+            }
+        });
     });
 }
 async function sealStopped(state, command, existing) {
+    const writersStopped = await stopMemberWriters(state, existing);
     return writeMember(state, {
         runId: command.runId,
         ownerFence: Math.max(command.ownerFence, existing?.ownerFence ?? 0),
@@ -255,9 +270,9 @@ async function sealStopped(state, command, existing) {
         workspaceId: command.workspaceId,
         directoryName: command.directoryName,
         phase: existing?.phase ?? 'prepare',
-        state: 'stopped',
-        writersStopped: true,
-        holding: false,
+        state: writersStopped ? 'stopped' : 'stopping',
+        writersStopped,
+        holding: !writersStopped,
         stopRequested: true,
         processes: existing?.processes ?? [],
         sessionId: existing?.sessionId,

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

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { mkdir, readFile, readdir, rename, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { batchSourceSnapshotRefSchema, sandboxBatchMemberStatusSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { releaseBatchDirectory } from '../server/directory-access.js';
 const runs = new Map();
 let freezeChain = Promise.resolve();
 export function serializeFreeze(action) {
@@ -33,8 +34,10 @@ export function objectFile(state, key) {
     return join(state.config.stateDir, 'batch-objects', key);
 }
 async function writeAtomic(path, body) {
+    // private
     await mkdir(join(path, '..'), { recursive: true, mode: 0o700 });
     const temporary = `${path}.${randomUUID()}.tmp`;
+    // private
     await writeFile(temporary, body, { mode: 0o600 });
     await rename(temporary, path);
 }
@@ -62,6 +65,7 @@ export async function readMember(state, runId) {
 export async function writeMember(state, record) {
     const next = { ...record, updatedAt: new Date().toISOString() };
     await writeAtomic(memberFile(state, record.runId), JSON.stringify(next));
+    releaseBatchDirectory(state, next);
     return next;
 }
 export async function listMembers(state) {

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

@@ -36,8 +36,16 @@ export async function dispatchBatchRoute(state, request, url) {
         return undefined;
     try {
         if (path === '/runtime/batch-sources/freeze') {
-            const result = batchSourceFreezeResultSchema.parse(await freezeBatchSource(state, await readBody(request)));
-            return { status: 200, body: result };
+            const controller = new AbortController();
+            const disconnected = () => controller.abort();
+            request.socket.once('close', disconnected);
+            try {
+                const result = batchSourceFreezeResultSchema.parse(await freezeBatchSource(state, await readBody(request), { signal: controller.signal }));
+                return { status: 200, body: result };
+            }
+            finally {
+                request.socket.off('close', disconnected);
+            }
         }
         if (path === '/runtime/batch-members/prepare')
             return { status: 200, body: await prepareBatchMember(state, await readBody(request)) };

package/dist/workspace-runtime/batch/source-candidate.js

@@ -39,8 +39,10 @@ export async function readSourceCandidate(state, batchId) {
 export async function writeSourceCandidate(state, candidate) {
     const path = sourceCandidateFile(state, candidate.snapshot.batchId);
     const directory = join(path, '..');
+    // private
     await mkdir(directory, { recursive: true, mode: 0o700 });
     const temporary = `${path}.${randomUUID()}.tmp`;
+    // private
     const handle = await open(temporary, 'wx', 0o600);
     try {
         await handle.writeFile(JSON.stringify(candidate));

package/dist/workspace-runtime/batch/source-capture.js

@@ -129,6 +129,7 @@ export async function restoreArchive(body, destination, expectedDigest) {
     await mkdir(temporary, { recursive: true });
     try {
         const bundle = join(temporary, 'source.bundle');
+        // private
         await writeFile(bundle, Buffer.from(archive.bundle, 'base64'), { mode: 0o600 });
         await gitWrite(temporary, ['clone', '--no-checkout', '--', bundle, destination]);
         await gitWrite(destination, ['checkout', '--detach', archive.commitHash]);

package/dist/workspace-runtime/batch/source-failure.js

@@ -29,7 +29,9 @@ export async function sourceFreezeError(state, batchId, failure, cause) {
     const directory = join(state.config.stateDir, 'batch-source-diagnostics');
     const detail = cause;
     try {
+        // private
         await mkdir(directory, { recursive: true, mode: 0o700 });
+        // private
         await writeFile(join(directory, `${diagnosticId}.json`), JSON.stringify({
             diagnosticId, batchId, ...failure, recordedAt: new Date().toISOString(), reason: redactedReason(cause),
             exitCode: typeof detail?.code === 'number' ? detail.code : undefined,

package/dist/workspace-runtime/batch/source-publish.js

@@ -25,6 +25,7 @@ async function publishRemote(state, candidate, source) {
     const cache = sourceCacheDir(state, snapshot.batchId);
     if (!remote || !snapshot.remoteRef)
         return reject(state, candidate, 'batch_source_push_failed', 'publish', false, 'not_published');
+    // private
     await mkdir(cache, { recursive: true, mode: 0o700 });
     if (!await lstat(join(cache, '.git')).catch(() => undefined))
         await gitWrite(cache, ['init', '--initial-branch', 'source']);
@@ -85,6 +86,7 @@ async function publishRemote(state, candidate, source) {
         if (!await verifyCache(cache, candidate))
             return reject(state, candidate, 'batch_source_snapshot_mismatch', 'verify', false, 'unknown');
     }
+    // private
     await writeFile(`${cache}.digest`, snapshot.digest, { mode: 0o600 });
 }
 async function publishArtifact(state, candidate, store) {
@@ -113,6 +115,7 @@ async function publishArtifact(state, candidate, store) {
             return reject(state, candidate, 'batch_source_upload_failed', 'publish', true, 'unknown', error);
         }
     }
+    // private
     await writeFile(`${cache}.digest`, snapshot.digest, { mode: 0o600 });
 }
 export async function publishSourceCandidate(state, candidate, source, store) {

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

@@ -0,0 +1,37 @@
+import { setTimeout as delay } from 'node:timers/promises';
+import { groupExited, 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))
+            process.stopped = true;
+        else
+            process.stopped = await stopProcessGroup(process);
+        if (!process.stopped)
+            stopped = false;
+    }
+    if (record.sessionId) {
+        const terminal = () => {
+            const session = state.journal.getSession(record.sessionId);
+            return Boolean(session && !session.turnBlock && ['completed', 'failed', 'interrupted'].includes(session.turnStatus ?? ''));
+        };
+        if (!terminal()) {
+            const session = state.journal.getSession(record.sessionId);
+            if (session?.threadId)
+                await state.native?.interrupt?.({ sessionId: record.sessionId, threadId: session.threadId }).catch(() => undefined);
+            const deadline = Date.now() + 2_000;
+            while (!terminal() && Date.now() < deadline)
+                await delay(15);
+            if (!terminal())
+                stopped = false;
+        }
+    }
+    const scope = `${record.workspaceId}:${record.directoryName}`;
+    if (state.journal.listManagedWrites(scope).some(writer => !writer.stoppedAt) ||
+        state.journal.listTerminals(record.workspaceId).some(terminal => terminal.directoryName === record.directoryName && terminal.status !== 'destroyed'))
+        stopped = false;
+    return stopped;
+}