gestalt-mobile 0.1.0

package/dist/server/server/platform/codex/normalizer.js

@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { relative } from 'node:path';
+export function normalizeCodexNotification(sessionId, sequence, occurredAt, notification, workspacePath) {
+    if (notification.method === 'item/agentMessage/delta')
+        return {
+            sessionId,
+            sequence,
+            occurredAt,
+            type: 'agentMessageDelta',
+            payload: { text: notification.params?.delta ?? '' },
+        };
+    if (notification.method === 'turn/completed')
+        return {
+            sessionId,
+            sequence,
+            occurredAt,
+            type: 'turnCompleted',
+            payload: notification.params ?? {},
+        };
+    if (notification.method === 'item/started' || notification.method === 'item/completed') {
+        const activity = safeActivity(notification.params?.item, workspacePath);
+        if (activity)
+            return { sessionId, sequence, occurredAt, type: 'activity.updated', payload: activity };
+    }
+    return null;
+}
+function safeActivity(item, workspacePath) {
+    if (!item || typeof item !== 'object')
+        return null;
+    const value = item;
+    if (typeof value.id !== 'string' || typeof value.type !== 'string')
+        return null;
+    const status = typeof value.status === 'string' ? ` · ${value.status}` : '';
+    if (value.type === 'commandExecution' && typeof value.command === 'string')
+        return { id: value.id, label: `Command${status}`, detail: value.command };
+    if (value.type === 'plan' && typeof value.text === 'string')
+        return { id: value.id, label: 'Plan', detail: value.text };
+    if (value.type === 'reasoning' && Array.isArray(value.summary)) {
+        const detail = reasoningSummary(value.summary).join('\n');
+        return detail ? { id: value.id, label: 'Reasoning summary', detail } : null;
+    }
+    if (value.type === 'fileChange' && Array.isArray(value.changes))
+        return {
+            id: value.id,
+            label: `fileChange${status}`,
+            detail: value.changes
+                .map((change) => change &&
+                typeof change === 'object' &&
+                typeof change.path === 'string'
+                ? relativePath(change.path, workspacePath)
+                : '')
+                .filter(Boolean)
+                .join('\n'),
+        };
+    if ((value.type === 'mcpToolCall' || value.type === 'dynamicToolCall') &&
+        typeof value.tool === 'string')
+        return { id: value.id, label: `Tool${status}`, detail: value.tool };
+    return null;
+}
+function relativePath(path, workspacePath) {
+    if (!workspacePath)
+        return path;
+    const value = relative(workspacePath, path);
+    return value && !value.startsWith('..') ? value : path;
+}
+function reasoningSummary(parts) {
+    return parts.flatMap((part) => {
+        if (typeof part === 'string')
+            return part ? [part] : [];
+        if (part &&
+            typeof part === 'object' &&
+            part.type === 'summary_text' &&
+            typeof part.text === 'string')
+            return [part.text];
+        return [];
+    });
+}

package/dist/server/server/platform/codex/protocol-compatibility.js

@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function protocolCompatibility(installedVersion, protocolVersion) {
+    if (!installedVersion)
+        return { compatible: false, code: 'CODEX_NOT_FOUND' };
+    if (installedVersion !== protocolVersion)
+        return { compatible: false, code: 'CODEX_PROTOCOL_MISMATCH' };
+    return { compatible: true };
+}

