gestalt-mobile 0.1.0

package/dist/server/server/app.js

@@ -0,0 +1,148 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import fastifyStatic from '@fastify/static';
+import fastify, {} from 'fastify';
+import { registerGetHealth } from './features/health/get-health/endpoint.js';
+import { registerGetBootstrap } from './features/catalog/get-bootstrap/endpoint.js';
+import { registerGetGitSummary } from './features/git/get-summary/endpoint.js';
+import { registerPushUpstream } from './features/git/push-upstream/endpoint.js';
+import { registerRefreshGit } from './features/git/refresh/endpoint.js';
+import { registerPullRebase } from './features/git/pull-rebase/endpoint.js';
+import { registerCheckoutBranch } from './features/git/checkout-branch/endpoint.js';
+import { registerCloneRepository } from './features/git/clone-repository/endpoint.js';
+import { registerGetSession } from './features/sessions/get-session/endpoint.js';
+import { registerListSessions } from './features/sessions/list-sessions/endpoint.js';
+import { registerListRecentThreads, } from './features/sessions/list-recent-threads/endpoint.js';
+import { registerPromoteRecentThread } from './features/sessions/promote-recent-thread/endpoint.js';
+import { registerGetHistory } from './features/sessions/get-history/endpoint.js';
+import { registerStartSession } from './features/sessions/start-session/endpoint.js';
+import { registerStartTurn } from './features/sessions/start-turn/endpoint.js';
+import { registerInterruptTurn } from './features/sessions/interrupt-turn/endpoint.js';
+import { registerStopSession } from './features/sessions/stop-session/endpoint.js';
+import { registerRestoreSession } from './features/sessions/restore-session/endpoint.js';
+import { registerReleaseSession } from './features/sessions/release-session/endpoint.js';
+import { registerForgetSession } from './features/sessions/forget-session/endpoint.js';
+import { registerRespondInteraction } from './features/sessions/respond-interaction/endpoint.js';
+import { stopSession } from './features/sessions/lifecycle/use-case.js';
+import { registerSessionEvents } from './features/sessions/session-events/endpoint.js';
+import { registerProblemHandler } from './platform/http/problem-handler.js';
+export async function buildApp(deps) {
+    const app = fastify({ logger: false });
+    if (deps.staticDir)
+        await app.register(fastifyStatic, { root: deps.staticDir });
+    registerGetHealth(app, deps.health);
+    if (deps.bootstrap)
+        registerGetBootstrap(app, deps.bootstrap);
+    if (deps.recentThreads)
+        registerListRecentThreads(app, deps.recentThreads);
+    if (deps.sessionRoutes) {
+        registerStartSession(app, {
+            ...deps.sessionRoutes,
+            reportFailure: (operation, error) => deps.logger.error(`${operation} failed: ${safeErrorLabel(error)}`),
+        });
+        registerGetSession(app, deps.sessionRoutes.find);
+        if (deps.sessionRoutes.list)
+            registerListSessions(app, { list: deps.sessionRoutes.list });
+        if (deps.sessionRoutes.readHistory)
+            registerGetHistory(app, {
+                find: deps.sessionRoutes.find,
+                read: deps.sessionRoutes.readHistory,
+                currentSequence: deps.sessionRoutes.currentSequence ?? (() => 0),
+            });
+        if (deps.sessionRoutes.startTurn)
+            registerStartTurn(app, {
+                find: deps.sessionRoutes.find,
+                start: deps.sessionRoutes.startTurn,
+                save: deps.sessionRoutes.save,
+            });
+        if (deps.sessionRoutes.interruptTurn)
+            registerInterruptTurn(app, {
+                find: deps.sessionRoutes.find,
+                interrupt: deps.sessionRoutes.interruptTurn,
+            });
+        if (deps.sessionRoutes.restore)
+            registerRestoreSession(app, {
+                find: deps.sessionRoutes.find,
+                restore: deps.sessionRoutes.restore,
+                save: deps.sessionRoutes.save,
+                idempotency: deps.sessionRoutes.idempotency,
+            });
+        if (deps.recentThreads && deps.sessionRoutes.promoteRecent)
+            registerPromoteRecentThread(app, {
+                list: () => deps.recentThreads.list(),
+                promote: deps.sessionRoutes.promoteRecent,
+            });
+        if (deps.sessionRoutes.release && deps.sessionRoutes.close)
+            registerReleaseSession(app, {
+                find: deps.sessionRoutes.find,
+                release: deps.sessionRoutes.release,
+                save: deps.sessionRoutes.save,
+                close: deps.sessionRoutes.close,
+                idempotency: deps.sessionRoutes.idempotency,
+            });
+        if (deps.sessionRoutes.remove && deps.sessionRoutes.close)
+            registerForgetSession(app, {
+                find: deps.sessionRoutes.find,
+                close: deps.sessionRoutes.close,
+                remove: deps.sessionRoutes.remove,
+            });
+        if (deps.sessionRoutes.close)
+            registerStopSession(app, {
+                find: deps.sessionRoutes.find,
+                stop: (session) => stopSession(session, deps.sessionRoutes.now()),
+                save: deps.sessionRoutes.save,
+                close: deps.sessionRoutes.close,
+                idempotency: deps.sessionRoutes.idempotency,
+            });
+        if (deps.sessionRoutes.replyInteraction && deps.interactions)
+            registerRespondInteraction(app, {
+                exists: (id) => deps.sessionRoutes.find(id) !== null,
+                resolve: (sessionId, requestId, resolvedAt) => deps.interactions.resolve(sessionId, requestId, resolvedAt),
+                validate: deps.interactions.validate,
+                reply: deps.sessionRoutes.replyInteraction,
+                resolved: deps.sessionRoutes.interactionResolved,
+                now: deps.sessionRoutes.now,
+            });
+    }
+    if (deps.sessionEvents)
+        registerSessionEvents(app, deps.sessionEvents);
+    if (deps.gitSummary && deps.sessionRoutes)
+        registerGetGitSummary(app, { find: deps.sessionRoutes.find, inspect: deps.gitSummary.inspect });
+    if (deps.gitSummary && deps.sessionRoutes)
+        registerPushUpstream(app, {
+            find: deps.sessionRoutes.find,
+            inspect: deps.gitSummary.inspectForPush ?? deps.gitSummary.inspect,
+            push: deps.gitSummary.push,
+            idempotency: deps.sessionRoutes.idempotency,
+        });
+    if (deps.gitSummary && deps.sessionRoutes)
+        registerRefreshGit(app, {
+            find: deps.sessionRoutes.find,
+            refresh: deps.gitSummary.refresh,
+            idempotency: deps.sessionRoutes.idempotency,
+        });
+    if (deps.gitSummary?.pull && deps.gitSummary.checkout && deps.sessionRoutes) {
+        registerPullRebase(app, { find: deps.sessionRoutes.find, pull: deps.gitSummary.pull });
+        registerCheckoutBranch(app, {
+            find: deps.sessionRoutes.find,
+            checkout: deps.gitSummary.checkout,
+        });
+    }
+    if (deps.gitSummary?.clone)
+        registerCloneRepository(app, { clone: deps.gitSummary.clone });
+    registerProblemHandler(app, Boolean(deps.staticDir));
+    return app;
+}
+function safeErrorLabel(error) {
+    if (typeof error === 'object' && error !== null && 'code' in error) {
+        const code = error.code;
+        if (typeof code === 'string' && /^[A-Z0-9_]+$/.test(code))
+            return code;
+    }
+    if (error instanceof Error && /^[A-Z0-9_]+$/.test(error.message))
+        return error.message;
+    return error instanceof Error ? error.name : 'UNKNOWN_ERROR';
+}

