@playcraft/cli 0.1.43-beta → 0.1.44-beta

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

@@ -0,0 +1,159 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { lstat, mkdir, open, readdir, readFile, realpath, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, isAbsolute, join, relative } from 'node:path';
+import { gzip, gunzip } from 'node:zlib';
+import { promisify } from 'node:util';
+import { excludeFromGit } from '../workspaces/dependencies.js';
+import { gitRead, gitWrite } from './git.js';
+const compress = promisify(gzip);
+const decompress = promisify(gunzip);
+const privateNames = new Set(['.git', 'node_modules', '.ssh', '.aws', '.azure', '.gnupg', '.codex', '.npm', '.pnpm-store',
+    '.config', '.npmrc', '.yarnrc', '.yarnrc.yml', '.netrc', '.git-credentials', 'credentials.json', 'credentials', 'secrets',
+    'id_rsa', 'id_ed25519', 'settings.local.json', '.playcraft.json', 'playcraft.config.json', '.playcraft-temp', '.playcraft-preview-out']);
+function included(path) {
+    return !path.split('/').some(name => privateNames.has(name) || /^\.env(?:$|\.)/.test(name) || /\.(?:pem|key|p12|pfx)$/.test(name))
+        && !path.startsWith('.playcraft/skills/');
+}
+/** Git keeps only the executable bit, so the digest must not depend on umask or group-write bits. */
+function snapshotMode(mode) {
+    return mode & 0o111 ? 0o755 : 0o644;
+}
+function inside(root, path) {
+    const rel = relative(root, path);
+    return rel !== '..' && !rel.startsWith('../') && !isAbsolute(rel);
+}
+export function digestFiles(files) {
+    const hash = createHash('sha256');
+    for (const [path, file] of files)
+        hash.update(path).update('\0').update(String(file.mode)).update('\0').update(file.body).update('\0');
+    return hash.digest('hex');
+}
+/** Working tree plus exact skill artifacts. Credentials, caches and node_modules are left out. */
+export async function readSourceFiles(root) {
+    const source = await realpath(root);
+    const paths = new Set((await gitRead(source, ['ls-files', '--cached', '--others', '--exclude-standard', '-z'])).split('\0').filter(Boolean));
+    const artifacts = await readdir(join(source, '.playcraft/skill-artifacts')).catch(error => {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    });
+    for (const name of artifacts)
+        if (/^[a-f0-9]{64}\.tar\.gz$/.test(name))
+            paths.add(`.playcraft/skill-artifacts/${name}`);
+    const files = new Map();
+    for (const path of [...paths].sort()) {
+        if (!included(path))
+            continue;
+        const full = join(source, path);
+        const stat = await lstat(full).catch(error => {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        });
+        if (!stat)
+            continue;
+        if (!stat.isFile() || stat.isSymbolicLink() || !inside(source, await realpath(full)))
+            throw new Error('batch_source_path_invalid');
+        const handle = await open(full, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            const body = await handle.readFile();
+            if (/^\.playcraft\/skill-artifacts\/[a-f0-9]{64}\.tar\.gz$/.test(path)
+                && createHash('sha256').update(body).digest('hex') !== path.slice(path.lastIndexOf('/') + 1, -7)) {
+                throw new Error('batch_source_path_invalid');
+            }
+            files.set(path, { body, mode: snapshotMode(stat.mode) });
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    return files;
+}
+/**
+ * Drops paths whose bytes change between two reads. A managed writer that could not be stopped
+ * does not become part of the frozen input.
+ */
+export async function filterUnstableFiles(root, files) {
+    const again = await readSourceFiles(root);
+    const stable = new Map();
+    for (const [path, file] of files) {
+        const next = again.get(path);
+        if (next && next.body.equals(file.body) && next.mode === file.mode)
+            stable.set(path, file);
+    }
+    return stable;
+}
+/** Independent root commit. The source branch, index and config are never written. */
+export async function captureIndependentSource(source, destination) {
+    const root = await realpath(source);
+    if (await lstat(destination).catch(() => undefined))
+        throw new Error('batch_source_destination_exists');
+    const headBefore = await gitRead(root, ['rev-parse', '--verify', 'HEAD']).catch(() => '');
+    let files = await readSourceFiles(root);
+    files = await filterUnstableFiles(root, files);
+    const digest = digestFiles(files);
+    const staging = join(dirname(destination), `.batch-source-${randomUUID()}`);
+    try {
+        await mkdir(staging, { recursive: true });
+        await gitWrite(staging, ['init', '--initial-branch', 'source']);
+        await gitWrite(staging, ['config', 'user.name', 'PlayCraft']);
+        await gitWrite(staging, ['config', 'user.email', 'playcraft@localhost']);
+        for (const [path, file] of files) {
+            const full = join(staging, path);
+            await mkdir(dirname(full), { recursive: true });
+            await writeFile(full, file.body, { mode: file.mode, flag: 'wx' });
+        }
+        if (headBefore !== await gitRead(root, ['rev-parse', '--verify', 'HEAD']).catch(() => ''))
+            throw new Error('batch_source_changed');
+        const after = await filterUnstableFiles(root, await readSourceFiles(root));
+        if (digestFiles(after) !== digest)
+            throw new Error('batch_source_changed');
+        await excludeFromGit(staging);
+        await excludeFromGit(staging, '/.env*');
+        for (const entry of ['/.playcraft.json', '/playcraft.config.json', '/.playcraft/skills/', '/.playcraft-temp/'])
+            await excludeFromGit(staging, entry);
+        await gitWrite(staging, ['add', '-A', '.']);
+        await gitWrite(staging, ['commit', '--allow-empty', '-m', 'Freeze batch source']);
+        const commitHash = (await gitWrite(staging, ['rev-parse', 'HEAD'])).trim();
+        await rename(staging, destination);
+        return { commitHash, digest };
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true });
+    }
+}
+export async function archiveSource(root, meta) {
+    const bundle = join(dirname(root), `.bundle-${randomUUID()}`);
+    try {
+        await gitWrite(root, ['bundle', 'create', bundle, 'HEAD']);
+        const body = JSON.stringify({ version: 1, ...meta, bundle: (await readFile(bundle)).toString('base64') });
+        return await compress(Buffer.from(body));
+    }
+    finally {
+        await rm(bundle, { force: true });
+    }
+}
+export async function restoreArchive(body, destination, expectedDigest) {
+    const archive = JSON.parse((await decompress(body, { maxOutputLength: 512 * 1024 * 1024 })).toString());
+    if (archive.version !== 1 || archive.digest !== expectedDigest || !archive.commitHash || !archive.bundle)
+        throw new Error('batch_snapshot_mismatch');
+    const temporary = join(dirname(destination), `.bundle-${randomUUID()}`);
+    await mkdir(temporary, { recursive: true });
+    try {
+        const bundle = join(temporary, 'source.bundle');
+        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]);
+        if (digestFiles(await readSourceFiles(destination)) !== expectedDigest)
+            throw new Error('batch_snapshot_mismatch');
+        return { commitHash: archive.commitHash };
+    }
+    catch (error) {
+        await rm(destination, { recursive: true, force: true });
+        throw error;
+    }
+    finally {
+        await rm(temporary, { recursive: true, force: true });
+    }
+}

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