package/dist/server/server/platform/codex/recent-thread-lister.js

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function createRecentThreadLister(deps) {
+    return {
+        async list() {
+            const profiles = (await deps.profiles.list()).filter((profile) => profile.state === 'ok');
+            const listed = await Promise.all(profiles.map(async ({ name }) => listProfileThreads(deps.launch, name, deps.root)));
+            const byId = new Map();
+            for (const thread of listed.flat()) {
+                const known = byId.get(thread.id);
+                if (!known || (thread.recencyAt ?? 0) > (known.recencyAt ?? 0))
+                    byId.set(thread.id, thread);
+            }
+            return [...byId.values()].sort((a, b) => (b.recencyAt ?? 0) - (a.recencyAt ?? 0));
+        },
+    };
+}
+async function listProfileThreads(launch, profile, cwd) {
+    const process = launch({ profile, cwd });
+    try {
+        await process.rpc.request('initialize', {
+            clientInfo: { name: 'gestalt-mobile', version: '0.1.0' },
+            capabilities: null,
+        });
+        const result = (await process.rpc.request('thread/list', {
+            limit: 20,
+            sortKey: 'recency_at',
+            sortDirection: 'desc',
+            sourceKinds: ['cli', 'appServer'],
+        }));
+        return (result.data ?? []).flatMap((thread) => {
+            if (typeof thread.id !== 'string' || typeof thread.cwd !== 'string')
+                return [];
+            return [{ id: thread.id, cwd: thread.cwd, recencyAt: toRecency(thread.recencyAt) }];
+        });
+    }
+    catch {
+        return [];
+    }
+    finally {
+        process.close();
+    }
+}
+function toRecency(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}

package/dist/server/server/platform/codex/server-request.js

@@ -0,0 +1,14 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function toPendingInteraction(input) {
+    const kind = {
+        'item/commandExecution/requestApproval': 'commandApproval',
+        'item/fileChange/requestApproval': 'fileChangeApproval',
+        'item/permissions/requestApproval': 'permissionsApproval',
+        'item/tool/requestUserInput': 'userInput',
+    }[input.method];
+    return kind ? { requestId: String(input.id), kind, payload: input.params } : null;
+}

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