package/dist/server/server/cli/list-sessions.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 { buildResumeCommand } from '../features/sessions/application/resume-command.js';
+export function formatSessions(sessions) {
+    if (!sessions.length)
+        return 'No sessions\n';
+    return sessions
+        .map((session) => `${session.id}\t${session.state}\t${session.profile}\t${session.workspaceId}\t${session.threadId ?? '-'}\n${session.threadId ? buildResumeCommand(session) : ''}`)
+        .join('\n');
+}

package/dist/server/server/cli.js

@@ -0,0 +1,126 @@
+/*
+ * 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 { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+import { composeRelayApp } from './composition.js';
+import { CliUsageError, parseConfig } from './config.js';
+import { CodexProfileCatalog } from './platform/catalog/codex-profile-catalog.js';
+const runFile = promisify(execFile);
+export const usage = `Usage: gestalt-mobile [options]
+
+Options:
+  --cwd <path>       Workspace root (default: current directory)
+  --host <address>   Listen address (default: 127.0.0.1)
+  --port <number>    Listen port (default: 3000)
+  --data-dir <path>  Directory for persistent application data
+  --help             Show this help
+  --version          Show the installed version`;
+export function packageRoot(moduleUrl) {
+    let directory = dirname(fileURLToPath(moduleUrl));
+    while (true) {
+        if (existsSync(resolve(directory, 'package.json')))
+            return directory;
+        const parent = dirname(directory);
+        if (parent === directory)
+            throw new Error('Gestalt Mobile package root is unavailable');
+        directory = parent;
+    }
+}
+export function packagedClientDir(moduleUrl) {
+    const directory = resolve(packageRoot(moduleUrl), 'dist/client');
+    return existsSync(resolve(directory, 'index.html')) ? directory : undefined;
+}
+export async function packageVersion(moduleUrl) {
+    const manifest = JSON.parse(await readFile(resolve(packageRoot(moduleUrl), 'package.json'), 'utf8'));
+    if (typeof manifest.version !== 'string')
+        throw new Error('Package version is unavailable');
+    return manifest.version;
+}
+export async function probeCodexVersion() {
+    return runFile('codex', ['--version'])
+        .then(({ stdout }) => stdout.trim() || null)
+        .catch(() => null);
+}
+export function installShutdownHandlers(app, signalSource = process) {
+    let closing;
+    const shutdown = () => {
+        closing ??= app.close();
+        return closing;
+    };
+    const onSignal = () => {
+        signalSource.removeListener('SIGINT', onSignal);
+        signalSource.removeListener('SIGTERM', onSignal);
+        void shutdown().catch((error) => {
+            process.exitCode = 1;
+            console.error(error instanceof Error ? error.message : 'Shutdown failed');
+        });
+    };
+    signalSource.once('SIGINT', onSignal);
+    signalSource.once('SIGTERM', onSignal);
+    return shutdown;
+}
+function parseInvocation(args, cwd) {
+    if (args.includes('--help')) {
+        if (args.length !== 1)
+            throw new CliUsageError('--help cannot be combined with other arguments');
+        return { command: 'help' };
+    }
+    if (args.includes('--version')) {
+        if (args.length !== 1)
+            throw new CliUsageError('--version cannot be combined with other arguments');
+        return { command: 'version' };
+    }
+    return { command: 'run', config: parseConfig(args, cwd) };
+}
+export async function runCli(dependencies = {}) {
+    const args = dependencies.args ?? process.argv.slice(2);
+    const cwd = dependencies.cwd ?? process.cwd();
+    const moduleUrl = dependencies.moduleUrl ?? import.meta.url;
+    const stdout = dependencies.stdout ?? process.stdout;
+    const stderr = dependencies.stderr ?? process.stderr;
+    let invocation;
+    try {
+        invocation = parseInvocation(args, cwd);
+    }
+    catch (error) {
+        if (!(error instanceof CliUsageError))
+            throw error;
+        stderr.write(`${error.message}\n\n${usage}\n`);
+        return error.exitCode;
+    }
+    if (invocation.command === 'help') {
+        stdout.write(`${usage}\n`);
+        return 0;
+    }
+    if (invocation.command === 'version') {
+        stdout.write(`${await packageVersion(moduleUrl)}\n`);
+        return 0;
+    }
+    const config = invocation.config;
+    const app = await (dependencies.compose ?? composeRelayApp)({
+        root: config.root,
+        dataDir: config.dataDir,
+        staticDir: packagedClientDir(moduleUrl),
+        profiles: new CodexProfileCatalog(),
+        installedCodexVersion: await (dependencies.probeCodexVersion ?? probeCodexVersion)(),
+        startAppServers: true,
+    });
+    installShutdownHandlers(app, dependencies.signalSource);
+    let address;
+    try {
+        address = await app.listen({ host: config.host, port: config.port });
+    }
+    catch (error) {
+        await app.close();
+        throw error;
+    }
+    stdout.write(`Gestalt Mobile listening on ${address}\n`);
+    return 0;
+}

package/dist/server/server/composition.js

@@ -0,0 +1,237 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { buildApp } from './app.js';
+import { FilesystemWorkspaceCatalog } from './platform/catalog/filesystem-workspace-catalog.js';
+import { protocolCompatibility } from './platform/codex/protocol-compatibility.js';
+import { launchCodexAppServer } from './platform/codex/codex-process-launcher.js';
+import { createRecentThreadLister } from './platform/codex/recent-thread-lister.js';
+import { CodexSessionRuntime } from './platform/codex/session-runtime.js';
+import { normalizeCodexNotification } from './platform/codex/normalizer.js';
+import { migrate } from './platform/persistence/migrate.js';
+import { openRelayDatabase } from './platform/persistence/sqlite.js';
+import { SqliteSessionRepository } from './platform/persistence/sqlite-session-repository.js';
+import { SqliteEventJournal } from './platform/persistence/sqlite-event-journal.js';
+import { SqlitePendingInteractionStore } from './platform/persistence/sqlite-pending-interaction-store.js';
+import { SqliteIdempotencyStore } from './platform/persistence/sqlite-idempotency-store.js';
+import { legacyRelayStatePath, relayStatePath } from './platform/persistence/state-path.js';
+import { SessionEventBus } from './platform/events/session-event-bus.js';
+import { checkoutBranch, cloneRepository, fetchUpstream, inspectGit, pullRebase, pushUpstream, } from './platform/git/git-inspector.js';
+import { GitFetchCoordinator } from './platform/git/git-fetch-coordinator.js';
+import { GitSummaryCache } from './platform/git/git-summary-cache.js';
+import { SessionSupervisor } from './platform/runtime/session-supervisor.js';
+import { mapWithConcurrency } from './platform/runtime/concurrency.js';
+import { RelaySession } from './features/sessions/model/relay-session.js';
+import { toPendingInteraction } from './platform/codex/server-request.js';
+import { isValidInteractionResponse } from './features/sessions/interaction/response-validator.js';
+import { promoteRecentThread } from './features/sessions/promote-recent-thread/use-case.js';
+const generatedProtocolVersion = 'codex-cli 0.144.3';
+export async function composeRelayApp(options) {
+    const root = resolve(options.root);
+    const databasePath = options.dataDir
+        ? join(resolve(options.dataDir), 'relay.sqlite')
+        : resolveStateDatabasePath(root, process.env.XDG_STATE_HOME ?? join(homedir(), '.local', 'state'));
+    const database = openRelayDatabase(databasePath);
+    migrate(database);
+    const sessions = new SqliteSessionRepository(database);
+    const journal = new SqliteEventJournal(database);
+    const interactions = new SqlitePendingInteractionStore(database);
+    const idempotency = new SqliteIdempotencyStore(database);
+    const withPendingInteractions = (session) => (session ? { ...session, pendingInteractions: interactions.list(session.id) } : null);
+    const events = new SessionEventBus();
+    const workspaces = new FilesystemWorkspaceCatalog(root);
+    const recentThreads = createRecentThreadLister({
+        root,
+        profiles: options.profiles,
+        launch: options.launchAppServer ?? launchCodexAppServer,
+    });
+    const protocol = protocolCompatibility(options.installedCodexVersion, generatedProtocolVersion);
+    const gitFetches = new GitFetchCoordinator(fetchUpstream);
+    const gitSummaries = new GitSummaryCache(inspectGit);
+    let recoverExitedSession = () => { };
+    const runtime = options.startAppServers
+        ? new CodexSessionRuntime(options.launchAppServer ?? launchCodexAppServer, undefined, (sessionId, notification) => {
+            const occurredAt = new Date().toISOString();
+            const normalized = normalizeCodexNotification(sessionId, 0, occurredAt, notification, sessions.find(sessionId)?.workspacePath);
+            if (!normalized)
+                return;
+            if (normalized.type === 'turnCompleted') {
+                const turnId = normalized.payload.turn?.id;
+                const session = sessions.find(sessionId);
+                if (session && turnId && session.activeTurnId === turnId)
+                    sessions.save(RelaySession.rehydrate(session).completeTurn(turnId, occurredAt).snapshot);
+            }
+            events.publish(journal.append(sessionId, normalized.type, normalized.payload, normalized.occurredAt));
+        }, (sessionId, request) => {
+            const interaction = toPendingInteraction(request);
+            const session = withPendingInteractions(sessions.find(sessionId));
+            if (!interaction || !session)
+                return false;
+            interactions.add(sessionId, interaction);
+            const updated = RelaySession.rehydrate(session).requestInteraction(interaction, new Date().toISOString()).snapshot;
+            sessions.save(updated);
+            events.publish(journal.append(sessionId, 'interaction.requested', interaction, updated.updatedAt));
+            return true;
+        }, (sessionId) => recoverExitedSession(sessionId))
+        : null;
+    const saveSession = (session) => {
+        sessions.save(session);
+        events.publish(journal.append(session.id, 'session.updated', session, session.updatedAt));
+    };
+    if (runtime) {
+        const supervisor = new SessionSupervisor(async (sessionId) => {
+            const session = sessions.find(sessionId);
+            if (!session || session.desiredState !== 'active' || !session.threadId)
+                return;
+            const recovering = RelaySession.rehydrate(session).beginRecovery(new Date().toISOString()).snapshot;
+            saveSession(recovering);
+            saveSession(await runtime.restore(recovering, new Date().toISOString()));
+        }, (sessionId) => {
+            const session = sessions.find(sessionId);
+            if (session)
+                saveSession(RelaySession.rehydrate(session).requireAttention(new Date().toISOString()).snapshot);
+        });
+        recoverExitedSession = (sessionId) => supervisor.recover(sessionId);
+    }
+    const app = await buildApp({
+        health: {
+            async read() {
+                return {
+                    status: protocol.compatible ? 'ok' : 'degraded',
+                    version: '0.1.0',
+                    codex: {
+                        installedVersion: options.installedCodexVersion,
+                        protocolVersion: generatedProtocolVersion,
+                        compatible: protocol.compatible,
+                    },
+                };
+            },
+        },
+        logger: console,
+        staticDir: options.staticDir,
+        recentThreads,
+        bootstrap: {
+            workspaces,
+            profiles: options.profiles,
+            sessions: {
+                list: () => sessions.list().map((session) => withPendingInteractions(session)),
+            },
+            protocolCompatible: protocol.compatible,
+        },
+        sessionRoutes: {
+            createId: randomUUID,
+            now: () => new Date().toISOString(),
+            save: saveSession,
+            find: (id) => withPendingInteractions(sessions.find(id)),
+            list: () => sessions.list().map((session) => withPendingInteractions(session)),
+            workspaces,
+            profiles: options.profiles,
+            activate: runtime
+                ? async (session, settings) => runtime.start(session, new Date().toISOString(), settings)
+                : undefined,
+            startTurn: runtime
+                ? async (session, text) => runtime.startTurn(session, text, new Date().toISOString())
+                : undefined,
+            readHistory: runtime ? (session) => runtime.readHistory(session) : undefined,
+            currentSequence: (sessionId) => journal.since(sessionId, 0).at(-1)?.sequence ?? 0,
+            interruptTurn: runtime
+                ? (session, turnId) => runtime.interruptTurn(session, turnId)
+                : undefined,
+            restore: runtime
+                ? (session) => runtime.restore(session, new Date().toISOString())
+                : undefined,
+            promoteRecent: runtime
+                ? (thread) => promoteRecentThread(thread, {
+                    createId: randomUUID,
+                    now: () => new Date().toISOString(),
+                    list: () => sessions.list(),
+                    save: saveSession,
+                    restore: (session) => runtime.restore(session, new Date().toISOString()),
+                })
+                : undefined,
+            release: (session) => RelaySession.rehydrate(session).release(new Date().toISOString()).snapshot,
+            remove: (id) => sessions.remove(id),
+            idempotency,
+            close: runtime ? (id) => runtime.stop(id) : undefined,
+            replyInteraction: runtime
+                ? (sessionId, requestId, value) => runtime.resolveServerRequest(sessionId, requestId, value)
+                : undefined,
+            interactionResolved: (sessionId, requestId, occurredAt) => {
+                events.publish(journal.append(sessionId, 'interaction.resolved', { requestId }, occurredAt));
+            },
+        },
+        sessionEvents: {
+            exists: (id) => sessions.find(id) !== null,
+            since: (id, after) => journal.since(id, after),
+            subscribe: (id, listener) => events.subscribe(id, listener),
+        },
+        interactions: {
+            resolve: (sessionId, requestId, resolvedAt) => interactions.resolve(sessionId, requestId, resolvedAt),
+            validate: (sessionId, requestId, value) => {
+                const interaction = interactions.find(sessionId, requestId);
+                if (!interaction)
+                    return false;
+                return isValidInteractionResponse(interaction.kind, value);
+            },
+        },
+        gitSummary: {
+            inspect: async (path) => {
+                const summary = await gitSummaries.inspect(path);
+                const fetchedAt = gitFetches.lastSuccessfulAt(path);
+                return { ...summary, fetchedAt: fetchedAt ? new Date(fetchedAt).toISOString() : null };
+            },
+            inspectForPush: inspectGit,
+            push: async (path, upstream) => {
+                await pushUpstream(path, upstream);
+                gitSummaries.invalidate(path);
+            },
+            refresh: async (path) => {
+                await gitFetches.refresh(path);
+                gitSummaries.invalidate(path);
+            },
+            pull: async (path) => {
+                await pullRebase(path);
+                gitSummaries.invalidate(path);
+            },
+            checkout: async (path, branch) => {
+                await checkoutBranch(path, branch);
+                gitSummaries.invalidate(path);
+            },
+            clone: async (workspaceId, address) => cloneRepository((await workspaces.resolve(workspaceId)).realPath, address),
+        },
+    });
+    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);
+            }
+        });
+    };
+    if (runtime)
+        app.addHook('onListen', () => void restoreActiveSessions());
+    app.addHook('onClose', async () => {
+        runtime?.stopAll();
+        database.close();
+    });
+    return app;
+}
+function resolveStateDatabasePath(root, stateHome) {
+    const currentPath = relayStatePath(root, stateHome);
+    if (existsSync(currentPath))
+        return currentPath;
+    const legacyPath = legacyRelayStatePath(root, stateHome);
+    return existsSync(legacyPath) ? legacyPath : currentPath;
+}

package/dist/server/server/config.js

@@ -0,0 +1,37 @@
+/*
+ * 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 CliUsageError extends Error {
+    exitCode = 2;
+}
+const optionNames = new Set(['--cwd', '--host', '--port', '--data-dir']);
+export function parseConfig(args, cwd = process.cwd()) {
+    const values = new Map();
+    for (let index = 0; index < args.length; index += 1) {
+        const option = args[index];
+        if (!option.startsWith('--'))
+            throw new CliUsageError(`Unexpected argument: ${option}`);
+        if (!optionNames.has(option))
+            throw new CliUsageError(`Unknown option: ${option}`);
+        if (values.has(option))
+            throw new CliUsageError(`Duplicate option: ${option}`);
+        const value = args[index + 1];
+        if (!value || value.startsWith('--'))
+            throw new CliUsageError(`Missing value for ${option}`);
+        values.set(option, value);
+        index += 1;
+    }
+    const portValue = values.get('--port') ?? '3000';
+    const port = Number(portValue);
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+        throw new CliUsageError(`Invalid --port: ${portValue}`);
+    return {
+        host: values.get('--host') ?? '127.0.0.1',
+        port,
+        root: resolve(cwd, values.get('--cwd') ?? '.'),
+        dataDir: values.get('--data-dir'),
+    };
+}

package/dist/server/server/features/catalog/application/ports.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/server/features/catalog/get-bootstrap/endpoint.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
+ */
+import { getBootstrap } from './use-case.js';
+export function registerGetBootstrap(app, deps) {
+    app.get('/api/bootstrap', async () => getBootstrap(deps));
+}

