gestalt-mobile 0.20.1 → 0.22.0

package/dist/server/server/platform/codex/rollout-execution-policy.js

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { createReadStream } from 'node:fs';
+import { isAbsolute } from 'node:path';
+import { createInterface } from 'node:readline';
+import { createSessionExecutionPolicy, } from '../../features/sessions/model/relay-session.js';
+/** Reads policy metadata only; prompts and model output are never retained or logged. */
+export async function readRolloutExecutionPolicy(rolloutPath) {
+    if (!isAbsolute(rolloutPath))
+        return undefined;
+    let gestaltOrigin = false;
+    let first;
+    let last;
+    try {
+        const lines = createInterface({
+            input: createReadStream(rolloutPath, { encoding: 'utf8' }),
+            crlfDelay: Infinity,
+        });
+        for await (const line of lines) {
+            let record;
+            try {
+                record = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!record || typeof record !== 'object')
+                continue;
+            const { type, payload } = record;
+            if (!payload || typeof payload !== 'object')
+                continue;
+            if (type === 'session_meta') {
+                gestaltOrigin = payload.originator === 'gestalt-mobile';
+                continue;
+            }
+            if (type !== 'turn_context')
+                continue;
+            const policy = decodeExecutionPolicy(payload);
+            if (!policy)
+                continue;
+            first ??= policy;
+            last = policy;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    // Gestalt does not mutate policy after thread creation. Its first context is
+    // therefore authoritative and cannot be contaminated by an earlier bad import.
+    return gestaltOrigin ? first : last;
+}
+function decodeExecutionPolicy(payload) {
+    const sandboxPolicy = payload.sandbox_policy;
+    const sandbox = sandboxPolicy && typeof sandboxPolicy === 'object'
+        ? sandboxPolicy.type
+        : undefined;
+    const approvalPolicy = payload.approval_policy;
+    if (sandbox !== 'read-only' && sandbox !== 'workspace-write' && sandbox !== 'danger-full-access')
+        return undefined;
+    if (approvalPolicy !== 'untrusted' &&
+        approvalPolicy !== 'on-request' &&
+        approvalPolicy !== 'never')
+        return undefined;
+    return createSessionExecutionPolicy({ sandbox, approvalPolicy });
+}

package/dist/server/server/platform/codex/session-runtime.js

@@ -22,11 +22,13 @@ class SessionResource {
     unregister;
     onDisposed;
     disposed = false;
+    explicitShutdown = false;
     pendingRequests = new Map();
     threadId;
     pendingThreadName;
     writtenThreadName;
     capabilities = new Map();
+    spawnedAgentModels = new Map();
     constructor(sessionId, process, planStatusLease, planMeasurementToken, unregister, onDisposed) {
         this.sessionId = sessionId;
         this.process = process;
@@ -50,6 +52,12 @@ class SessionResource {
         this.onDisposed();
         return true;
     }
+    beginExplicitShutdown() {
+        this.explicitShutdown = true;
+    }
+    get exitedUnexpectedly() {
+        return !this.explicitShutdown;
+    }
     get active() {
         return !this.disposed;
     }
@@ -90,14 +98,14 @@ export class CodexSessionRuntime {
     sessions = new Map();
     historyReads = new Map();
     writerAcquisitions = new Map();
-    async start(session, now, settings = {}) {
+    async start(session, now) {
         const resource = await this.createResource(session);
         try {
             await resource.process.rpc.request('initialize', {
                 clientInfo: { name: 'gestalt-mobile', version: '0.1.0' },
                 capabilities: { experimentalApi: true },
             });
-            const startedThreadId = await this.startThread(resource.process, session, settings);
+            const startedThreadId = await this.startThread(resource.process, session);
             resource.threadId = startedThreadId;
             this.sessions.set(session.id, resource);
             await this.writePendingThreadName(session.id);
@@ -111,10 +119,15 @@ export class CodexSessionRuntime {
         }
     }
     stop(sessionId) {
-        this.sessions.get(sessionId)?.dispose();
+        const resource = this.sessions.get(sessionId);
+        resource?.beginExplicitShutdown();
+        resource?.dispose();
     }
     async release(sessionId) {
         const resource = this.sessions.get(sessionId);
+        // Mark intent before the await below: a process-exit callback can race the
+        // unsubscribe response, but it must not turn an explicit close into recovery.
+        resource?.beginExplicitShutdown();
         if (resource?.threadId) {
             try {
                 await resource.process.rpc.request('thread/unsubscribe', { threadId: resource.threadId });
@@ -127,7 +140,12 @@ export class CodexSessionRuntime {
     }
     /** Releases all relay-owned app-server children during graceful shutdown. */
     stopAll() {
-        for (const resource of [...this.sessions.values()])
+        // Exit delivery can already be queued when shutdown begins. Declare the
+        // shared intent for every owner before closing any process.
+        const resources = [...this.sessions.values()];
+        for (const resource of resources)
+            resource.beginExplicitShutdown();
+        for (const resource of resources)
             resource.dispose();
     }
     /** Keeps a detached session's supervised-plan status observable without launching Codex. */
@@ -236,7 +254,7 @@ export class CodexSessionRuntime {
             throw new Error('CODEX_THREAD_ID_MISSING');
         const owned = this.sessions.get(session.id);
         if (owned)
-            return this.decodeHistory(owned.process, session.threadId);
+            return this.decodeHistory(owned.process, session.threadId, owned);
         const existing = this.historyReads.get(session.id);
         if (existing)
             return existing;
@@ -294,6 +312,9 @@ export class CodexSessionRuntime {
                         ...(typeof value.agentRole === 'string' && value.agentRole.length <= 128
                             ? { role: value.agentRole }
                             : {}),
+                        ...(owned.spawnedAgentModels.get(value.id)
+                            ? { model: owned.spawnedAgentModels.get(value.id) }
+                            : {}),
                     },
                 ];
             }));
@@ -329,8 +350,14 @@ export class CodexSessionRuntime {
             process.close();
         }
     }
-    async decodeHistory(process, threadId) {
-        const result = decodeThreadRead(await process.rpc.request('thread/read', { threadId, includeTurns: true }));
+    async decodeHistory(process, threadId, resource) {
+        const response = await process.rpc.request('thread/read', { threadId, includeTurns: true });
+        if (resource) {
+            resource.spawnedAgentModels.clear();
+            for (const [childId, model] of decodeSpawnedAgentModels(response))
+                resource.spawnedAgentModels.set(childId, model);
+        }
+        const result = decodeThreadRead(response);
         const rawTurns = result;
         const activeTurn = rawTurns.find((turn) => turn.status === 'inProgress' && typeof turn.id === 'string');
         return {
@@ -360,6 +387,10 @@ export class CodexSessionRuntime {
                 await resource.process.rpc.request('thread/resume', {
                     threadId: session.threadId,
                     cwd: session.workspacePath,
+                    ...(session.executionPolicy?.approvalPolicy
+                        ? { approvalPolicy: session.executionPolicy.approvalPolicy }
+                        : {}),
+                    ...(session.executionPolicy?.sandbox ? { sandbox: session.executionPolicy.sandbox } : {}),
                     dynamicTools: [gestaltQuizDynamicTool, gestaltOrgPlanAttentionDynamicTool],
                 });
                 result = {
@@ -371,9 +402,7 @@ export class CodexSessionRuntime {
             catch (error) {
                 if (!canRebindMissingRollout(session, error))
                     throw error;
-                const replacementThreadId = await this.startThread(resource.process, session, {
-                    model: session.model,
-                });
+                const replacementThreadId = await this.startThread(resource.process, session);
                 result = rebindMissingRollout(session, error, replacementThreadId, now);
             }
             resource.threadId = result.session.threadId;
@@ -432,16 +461,16 @@ export class CodexSessionRuntime {
             resource.pendingRequests.set(requestId, { resolve, reject });
         });
     }
-    async startThread(process, session, settings = {}) {
-        return decodeThreadStart(await process.rpc.request('thread/start', this.threadStartParams(session, settings)));
+    async startThread(process, session) {
+        return decodeThreadStart(await process.rpc.request('thread/start', this.threadStartParams(session)));
     }
-    threadStartParams(session, settings) {
+    threadStartParams(session) {
         return {
             cwd: session.workspacePath,
-            approvalPolicy: settings.approvalPolicy ?? 'on-request',
+            approvalPolicy: session.executionPolicy?.approvalPolicy ?? 'on-request',
             dynamicTools: [gestaltQuizDynamicTool, gestaltOrgPlanAttentionDynamicTool],
-            ...(settings.model ? { model: settings.model } : {}),
-            ...(settings.sandbox ? { sandbox: settings.sandbox } : {}),
+            ...(session.model ? { model: session.model } : {}),
+            ...(session.executionPolicy?.sandbox ? { sandbox: session.executionPolicy.sandbox } : {}),
         };
     }
     async createResource(session) {
@@ -477,7 +506,7 @@ export class CodexSessionRuntime {
             // Own process exit before resume/initialization can make this resource appear healthy.
             // A short-lived child could otherwise leave a durable ready session without a writer.
             const exitUnsubscribe = process.onExit?.(() => {
-                if (resource.dispose())
+                if (resource.dispose() && resource.exitedUnexpectedly)
                     this.onProcessExit?.(session.id);
             }) ?? (() => { });
             resource.attach([exitUnsubscribe]);
@@ -666,6 +695,36 @@ function decodeHistoryItem(value) {
     }
     return [];
 }
+/** Recovers optional spawn metadata without exposing collaboration prompts to chat history. */
+function decodeSpawnedAgentModels(value) {
+    const models = new Map();
+    const turns = asRecord(asRecord(value)?.thread)?.turns;
+    if (!Array.isArray(turns) || turns.length > 10_000)
+        return models;
+    for (const turn of turns) {
+        const items = asRecord(turn)?.items;
+        if (!Array.isArray(items) || items.length > 10_000)
+            continue;
+        for (const candidate of items) {
+            const item = asRecord(candidate);
+            const model = boundedString(item?.model, 256);
+            if (item?.type !== 'collabAgentToolCall' ||
+                (item.tool !== 'spawnAgent' && item.tool !== 'spawn_agent') ||
+                !model ||
+                !Array.isArray(item.receiverThreadIds) ||
+                item.receiverThreadIds.length > 64)
+                continue;
+            for (const receiver of item.receiverThreadIds) {
+                const childId = boundedString(receiver, 256);
+                if (childId)
+                    models.set(childId, model);
+                if (models.size >= 64)
+                    return models;
+            }
+        }
+    }
+    return models;
+}
 function decodeUserMessageContent(value) {
     if (!Array.isArray(value) || value.length > 1_000)
         return [];