@@ -0,0 +1,142 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { RelaySession, } from '../../features/sessions/model/relay-session.js';
+export class CodexSessionRuntime {
+    launch;
+    processes;
+    onNotification;
+    onServerRequest;
+    onProcessExit;
+    constructor(launch, processes = new Map(), onNotification, onServerRequest, onProcessExit) {
+        this.launch = launch;
+        this.processes = processes;
+        this.onNotification = onNotification;
+        this.onServerRequest = onServerRequest;
+        this.onProcessExit = onProcessExit;
+    }
+    pendingRequests = new Map();
+    exitUnsubscribers = new Map();
+    async start(session, now, settings = {}) {
+        const process = this.launch({ profile: session.profile, cwd: session.workspacePath });
+        try {
+            process.rpc.onNotification((notification) => this.onNotification?.(session.id, notification));
+            process.rpc.onServerRequest((request) => this.holdServerRequest(session.id, request));
+            this.attachExitHandler(session.id, process);
+            await process.rpc.request('initialize', {
+                clientInfo: { name: 'gestalt-mobile', version: '0.1.0' },
+                capabilities: null,
+            });
+            const result = (await process.rpc.request('thread/start', {
+                cwd: session.workspacePath,
+                approvalPolicy: settings.approvalPolicy ?? 'on-request',
+                ...(settings.model ? { model: settings.model } : {}),
+                ...(settings.sandbox ? { sandbox: settings.sandbox } : {}),
+            }));
+            if (!result.thread?.id)
+                throw new Error('CODEX_THREAD_ID_MISSING');
+            this.processes.set(session.id, process);
+            return RelaySession.rehydrate(session).bindThread(result.thread.id, now).snapshot;
+        }
+        catch (error) {
+            process.close();
+            throw error;
+        }
+    }
+    stop(sessionId) {
+        this.exitUnsubscribers.get(sessionId)?.();
+        this.exitUnsubscribers.delete(sessionId);
+        this.processes.get(sessionId)?.close();
+        this.processes.delete(sessionId);
+    }
+    /** Releases all relay-owned app-server children during graceful shutdown. */
+    stopAll() {
+        for (const sessionId of [...this.processes.keys()])
+            this.stop(sessionId);
+    }
+    resolveServerRequest(sessionId, requestId, result) {
+        const key = `${sessionId}:${requestId}`;
+        const resolve = this.pendingRequests.get(key);
+        if (!resolve)
+            return false;
+        this.pendingRequests.delete(key);
+        resolve(result);
+        return true;
+    }
+    async startTurn(session, text, now) {
+        const process = this.processes.get(session.id);
+        if (!process || !session.threadId)
+            throw new Error('CODEX_SESSION_NOT_RUNNING');
+        const result = (await process.rpc.request('turn/start', {
+            threadId: session.threadId,
+            input: [{ type: 'text', text, text_elements: [] }],
+        }));
+        if (!result.turn?.id)
+            throw new Error('CODEX_TURN_ID_MISSING');
+        return RelaySession.rehydrate(session).startTurn(result.turn.id, now).snapshot;
+    }
+    async interruptTurn(session, turnId) {
+        const process = this.processes.get(session.id);
+        if (!process || !session.threadId)
+            throw new Error('CODEX_SESSION_NOT_RUNNING');
+        await process.rpc.request('turn/interrupt', { threadId: session.threadId, turnId });
+    }
+    async readHistory(session) {
+        const process = this.processes.get(session.id);
+        if (!process || !session.threadId)
+            throw new Error('CODEX_SESSION_NOT_RUNNING');
+        const result = (await process.rpc.request('thread/read', {
+            threadId: session.threadId,
+            includeTurns: true,
+        }));
+        const rawTurns = result.thread?.turns ?? [];
+        const activeTurn = rawTurns.find((turn) => turn.status === 'inProgress' && typeof turn.id === 'string');
+        return {
+            turns: rawTurns.map((turn) => ({
+                items: turn.items ?? [],
+                startedAt: typeof turn.startedAt === 'number' ? turn.startedAt : null,
+                completedAt: typeof turn.completedAt === 'number' ? turn.completedAt : null,
+            })),
+            activeTurnId: typeof activeTurn?.id === 'string' ? activeTurn.id : null,
+        };
+    }
+    async restore(session, now) {
+        if (!session.threadId)
+            throw new Error('CODEX_THREAD_ID_MISSING');
+        const process = this.launch({ profile: session.profile, cwd: session.workspacePath });
+        try {
+            process.rpc.onNotification((notification) => this.onNotification?.(session.id, notification));
+            process.rpc.onServerRequest((request) => this.holdServerRequest(session.id, request));
+            this.attachExitHandler(session.id, process);
+            await process.rpc.request('initialize', {
+                clientInfo: { name: 'gestalt-mobile', version: '0.1.0' },
+                capabilities: null,
+            });
+            await process.rpc.request('thread/resume', {
+                threadId: session.threadId,
+                cwd: session.workspacePath,
+            });
+            this.processes.set(session.id, process);
+            return RelaySession.rehydrate(session).restore(now).snapshot;
+        }
+        catch (error) {
+            process.close();
+            throw error;
+        }
+    }
+    holdServerRequest(sessionId, request) {
+        if (!this.onServerRequest?.(sessionId, request)) {
+            return Promise.reject(new Error('CODEX_SERVER_REQUEST_UNSUPPORTED'));
+        }
+        return new Promise((resolve) => this.pendingRequests.set(`${sessionId}:${request.id}`, resolve));
+    }
+    attachExitHandler(sessionId, process) {
+        this.exitUnsubscribers.set(sessionId, process.onExit?.(() => {
+            this.processes.delete(sessionId);
+            this.exitUnsubscribers.delete(sessionId);
+            this.onProcessExit?.(sessionId);
+        }) ?? (() => { }));
+    }
+}

package/dist/server/server/platform/codex/thread-id.js

@@ -0,0 +1,10 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function requireThreadId(threadId) {
+    if (!threadId)
+        throw new Error('THREAD_REQUIRED');
+    return threadId;
+}

package/dist/server/server/platform/events/replay.js

@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function replayOrResync(events, after) {
+    if (!events.length)
+        return { kind: 'replay', events: [] };
+    return events[0].sequence > after + 1
+        ? { kind: 'resync' }
+        : { kind: 'replay', events: events.filter((event) => event.sequence > after) };
+}