@@ -4,7 +4,7 @@ import { startLauncherProcess } from './launcher-client.js';
 import { chmod, mkdir, mkdtemp, rm } from 'node:fs/promises';
 import { relative, join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { APPROVAL_METHODS, executionPolicy, nativeApprovalResponse, NATIVE_APPROVALS_REVIEWER, threadExecutionParams } from './permissions.js';
+import { APPROVAL_METHODS, executionPolicy, nativeApprovalResponse, NATIVE_APPROVALS_REVIEWER, resolveSessionExecution, sessionCanEscalate, threadExecutionParams } from './permissions.js';
 import { workspaceApprovalResponseSchema } from '@playcraft/common/cloud-workspace/runtime';
 import { portableCodexConfig, writePortableCodexCatalog } from './config-toml.js';
 import { createJsonRpcStdioClient, NativeRpcResponseError } from './jsonrpc-stdio.js';
@@ -212,7 +212,7 @@ export function createCodexAppServerAdapter(options) {
         if (await readProjectSkillsLockFile(cwd) === null) {
             if (options.config.workspaceMode === 'multi')
                 throw new NativePreparationError('workspace_skills_unavailable');
-            const execution = executionPolicy(cwd, permissionMode, options.fixedExecution);
+            const execution = resolveSessionExecution(cwd, permissionMode, sessionId ? options.trustedExecution?.(sessionId) : undefined, options.fixedExecution);
             const selected = threadExecutionParams(execution);
             return { params: { ...modelConfig, ...selected, config: { ...modelConfig.config, ...selected.config },
                     ...(options.workspaceUi && !options.fixedExecution ? { developerInstructions: WORKSPACE_UI_INSTRUCTIONS } : {}) },
@@ -239,7 +239,7 @@ export function createCodexAppServerAdapter(options) {
                 ...(options.workspaceUi && !options.fixedExecution ? [WORKSPACE_UI_INSTRUCTIONS] : []),
             ].join('\n');
             const discoveryHash = createHash('sha256').update(JSON.stringify(listing.skills.map(skill => skill.path).sort())).digest('hex');
-            const execution = executionPolicy(cwd, permissionMode, options.fixedExecution);
+            const execution = resolveSessionExecution(cwd, permissionMode, sessionId ? options.trustedExecution?.(sessionId) : undefined, options.fixedExecution);
             const selected = threadExecutionParams(execution);
             return { params: { ...modelConfig, ...selected, config: { ...config, ...selected.config }, developerInstructions },
                 execution, modelConfigId, activate, skillsHash: frozen.lockHash, discoveryHash, mcpHash: mcp?.hash };
@@ -678,7 +678,7 @@ export function createCodexAppServerAdapter(options) {
                     throw new Error('native_receipt_lost');
                 prepared.activate();
                 threads.set(threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
-                    discoveryHash: prepared.discoveryHash, mcpHash: prepared.mcpHash, resolvedModel: 'model' in prepared.params ? prepared.params.model : model, modelConfigId: prepared.modelConfigId, reasoningEffort: input.reasoningEffort, permissionMode: input.permissionMode ?? 'auto', canEscalate: prepared.execution.approvalPolicy === 'on-request' || (!options.fixedExecution && prepared.execution.sandboxPolicy.type === 'dangerFullAccess'), hasNativeHistory: false, loaded: true });
+                    discoveryHash: prepared.discoveryHash, mcpHash: prepared.mcpHash, resolvedModel: 'model' in prepared.params ? prepared.params.model : model, modelConfigId: prepared.modelConfigId, reasoningEffort: input.reasoningEffort, permissionMode: input.permissionMode ?? 'auto', canEscalate: sessionCanEscalate(Boolean(options.trustedExecution?.(input.sessionId)), prepared.execution, Boolean(options.fixedExecution)), hasNativeHistory: false, loaded: true });
                 threads.get(threadId).readOnlyConfirmed = isReadOnlySnapshot(result);
                 return { threadId, modelConfigId: prepared.modelConfigId, reasoningEffort: input.reasoningEffort, permissionMode: input.permissionMode ?? 'auto' };
             });
