gestalt-mobile 0.20.1 → 0.22.0

package/dist/server/server/platform/filesystem/filesystem-workspace-files.js

@@ -0,0 +1,559 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { copyFile, lstat, mkdir, open, readdir, realpath, rename, rm, stat, writeFile, } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { basename, extname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+/** Lists exactly one directory; symlinks are represented but never followed. */
+export class FilesystemWorkspaceFiles {
+    filesystem;
+    mutationHooks;
+    cursors = new Map();
+    constructor(filesystem = { lstat, readdir, realpath, stat }, mutationHooks = {}) {
+        this.filesystem = filesystem;
+        this.mutationHooks = mutationHooks;
+    }
+    async list(workspaceRoot, input) {
+        const root = await this.canonicalDirectory(workspaceRoot);
+        if (!root)
+            return { kind: 'unreadable' };
+        const target = await this.targetDirectory(root, input.directory);
+        if (target.kind !== 'directory')
+            return target;
+        const cursor = input.cursor === undefined ? undefined : this.cursors.get(input.cursor);
+        if (input.cursor !== undefined && !cursor)
+            return { kind: 'invalid-cursor' };
+        if (cursor &&
+            (cursor.d !== input.directory ||
+                cursor.i !== Number(target.metadata.ino) ||
+                cursor.m !== Number(target.metadata.mtimeMs)))
+            return { kind: 'stale-cursor' };
+        try {
+            const names = await this.filesystem.readdir(target.path, { encoding: 'utf8' });
+            const entries = [];
+            for (const name of names) {
+                if (name === '.git')
+                    continue;
+                const child = join(target.path, name);
+                try {
+                    const metadata = await this.filesystem.lstat(child);
+                    const kind = metadata.isSymbolicLink()
+                        ? 'symlink'
+                        : metadata.isDirectory()
+                            ? 'directory'
+                            : metadata.isFile()
+                                ? 'file'
+                                : null;
+                    if (!kind)
+                        continue;
+                    const path = input.directory === '' ? name : `${input.directory}/${name}`;
+                    entries.push({
+                        name,
+                        path,
+                        kind,
+                        ...(kind === 'file'
+                            ? { size: metadata.size, modifiedAt: metadata.mtime.toISOString() }
+                            : {}),
+                    });
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        return { kind: 'unreadable' };
+                }
+            }
+            entries.sort(compareEntries);
+            if (cursor && cursor.s !== snapshot(entries))
+                return { kind: 'stale-cursor' };
+            const start = cursor ? entries.findIndex((entry) => entry.name === cursor.a) + 1 : 0;
+            if (cursor && start === 0)
+                return { kind: 'stale-cursor' };
+            const pageEntries = entries.slice(start, start + input.limit);
+            const last = pageEntries.at(-1);
+            const nextCursor = start + pageEntries.length < entries.length && last
+                ? this.rememberCursor({
+                    d: input.directory,
+                    i: Number(target.metadata.ino),
+                    m: Number(target.metadata.mtimeMs),
+                    a: last.name,
+                    s: snapshot(entries),
+                })
+                : undefined;
+            const page = {
+                directory: input.directory,
+                entries: pageEntries,
+                ...(nextCursor ? { nextCursor } : {}),
+            };
+            return { kind: 'available', page };
+        }
+        catch (error) {
+            return error.code === 'ENOENT'
+                ? { kind: 'missing' }
+                : { kind: 'unreadable' };
+        }
+    }
+    async copy(rootPath, input) {
+        return this.transfer(rootPath, input, false);
+    }
+    async move(rootPath, input) {
+        return this.transfer(rootPath, input, true);
+    }
+    async upload(rootPath, input) {
+        if (!validName(input.filename))
+            return { kind: 'invalid-destination' };
+        const root = await this.canonicalDirectory(rootPath);
+        if (!root)
+            return { kind: 'unreadable' };
+        const parent = await anchoredDirectory(root, input.directory);
+        if (!parent)
+            return { kind: 'invalid-destination' };
+        try {
+            await this.mutationHooks.afterParentCheck?.('upload');
+            if (!(await stableAnchor(root, input.directory, parent.path)))
+                return { kind: 'invalid-destination' };
+            const target = await this.targetName(parent.path, input.filename, input.conflict, 'file');
+            if (typeof target !== 'string')
+                return target;
+            const temp = join(parent.path, `.${randomUUID()}.upload`);
+            await writeFile(temp, input.content, { flag: 'wx' });
+            try {
+                await this.mutationHooks.beforePublish?.('upload');
+                await this.publishFile(temp, target, input.conflict);
+            }
+            finally {
+                await rm(temp, { force: true }).catch(() => undefined);
+            }
+            return {
+                kind: 'available',
+                source: '',
+                path: input.directory ? `${input.directory}/${basename(target)}` : basename(target),
+                entryKind: 'file',
+                conflict: input.conflict,
+            };
+        }
+        catch {
+            return { kind: 'unreadable' };
+        }
+        finally {
+            await parent.close();
+        }
+    }
+    async delete(rootPath, input) {
+        if (!input.recursive)
+            return { kind: 'invalid-destination' };
+        if (input.path === '.git' || input.path.startsWith('.git/'))
+            return { kind: 'protected' };
+        if (!validRelative(input.path))
+            return { kind: 'invalid-destination' };
+        const root = await this.canonicalDirectory(rootPath);
+        if (!root)
+            return { kind: 'unreadable' };
+        const parent = await anchoredDirectory(root, dirnameRelative(input.path));
+        if (!parent)
+            return { kind: 'missing' };
+        try {
+            await this.mutationHooks.afterParentCheck?.('delete');
+            if (!(await stableAnchor(root, dirnameRelative(input.path), parent.path)))
+                return { kind: 'missing' };
+            const target = join(parent.path, basename(input.path));
+            const metadata = await safeLstat(target);
+            if (!metadata || metadata.isSymbolicLink())
+                return { kind: 'missing' };
+            await rm(target, { recursive: metadata.isDirectory(), force: false });
+            return {
+                kind: 'available',
+                source: input.path,
+                path: input.path,
+                entryKind: metadata.isDirectory() ? 'directory' : 'file',
+                conflict: 'reject',
+            };
+        }
+        catch {
+            return { kind: 'unreadable' };
+        }
+        finally {
+            await parent.close();
+        }
+    }
+    async transfer(rootPath, input, moving) {
+        if (!validRelative(input.source) ||
+            (input.destinationDirectory !== '' && !validRelative(input.destinationDirectory)))
+            return { kind: 'invalid-destination' };
+        const root = await this.canonicalDirectory(rootPath);
+        if (!root)
+            return { kind: 'unreadable' };
+        if (input.source === '.git' || input.source.startsWith('.git/'))
+            return { kind: 'protected' };
+        const sourceParent = await anchoredDirectory(root, dirnameRelative(input.source));
+        if (!sourceParent)
+            return { kind: 'missing' };
+        const parent = await anchoredDirectory(root, input.destinationDirectory);
+        if (!parent) {
+            await sourceParent.close();
+            return { kind: 'invalid-destination' };
+        }
+        const source = join(sourceParent.path, basename(input.source));
+        const sourceMetadata = await safeLstat(source);
+        if (!sourceMetadata || sourceMetadata.isSymbolicLink()) {
+            await Promise.all([sourceParent.close(), parent.close()]);
+            return { kind: 'missing' };
+        }
+        if (dirnameRelative(input.source) === input.destinationDirectory && moving) {
+            await Promise.all([sourceParent.close(), parent.close()]);
+            return { kind: 'same-parent' };
+        }
+        if (sourceMetadata.isDirectory() &&
+            (input.destinationDirectory === input.source ||
+                input.destinationDirectory.startsWith(`${input.source}/`))) {
+            await Promise.all([sourceParent.close(), parent.close()]);
+            return { kind: 'source-inside-destination' };
+        }
+        const target = await this.targetName(parent.path, basename(source), input.conflict, sourceMetadata.isFile() ? 'file' : 'directory');
+        if (typeof target !== 'string') {
+            await Promise.all([sourceParent.close(), parent.close()]);
+            return target;
+        }
+        try {
+            await this.mutationHooks.afterParentCheck?.(moving ? 'move' : 'copy');
+            if (!(await stableAnchor(root, dirnameRelative(input.source), sourceParent.path)) ||
+                !(await stableAnchor(root, input.destinationDirectory, parent.path)))
+                return { kind: 'invalid-destination' };
+            await this.mutationHooks.beforePublish?.(moving ? 'move' : 'copy');
+            if (moving) {
+                await this.publishMove(source, target, input.conflict, sourceMetadata.isDirectory());
+            }
+            else if (sourceMetadata.isFile()) {
+                const temp = join(parent.path, `.${randomUUID()}.copy`);
+                try {
+                    const sourceHandle = await open(source, constants.O_RDONLY | constants.O_NOFOLLOW);
+                    try {
+                        await copyFile(procPath(sourceHandle.fd), temp, 0);
+                    }
+                    finally {
+                        await sourceHandle.close();
+                    }
+                    await this.publishFile(temp, target, input.conflict);
+                }
+                finally {
+                    await rm(temp, { force: true }).catch(() => undefined);
+                }
+            }
+            else {
+                const temp = join(parent.path, `.${randomUUID()}.copy-directory`);
+                try {
+                    const sourceDirectory = await openDirectory(source);
+                    if (!sourceDirectory)
+                        throw new Error('source changed');
+                    try {
+                        await copyTree(sourceDirectory.path, temp, true);
+                    }
+                    finally {
+                        await sourceDirectory.close();
+                    }
+                    await this.publishDirectory(temp, target, input.conflict);
+                }
+                finally {
+                    await rm(temp, { recursive: true, force: true }).catch(() => undefined);
+                }
+            }
+            return {
+                kind: 'available',
+                source: input.source,
+                path: input.destinationDirectory
+                    ? `${input.destinationDirectory}/${basename(target)}`
+                    : basename(target),
+                entryKind: sourceMetadata.isDirectory() ? 'directory' : 'file',
+                conflict: input.conflict,
+            };
+        }
+        catch {
+            return { kind: 'unreadable' };
+        }
+        finally {
+            await Promise.all([sourceParent.close(), parent.close()]);
+        }
+    }
+    async safeDirectory(root, directory) {
+        if (directory !== '' && !validRelative(directory))
+            return null;
+        const entry = await this.safeEntry(root, directory, true);
+        return entry?.metadata.isDirectory() ? entry.path : null;
+    }
+    async targetName(parent, name, conflict, sourceKind) {
+        let target = join(parent, name);
+        const existing = await safeLstat(target);
+        if (!existing)
+            return target;
+        if (existing.isSymbolicLink())
+            return { kind: 'symlink' };
+        if (conflict === 'reject')
+            return { kind: 'conflict', replaceAllowed: sourceKind === 'file' && existing.isFile() };
+        if (conflict === 'replace') {
+            if (sourceKind !== 'file' || !existing.isFile())
+                return { kind: 'replace-unsupported' };
+            return target;
+        }
+        const extension = extname(name);
+        const stem = extension ? name.slice(0, -extension.length) : name;
+        for (let index = 1; index < 10000; index += 1) {
+            target = join(parent, `${stem} (${index === 1 ? 'copy' : index})${extension}`);
+            if (!(await safeLstat(target)))
+                return target;
+        }
+        return { kind: 'unreadable' };
+    }
+    async safeEntry(root, value, allowRoot = false) {
+        if (value === '' && !allowRoot)
+            return null;
+        let path = root;
+        for (const segment of value === '' ? [] : value.split('/')) {
+            if (!validName(segment))
+                return null;
+            path = join(path, segment);
+            const metadata = await safeLstat(path);
+            if (!metadata || metadata.isSymbolicLink())
+                return null;
+            try {
+                if (!within(root, await realpath(path)))
+                    return null;
+            }
+            catch {
+                return null;
+            }
+        }
+        const metadata = await safeLstat(path);
+        return metadata && !metadata.isSymbolicLink() ? { path, metadata } : null;
+    }
+    async publishFile(temp, target, conflict) {
+        const reservation = conflict === 'replace' ? null : await reserveFile(target);
+        try {
+            await rename(temp, target);
+        }
+        catch (error) {
+            if (reservation)
+                await removeReservation(target, reservation, false);
+            throw error;
+        }
+    }
+    async publishDirectory(temp, target, conflict) {
+        const reservation = conflict === 'replace' ? null : await reserveDirectory(target);
+        try {
+            await rename(temp, target);
+        }
+        catch (error) {
+            if (reservation)
+                await removeReservation(target, reservation, true);
+            throw error;
+        }
+    }
+    async publishMove(source, target, conflict, directory) {
+        const reservation = conflict === 'replace'
+            ? null
+            : directory
+                ? await reserveDirectory(target)
+                : await reserveFile(target);
+        try {
+            await rename(source, target);
+        }
+        catch (error) {
+            if (reservation)
+                await removeReservation(target, reservation, directory);
+            throw error;
+        }
+    }
+    rememberCursor(cursor) {
+        const token = randomUUID();
+        this.cursors.set(token, cursor);
+        if (this.cursors.size > 2_000)
+            this.cursors.delete(this.cursors.keys().next().value);
+        return token;
+    }
+    async canonicalDirectory(path) {
+        if (!isAbsolute(path))
+            return null;
+        try {
+            const canonical = await this.filesystem.realpath(resolve(path));
+            return (await this.filesystem.stat(canonical)).isDirectory() ? canonical : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async targetDirectory(root, directory) {
+        let path = root;
+        for (const segment of directory === '' ? [] : directory.split('/')) {
+            path = join(path, segment);
+            try {
+                const metadata = await this.filesystem.lstat(path);
+                if (metadata.isSymbolicLink())
+                    return { kind: 'missing' };
+                const canonical = await this.filesystem.realpath(path);
+                if (!within(root, canonical))
+                    return { kind: 'missing' };
+            }
+            catch (error) {
+                return error.code === 'ENOENT'
+                    ? { kind: 'missing' }
+                    : { kind: 'unreadable' };
+            }
+        }
+        try {
+            const metadata = await this.filesystem.lstat(path);
+            if (metadata.isSymbolicLink())
+                return { kind: 'missing' };
+            if (!metadata.isDirectory())
+                return { kind: 'not-directory' };
+            const canonical = await this.filesystem.realpath(path);
+            if (!within(root, canonical) || !(await this.filesystem.stat(canonical)).isDirectory())
+                return { kind: 'missing' };
+            return { kind: 'directory', path: canonical, metadata };
+        }
+        catch (error) {
+            return error.code === 'ENOENT'
+                ? { kind: 'missing' }
+                : { kind: 'unreadable' };
+        }
+    }
+}
+function within(root, candidate) {
+    const path = relative(root, candidate);
+    return path === '' || (!path.startsWith(`..${sep}`) && path !== '..' && !isAbsolute(path));
+}
+function compareEntries(left, right) {
+    const rank = { directory: 0, file: 1, symlink: 2 };
+    return rank[left.kind] - rank[right.kind] || compareCodePoints(left.name, right.name);
+}
+/** Unicode scalar-value ordering, independent of host locale and UTF-16 code units. */
+function compareCodePoints(left, right) {
+    let leftIndex = 0;
+    let rightIndex = 0;
+    while (leftIndex < left.length && rightIndex < right.length) {
+        const leftPoint = left.codePointAt(leftIndex);
+        const rightPoint = right.codePointAt(rightIndex);
+        if (leftPoint !== rightPoint)
+            return leftPoint < rightPoint ? -1 : 1;
+        leftIndex += leftPoint > 0xffff ? 2 : 1;
+        rightIndex += rightPoint > 0xffff ? 2 : 1;
+    }
+    return leftIndex === left.length ? (rightIndex === right.length ? 0 : -1) : 1;
+}
+function snapshot(entries) {
+    return entries.map((entry) => `${entry.kind}\0${entry.name}`).join('\0');
+}
+function validRelative(value) {
+    return (value !== '' &&
+        !value.includes('\\') &&
+        !value.includes('\0') &&
+        value.split('/').every(validName));
+}
+function validName(value) {
+    return (value !== '' &&
+        value !== '.' &&
+        value !== '..' &&
+        value !== '.git' &&
+        !value.includes('/') &&
+        !value.includes('\\') &&
+        !value.includes('\0'));
+}
+async function safeLstat(path) {
+    try {
+        return await lstat(path);
+    }
+    catch {
+        return null;
+    }
+}
+function dirnameRelative(path) {
+    const slash = path.lastIndexOf('/');
+    return slash < 0 ? '' : path.slice(0, slash);
+}
+function procPath(fd) {
+    return `/proc/self/fd/${fd}`;
+}
+async function openDirectory(path) {
+    try {
+        const handle = await open(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+        return { path: procPath(handle.fd), close: () => handle.close() };
+    }
+    catch {
+        return null;
+    }
+}
+async function anchoredDirectory(root, directory) {
+    if (directory !== '' && !validRelative(directory))
+        return null;
+    let current = await openDirectory(root);
+    if (!current)
+        return null;
+    for (const segment of directory === '' ? [] : directory.split('/')) {
+        const next = await openDirectory(join(current.path, segment));
+        await current.close();
+        if (!next)
+            return null;
+        current = next;
+    }
+    return current;
+}
+async function reserveFile(path) {
+    const reservation = await open(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 0o600);
+    try {
+        return await reservation.stat();
+    }
+    finally {
+        await reservation.close();
+    }
+}
+async function reserveDirectory(path) {
+    await mkdir(path);
+    return lstat(path);
+}
+async function removeReservation(path, reservation, directory) {
+    const current = await safeLstat(path);
+    if (current?.dev === reservation.dev && current.ino === reservation.ino)
+        await rm(path, { recursive: directory, force: true }).catch(() => undefined);
+}
+async function stableAnchor(root, directory, anchor) {
+    try {
+        const current = await realpath(directory ? join(root, ...directory.split('/')) : root);
+        const anchored = await realpath(anchor);
+        return current === anchored && within(root, anchored);
+    }
+    catch {
+        return false;
+    }
+}
+async function copyTree(source, target, directory) {
+    if (!directory) {
+        const sourceHandle = await open(source, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            await copyFile(procPath(sourceHandle.fd), target, 0);
+        }
+        finally {
+            await sourceHandle.close();
+        }
+        return;
+    }
+    await mkdir(target);
+    for (const name of await readdir(source)) {
+        const childSource = join(source, name);
+        const metadata = await lstat(childSource);
+        if (metadata.isSymbolicLink() || name === '.git')
+            throw new Error('unsupported source');
+        if (metadata.isDirectory()) {
+            const child = await openDirectory(childSource);
+            if (!child)
+                throw new Error('source changed');
+            try {
+                await copyTree(child.path, join(target, name), true);
+            }
+            finally {
+                await child.close();
+            }
+        }
+        else {
+            await copyTree(childSource, join(target, name), false);
+        }
+    }
+}

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

@@ -3,7 +3,7 @@
  * 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, model TEXT, branch TEXT, 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, effective_skill_selection_json TEXT, last_org_plan_json TEXT, 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, turn_id TEXT, requested_at TEXT, resolved_at TEXT, outcome TEXT, operation_key TEXT, resolution_state TEXT NOT NULL DEFAULT 'active', 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, autopilot_outbox_id INTEGER, PRIMARY KEY (session_id, sequence), UNIQUE(session_id, autopilot_outbox_id)); 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)); CREATE TABLE IF NOT EXISTS autopilot_sessions (session_id TEXT PRIMARY KEY REFERENCES relay_sessions(id) ON DELETE CASCADE, state TEXT NOT NULL, requested_enabled INTEGER NOT NULL, plan_identity TEXT, plan_fingerprint TEXT, generation INTEGER NOT NULL, no_progress_count INTEGER NOT NULL, next_evaluation_at TEXT, last_control_id TEXT, stop_reason TEXT, updated_at TEXT NOT NULL); CREATE TABLE IF NOT EXISTS autopilot_controls (session_id TEXT NOT NULL REFERENCES relay_sessions(id) ON DELETE CASCADE, control_id TEXT NOT NULL, status TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, failure_code TEXT, turn_id TEXT, PRIMARY KEY (session_id, control_id)); CREATE TABLE IF NOT EXISTS autopilot_outbox (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL REFERENCES relay_sessions(id) ON DELETE CASCADE, type TEXT NOT NULL, payload_json TEXT NOT NULL, occurred_at TEXT NOT NULL);`;
+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, model TEXT, branch TEXT, sandbox TEXT, approval_policy TEXT, 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, effective_skill_selection_json TEXT, last_org_plan_json TEXT, 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, turn_id TEXT, requested_at TEXT, resolved_at TEXT, outcome TEXT, operation_key TEXT, resolution_state TEXT NOT NULL DEFAULT 'active', 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, autopilot_outbox_id INTEGER, PRIMARY KEY (session_id, sequence), UNIQUE(session_id, autopilot_outbox_id)); 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)); CREATE TABLE IF NOT EXISTS autopilot_sessions (session_id TEXT PRIMARY KEY REFERENCES relay_sessions(id) ON DELETE CASCADE, state TEXT NOT NULL, requested_enabled INTEGER NOT NULL, plan_identity TEXT, plan_fingerprint TEXT, generation INTEGER NOT NULL, no_progress_count INTEGER NOT NULL, next_evaluation_at TEXT, last_control_id TEXT, stop_reason TEXT, updated_at TEXT NOT NULL); CREATE TABLE IF NOT EXISTS autopilot_controls (session_id TEXT NOT NULL REFERENCES relay_sessions(id) ON DELETE CASCADE, control_id TEXT NOT NULL, status TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL, failure_code TEXT, turn_id TEXT, PRIMARY KEY (session_id, control_id)); CREATE TABLE IF NOT EXISTS autopilot_outbox (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL REFERENCES relay_sessions(id) ON DELETE CASCADE, type TEXT NOT NULL, payload_json TEXT NOT NULL, occurred_at TEXT NOT NULL);`;
 export function migrate(database) {
     database.exec(schema);
     database.exec("CREATE INDEX IF NOT EXISTS session_events_autopilot_audit_tail_v2 ON session_events(session_id, type, sequence DESC) WHERE type IN ('autopilot.continuation-scheduled','autopilot.control-issued','autopilot.turn-started','autopilot.turn-failed','autopilot.progress-reset','autopilot.updated','org-plan.attention-required','org-plan.attention-resolved')");
@@ -18,6 +18,10 @@ export function migrate(database) {
         database.exec('ALTER TABLE relay_sessions ADD COLUMN branch TEXT');
     if (!columns.some((column) => column.name === 'attention_tool_capability'))
         database.exec('ALTER TABLE relay_sessions ADD COLUMN attention_tool_capability TEXT');
+    if (!columns.some((column) => column.name === 'sandbox'))
+        database.exec('ALTER TABLE relay_sessions ADD COLUMN sandbox TEXT');
+    if (!columns.some((column) => column.name === 'approval_policy'))
+        database.exec('ALTER TABLE relay_sessions ADD COLUMN approval_policy TEXT');
     const interactionColumns = database
         .prepare('PRAGMA table_info(pending_interactions)')
         .all();

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

@@ -3,7 +3,7 @@
  * Designed by Denis Roio <jaromil@dyne.org>
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
-import { createEffectiveSkillSelection, } from '../../features/sessions/model/relay-session.js';
+import { createEffectiveSkillSelection, createSessionExecutionPolicy, } from '../../features/sessions/model/relay-session.js';
 export class SqliteSessionRepository {
     db;
     constructor(db) {
@@ -11,8 +11,8 @@ export class SqliteSessionRepository {
     }
     save(session) {
         this.db
-            .prepare('INSERT INTO relay_sessions (id,workspace_id,workspace_path,profile,model,branch,thread_id,state,desired_state,active_turn_id,protocol_version,attention_tool_capability,failure_count,effective_skill_selection_json,last_org_plan_json,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET workspace_id=excluded.workspace_id,workspace_path=excluded.workspace_path,profile=excluded.profile,model=excluded.model,branch=excluded.branch,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,attention_tool_capability=excluded.attention_tool_capability,failure_count=excluded.failure_count,effective_skill_selection_json=excluded.effective_skill_selection_json,last_org_plan_json=excluded.last_org_plan_json,updated_at=excluded.updated_at')
-            .run(session.id, session.workspaceId, session.workspacePath, session.profile, session.model ?? null, session.branch ?? null, session.threadId, session.state, session.desiredState, session.activeTurnId, session.protocolVersion, session.attentionToolCapability ?? null, session.failureCount, session.effectiveSkillSelection === undefined
+            .prepare('INSERT INTO relay_sessions (id,workspace_id,workspace_path,profile,model,branch,sandbox,approval_policy,thread_id,state,desired_state,active_turn_id,protocol_version,attention_tool_capability,failure_count,effective_skill_selection_json,last_org_plan_json,created_at,updated_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET workspace_id=excluded.workspace_id,workspace_path=excluded.workspace_path,profile=excluded.profile,model=excluded.model,branch=excluded.branch,sandbox=excluded.sandbox,approval_policy=excluded.approval_policy,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,attention_tool_capability=excluded.attention_tool_capability,failure_count=excluded.failure_count,effective_skill_selection_json=excluded.effective_skill_selection_json,last_org_plan_json=excluded.last_org_plan_json,updated_at=excluded.updated_at')
+            .run(session.id, session.workspaceId, session.workspacePath, session.profile, session.model ?? null, session.branch ?? null, session.executionPolicy?.sandbox ?? null, session.executionPolicy?.approvalPolicy ?? null, session.threadId, session.state, session.desiredState, session.activeTurnId, session.protocolVersion, session.attentionToolCapability ?? null, session.failureCount, session.effectiveSkillSelection === undefined
             ? null
             : JSON.stringify(session.effectiveSkillSelection), session.lastOrgPlan === undefined ? null : JSON.stringify(session.lastOrgPlan), session.createdAt, session.updatedAt);
     }
@@ -28,6 +28,13 @@ export class SqliteSessionRepository {
     }
 }
 function map(row) {
+    const sandbox = row.sandbox ?? null;
+    const approvalPolicy = row.approval_policy ?? null;
+    if (approvalPolicy === null && sandbox !== null)
+        throw new Error('SESSION_EXECUTION_POLICY_INVALID');
+    const executionPolicy = approvalPolicy === null
+        ? undefined
+        : createSessionExecutionPolicy({ sandbox: sandbox ?? undefined, approvalPolicy });
     const effectiveSkillSelection = row.effective_skill_selection_json
         ? createEffectiveSkillSelection(JSON.parse(row.effective_skill_selection_json))
         : undefined;
@@ -41,6 +48,7 @@ function map(row) {
         profile: row.profile,
         ...(row.model === null ? {} : { model: row.model }),
         ...(row.branch === null ? {} : { branch: row.branch }),
+        ...(executionPolicy === undefined ? {} : { executionPolicy }),
         threadId: row.thread_id,
         state: row.state,
         desiredState: row.desired_state,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gestalt-mobile",
-  "version": "0.20.1",
+  "version": "0.22.0",
   "description": "Mobile-first web relay for durable Codex development sessions",
   "keywords": [
     "codex",