package/dist/server/server/platform/events/session-event-bus.js

@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export class SessionEventBus {
+    listeners = new Map();
+    publish(event) {
+        this.listeners.get(event.sessionId)?.forEach((listener) => listener(event));
+    }
+    subscribe(sessionId, listener) {
+        const listeners = this.listeners.get(sessionId) ?? new Set();
+        listeners.add(listener);
+        this.listeners.set(sessionId, listeners);
+        return () => listeners.delete(listener);
+    }
+}

package/dist/server/server/platform/events/slow-client.js

@@ -0,0 +1,9 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export const slowClientLimitBytes = 1024 * 1024;
+export function isSlowClient(bufferedBytes) {
+    return bufferedBytes > slowClientLimitBytes;
+}

package/dist/server/server/platform/events/websocket-heartbeat.js

@@ -0,0 +1,20 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function installWebSocketHeartbeat(socket, intervalMs = 25_000) {
+    let alive = true;
+    socket.on('pong', () => {
+        alive = true;
+    });
+    const interval = setInterval(() => {
+        if (!alive) {
+            socket.terminate();
+            return;
+        }
+        alive = false;
+        socket.ping();
+    }, intervalMs);
+    return () => clearInterval(interval);
+}

package/dist/server/server/platform/git/command.js

@@ -0,0 +1,13 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execute = promisify(execFile);
+export const GIT_READ_TIMEOUT_MS = 15_000;
+export const GIT_FETCH_TIMEOUT_MS = 120_000;
+export async function git(cwd, args, timeoutMs = GIT_READ_TIMEOUT_MS) {
+    return (await execute('git', args, { cwd, shell: false, timeout: timeoutMs })).stdout;
+}

package/dist/server/server/platform/git/git-fetch-coordinator.js

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { resolve } from 'node:path';
+export class GitFetchCoordinator {
+    fetchWorkspace;
+    now;
+    throttleMs;
+    inFlight = new Map();
+    lastSuccessfulFetch = new Map();
+    constructor(fetchWorkspace, now = Date.now, throttleMs = 60_000) {
+        this.fetchWorkspace = fetchWorkspace;
+        this.now = now;
+        this.throttleMs = throttleMs;
+    }
+    lastSuccessfulAt(workspacePath) {
+        return this.lastSuccessfulFetch.get(resolve(workspacePath)) ?? null;
+    }
+    refresh(workspacePath) {
+        const key = resolve(workspacePath);
+        const active = this.inFlight.get(key);
+        if (active)
+            return active;
+        const lastFetchedAt = this.lastSuccessfulFetch.get(key);
+        if (lastFetchedAt !== undefined && this.now() - lastFetchedAt < this.throttleMs) {
+            return Promise.resolve();
+        }
+        const refresh = this.fetchWorkspace(workspacePath)
+            .then(() => {
+            this.lastSuccessfulFetch.set(key, this.now());
+        })
+            .finally(() => {
+            this.inFlight.delete(key);
+        });
+        this.inFlight.set(key, refresh);
+        return refresh;
+    }
+}

package/dist/server/server/platform/git/git-inspector.js

