gestalt-mobile 0.1.0

package/dist/server/server/platform/persistence/retention.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 eventRetention = 2000;
+export function retainedSequences(sequences) {
+    return sequences.slice(-eventRetention);
+}

package/dist/server/server/platform/persistence/sqlite-event-journal.js

@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export class SqliteEventJournal {
+    db;
+    retain;
+    constructor(db, retain = 2000) {
+        this.db = db;
+        this.retain = retain;
+    }
+    append(sessionId, type, payload, occurredAt) {
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            const row = this.db
+                .prepare('SELECT next_sequence AS sequence FROM relay_sessions WHERE id = ?')
+                .get(sessionId);
+            if (!row)
+                throw new Error('SESSION_NOT_FOUND');
+            this.db
+                .prepare('INSERT INTO session_events (session_id,sequence,occurred_at,type,payload_json) VALUES (?,?,?,?,?)')
+                .run(sessionId, row.sequence, occurredAt, type, JSON.stringify(payload));
+            this.db
+                .prepare('UPDATE relay_sessions SET next_sequence = next_sequence + 1 WHERE id = ?')
+                .run(sessionId);
+            this.db
+                .prepare('DELETE FROM session_events WHERE session_id = ? AND sequence NOT IN (SELECT sequence FROM session_events WHERE session_id = ? ORDER BY sequence DESC LIMIT ?)')
+                .run(sessionId, sessionId, this.retain);
+            const event = { sessionId, sequence: row.sequence, type, occurredAt, payload };
+            this.db.exec('COMMIT');
+            return event;
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    since(sessionId, after) {
+        return this.db
+            .prepare('SELECT sequence,type,occurred_at,payload_json FROM session_events WHERE session_id = ? AND sequence > ? ORDER BY sequence')
+            .all(sessionId, after).map((row) => ({
+            sessionId,
+            sequence: row.sequence,
+            type: row.type,
+            occurredAt: row.occurred_at,
+            payload: JSON.parse(row.payload_json),
+        }));
+    }
+}

package/dist/server/server/platform/persistence/sqlite-idempotency-store.js

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export class SqliteIdempotencyStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    get(scope, key) {
+        const row = this.db
+            .prepare('SELECT status_code, body_json FROM idempotency_results WHERE scope = ? AND key = ?')
+            .get(scope, key);
+        return row ? { statusCode: row.status_code, body: row.body_json } : null;
+    }
+    put(scope, key, statusCode, body) {
+        this.db
+            .prepare('INSERT OR IGNORE INTO idempotency_results (scope,key,status_code,body_json) VALUES (?,?,?,?)')
+            .run(scope, key, statusCode, body);
+    }
+}

package/dist/server/server/platform/persistence/sqlite-pending-interaction-store.js

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export class SqlitePendingInteractionStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    add(sessionId, interaction) {
+        this.db
+            .prepare('INSERT INTO pending_interactions (session_id,request_id,kind,payload_json) VALUES (?,?,?,?)')
+            .run(sessionId, interaction.requestId, interaction.kind, JSON.stringify(interaction.payload));
+    }
+    resolve(sessionId, requestId, resolvedAt) {
+        return (this.db
+            .prepare('UPDATE pending_interactions SET resolved_at = ? WHERE session_id = ? AND request_id = ? AND resolved_at IS NULL')
+            .run(resolvedAt, sessionId, requestId).changes === 1);
+    }
+    list(sessionId) {
+        return this.db
+            .prepare('SELECT request_id,kind,payload_json FROM pending_interactions WHERE session_id = ? AND resolved_at IS NULL ORDER BY rowid')
+            .all(sessionId).map((row) => ({
+            requestId: row.request_id,
+            kind: row.kind,
+            payload: JSON.parse(row.payload_json),
+        }));
+    }
+    find(sessionId, requestId) {
+        return this.list(sessionId).find((interaction) => interaction.requestId === requestId) ?? null;
+    }
+}