package/dist/server/server/features/catalog/get-bootstrap/request.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/server/features/catalog/get-bootstrap/response.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/server/features/catalog/get-bootstrap/use-case.js

@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+export async function getBootstrap(deps) {
+    const [workspaces, profiles] = await Promise.all([deps.workspaces.list(), deps.profiles.list()]);
+    return {
+        workspaces,
+        profiles,
+        sessions: deps.sessions.list(),
+        capabilities: {
+            approvals: true,
+            userInput: true,
+            git: true,
+            protocolCompatible: deps.protocolCompatible,
+        },
+    };
+}

package/dist/server/server/features/git/checkout-branch/endpoint.js

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { z } from 'zod';
+const requestSchema = z.object({ branch: z.string().min(1) });
+export function registerCheckoutBranch(app, deps) {
+    app.post('/api/sessions/:id/git/checkout', async (request, reply) => {
+        const session = deps.find(request.params.id);
+        if (!session)
+            return reply.code(404).send({ code: 'SESSION_NOT_FOUND' });
+        const parsed = requestSchema.safeParse(request.body);
+        if (!parsed.success)
+            return reply.code(400).send({ code: 'INVALID_BRANCH' });
+        try {
+            await deps.checkout(session.workspacePath, parsed.data.branch);
+            return reply.code(202).send({ accepted: true });
+        }
+        catch (error) {
+            return reply.code(409).send({
+                code: 'GIT_CHECKOUT_FAILED',
+                detail: error instanceof Error ? error.message : 'Git checkout failed.',
+            });
+        }
+    });
+}

package/dist/server/server/features/git/clone-repository/endpoint.js

@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2026 Dyne.org foundation
+ * Designed by Denis Roio <jaromil@dyne.org>
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+import { z } from 'zod';
+const requestSchema = z.object({
+    address: z.string().trim().min(1).max(2_048),
+    workspaceId: z.string().trim().min(1),
+});
+export function registerCloneRepository(app, deps) {
+    app.post('/api/git/clone', async (request, reply) => {
+        const parsed = requestSchema.safeParse(request.body);
+        if (!parsed.success)
+            return reply.code(400).send({ code: 'INVALID_CLONE_ADDRESS' });
+        await deps.clone(parsed.data.workspaceId, parsed.data.address);
+        return reply.code(202).send({ accepted: true });
+    });
+}