@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { GIT_FETCH_TIMEOUT_MS, git } from './command.js';
+export function parseDirtyCounts(value) {
+    return value
+        .split('\n')
+        .filter(Boolean)
+        .reduce((counts, line) => ({
+        staged: counts.staged + (line[0] && line[0] !== ' ' && line.slice(0, 2) !== '??' ? 1 : 0),
+        unstaged: counts.unstaged + (line.slice(0, 2) !== '??' && line[1] && line[1] !== ' ' ? 1 : 0),
+        untracked: counts.untracked + (line.slice(0, 2) === '??' ? 1 : 0),
+    }), { staged: 0, unstaged: 0, untracked: 0 });
+}
+export function parseDivergence(value) {
+    const [ahead, behind] = value.trim().split(/\s+/).map(Number);
+    return {
+        ahead: Number.isSafeInteger(ahead) ? ahead : 0,
+        behind: Number.isSafeInteger(behind) ? behind : 0,
+    };
+}
+export async function inspectGit(cwd) {
+    try {
+        await git(cwd, ['rev-parse', '--is-inside-work-tree']);
+        const branch = await git(cwd, ['branch', '--show-current']).then((value) => value.trim() || null);
+        const branches = (await git(cwd, ['branch', '--format=%(refname:short)']))
+            .split('\n')
+            .map((value) => value.trim())
+            .filter(Boolean);
+        const upstream = branch
+            ? await git(cwd, ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'])
+                .then((value) => value.trim())
+                .catch(() => null)
+            : null;
+        const divergence = upstream
+            ? parseDivergence(await git(cwd, ['rev-list', '--left-right', '--count', 'HEAD...@{upstream}']))
+            : { ahead: 0, behind: 0 };
+        const dirty = parseDirtyCounts(await git(cwd, ['status', '--porcelain=v1']));
+        const commits = (await git(cwd, ['log', '-20', '--format=%H%x1f%h%x1f%s%x1f%an%x1f%aI']))
+            .trim()
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => {
+            const [hash, shortHash, subject, author, authoredAt] = line.split('\x1f');
+            return {
+                hash: hash,
+                shortHash: shortHash,
+                subject: subject,
+                author: author,
+                authoredAt: authoredAt,
+            };
+        });
+        return {
+            available: true,
+            branch,
+            branches,
+            upstream,
+            ...divergence,
+            dirty,
+            commits,
+            fetchedAt: null,
+        };
+    }
+    catch {
+        return {
+            available: false,
+            branch: null,
+            branches: [],
+            upstream: null,
+            ahead: 0,
+            behind: 0,
+            dirty: { staged: 0, unstaged: 0, untracked: 0 },
+            commits: [],
+            fetchedAt: null,
+        };
+    }
+}
+export async function pushUpstream(cwd, upstream) {
+    const separator = upstream.indexOf('/');
+    if (separator < 1 || separator === upstream.length - 1)
+        throw new Error('NO_UPSTREAM');
+    await git(cwd, [
+        'push',
+        upstream.slice(0, separator),
+        `HEAD:refs/heads/${upstream.slice(separator + 1)}`,
+    ]);
+}
+export async function fetchUpstream(cwd) {
+    const upstream = await git(cwd, [
+        'rev-parse',
+        '--abbrev-ref',
+        '--symbolic-full-name',
+        '@{upstream}',
+    ]);
+    const remote = upstream.trim().split('/')[0];
+    if (!remote)
+        throw new Error('NO_UPSTREAM');
+    await git(cwd, ['fetch', '--prune', remote], GIT_FETCH_TIMEOUT_MS);
+}
+export async function pullRebase(cwd) {
+    await git(cwd, ['pull', '--rebase'], GIT_FETCH_TIMEOUT_MS);
+}
+export async function checkoutBranch(cwd, branch) {
+    const branches = (await git(cwd, ['branch', '--format=%(refname:short)']))
+        .split('\n')
+        .map((value) => value.trim())
+        .filter(Boolean);
+    if (!branches.includes(branch))
+        throw new Error('LOCAL_BRANCH_NOT_FOUND');
+    await git(cwd, ['switch', branch]);
+}
+export async function cloneRepository(workspaceRoot, address) {
+    await git(workspaceRoot, ['clone', '--', address], GIT_FETCH_TIMEOUT_MS);
+}

package/dist/server/server/platform/git/git-summary-cache.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { resolve } from 'node:path';
+/** Caches successful workspace inspections until a Git mutation invalidates them. */
+export class GitSummaryCache {
+    inspectWorkspace;
+    summaries = new Map();
+    constructor(inspectWorkspace) {
+        this.inspectWorkspace = inspectWorkspace;
+    }
+    async inspect(workspacePath) {
+        const key = resolve(workspacePath);
+        const cached = this.summaries.get(key);
+        if (cached !== undefined)
+            return cached;
+        const summary = await this.inspectWorkspace(workspacePath);
+        this.summaries.set(key, summary);
+        return summary;
+    }
+    invalidate(workspacePath) {
+        this.summaries.delete(resolve(workspacePath));
+    }
+}