@@ -705,7 +705,7 @@ export function createCodexAppServerAdapter(options) {
                     return undefined;
                 prepared.activate();
                 threads.set(input.threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
-                    discoveryHash: prepared.discoveryHash, mcpHash: prepared.mcpHash, resolvedModel: 'model' in prepared.params ? prepared.params.model : model, modelConfigId: prepared.modelConfigId, reasoningEffort: input.reasoningEffort, permissionMode: input.permissionMode ?? 'auto', canEscalate: prepared.execution.approvalPolicy === 'on-request' || (!options.fixedExecution && prepared.execution.sandboxPolicy.type === 'dangerFullAccess'), hasNativeHistory: true, loaded: true });
+                    discoveryHash: prepared.discoveryHash, mcpHash: prepared.mcpHash, resolvedModel: 'model' in prepared.params ? prepared.params.model : model, modelConfigId: prepared.modelConfigId, reasoningEffort: input.reasoningEffort, permissionMode: input.permissionMode ?? 'auto', canEscalate: sessionCanEscalate(Boolean(options.trustedExecution?.(input.sessionId)), prepared.execution, Boolean(options.fixedExecution)), hasNativeHistory: true, loaded: true });
                 threads.get(input.threadId).readOnlyConfirmed = readOnlyConfirmed;
                 return { modelConfigId: prepared.modelConfigId, reasoningEffort: input.reasoningEffort, permissionMode: input.permissionMode ?? 'auto' };
             });
