npm - gestalt-mobile - Versions diffs - 0.16.2 → 0.16.4 - Mend

gestalt-mobile 0.16.2 → 0.16.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

package/dist/client/index.html CHANGED Viewed

@@ -16,8 +16,8 @@ SPDX-License-Identifier: AGPL-3.0-or-later
     <link rel="icon" href="/icons/gestalt-mobile-192.png" />
     <link rel="apple-touch-icon" href="/icons/gestalt-mobile-180.png" />
     <title>Gestalt Mobile</title>
-    <script type="module" crossorigin src="/assets/index-DT1VwqSF.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BotpWcLh.css">
+    <script type="module" crossorigin src="/assets/index-bKzoif3G.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-D9v-aHYI.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/server/server/composition.js CHANGED Viewed

@@ -162,7 +162,7 @@ export async function composeRelayApp(options) {
                 }
                 events.publish(journal.append(sessionId, 'plan.updated', { plan: update.plan, reason: update.reason }, occurredAt));
             }
-        }, options.planMeasurementBaseUrl)
+        }, options.planMeasurementBaseUrl, 30_000, 64, root)
         : null;
     if (runtime && planMeasurementHelperPath) {
         planMeasurementRefresh = new PlanMeasurementRefresh(async (sessionId) => {
@@ -189,7 +189,14 @@ export async function composeRelayApp(options) {
             if (session)
                 saveSession(RelaySession.rehydrate(session).requireAttention(new Date().toISOString()).snapshot);
         });
-        recoverExitedSession = (sessionId) => supervisor.recover(sessionId);
+        // An exited child has released our writer.  Do not repeatedly resume a
+        // durable thread: another Codex client may acquire it between callbacks.
+        recoverExitedSession = (sessionId) => {
+            supervisor.cancel(sessionId);
+            const session = sessions.find(sessionId);
+            if (session)
+                saveSession(RelaySession.rehydrate(session).stop(new Date().toISOString()).snapshot);
+        };
     }
     let authorization;
     if (passkeyAuthEnabled) {
@@ -283,8 +290,12 @@ export async function composeRelayApp(options) {
                     ? async (session, settings) => runtime.start(session, new Date().toISOString(), settings)
                     : undefined,
                 startTurn: runtime
-                    ? async (session, text) => runtime.startTurn(session, text, new Date().toISOString())
+                    ? async (session, text, clientUserMessageId) => runtime.startTurn(session, text, clientUserMessageId, new Date().toISOString())
+                    : undefined,
+                ensureWriter: runtime
+                    ? (session) => runtime.ensureWriter(session, new Date().toISOString())
                     : undefined,
+                releaseWriter: runtime ? (id) => runtime.release(id) : undefined,
                 onTurnStarted: (session) => planMeasurementRefresh?.refreshNow(session.id),
                 models,
                 readHistory: runtime ? (session) => runtime.readHistory(session) : undefined,
@@ -301,7 +312,7 @@ export async function composeRelayApp(options) {
                         now: () => new Date().toISOString(),
                         list: () => sessions.list(),
                         save: saveSession,
-                        restore: (session) => runtime.restore(session, new Date().toISOString()),
+                        read: (session) => runtime.readHistory(session),
                     })
                     : undefined,
                 release: (session) => RelaySession.rehydrate(session).release(new Date().toISOString()).snapshot,
@@ -402,25 +413,18 @@ export async function composeRelayApp(options) {
         database.close();
         throw error;
     }
-    const restoreActiveSessions = async () => {
-        if (!runtime)
-            return;
-        await mapWithConcurrency(sessions
-            .list()
-            .filter((session) => session.desiredState === 'active' && session.threadId !== null), 2, async (session) => {
-            try {
-                saveSession(await runtime.restore(session, new Date().toISOString()));
-            }
-            catch {
-                saveSession(RelaySession.rehydrate(session).requireAttention(new Date().toISOString()).snapshot);
-            }
+    const detachActiveSessions = async () => {
+        await mapWithConcurrency(sessions.list().filter((session) => session.threadId !== null), 2, async (session) => {
+            if (session.desiredState === 'active')
+                saveSession(RelaySession.rehydrate(session).stop(new Date().toISOString()).snapshot);
+            await runtime?.watchPlanStatus(session);
         });
     };
     app.addHook('onListen', async () => {
         const profile = (await options.profiles.list()).find((item) => item.state === 'ok')?.name;
         if (profile)
             await editorSkillCatalog.refresh(profile, root);
-        await restoreActiveSessions();
+        await detachActiveSessions();
     });
     app.addHook('onClose', async () => {
         planMeasurementRefresh?.stopAll();

package/dist/server/server/features/sessions/application/writer-acquisition.js ADDED Viewed

@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export class WriterAcquisitionError extends Error {
+    kind;
+    constructor(kind) {
+        super(kind);
+        this.kind = kind;
+        this.name = 'WriterAcquisitionError';
+    }
+}
+export function writerAcquisitionProblem(kind) {
+    switch (kind) {
+        case 'writerBusy':
+            return {
+                status: 409,
+                code: 'SESSION_WRITER_BUSY',
+                retryable: true,
+                detail: 'This thread is active in another Codex client. Release it there, then retry.',
+            };
+        case 'rolloutMissing':
+            return {
+                status: 409,
+                code: 'SESSION_ROLLOUT_MISSING',
+                retryable: false,
+                detail: 'This stored thread is no longer available.',
+            };
+        case 'workspaceUnavailable':
+            return {
+                status: 409,
+                code: 'SESSION_WORKSPACE_UNAVAILABLE',
+                retryable: true,
+                detail: 'The session workspace is unavailable.',
+            };
+        case 'runtimeDependencyFailed':
+            return {
+                status: 502,
+                code: 'SESSION_RUNTIME_DEPENDENCY_FAILED',
+                retryable: true,
+                detail: 'A required Codex runtime dependency is unavailable.',
+            };
+        case 'protocolIncompatible':
+            return {
+                status: 503,
+                code: 'CODEX_PROTOCOL_INCOMPATIBLE',
+                retryable: false,
+                detail: 'The installed Codex runtime is incompatible with this relay.',
+            };
+        case 'runtimeUnavailable':
+            return {
+                status: 503,
+                code: 'SESSION_RUNTIME_UNAVAILABLE',
+                retryable: true,
+                detail: 'The Codex runtime is unavailable. Retry shortly.',
+            };
+    }
+}

package/dist/server/server/features/sessions/get-history/history-mapper.js CHANGED Viewed

@@ -34,7 +34,16 @@ function toChatItem(item, timestamp, turnId) {
                         .join('\n')
                     : '';
                 return text
-                    ? [{ id, kind: 'user', text, ...owner, ...(timestamp ? { occurredAt: timestamp } : {}) }]
+                    ? [
+                        {
+                            id,
+                            kind: 'user',
+                            text,
+                            ...owner,
+                            ...(typeof item.clientId === 'string' ? { operationId: item.clientId } : {}),
+                            ...(timestamp !== undefined ? { occurredAt: timestamp } : {}),
+                        },
+                    ]
                     : [];
             }
             case 'agentMessage':
@@ -48,7 +57,7 @@ function toChatItem(item, timestamp, turnId) {
                             ...(item.phase === 'commentary' || item.phase === 'final_answer'
                                 ? { phase: item.phase }
                                 : {}),
-                            ...(timestamp ? { occurredAt: timestamp } : {}),
+                            ...(timestamp !== undefined ? { occurredAt: timestamp } : {}),
                         },
                     ]
                     : [];
@@ -56,10 +65,28 @@ function toChatItem(item, timestamp, turnId) {
                 if (!Array.isArray(item.summary))
                     return [];
                 const summary = reasoningSummary(item.summary);
-                return summary.length ? [{ id, kind: 'reasoning', summary, ...owner }] : [];
+                return summary.length
+                    ? [
+                        {
+                            id,
+                            kind: 'reasoning',
+                            summary,
+                            ...owner,
+                            ...(timestamp !== undefined ? { occurredAt: timestamp } : {}),
+                        },
+                    ]
+                    : [];
             case 'plan':
                 return typeof item.text === 'string'
-                    ? [{ id, kind: 'plan', text: item.text, ...owner }]
+                    ? [
+                        {
+                            id,
+                            kind: 'plan',
+                            text: item.text,
+                            ...owner,
+                            ...(timestamp !== undefined ? { occurredAt: timestamp } : {}),
+                        },
+                    ]
                     : [];
             case 'commandExecution':
                 return typeof item.command === 'string' && typeof item.status === 'string'
@@ -70,6 +97,7 @@ function toChatItem(item, timestamp, turnId) {
                             command: item.command,
                             status: item.status,
                             ...owner,
+                            ...(timestamp !== undefined ? { occurredAt: timestamp } : {}),
                             ...(typeof item.exitCode === 'number' ? { exitCode: item.exitCode } : {}),
                         },
                     ]
@@ -79,9 +107,32 @@ function toChatItem(item, timestamp, turnId) {
                     return [];
                 const paths = item.changes.flatMap((change) => isRecord(change) && typeof change.path === 'string' ? [change.path] : []);
                 return paths.length
-                    ? [{ id, kind: 'fileChange', paths, status: item.status, ...owner }]
+                    ? [
+                        {
+                            id,
+                            kind: 'fileChange',
+                            paths,
+                            status: item.status,
+                            ...owner,
+                            ...(timestamp !== undefined ? { occurredAt: timestamp } : {}),
+                        },
+                    ]
                     : [];
             }
+            case 'mcpToolCall':
+            case 'dynamicToolCall':
+                return typeof item.tool === 'string' && typeof item.status === 'string'
+                    ? [
+                        {
+                            id,
+                            kind: 'tool',
+                            name: item.tool,
+                            status: item.status,
+                            ...owner,
+                            ...(timestamp !== undefined ? { occurredAt: timestamp } : {}),
+                        },
+                    ]
+                    : [];
             default:
                 return [];
         }

package/dist/server/server/features/sessions/model/relay-session.js CHANGED Viewed

@@ -6,6 +6,14 @@
 import { DomainError } from './errors.js';
 import { createSkillSelection, normalizeSkillProfileName, } from '../../skills/model/skill-profile.js';
 import { interactionId, profileName, sessionId, threadId, turnId, workspaceId, workspacePath, } from './value-objects.js';
+/** A durable thread can be read even when this relay has no live writer. */
+export function isSessionReadable(session) {
+    return session.threadId !== null;
+}
+/** Writer ownership is deliberately transient: only a live relay state implies it. */
+export function relayOwnsWriter(session) {
+    return session.state === 'ready' || session.state === 'turnActive';
+}
 export function createEffectiveSkillSelection(input) {
     return {
         ...(input.selectedProfileName === undefined

package/dist/server/server/features/sessions/promote-recent-thread/endpoint.js CHANGED Viewed

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { z } from 'zod';
+import { RecentThreadHistoryUnavailable } from './use-case.js';
 const requestSchema = z.object({
     threadId: z.string().min(1),
     cwd: z.string().startsWith('/'),
@@ -20,9 +21,14 @@ export function registerPromoteRecentThread(app, deps) {
             return reply.code(202).send(await deps.promote(thread));
         }
         catch (error) {
+            const historyUnavailable = error instanceof RecentThreadHistoryUnavailable;
             return reply.code(409).send({
-                code: 'RECENT_THREAD_OPEN_FAILED',
-                detail: error instanceof Error ? error.message : 'Could not open the recent session.',
+                code: historyUnavailable
+                    ? 'RECENT_THREAD_HISTORY_UNAVAILABLE'
+                    : 'RECENT_THREAD_OPEN_FAILED',
+                detail: historyUnavailable
+                    ? 'The selected thread history is currently unavailable. Retry after Codex is available.'
+                    : 'The selected thread could not be opened. Retry shortly.',
             });
         }
     });

package/dist/server/server/features/sessions/promote-recent-thread/use-case.js CHANGED Viewed

@@ -4,10 +4,38 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { RelaySession } from '../model/relay-session.js';
+export class RecentThreadHistoryUnavailable extends Error {
+    constructor() {
+        super('RECENT_THREAD_HISTORY_UNAVAILABLE');
+    }
+}
+const inFlightPromotions = new Map();
 export async function promoteRecentThread(thread, deps) {
+    const key = `${thread.profile}:${thread.cwd}:${thread.id}`;
+    const ongoing = inFlightPromotions.get(key);
+    if (ongoing)
+        return ongoing;
+    const operation = promote(thread, deps);
+    inFlightPromotions.set(key, operation);
+    try {
+        return await operation;
+    }
+    finally {
+        if (inFlightPromotions.get(key) === operation)
+            inFlightPromotions.delete(key);
+    }
+}
+async function promote(thread, deps) {
     const existing = deps.list().find((session) => session.threadId === thread.id);
-    if (existing?.state === 'ready' || existing?.state === 'turnActive')
+    if (existing) {
+        try {
+            await deps.read(existing);
+        }
+        catch {
+            throw new RecentThreadHistoryUnavailable();
+        }
         return existing;
+    }
     const now = deps.now();
     const imported = existing ??
         RelaySession.fromExistingThread({
@@ -18,9 +46,13 @@ export async function promoteRecentThread(thread, deps) {
             threadId: thread.id,
             now,
         }).snapshot;
-    if (!existing)
-        deps.save(imported);
-    const active = await deps.restore(imported);
-    deps.save(active);
-    return active;
+    // Validate first: an unavailable thread must never leave an imported stub.
+    try {
+        await deps.read(imported);
+    }
+    catch {
+        throw new RecentThreadHistoryUnavailable();
+    }
+    deps.save(imported);
+    return imported;
 }

package/dist/server/server/features/sessions/register-routes.js CHANGED Viewed

@@ -60,6 +60,8 @@ export function registerSessionRoutes(app, deps) {
             registerStartTurn(app, {
                 find: sessions.find,
                 start: sessions.startTurn,
+                ensureWriter: sessions.ensureWriter,
+                releaseWriter: sessions.releaseWriter,
                 save: sessions.save,
                 onStarted: sessions.onTurnStarted,
                 idempotency: sessions.idempotency,

package/dist/server/server/features/sessions/start-turn/endpoint.js CHANGED Viewed

@@ -4,8 +4,11 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 import { createHash } from 'node:crypto';
+import { RelaySession } from '../model/relay-session.js';
+import { WriterAcquisitionError, writerAcquisitionProblem, } from '../application/writer-acquisition.js';
 export function registerStartTurn(app, deps) {
     const inflight = new Map();
+    const sessionOperations = new Map();
     // Durable idempotency results are session-scoped and replay for as long as the
     // store retains them; a reused key with a different prompt is rejected.
     // Text is capped at 100,000 characters; leave room for JSON encoding only.
@@ -16,7 +19,7 @@ export function registerStartTurn(app, deps) {
         const text = request.body.text?.trim() ?? '';
         if (text.length > 100_000)
             return reply.code(400).send({ code: 'TURN_INPUT_TOO_LONG' });
-        if (!text || session.state !== 'ready')
+        if (!text)
             return reply.code(409).send({ code: 'SESSION_NOT_READY' });
         const key = request.headers['idempotency-key'];
         if (typeof key === 'string' && key && deps.idempotency) {
@@ -28,15 +31,31 @@ export function registerStartTurn(app, deps) {
             const inflightKey = `${scope}:${key}`;
             const operation = inflight.get(inflightKey) ??
                 (async () => {
-                    const started = await deps.start(session, text);
-                    deps.save(started);
-                    deps.onStarted?.(started);
-                    const result = {
-                        statusCode: 202,
-                        body: JSON.stringify({ fingerprint, response: started }),
-                    };
-                    deps.idempotency.put(scope, key, result.statusCode, result.body);
-                    return result;
+                    return serializeSession(sessionOperations, session.id, async () => {
+                        const current = deps.find(session.id);
+                        if (!current)
+                            return { statusCode: 404, body: JSON.stringify({ code: 'SESSION_NOT_FOUND' }) };
+                        const durable = deps.idempotency.get(scope, key);
+                        if (durable)
+                            return durable;
+                        if (current.state === 'turnActive')
+                            return { statusCode: 409, body: JSON.stringify({ code: 'SESSION_TURN_ACTIVE' }) };
+                        let started;
+                        try {
+                            started = await startWithWriter(deps, current, text, key);
+                        }
+                        catch (error) {
+                            if (error instanceof StartTurnProblem)
+                                return error.result;
+                            throw error;
+                        }
+                        const result = {
+                            statusCode: 202,
+                            body: JSON.stringify({ fingerprint, response: started }),
+                        };
+                        deps.idempotency.put(scope, key, result.statusCode, result.body);
+                        return result;
+                    });
                 })();
             inflight.set(inflightKey, operation);
             try {
@@ -46,14 +65,113 @@ export function registerStartTurn(app, deps) {
                 inflight.delete(inflightKey);
             }
         }
-        const started = await deps.start(session, text);
+        return serializeSession(sessionOperations, session.id, async () => {
+            const current = deps.find(session.id);
+            if (!current)
+                return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+            if (current.state === 'turnActive')
+                return reply.code(409).send({ code: 'SESSION_TURN_ACTIVE' });
+            try {
+                return reply
+                    .code(202)
+                    .send(await startWithWriter(deps, current, text, typeof key === 'string' ? key : undefined));
+            }
+            catch (error) {
+                if (error instanceof StartTurnProblem)
+                    return reply.code(error.result.statusCode).send(JSON.parse(error.result.body));
+                throw error;
+            }
+        });
+    });
+}
+async function startWithWriter(deps, session, text, key) {
+    const writable = await ensureWriter(deps, session);
+    if ('body' in writable)
+        throw new StartTurnProblem(writable);
+    try {
+        if (writable.session !== session)
+            deps.save(writable.session);
+    }
+    catch (error) {
+        await cleanupAcquiredWriter(deps, writable.session, session);
+        throw error;
+    }
+    try {
+        const started = await deps.start(writable.session, text, key);
         deps.save(started);
         deps.onStarted?.(started);
-        return reply.code(202).send(started);
+        return started;
+    }
+    catch (error) {
+        if (writable.session !== session)
+            await cleanupAcquiredWriter(deps, writable.session, session);
+        throw error;
+    }
+}
+class StartTurnProblem extends Error {
+    result;
+    constructor(result) {
+        super('START_TURN_PROBLEM');
+        this.result = result;
+    }
+}
+async function serializeSession(operations, sessionId, operation) {
+    const prior = operations.get(sessionId) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+        release = resolve;
     });
+    operations.set(sessionId, current);
+    await prior;
+    try {
+        return await operation();
+    }
+    finally {
+        release();
+        if (operations.get(sessionId) === current)
+            operations.delete(sessionId);
+    }
+}
+/** Cleanup is best effort: never replace the original start/persistence error. */
+async function cleanupAcquiredWriter(deps, acquired, original) {
+    try {
+        await deps.releaseWriter?.(acquired.id);
+    }
+    catch {
+        // Process loss is already a valid release outcome.
+    }
+    try {
+        deps.save(original);
+    }
+    catch {
+        // The original I/O failure remains the observable failure.
+    }
+}
+async function ensureWriter(deps, session) {
+    if (!deps.ensureWriter) {
+        if (session.state === 'ready')
+            return { session, replacementCreated: false };
+        return failure('runtimeUnavailable');
+    }
+    try {
+        return await deps.ensureWriter(session);
+    }
+    catch (error) {
+        if (error instanceof WriterAcquisitionError &&
+            error.kind === 'writerBusy' &&
+            session.state !== 'stopped')
+            deps.save(RelaySession.rehydrate(session).stop(new Date().toISOString()).snapshot);
+        return failure(error instanceof WriterAcquisitionError ? error.kind : 'runtimeUnavailable');
+    }
+}
+function failure(kind) {
+    const problem = writerAcquisitionProblem(kind);
+    return { statusCode: problem.status, body: JSON.stringify(problem) };
 }
 function replay(result, fingerprint, reply) {
     const cached = JSON.parse(result.body);
+    if (cached.fingerprint === undefined)
+        return reply.code(result.statusCode).send(cached);
     if (cached.fingerprint !== fingerprint)
         return reply.code(409).send({ code: 'IDEMPOTENCY_KEY_REUSED' });
     return reply.code(result.statusCode).send(cached.response);

package/dist/server/server/platform/codex/json-rpc-client.js CHANGED Viewed

@@ -6,6 +6,7 @@
 import { createInterface } from 'node:readline';
 export const CODEX_THREAD_NOT_FOUND = 'CODEX_THREAD_NOT_FOUND';
 export const CODEX_JSON_RPC_ERROR = 'CODEX_JSON_RPC_ERROR';
+export const CODEX_THREAD_WRITER_BUSY = 'CODEX_THREAD_WRITER_BUSY';
 /** A bounded representation of an app-server JSON-RPC failure. */
 export class CodexJsonRpcError extends Error {
     code;
@@ -25,10 +26,19 @@ export class CodexJsonRpcError extends Error {
 export function isMissingCodexThreadRollout(error) {
     return error instanceof CodexJsonRpcError && error.kind === CODEX_THREAD_NOT_FOUND;
 }
+/** Compatibility shim for the confirmed Codex 0.146 active-writer response. */
+export function isCodexThreadWriterBusy(error) {
+    return error instanceof CodexJsonRpcError && error.kind === CODEX_THREAD_WRITER_BUSY;
+}
 function classifyCodexJsonRpcError(code, message) {
-    return code === -32600 && /^no rollout found for thread id\b/i.test(message)
-        ? CODEX_THREAD_NOT_FOUND
-        : CODEX_JSON_RPC_ERROR;
+    if (code !== -32600)
+        return CODEX_JSON_RPC_ERROR;
+    if (/^no rollout found for thread id\b/i.test(message))
+        return CODEX_THREAD_NOT_FOUND;
+    // Fixture-backed exact protocol wording: do not broaden this into a heuristic.
+    if (/^thread .* already has an active writer$/i.test(message))
+        return CODEX_THREAD_WRITER_BUSY;
+    return CODEX_JSON_RPC_ERROR;
 }
 function boundMessage(message) {
     return message