package/dist/server/server/platform/git/git-summary.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function toGitSummary(input) {
+    return { ...input, canPush: Boolean(input.upstream) && input.ahead > 0 };
+}

package/dist/server/server/platform/http/idempotency.js

@@ -0,0 +1,9 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function idempotencyKey(headers) {
+    const value = headers['idempotency-key'];
+    return typeof value === 'string' && value.trim() ? value : null;
+}

package/dist/server/server/platform/http/problem-handler.js

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function registerProblemHandler(app, serveSpa = false) {
+    app.setNotFoundHandler((request, reply) => {
+        if (serveSpa && request.method === 'GET' && !request.url.startsWith('/api/')) {
+            return reply.type('text/html; charset=utf-8').sendFile('index.html');
+        }
+        const problem = {
+            type: 'urn:gestalt-mobile:error:not-found',
+            title: 'Not found',
+            status: 404,
+            detail: `No route matches ${request.method} ${request.url}`,
+            code: 'NOT_FOUND',
+            retryable: false,
+        };
+        return reply.code(404).type('application/problem+json').send(problem);
+    });
+    app.setErrorHandler((error, _request, reply) => {
+        const problem = {
+            type: 'urn:gestalt-mobile:error:internal',
+            title: 'Internal server error',
+            status: 500,
+            detail: 'The relay could not complete this request.',
+            code: 'INTERNAL_ERROR',
+            retryable: true,
+        };
+        return reply.code(500).type('application/problem+json').send(problem);
+    });
+}

package/dist/server/server/platform/http/problem.js

@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export function problem(code, status, detail, retryable = false) {
+    return {
+        type: `urn:gestalt-mobile:error:${code.toLowerCase()}`,
+        title: code.replaceAll('_', ' '),
+        status,
+        detail,
+        code,
+        retryable,
+    };
+}

package/dist/server/server/platform/observability/safe-log.js

@@ -0,0 +1,9 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+const sensitive = /prompt|message|output|answer|token|secret|environment/i;
+export function safeLogFields(fields) {
+    return Object.fromEntries(Object.entries(fields).filter(([key]) => !sensitive.test(key)));
+}

package/dist/server/server/platform/persistence/migrate.js

@@ -0,0 +1,9 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+const schema = `CREATE TABLE IF NOT EXISTS relay_sessions (id TEXT PRIMARY KEY, workspace_id TEXT NOT NULL, workspace_path TEXT NOT NULL, profile TEXT NOT NULL, thread_id TEXT, state TEXT NOT NULL, desired_state TEXT NOT NULL, active_turn_id TEXT, protocol_version TEXT, failure_count INTEGER NOT NULL DEFAULT 0, next_sequence INTEGER NOT NULL DEFAULT 1, created_at TEXT NOT NULL, updated_at TEXT NOT NULL); CREATE TABLE IF NOT EXISTS pending_interactions (session_id TEXT NOT NULL REFERENCES relay_sessions(id) ON DELETE CASCADE, request_id TEXT NOT NULL, kind TEXT NOT NULL, payload_json TEXT NOT NULL, resolved_at TEXT, PRIMARY KEY (session_id, request_id)); CREATE TABLE IF NOT EXISTS session_events (session_id TEXT NOT NULL REFERENCES relay_sessions(id) ON DELETE CASCADE, sequence INTEGER NOT NULL, occurred_at TEXT NOT NULL, type TEXT NOT NULL, payload_json TEXT NOT NULL, PRIMARY KEY (session_id, sequence)); CREATE TABLE IF NOT EXISTS idempotency_results (scope TEXT NOT NULL, key TEXT NOT NULL, status_code INTEGER NOT NULL, body_json TEXT NOT NULL, PRIMARY KEY (scope, key));`;
+export function migrate(database) {
+    database.exec(schema);
+}