@playcraft/cli 0.1.71 → 0.1.73

package/dist/workspace-runtime/codex/remix-references-broker.js

@@ -5,16 +5,30 @@ import { PLATFORM_ROUTES, platformEndpoint, WORKSPACE_REMIX_REFERENCE_BODY_MAX_B
 import { withDirectoryWrite } from '../server/directory-access.js';
 import { wakeSourceEventUploader } from '../server/source-uploader.js';
 import { workspaceContextFromRoot } from '../workspaces/registry.js';
-import { importWorkspaceRemixReference, listWorkspaceRemixReferences } from '../workspaces/remix-references.js';
+import { importWorkspaceRemixReference, listWorkspaceRemixReferences, } from '../workspaces/remix-references.js';
 import { shareWorkspaceGit } from '../workspaces/shared-git.js';
+import { prepareStarterTemplate } from '../workspaces/starter-template.js';
 import { batchDirectoryHeld } from '../batch/occupancy.js';
 import { verifyLauncherOrigin } from './launcher-client.js';
-import { localRemixReference, RemixReferenceToolError, remixReferenceToolRequestSchema } from '../../references/protocol.js';
+import { localRemixReference, RemixReferenceToolError, remixReferenceToolRequestSchema, } from '../../references/protocol.js';
 const ACTIVE = new Set(['dispatched', 'accepted', 'uncertain']);
-const candidatesSchema = z.object({ items: z.array(z.unknown()).max(50),
-    total: z.number().int().nonnegative(), page: z.number().int().positive(), pageSize: z.number().int().positive() }).strict();
-const SOURCE_ERRORS = new Set(['remix_reference_unavailable', 'remix_reference_too_large', 'remix_reference_incomplete',
-    'remix_reference_unsupported', 'remix_reference_source_changed', 'workspace_access_denied', 'workspace_permission_denied']);
+const candidatesSchema = z
+    .object({
+    items: z.array(z.unknown()).max(50),
+    total: z.number().int().nonnegative(),
+    page: z.number().int().positive(),
+    pageSize: z.number().int().positive(),
+})
+    .strict();
+const SOURCE_ERRORS = new Set([
+    'remix_reference_unavailable',
+    'remix_reference_too_large',
+    'remix_reference_incomplete',
+    'remix_reference_unsupported',
+    'remix_reference_source_changed',
+    'workspace_access_denied',
+    'workspace_permission_denied',
+]);
 /** Executes source-reference operations only for the shell and native turn owning this route. */
 export class WorkspaceRemixReferencesBroker {
     state;
@@ -24,27 +38,53 @@ export class WorkspaceRemixReferencesBroker {
     operation(context, valid, write = false) {
         const state = this.state;
         const session = state.journal.getSession(context.sessionId);
-        const operations = state.journal.listOperations().map(item => item.operation).filter(operation => ['session.turn', 'session.review', 'session.compact'].includes(operation.kind)
-            && ACTIVE.has(operation.status) && operation.generation === state.config.generation && operation.runtimeEpoch === state.runtimeEpoch);
+        const operations = state.journal
+            .listOperations()
+            .map((item) => item.operation)
+            .filter((operation) => ['session.turn', 'session.review', 'session.compact'].includes(operation.kind) &&
+            ACTIVE.has(operation.status) &&
+            operation.generation === state.config.generation &&
+            operation.runtimeEpoch === state.runtimeEpoch);
         const operation = operations.length === 1 ? operations[0] : undefined;
-        if (!valid() || context.refsBlocked || state.journal.destroyed() || !operation || operation.kind !== 'session.turn' || operation.sessionId !== context.sessionId
-            || operation.generation !== state.config.generation || operation.runtimeEpoch !== state.runtimeEpoch
-            || operation.clientRequestId !== context.clientRequestId || !operation.workspaceId || !operation.directoryName
-            || operation.directoryName === 'root' || !operation.nativeThreadId || !operation.nativeTurnId
-            || !session || session.threadId !== operation.nativeThreadId || session.activeTurnId !== operation.nativeTurnId
-            || session.cwd !== context.cwd || session.workspaceId !== operation.workspaceId
-            || (session.directoryName ?? 'basic') !== operation.directoryName || session.turnBlock === 'uncertain'
-            || !['running', 'waiting_for_user'].includes(session.turnStatus ?? ''))
+        if (!valid() ||
+            context.refsBlocked ||
+            state.journal.destroyed() ||
+            !operation ||
+            operation.kind !== 'session.turn' ||
+            operation.sessionId !== context.sessionId ||
+            operation.generation !== state.config.generation ||
+            operation.runtimeEpoch !== state.runtimeEpoch ||
+            operation.clientRequestId !== context.clientRequestId ||
+            !operation.workspaceId ||
+            !operation.directoryName ||
+            operation.directoryName === 'root' ||
+            !operation.nativeThreadId ||
+            !operation.nativeTurnId ||
+            !session ||
+            session.threadId !== operation.nativeThreadId ||
+            session.activeTurnId !== operation.nativeTurnId ||
+            session.cwd !== context.cwd ||
+            session.workspaceId !== operation.workspaceId ||
+            (session.directoryName ?? 'basic') !== operation.directoryName ||
+            session.turnBlock === 'uncertain' ||
+            !['running', 'waiting_for_user'].includes(session.turnStatus ?? ''))
             throw new RemixReferenceToolError('remix_reference_turn_unavailable');
         if (write) {
             if ((operation.leaseFence ?? 0) < state.acceptedLeaseFence)
                 throw new RemixReferenceToolError('remix_reference_turn_unavailable');
-            if (context.readOnly || operation.workMode === 'plan' || operation.permissionMode === 'read-only' || session.permissionMode === 'read-only')
+            if (context.readOnly ||
+                operation.workMode === 'plan' ||
+                operation.permissionMode === 'read-only' ||
+                session.permissionMode === 'read-only')
                 throw new RemixReferenceToolError('remix_reference_readonly');
-            if (state.journal.listSessions().some(other => other.sessionId !== context.sessionId
-                && other.workspaceId === operation.workspaceId
-                && ((other.directoryName ?? 'basic') === operation.directoryName || other.directoryName === 'root')
-                && (other.turnBlock === 'uncertain' || ['starting', 'running', 'waiting_for_user'].includes(other.turnStatus ?? ''))))
+            if (state.journal
+                .listSessions()
+                .some((other) => other.sessionId !== context.sessionId &&
+                other.workspaceId === operation.workspaceId &&
+                ((other.directoryName ?? 'basic') === operation.directoryName ||
+                    other.directoryName === 'root') &&
+                (other.turnBlock === 'uncertain' ||
+                    ['starting', 'running', 'waiting_for_user'].includes(other.turnStatus ?? ''))))
                 throw new RemixReferenceToolError('turn_already_active');
         }
         return operation;
@@ -52,16 +92,20 @@ export class WorkspaceRemixReferencesBroker {
     async current(context, valid, write = false) {
         const operation = this.operation(context, valid, write);
         const scope = await workspaceContextFromRoot(this.state, context.cwd);
-        if (scope.workspaceId !== operation.workspaceId || scope.directoryName !== operation.directoryName)
+        if (scope.workspaceId !== operation.workspaceId ||
+            scope.directoryName !== operation.directoryName)
             throw new RemixReferenceToolError('remix_reference_scope_mismatch');
-        if (write && await batchDirectoryHeld(this.state, scope.workspaceId, scope.directoryName))
+        if (write && (await batchDirectoryHeld(this.state, scope.workspaceId, scope.directoryName)))
             throw new RemixReferenceToolError('batch_workspace_readonly');
         this.operation(context, valid, write);
         return { ...scope, operation };
     }
     async forward(request, response, context, valid) {
         const reply = (status, value) => {
-            response.writeHead(status, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+            response.writeHead(status, {
+                'content-type': 'application/json',
+                'cache-control': 'no-store',
+            });
             response.end(JSON.stringify(value));
         };
         try {
@@ -77,41 +121,87 @@ export class WorkspaceRemixReferencesBroker {
             if (!parsed.success)
                 throw new RemixReferenceToolError('invalid_remix_reference_tool_request');
             const input = parsed.data;
-            const write = input.action === 'import';
+            const write = input.action === 'import' || input.action === 'prepare-starter-template';
             const scope = await this.current(context, valid, write);
             const callerCwd = await realpath(input.cwd);
             const childPath = relative(context.cwd, callerCwd);
-            if (isAbsolute(childPath) || childPath === '..' || childPath.startsWith('../') || input.workspaceId !== undefined && input.workspaceId !== scope.workspaceId
-                || input.directoryName !== undefined && input.directoryName !== scope.directoryName)
+            if (isAbsolute(childPath) ||
+                childPath === '..' ||
+                childPath.startsWith('../') ||
+                (input.workspaceId !== undefined && input.workspaceId !== scope.workspaceId) ||
+                (input.directoryName !== undefined && input.directoryName !== scope.directoryName))
                 throw new RemixReferenceToolError('remix_reference_scope_mismatch');
             const socketPath = process.env.PLAYCRAFT_LAUNCHER_SOCKET;
-            if (!socketPath || !context.boundaryId || !request.socket.localPort || !request.socket.remotePort
-                || !await verifyLauncherOrigin({ socketPath, boundaryId: context.boundaryId, runtimeEpoch: this.state.runtimeEpoch,
-                    serverPort: request.socket.localPort, clientPort: request.socket.remotePort, cwd: context.originCwd ?? callerCwd }))
+            if (!socketPath ||
+                !context.boundaryId ||
+                !request.socket.localPort ||
+                !request.socket.remotePort ||
+                !(await verifyLauncherOrigin({
+                    socketPath,
+                    boundaryId: context.boundaryId,
+                    runtimeEpoch: this.state.runtimeEpoch,
+                    serverPort: request.socket.localPort,
+                    clientPort: request.socket.remotePort,
+                    cwd: context.originCwd ?? callerCwd,
+                })))
                 throw new RemixReferenceToolError('remix_reference_turn_unavailable');
             await this.current(context, valid, write);
             if (input.action === 'list') {
                 const items = await this.state.journal.exclusive(`workspace:${scope.workspaceId}:${scope.directoryName}`, () => listWorkspaceRemixReferences(context.cwd, scope.directoryName));
                 this.operation(context, valid);
-                return reply(200, { ok: true, workspaceId: scope.workspaceId, directoryName: scope.directoryName,
-                    items: items.map(reference => localRemixReference(context.cwd, reference)) });
+                return reply(200, {
+                    ok: true,
+                    workspaceId: scope.workspaceId,
+                    directoryName: scope.directoryName,
+                    items: items.map((reference) => localRemixReference(context.cwd, reference)),
+                });
             }
             if (input.action === 'search') {
-                const result = candidatesSchema.parse(await this.upstream(scope, { action: 'search', source: input.source,
-                    ...(input.tagCategory === undefined ? {} : { tagCategory: input.tagCategory, tagValues: input.tagValues }),
-                    ...(input.q === undefined ? {} : { q: input.q }), page: input.page, limit: input.limit }, 2 * 1024 * 1024));
+                const result = candidatesSchema.parse(await this.upstream(scope, {
+                    action: 'search',
+                    source: input.source,
+                    ...(input.tagCategory === undefined
+                        ? {}
+                        : { tagCategory: input.tagCategory, tagValues: input.tagValues }),
+                    ...(input.q === undefined ? {} : { q: input.q }),
+                    page: input.page,
+                    limit: input.limit,
+                }, 2 * 1024 * 1024));
                 await this.current(context, valid);
-                return reply(200, { ok: true, workspaceId: scope.workspaceId, directoryName: scope.directoryName, ...result,
-                    items: result.items.map(item => workspaceRemixReferenceCandidateSchema.parse(item)) });
+                return reply(200, {
+                    ok: true,
+                    workspaceId: scope.workspaceId,
+                    directoryName: scope.directoryName,
+                    ...result,
+                    items: result.items.map((item) => workspaceRemixReferenceCandidateSchema.parse(item)),
+                });
+            }
+            if (input.action === 'prepare-starter-template') {
+                const result = await withDirectoryWrite(this.state, {
+                    workspaceId: scope.workspaceId, directoryName: scope.directoryName,
+                    sessionId: context.sessionId, wait: false,
+                }, async () => {
+                    await this.current(context, valid, true);
+                    const raw = await this.upstream(scope, { action: 'starter-template' }, WORKSPACE_REMIX_REFERENCE_BODY_MAX_BYTES);
+                    await this.current(context, valid, true);
+                    return prepareStarterTemplate(context.cwd, raw, () => this.operation(context, valid, true));
+                });
+                return reply(200, { ok: true, workspaceId: scope.workspaceId, directoryName: scope.directoryName, ...result });
             }
-            const result = await withDirectoryWrite(this.state, { workspaceId: scope.workspaceId, directoryName: scope.directoryName,
-                sessionId: context.sessionId, wait: false }, async () => {
+            const result = await withDirectoryWrite(this.state, {
+                workspaceId: scope.workspaceId,
+                directoryName: scope.directoryName,
+                sessionId: context.sessionId,
+                wait: false,
+            }, async () => {
                 await this.current(context, valid, true);
                 const raw = await this.upstream(scope, { action: 'export', projectUuid: input.projectUuid, branchName: input.branchName }, WORKSPACE_REMIX_REFERENCE_BODY_MAX_BYTES);
                 await this.current(context, valid, true);
                 const snapshot = workspaceRemixReferenceExportSchema.parse(raw);
-                if (snapshot.source.environment !== this.state.config.environment || snapshot.source.projectUuid !== input.projectUuid
-                    || snapshot.source.branchName !== input.branchName)
+                if (snapshot.source.environment !== this.state.config.environment ||
+                    !('projectUuid' in snapshot.source) ||
+                    snapshot.source.projectUuid !== input.projectUuid ||
+                    snapshot.source.branchName !== input.branchName)
                     throw new RemixReferenceToolError('remix_reference_unavailable');
                 return this.state.journal.exclusive(`workspace:${scope.workspaceId}:${scope.directoryName}`, async () => {
                     await this.current(context, valid, true);
@@ -121,45 +211,91 @@ export class WorkspaceRemixReferencesBroker {
                         this.operation(context, valid, true);
                     });
                     this.operation(context, valid, true);
-                    await this.state.journal.allocateSourceEvent({ runtimeId: this.state.config.runtimeId,
-                        generation: this.state.config.generation, runtimeEpoch: this.state.runtimeEpoch,
-                        type: 'workspace.references.imported', occurredAt: new Date().toISOString(),
-                        sessionId: context.sessionId, workspaceId: scope.workspaceId, operationId: scope.operation.operationId,
-                        payload: { sessionId: context.sessionId, workspaceId: scope.workspaceId, directoryName: scope.directoryName,
-                            referenceId: reference.referenceId, path: reference.path, contentHash: reference.contentHash } });
-                    await this.state.journal.allocateSourceEvent({ runtimeId: this.state.config.runtimeId,
-                        generation: this.state.config.generation, runtimeEpoch: this.state.runtimeEpoch,
-                        type: 'files.changed', occurredAt: new Date().toISOString(), sessionId: context.sessionId,
-                        workspaceId: scope.workspaceId, operationId: scope.operation.operationId,
-                        payload: { workspaceId: scope.workspaceId, directoryName: scope.directoryName,
-                            paths: [reference.path, WORKSPACE_REMIX_REFERENCES_MANIFEST], source: 'workspace.references.import',
-                            operationId: scope.operation.operationId } });
+                    await this.state.journal.allocateSourceEvent({
+                        runtimeId: this.state.config.runtimeId,
+                        generation: this.state.config.generation,
+                        runtimeEpoch: this.state.runtimeEpoch,
+                        type: 'workspace.references.imported',
+                        occurredAt: new Date().toISOString(),
+                        sessionId: context.sessionId,
+                        workspaceId: scope.workspaceId,
+                        operationId: scope.operation.operationId,
+                        payload: {
+                            sessionId: context.sessionId,
+                            workspaceId: scope.workspaceId,
+                            directoryName: scope.directoryName,
+                            referenceId: reference.referenceId,
+                            path: reference.path,
+                            contentHash: reference.contentHash,
+                        },
+                    });
+                    await this.state.journal.allocateSourceEvent({
+                        runtimeId: this.state.config.runtimeId,
+                        generation: this.state.config.generation,
+                        runtimeEpoch: this.state.runtimeEpoch,
+                        type: 'files.changed',
+                        occurredAt: new Date().toISOString(),
+                        sessionId: context.sessionId,
+                        workspaceId: scope.workspaceId,
+                        operationId: scope.operation.operationId,
+                        payload: {
+                            workspaceId: scope.workspaceId,
+                            directoryName: scope.directoryName,
+                            paths: [reference.path, WORKSPACE_REMIX_REFERENCES_MANIFEST],
+                            source: 'workspace.references.import',
+                            operationId: scope.operation.operationId,
+                        },
+                    });
                     wakeSourceEventUploader(this.state);
                     return reference;
                 });
             });
-            return reply(200, { ok: true, workspaceId: scope.workspaceId, directoryName: scope.directoryName,
-                reference: localRemixReference(context.cwd, result) });
+            return reply(200, {
+                ok: true,
+                workspaceId: scope.workspaceId,
+                directoryName: scope.directoryName,
+                reference: localRemixReference(context.cwd, result),
+            });
         }
         catch (error) {
             if (response.headersSent) {
                 response.destroy();
                 return;
             }
-            const code = error instanceof SyntaxError ? 'invalid_remix_reference_tool_request' : error instanceof RemixReferenceToolError ? error.code
-                : error instanceof Error && /^(?:remix_reference_[a-z_]+|directory_busy)$/.test(error.message)
-                    ? error.message : 'remix_reference_tool_failed';
-            reply(code === 'invalid_remix_reference_tool_request' ? 400
-                : ['turn_already_active', 'batch_workspace_readonly', 'directory_busy'].includes(code) ? 409 : 403, { ok: false, error: { code } });
+            const code = error instanceof SyntaxError
+                ? 'invalid_remix_reference_tool_request'
+                : error instanceof RemixReferenceToolError
+                    ? error.code
+                    : error instanceof Error &&
+                        /^(?:remix_reference_[a-z_]+|directory_busy)$/.test(error.message)
+                        ? error.message
+                        : 'remix_reference_tool_failed';
+            reply(code === 'invalid_remix_reference_tool_request'
+                ? 400
+                : ['turn_already_active', 'batch_workspace_readonly', 'directory_busy'].includes(code)
+                    ? 409
+                    : 403, { ok: false, error: { code } });
         }
     }
     async upstream(scope, input, limit) {
         const config = this.state.config;
         const response = await fetch(platformEndpoint(config.publicBaseUrl, PLATFORM_ROUTES.remixReferenceTools), {
-            method: 'POST', redirect: 'error', signal: AbortSignal.timeout(120_000),
-            headers: { authorization: `Bearer ${config.controlToken}`, 'content-type': 'application/json', 'playcraft-env': config.environment },
-            body: JSON.stringify({ runtimeId: config.runtimeId, generation: config.generation, runtimeEpoch: this.state.runtimeEpoch,
-                workspaceId: scope.workspaceId, directoryName: scope.directoryName, ...input }),
+            method: 'POST',
+            redirect: 'error',
+            signal: AbortSignal.timeout(120_000),
+            headers: {
+                authorization: `Bearer ${config.controlToken}`,
+                'content-type': 'application/json',
+                'playcraft-env': config.environment,
+            },
+            body: JSON.stringify({
+                runtimeId: config.runtimeId,
+                generation: config.generation,
+                runtimeEpoch: this.state.runtimeEpoch,
+                workspaceId: scope.workspaceId,
+                directoryName: scope.directoryName,
+                ...input,
+            }),
         });
         const chunks = [];
         let bytes = 0;
@@ -175,8 +311,13 @@ export class WorkspaceRemixReferencesBroker {
         }
         const value = JSON.parse(Buffer.concat(chunks).toString('utf8'));
         if (!response.ok) {
-            const code = [value?.reason, value?.code, value?.message, value?.error?.reason, value?.error?.code]
-                .find(code => typeof code === 'string' && SOURCE_ERRORS.has(code));
+            const code = [
+                value?.reason,
+                value?.code,
+                value?.message,
+                value?.error?.reason,
+                value?.error?.code,
+            ].find((code) => typeof code === 'string' && SOURCE_ERRORS.has(code));
             throw new RemixReferenceToolError(code ?? 'remix_reference_unavailable');
         }
         return value;

package/dist/workspace-runtime/persistence/journal.js

@@ -109,6 +109,9 @@ export class RuntimeJournal {
     getWorkspace(workspaceId) {
         return this.snapshot.workspaces[workspaceId];
     }
+    listWorkspaces() {
+        return Object.values(this.snapshot.workspaces);
+    }
     async putWorkspace(binding) {
         const parsed = workspaceRegistrationSchema.parse(binding);
         await this.run('upsertRecord', { bucket: 'workspaces', key: parsed.workspaceId, body: parsed });

package/dist/workspace-runtime/serve.js

@@ -33,7 +33,7 @@ import { revisionScope } from './workspaces/registry.js';
 import { observeWorkspaceArtifacts } from './workspaces/artifact-events.js';
 import { loadWorkspaceMcpConfig } from './codex/mcp-config.js';
 import { startSourceEventUploader, stopSourceEventUploader } from './server/source-uploader.js';
-import { platformExportTarget, readPlatformExport, startPlatformExport } from './workspaces/platform-export.js';
+import { platformExportTarget, readPlatformExport, startPlatformExport, syncWorkspaceBindings } from './workspaces/platform-export.js';
 import { scheduledTaskProposalHandler } from './workspaces/scheduled-task-proposals.js';
 import { executionContextToolHandler } from './workspaces/execution-context.js';
 import { registerLevelEditorRequest, startLevelEditorRequestQueue, stopLevelEditorRequestQueue } from './workspaces/level-editor-requests.js';
@@ -352,6 +352,8 @@ export async function startWorkspaceRuntime(config, options = {}) {
         const port = await listenOn(server, config.listen.host, config.listen.port);
         startLevelEditorRequestQueue(state);
         startSkillActivationRequestQueue(state);
+        // After listening: the platform registers a missed binding through this server before it replies.
+        void syncWorkspaceBindings(state);
         return {
             config: state.config,
             state,

package/dist/workspace-runtime/server/directory-access.js

@@ -1,6 +1,7 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { randomUUID } from 'node:crypto';
 import { isTurnControl, takesWorkspaceDirectory, takesExecutionSlot, transitionOperation, } from '@playcraft/common/cloud-workspace/runtime';
+import { batchDirectoryHeld } from '../batch/occupancy.js';
 import { listMembers, readSnapshot } from '../batch/records.js';
 const context = new AsyncLocalStorage();
 const gates = new WeakMap();
@@ -481,6 +482,15 @@ export function releaseBatchDirectory(state, member) {
     if (!member.holding && member.writersStopped)
         instances.get(state)?.release(`run:${member.runId}`);
 }
+/**
+ * A lease rejection names its cause so callers can tell a running batch member apart from ordinary
+ * directory contention: the former is a production lock, not a failure. A damaged member record
+ * must not replace the rejection with a failed response.
+ */
+export async function directoryBusyCode(state, workspaceId, directoryName = 'basic') {
+    const held = await batchDirectoryHeld(state, workspaceId, directoryName).catch(() => false);
+    return held ? 'batch_workspace_readonly' : 'directory_busy';
+}
 export async function withDirectoryFreeze(state, scope, action, quiesce, options) {
     const pending = freezing.get(state) ??
         new Map();