@@ -730,7 +730,7 @@ export function createCodexAppServerAdapter(options) {
                 const permissionMode = input.permissionMode ?? thread.permissionMode ?? 'auto';
                 const workMode = input.workMode ?? 'execute';
                 let activateModel = () => { };
-                let execution = executionPolicy(thread.cwd ?? options.config.workspaceRoot, permissionMode, options.fixedExecution);
+                let execution = resolveSessionExecution(thread.cwd ?? options.config.workspaceRoot, permissionMode, options.trustedExecution?.(input.sessionId), options.fixedExecution);
                 if (thread.cwd) {
                     try {
                         const prepared = await lockedThreadConfig(thread.cwd, input.modelConfigId ?? thread.modelConfigId, input.sessionId, reasoningEffort, input.clientRequestId, permissionMode);
@@ -774,7 +774,7 @@ export function createCodexAppServerAdapter(options) {
                 thread.readOnlyConfirmationFailed = false;
                 if (execution.sandboxPolicy.type !== 'readOnly' || execution.approvalPolicy !== 'never')
                     thread.readOnlyConfirmed = false;
-                thread.canEscalate = execution.approvalPolicy === 'on-request' || (!options.fixedExecution && execution.sandboxPolicy.type === 'dangerFullAccess');
+                thread.canEscalate = sessionCanEscalate(Boolean(options.trustedExecution?.(input.sessionId)), execution, Boolean(options.fixedExecution));
                 if (input.simulateLostReceipt)
                     return { outcome: 'uncertain', threadId: input.threadId };
                 try {

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

@@ -1,5 +1,14 @@
 export const NATIVE_APPROVALS_REVIEWER = 'user';
-/** Fixed production/coordinator boundaries may only become narrower. */
+/** Trusted batch policy wins over the adapter-wide fixed policy. A browser mode may only narrow it. */
+export function resolveSessionExecution(cwd, mode, trusted, fixed) {
+    return executionPolicy(cwd, mode, trusted ?? fixed);
+}
+/** A trusted unattended session cannot be escalated by a browser approval. */
+export function sessionCanEscalate(trusted, execution, adapterHasFixedExecution) {
+    if (trusted)
+        return false;
+    return execution.approvalPolicy === 'on-request' || (!adapterHasFixedExecution && execution.sandboxPolicy.type === 'dangerFullAccess');
+}
 export function executionPolicy(cwd, mode, fixed) {
     const directory = fixed?.cwd ?? cwd;
     if (mode === 'read-only')

package/dist/workspace-runtime/production/controller.js

@@ -8,6 +8,7 @@ import { productionExecutionRequestSchema } from './contracts.js';
 import { executeProductionStage } from './stages.js';
 import { groupExited, stopProductionGroup } from './processes.js';
 import { workspaceDirectoryOccupied } from '../workspaces/directory-maintenance.js';
+import { batchDirectoryHeld } from '../batch/occupancy.js';
 import { settleDependencyInstalls } from '../workspaces/dependencies.js';
 import { verifyProductionLease } from './storage.js';
 const execute = promisify(execFile);
@@ -56,6 +57,8 @@ export async function productionDirectoryBusy(state, workspaceId, directoryName
             && !attempt.stopped && attempt.workspaceId === workspaceId && attempt.directoryName === directoryName)
             return true;
     }
+    if (await batchDirectoryHeld(state, workspaceId, directoryName))
+        return true;
     return false;
 }
 export async function executeSandboxProduction(state, raw) {

package/dist/workspace-runtime/serve.js

@@ -5,6 +5,7 @@ import { createServer } from 'node:http';
 import { INCOMPATIBLE_EXIT_CODE, negotiateProtocol, transitionOperation, } from '@playcraft/common/cloud-workspace/runtime';
 import { RuntimeJournal } from './persistence/journal.js';
 import { createCodexAppServerAdapter } from './codex/app-server.js';
+import { trustedMemberPolicy } from './batch/policy.js';
 import { createLoopbackNativeAdapter } from './codex/loopback.js';
 import { attachNativeCollector } from './server/dispatch.js';
 import { handleRuntimeRequest } from './server/http.js';
@@ -275,6 +276,7 @@ function defaultNativeAdapter(state) {
                 return loadWorkspaceSkillArtifact(state, workspaceId, entry, directoryName === 'root' ? 'basic' : directoryName);
             },
             onSkillProcessRestart: process => state.journal.noteExecutionGroup(process),
+            trustedExecution: sessionId => trustedMemberPolicy(state, sessionId),
         });
     }
     return undefined;

package/dist/workspace-runtime/server/connectivity.js

@@ -2,6 +2,8 @@ import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
 import { PLATFORM_ROUTES, modelConnectivityPath, platformEndpoint, } from '@playcraft/common/cloud-workspace/runtime';
 const PROBE_TIMEOUT_MS = 4_000;
+// Issuance performs current authority reads and signing, rather than an endpoint echo.
+const CREDENTIAL_TIMEOUT_MS = 10_000;
 const CACHE_MS = 15_000;
 const CREDENTIAL_RENEW_BEFORE_MS = 30_000;
 const MAX_RESPONSE_BYTES = 16 * 1024;
@@ -59,7 +61,7 @@ async function responseJson(response) {
     }
 }
 async function requestProbe(target, init, credentials = false) {
-    const signal = AbortSignal.timeout(PROBE_TIMEOUT_MS);
+    const signal = AbortSignal.timeout(credentials ? CREDENTIAL_TIMEOUT_MS : PROBE_TIMEOUT_MS);
     try {
         const response = await fetch(target, { ...init, redirect: 'error', signal });
         if (!response.ok) {
@@ -134,6 +136,7 @@ async function modelProxyProbe(config, entry) {
     }
     if (entry.credential && Date.parse(entry.credential.expiresAt) <= Date.now() + CREDENTIAL_RENEW_BEFORE_MS)
         entry.credential = undefined;
+    const reusedCredential = Boolean(entry.credential);
     if (!entry.credential) {
         const response = await requestProbe(credentialEndpoint, {
             method: 'POST', headers: { authorization: `Bearer ${config.controlToken}`, 'content-type': 'application/json', 'playcraft-env': config.environment },
@@ -152,8 +155,13 @@ async function modelProxyProbe(config, entry) {
     const target = new URL(platformEndpoint(config.publicBaseUrl, modelConnectivityPath(credential.configId)));
     target.searchParams.set('nonce', nonce);
     const result = await requestProbe(target, { method: 'GET', headers: { authorization: `Bearer ${credential.token}`, 'playcraft-env': config.environment } });
-    if (result.state.reason === 'endpoint_rejected')
+    if (result.state.reason === 'endpoint_rejected') {
         entry.credential = undefined;
+        // A restore can invalidate an otherwise unexpired credential. Reissue once for this
+        // read-only echo; a fresh refusal remains a refusal. Model turns are never replayed here.
+        if (reusedCredential)
+            return modelProxyProbe(config, entry);
+    }
     if (result.state.status !== 'ready')
         return result.state;
     return echoMatches(result.body, { service: 'playcraft-model-proxy', ...scope(config), configId: credential.configId, nonce })

package/dist/workspace-runtime/server/dispatch.js

@@ -1241,7 +1241,11 @@ async function releaseManagedWrite(state, writeId, workspaceId) {
     await state.journal.putManagedWrite({ ...lease, stoppedAt: new Date().toISOString() });
     return true;
 }
+const nativeCollectors = new WeakSet();
 export function attachNativeCollector(state) {
+    if (nativeCollectors.has(state))
+        return;
+    nativeCollectors.add(state);
     state.native?.onCollected?.((event) => {
         void ingestCollected(state, event).then(async () => {
             if (event.kind !== 'notification' || !event.method)

package/dist/workspace-runtime/server/http.js

@@ -25,6 +25,7 @@ import { loadWorkspaceSkillArtifact } from '../workspaces/skill-artifact-loader.
 import { join } from 'node:path';
 import { terminalHost } from './terminal-host.js';
 import { productionCapability, productionDirectoryBusy, executeSandboxProduction, sandboxProductionReceipt } from '../production/controller.js';
+import { dispatchBatchRoute } from '../batch/routes.js';
 import { cleanupWorkspaceDirectories, syncWorkspaceDirectories } from '../workspaces/directory-maintenance.js';
 import { registerWorkspaceDirectory, restoreWorkspaceDirectory } from '../workspaces/directories.js';
 import { readWorkspaceDirectoryStats } from '../workspaces/directory-stats.js';
@@ -50,6 +51,11 @@ export async function handleRuntimeRequest(state, request, response) {
         return;
     }
     try {
+        const batch = await dispatchBatchRoute(state, request, url);
+        if (batch) {
+            writeJson(response, batch.status, batch.body);
+            return;
+        }
         if (request.method === 'GET' && url.pathname === '/runtime/production/capability') {
             writeJson(response, 200, await productionCapability(state));
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/cli",
-  "version": "0.1.43-beta",
+  "version": "0.1.44-beta",
   "private": false,
   "type": "module",
   "engines": {
@@ -51,8 +51,8 @@
     "@gltf-transform/core": "^4.3.0",
     "@gltf-transform/extensions": "^4.3.0",
     "@gltf-transform/functions": "^4.3.0",
-    "@playcraft/build": "^0.1.43-beta",
-    "@playcraft/common": "^0.1.43-beta",
+    "@playcraft/build": "^0.1.44-beta",
+    "@playcraft/common": "^0.1.44-beta",
     "better-sqlite3-pinned": "npm:better-sqlite3@13.0.3",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",