package/dist/server/server/platform/persistence/sqlite-session-repository.js

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export class SqliteSessionRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    save(session) {
+        this.db
+            .prepare('INSERT INTO relay_sessions (id,workspace_id,workspace_path,profile,thread_id,state,desired_state,active_turn_id,protocol_version,failure_count,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET workspace_id=excluded.workspace_id,workspace_path=excluded.workspace_path,profile=excluded.profile,thread_id=excluded.thread_id,state=excluded.state,desired_state=excluded.desired_state,active_turn_id=excluded.active_turn_id,protocol_version=excluded.protocol_version,failure_count=excluded.failure_count,updated_at=excluded.updated_at')
+            .run(session.id, session.workspaceId, session.workspacePath, session.profile, session.threadId, session.state, session.desiredState, session.activeTurnId, session.protocolVersion, session.failureCount, session.createdAt, session.updatedAt);
+    }
+    find(id) {
+        const row = this.db.prepare('SELECT * FROM relay_sessions WHERE id = ?').get(id);
+        return row ? map(row) : null;
+    }
+    list() {
+        return this.db.prepare('SELECT * FROM relay_sessions ORDER BY updated_at DESC').all().map(map);
+    }
+    remove(id) {
+        this.db.prepare('DELETE FROM relay_sessions WHERE id = ?').run(id);
+    }
+}
+function map(row) {
+    return {
+        id: row.id,
+        workspaceId: row.workspace_id,
+        workspacePath: row.workspace_path,
+        profile: row.profile,
+        threadId: row.thread_id,
+        state: row.state,
+        desiredState: row.desired_state,
+        activeTurnId: row.active_turn_id,
+        protocolVersion: row.protocol_version,
+        failureCount: row.failure_count,
+        pendingInteractions: [],
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}

package/dist/server/server/platform/persistence/sqlite.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
+ */
+import { DatabaseSync } from 'node:sqlite';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+export function openRelayDatabase(path) {
+    mkdirSync(dirname(path), { recursive: true });
+    const database = new DatabaseSync(path);
+    database.exec('PRAGMA journal_mode = WAL; PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 5000;');
+    return database;
+}

package/dist/server/server/platform/persistence/state-path.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+export function relayStatePath(root, stateHome) {
+    return statePath(root, stateHome, 'gestalt-mobile');
+}
+export function legacyRelayStatePath(root, stateHome) {
+    return statePath(root, stateHome, 'codex-relay');
+}
+function statePath(root, stateHome, applicationName) {
+    return join(stateHome, applicationName, createHash('sha256').update(root).digest('hex').slice(0, 12), 'relay.sqlite');
+}

package/dist/server/server/platform/runtime/clock.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 systemClock = {
+    now: () => Date.now(),
+    sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+};

package/dist/server/server/platform/runtime/concurrency.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 async function mapWithConcurrency(values, limit, task) {
+    let index = 0;
+    await Promise.all(Array.from({ length: Math.min(limit, values.length) }, async () => {
+        while (index < values.length) {
+            const value = values[index++];
+            if (value !== undefined)
+                await task(value);
+        }
+    }));
+}

package/dist/server/server/platform/runtime/retry-policy.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 recoveryDelays = [500, 2000, 5000];
+export function recoveryDelay(failureCount) {
+    return recoveryDelays[failureCount] ?? null;
+}

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

@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { recoveryDelay } from './retry-policy.js';
+export class SessionSupervisor {
+    restore;
+    requireAttention;
+    timers = new Map();
+    constructor(restore, requireAttention) {
+        this.restore = restore;
+        this.requireAttention = requireAttention;
+    }
+    recover(sessionId, failureCount = 0) {
+        this.cancel(sessionId);
+        void this.attempt(sessionId, failureCount);
+    }
+    cancel(sessionId) {
+        const timer = this.timers.get(sessionId);
+        if (timer)
+            clearTimeout(timer);
+        this.timers.delete(sessionId);
+    }
+    async attempt(sessionId, failureCount) {
+        try {
+            await this.restore(sessionId);
+        }
+        catch {
+            const delay = recoveryDelay(failureCount);
+            if (delay === null) {
+                this.requireAttention(sessionId);
+                return;
+            }
+            this.timers.set(sessionId, setTimeout(() => {
+                this.timers.delete(sessionId);
+                void this.attempt(sessionId, failureCount + 1);
+            }, delay));
+        }
+    }
+}

package/dist/server/shared/contracts/problem.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export {};

package/dist/server/shared/contracts/session-event.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export {};

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "gestalt-mobile",
+  "version": "0.1.0",
+  "description": "Mobile-first web relay for durable Codex development sessions",
+  "keywords": [
+    "codex",
+    "gestalt",
+    "mobile",
+    "development"
+  ],
+  "homepage": "https://github.com/dyne/gestalt-mobile#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dyne/gestalt-mobile.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dyne/gestalt-mobile/issues"
+  },
+  "author": "Dyne.org foundation",
+  "license": "AGPL-3.0-or-later",
+  "type": "module",
+  "bin": {
+    "gestalt-mobile": "dist/server/server/main.js"
+  },
+  "files": [
+    "dist/server",
+    "dist/client",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "scripts": {
+    "dev": "node scripts/dev.mjs",
+    "dev:server": "tsx watch src/server/main.ts -- --cwd ..",
+    "start": "node dist/server/server/main.js",
+    "dev:client": "vite",
+    "build": "npm run build:server && npm run build:client",
+    "build:server": "node scripts/build-server.mjs",
+    "build:client": "vite build",
+    "prepack": "npm run build",
+    "check": "tsc -p tsconfig.server.json --noEmit && svelte-check --tsconfig ./tsconfig.json --fail-on-warnings",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:package": "node scripts/smoke-packed-cli.mjs",
+    "test:e2e": "playwright test",
+    "license:check": "node scripts/check-license-headers.mjs",
+    "license:apply": "node scripts/apply-license-headers.mjs"
+  },
+  "dependencies": {
+    "@fastify/static": "^10.1.0",
+    "fastify": "^5.10.0",
+    "ws": "^8.21.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.61.1",
+    "@sveltejs/vite-plugin-svelte": "^7.2.0",
+    "@testing-library/svelte": "^5.4.2",
+    "@types/node": "^24.13.3",
+    "@types/ws": "^8.18.1",
+    "eslint": "^10.7.0",
+    "jsdom": "^29.1.1",
+    "prettier": "^3.9.5",
+    "prettier-plugin-svelte": "^4.1.1",
+    "svelte": "^5.56.4",
+    "svelte-check": "^4.7.2",
+    "tsx": "^4.23.1",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.64.0",
+    "vite": "^8.1.4",
+    "vitest": "^4.1.10"
+  }
+}