@xfey/tutti 0.1.0

package/dist/server-shell/cli/machine-local.js

@@ -0,0 +1,223 @@
+import { randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { ID_PREFIXES, isPrefixedId } from "@tutti/shared/ids";
+import { LaunchError } from "./errors.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function ensurePrivateDirectory(directoryPath) {
+    mkdirSync(directoryPath, { recursive: true, mode: 0o700 });
+    chmodSync(directoryPath, 0o700);
+}
+function writePrivateJsonFile(filePath, value) {
+    ensurePrivateDirectory(dirname(filePath));
+    const tempPath = `${filePath}.${process.pid}.tmp`;
+    writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    chmodSync(tempPath, 0o600);
+    renameSync(tempPath, filePath);
+    chmodSync(filePath, 0o600);
+}
+function readJsonFile(filePath) {
+    if (!existsSync(filePath)) {
+        return { kind: "missing" };
+    }
+    return { kind: "loaded", value: JSON.parse(readFileSync(filePath, "utf8")) };
+}
+export function getProjectLocalStoreRoot(tuttiHome, projectId) {
+    return join(tuttiHome, "projects", projectId);
+}
+export function getMachineProjectBindingPath(tuttiHome, projectId) {
+    return join(getProjectLocalStoreRoot(tuttiHome, projectId), "binding.json");
+}
+export function getMachineRuntimeEndpointPath(tuttiHome, projectId) {
+    return join(getProjectLocalStoreRoot(tuttiHome, projectId), "runtime", "endpoint.json");
+}
+export function createHostRegistrationSecretRef(projectId) {
+    return `host_registration:${projectId}`;
+}
+export function getHostRegistrationSecretPath(tuttiHome, projectId) {
+    return join(tuttiHome, "credentials", "host-registration", `${projectId}.json`);
+}
+export function createHostRegistrationSecret() {
+    return randomBytes(32).toString("base64url");
+}
+export function createMachineRuntimeEndpointToken() {
+    return randomBytes(32).toString("base64url");
+}
+export function readMachineProjectBinding(tuttiHome, projectId) {
+    const readResult = readJsonFile(getMachineProjectBindingPath(tuttiHome, projectId));
+    if (readResult.kind === "missing") {
+        return null;
+    }
+    const raw = readResult.value;
+    if (!isRecord(raw) ||
+        raw.project_id !== projectId ||
+        typeof raw.workspace_root !== "string" ||
+        typeof raw.local_store_root !== "string" ||
+        typeof raw.updated_at !== "string" ||
+        (raw.relay_project_ref !== undefined &&
+            (typeof raw.relay_project_ref !== "string" ||
+                !isPrefixedId(raw.relay_project_ref, ID_PREFIXES.relayProject))) ||
+        (raw.host_registration_secret_ref !== undefined &&
+            typeof raw.host_registration_secret_ref !== "string")) {
+        throw new LaunchError("project_identity_conflict", "Machine-local project binding is invalid or conflicts with the Git config project identity", "Inspect or remove the project binding under TUTTI_HOME after confirming it is not needed.");
+    }
+    const binding = {
+        project_id: raw.project_id,
+        workspace_root: raw.workspace_root,
+        local_store_root: raw.local_store_root,
+        updated_at: raw.updated_at,
+    };
+    if (raw.relay_project_ref !== undefined) {
+        binding.relay_project_ref = raw.relay_project_ref;
+    }
+    if (raw.host_registration_secret_ref !== undefined) {
+        binding.host_registration_secret_ref = raw.host_registration_secret_ref;
+    }
+    return binding;
+}
+export function readMachineRuntimeEndpoint(tuttiHome, projectId) {
+    const readResult = readJsonFile(getMachineRuntimeEndpointPath(tuttiHome, projectId));
+    if (readResult.kind === "missing") {
+        return null;
+    }
+    const raw = readResult.value;
+    if (!isRecord(raw) ||
+        raw.project_id !== projectId ||
+        typeof raw.pid !== "number" ||
+        !Number.isInteger(raw.pid) ||
+        typeof raw.base_url !== "string" ||
+        typeof raw.token !== "string" ||
+        raw.token.trim() === "" ||
+        typeof raw.workspace_root !== "string" ||
+        typeof raw.updated_at !== "string") {
+        throw new LaunchError("existing_server_unhealthy", "Machine-local runtime endpoint is invalid", "Remove the stale runtime endpoint after confirming no host server is running.");
+    }
+    return {
+        project_id: raw.project_id,
+        pid: raw.pid,
+        base_url: raw.base_url,
+        token: raw.token,
+        workspace_root: raw.workspace_root,
+        updated_at: raw.updated_at,
+    };
+}
+export function writeMachineRuntimeEndpoint(options) {
+    const now = (options.now ?? (() => new Date()))().toISOString();
+    const token = options.token ?? createMachineRuntimeEndpointToken();
+    if (token.trim() === "") {
+        throw new LaunchError("existing_server_unhealthy", "Machine-local runtime endpoint token must be non-empty", "Restart the host server so it can write a valid runtime endpoint.");
+    }
+    const record = {
+        project_id: options.projectId,
+        pid: options.pid,
+        base_url: options.baseUrl,
+        token,
+        workspace_root: resolve(options.workspaceRoot),
+        updated_at: now,
+    };
+    writePrivateJsonFile(getMachineRuntimeEndpointPath(options.tuttiHome, options.projectId), record);
+    return record;
+}
+export function deleteMachineRuntimeEndpoint(options) {
+    const endpointPath = getMachineRuntimeEndpointPath(options.tuttiHome, options.projectId);
+    if (!existsSync(endpointPath)) {
+        return false;
+    }
+    if (options.expectedToken !== undefined) {
+        const existing = readMachineRuntimeEndpoint(options.tuttiHome, options.projectId);
+        if (existing?.token !== options.expectedToken) {
+            return false;
+        }
+    }
+    unlinkSync(endpointPath);
+    return true;
+}
+export function readHostRegistrationSecret(tuttiHome, projectId) {
+    const readResult = readJsonFile(getHostRegistrationSecretPath(tuttiHome, projectId));
+    if (readResult.kind === "missing") {
+        throw new LaunchError("relay_registration_failed", "Host registration secret is missing from the machine-local credential store", "Run `tutti launch` again so Tutti can recreate the host registration credential.");
+    }
+    const raw = readResult.value;
+    if (!isRecord(raw) ||
+        raw.kind !== "host_registration_secret_v1" ||
+        raw.project_id !== projectId ||
+        typeof raw.secret !== "string" ||
+        raw.secret.trim() === "" ||
+        typeof raw.created_at !== "string" ||
+        typeof raw.updated_at !== "string") {
+        throw new LaunchError("relay_registration_failed", "Host registration secret file is invalid", "Remove the invalid host registration credential only after confirming this host should be re-registered.");
+    }
+    return {
+        kind: "host_registration_secret_v1",
+        project_id: raw.project_id,
+        secret: raw.secret,
+        created_at: raw.created_at,
+        updated_at: raw.updated_at,
+    };
+}
+export function updateMachineProjectRelayBinding(options) {
+    const existing = readMachineProjectBinding(options.tuttiHome, options.projectId);
+    if (existing === null) {
+        throw new LaunchError("relay_registration_failed", "Machine-local project binding is missing after Relay registration", "Run `tutti launch` again from the project workspace.");
+    }
+    const binding = {
+        ...existing,
+        relay_project_ref: options.relayProjectRef,
+        updated_at: (options.now ?? (() => new Date()))().toISOString(),
+    };
+    writePrivateJsonFile(getMachineProjectBindingPath(options.tuttiHome, options.projectId), binding);
+    return binding;
+}
+function ensureHostRegistrationSecret(tuttiHome, projectId, now) {
+    const secretPath = getHostRegistrationSecretPath(tuttiHome, projectId);
+    const ref = createHostRegistrationSecretRef(projectId);
+    if (existsSync(secretPath)) {
+        return { ref, created: false };
+    }
+    const timestamp = now().toISOString();
+    const secretFile = {
+        kind: "host_registration_secret_v1",
+        project_id: projectId,
+        secret: createHostRegistrationSecret(),
+        created_at: timestamp,
+        updated_at: timestamp,
+    };
+    writePrivateJsonFile(secretPath, secretFile);
+    return { ref, created: true };
+}
+export function ensureMachineProjectBinding(options) {
+    const now = options.now ?? (() => new Date());
+    const workspaceRoot = resolve(options.workspaceRoot);
+    const localStoreRoot = getProjectLocalStoreRoot(options.tuttiHome, options.projectId);
+    const bindingPath = getMachineProjectBindingPath(options.tuttiHome, options.projectId);
+    const secret = ensureHostRegistrationSecret(options.tuttiHome, options.projectId, now);
+    const existing = readMachineProjectBinding(options.tuttiHome, options.projectId);
+    if (existing !== null &&
+        resolve(existing.workspace_root) !== workspaceRoot &&
+        options.allowWorkspaceRootTakeover !== true) {
+        throw new LaunchError("project_identity_conflict", "This project is already bound to a different workspace root on this machine", "Use the future takeover flow, or remove the stale binding only after verifying no host server is running.");
+    }
+    const binding = {
+        project_id: options.projectId,
+        workspace_root: workspaceRoot,
+        local_store_root: localStoreRoot,
+        host_registration_secret_ref: existing?.host_registration_secret_ref ?? secret.ref,
+        updated_at: now().toISOString(),
+    };
+    if (existing?.relay_project_ref !== undefined) {
+        binding.relay_project_ref = existing.relay_project_ref;
+    }
+    writePrivateJsonFile(bindingPath, binding);
+    return {
+        binding,
+        binding_path: bindingPath,
+        host_registration_secret_ref: binding.host_registration_secret_ref ?? secret.ref,
+        host_registration_secret_created: secret.created,
+    };
+}
+//# sourceMappingURL=machine-local.js.map

package/dist/server-shell/cli/project-identity.d.ts

@@ -0,0 +1,20 @@
+import { type ProjectId } from "@tutti/shared/ids";
+export declare const PROJECT_ID_GIT_CONFIG_KEY = "tutti.project-id";
+export declare const PROJECT_DISPLAY_NAME_GIT_CONFIG_KEY = "tutti.project-display-name";
+export type ProjectIdentityReadResult = {
+    kind: "missing";
+} | {
+    kind: "present";
+    project_id: ProjectId;
+    source: "git_config";
+};
+export declare function readProjectIdentity(workspaceRoot: string): ProjectIdentityReadResult;
+export declare function writeProjectIdentity(workspaceRoot: string, projectId: ProjectId): void;
+export declare function readProjectDisplayName(workspaceRoot: string): string | null;
+export declare function writeProjectDisplayName(workspaceRoot: string, displayName: string): void;
+export declare function ensureProjectIdentity(workspaceRoot: string, projectId?: ProjectId): {
+    project_id: ProjectId;
+    created: boolean;
+    source: "git_config";
+};
+//# sourceMappingURL=project-identity.d.ts.map

package/dist/server-shell/cli/project-identity.js

@@ -0,0 +1,87 @@
+import { spawnSync } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import { createProjectId, ID_PREFIXES, isPrefixedId } from "@tutti/shared/ids";
+import { LaunchError } from "./errors.js";
+export const PROJECT_ID_GIT_CONFIG_KEY = "tutti.project-id";
+export const PROJECT_DISPLAY_NAME_GIT_CONFIG_KEY = "tutti.project-display-name";
+function runGitRaw(args, cwd) {
+    const result = spawnSync("git", [...args], {
+        cwd,
+        encoding: "utf8",
+        shell: false,
+    });
+    return {
+        status: result.status,
+        stdout: result.stdout ?? "",
+        stderr: result.stderr ?? "",
+        ...(result.error === undefined ? {} : { error: result.error }),
+    };
+}
+function runGit(args, cwd) {
+    const result = runGitRaw(args, cwd);
+    if (result.status !== 0) {
+        const stderr = result.stderr.trim();
+        throw new LaunchError("git_bootstrap_failed", stderr.length > 0 ? stderr : `git ${args.join(" ")} failed`, "Resolve the Git error and run `tutti launch` again.");
+    }
+    return result.stdout.trim();
+}
+function readGitTopLevel(workspaceRoot) {
+    const result = runGitRaw(["rev-parse", "--show-toplevel"], workspaceRoot);
+    if (result.status !== 0) {
+        return null;
+    }
+    return resolve(result.stdout.trim());
+}
+function resolvePhysicalPath(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
+export function readProjectIdentity(workspaceRoot) {
+    const resolvedWorkspaceRoot = resolve(workspaceRoot);
+    const gitTopLevel = readGitTopLevel(resolvedWorkspaceRoot);
+    if (gitTopLevel === null ||
+        resolvePhysicalPath(gitTopLevel) !== resolvePhysicalPath(resolvedWorkspaceRoot)) {
+        return { kind: "missing" };
+    }
+    const result = runGitRaw(["config", "--local", "--get", PROJECT_ID_GIT_CONFIG_KEY], resolvedWorkspaceRoot);
+    if (result.status !== 0) {
+        return { kind: "missing" };
+    }
+    const projectId = result.stdout.trim();
+    if (!isPrefixedId(projectId, ID_PREFIXES.project)) {
+        throw new LaunchError("unsupported_tutti_schema", "`tutti.project-id` must be a prj_<ULID> opaque id", "Fix the local Git config project identity before launching.");
+    }
+    return {
+        kind: "present",
+        project_id: projectId,
+        source: "git_config",
+    };
+}
+export function writeProjectIdentity(workspaceRoot, projectId) {
+    runGit(["config", "--local", PROJECT_ID_GIT_CONFIG_KEY, projectId], resolve(workspaceRoot));
+}
+export function readProjectDisplayName(workspaceRoot) {
+    const result = runGitRaw(["config", "--local", "--get", PROJECT_DISPLAY_NAME_GIT_CONFIG_KEY], resolve(workspaceRoot));
+    if (result.status !== 0) {
+        return null;
+    }
+    const displayName = result.stdout.trim();
+    return displayName.length === 0 ? null : displayName;
+}
+export function writeProjectDisplayName(workspaceRoot, displayName) {
+    runGit(["config", "--local", PROJECT_DISPLAY_NAME_GIT_CONFIG_KEY, displayName], resolve(workspaceRoot));
+}
+export function ensureProjectIdentity(workspaceRoot, projectId = createProjectId()) {
+    const existing = readProjectIdentity(workspaceRoot);
+    if (existing.kind === "present") {
+        return { project_id: existing.project_id, created: false, source: existing.source };
+    }
+    writeProjectIdentity(workspaceRoot, projectId);
+    return { project_id: projectId, created: true, source: "git_config" };
+}
+//# sourceMappingURL=project-identity.js.map

package/dist/server-shell/cli/relay-registration.d.ts

@@ -0,0 +1,31 @@
+import { type ConnectRelayHostTunnelOptions, type RelayHostTunnelHandle, type RegisterRelayHostConnectionOptions, type RegisterRelayHostConnectionResponse } from "@tutti/relay-client";
+import type { HostConnectionRef, RelayProjectRef } from "@tutti/shared/ids";
+import { LaunchError } from "./errors.js";
+import type { LaunchPreparationResult } from "./launch.js";
+type FetchLike = (input: string | URL, init?: RequestInit) => Promise<Response>;
+export type HostLaunchRelaySummary = {
+    relay_project_ref: RelayProjectRef;
+    host_connection_ref: HostConnectionRef;
+    join_url?: string;
+    join_url_visibility: "visible_once" | "not_recoverable";
+    join_token_expires_at?: string;
+    join_token_reusable: boolean;
+    tunnel_url: string;
+    connected_at: string;
+};
+export type RelayHostConnectionRegistrar = (options: RegisterRelayHostConnectionOptions) => Promise<RegisterRelayHostConnectionResponse>;
+export type RelayHostTunnelConnector = (options: ConnectRelayHostTunnelOptions) => RelayHostTunnelHandle;
+export type RegisteredRelayHostConnection = {
+    summary: HostLaunchRelaySummary;
+    hostConnectionToken: string;
+};
+export declare function relayErrorToLaunchError(error: unknown, relayUrl: string): LaunchError;
+export declare function registerHostWithRelay(options: {
+    preparation: LaunchPreparationResult;
+    fetchImpl: FetchLike;
+    registerRelayHostConnection: RelayHostConnectionRegistrar;
+    serverVersion: string;
+    now?: () => Date;
+}): Promise<RegisteredRelayHostConnection>;
+export {};
+//# sourceMappingURL=relay-registration.d.ts.map

package/dist/server-shell/cli/relay-registration.js

@@ -0,0 +1,61 @@
+import { basename } from "node:path";
+import { RelayHostControlClientError, } from "@tutti/relay-client";
+import { readHostRegistrationSecret, updateMachineProjectRelayBinding } from "./machine-local.js";
+import { LaunchError } from "./errors.js";
+import { readProjectDisplayName } from "./project-identity.js";
+export function relayErrorToLaunchError(error, relayUrl) {
+    if (error instanceof LaunchError) {
+        return error;
+    }
+    if (error instanceof RelayHostControlClientError) {
+        if (error.code === "relay_unavailable") {
+            return new LaunchError("relay_unavailable", `Cannot register host connection because Relay is unavailable at ${relayUrl}`, "Keep the project host stopped, start or fix Relay, then run `tutti launch` again.");
+        }
+        return new LaunchError("relay_registration_failed", `Relay rejected host registration${error.relayErrorCode === undefined ? "" : ` (${error.relayErrorCode})`}`, error.retryable
+            ? "Retry after Relay recovers, or run `tutti launch` again with a new registration command."
+            : "Check Relay host-control registration state and this machine's host registration credential.");
+    }
+    return new LaunchError("relay_registration_failed", "Relay host registration failed before a join URL could be created", "Retry `tutti launch`; if it keeps failing, inspect Relay host-control logs.");
+}
+export async function registerHostWithRelay(options) {
+    const hostSecret = readHostRegistrationSecret(options.preparation.tutti_home, options.preparation.project_id);
+    const registrationOptions = {
+        relayUrl: options.preparation.relay_url,
+        projectId: options.preparation.project_id,
+        hostRegistrationSecret: hostSecret.secret,
+        displayName: readProjectDisplayName(options.preparation.workspace_root) ??
+            (basename(options.preparation.workspace_root) || options.preparation.project_id),
+        serverVersion: options.serverVersion,
+        joinToken: { mode: "rotate" },
+        fetch: options.fetchImpl,
+        ...(options.now === undefined ? {} : { issuedAt: options.now() }),
+    };
+    const response = await options.registerRelayHostConnection(registrationOptions);
+    if (response.disposition.kind !== "registered" || response.result === undefined) {
+        throw new LaunchError("relay_registration_failed", "Relay host registration did not complete", "Retry `tutti launch` with a new registration command.");
+    }
+    const result = response.result;
+    if (result.join_token.visibility !== "visible_once" || result.join_token.join_url === undefined) {
+        throw new LaunchError("relay_registration_failed", "Relay did not return a visible join URL for this launch", "Retry `tutti launch` so the host can rotate a fresh visible-once join URL.");
+    }
+    updateMachineProjectRelayBinding({
+        tuttiHome: options.preparation.tutti_home,
+        projectId: options.preparation.project_id,
+        relayProjectRef: result.relay_project.relay_project_ref,
+        ...(options.now === undefined ? {} : { now: options.now }),
+    });
+    return {
+        summary: {
+            relay_project_ref: result.relay_project.relay_project_ref,
+            host_connection_ref: result.host_connection.host_connection_ref,
+            join_url: result.join_token.join_url,
+            join_url_visibility: result.join_token.visibility,
+            join_token_expires_at: result.join_token.expires_at,
+            join_token_reusable: result.join_token.reusable,
+            tunnel_url: result.host_connection.tunnel_url,
+            connected_at: result.host_connection.connected_at,
+        },
+        hostConnectionToken: result.host_connection_token,
+    };
+}
+//# sourceMappingURL=relay-registration.js.map

package/dist/server-shell/command-idempotency/index.d.ts

@@ -0,0 +1,44 @@
+import type { IdempotencyKey } from "@tutti/shared/ids";
+import { type CommandIdempotencyRecordLike, type CommandReplayDecision } from "@tutti/shared/utils/command-idempotency";
+import { type SqliteDatabase } from "../../store/index.js";
+export type CommandRequestHashInput = {
+    command_name: string;
+    target_ref?: string | null;
+    payload: unknown;
+};
+export type CommandIdempotencyRecordRow = {
+    command_id: IdempotencyKey;
+    command_name: string;
+    target_ref: string | null;
+    request_hash: string;
+    status: "in_progress" | "completed" | "failed";
+    disposition_json: string | null;
+};
+export type ExecuteIdempotentCommandOptions<TDisposition, TResult> = {
+    db: SqliteDatabase;
+    command_id: IdempotencyKey;
+    command_name: string;
+    target_ref?: string | null;
+    payload: unknown;
+    now?: () => Date;
+    execute: (tx: SqliteDatabase) => {
+        disposition: TDisposition;
+        result?: TResult;
+    };
+};
+export type ExecuteIdempotentCommandResult<TDisposition, TResult> = {
+    command_id: IdempotencyKey;
+    disposition: TDisposition;
+    result?: TResult;
+    replayed: boolean;
+};
+export declare class CommandReplayMismatchError extends Error {
+    readonly statusCode = 409;
+    readonly code = "command_replay_mismatch";
+    constructor();
+}
+export declare function createCommandRequestHash(input: CommandRequestHashInput): string;
+export declare function decideCommandIdempotencyReplay(record: CommandIdempotencyRecordLike | null | undefined, input: CommandRequestHashInput): CommandReplayDecision;
+export declare function readCommandIdempotencyRecord(db: SqliteDatabase, commandId: IdempotencyKey): CommandIdempotencyRecordLike | null;
+export declare function executeIdempotentCommand<TDisposition, TResult>(options: ExecuteIdempotentCommandOptions<TDisposition, TResult>): ExecuteIdempotentCommandResult<TDisposition, TResult>;
+//# sourceMappingURL=index.d.ts.map

package/dist/server-shell/command-idempotency/index.js

@@ -0,0 +1,155 @@
+import { createHash } from "node:crypto";
+import { createCommandRequestCanonicalInput, createInterruptedCommandDisposition, decideCommandReplay, redactCommandDisposition, } from "@tutti/shared/utils/command-idempotency";
+import { withHostStoreTransaction } from "../../store/index.js";
+export class CommandReplayMismatchError extends Error {
+    statusCode = 409;
+    code = "command_replay_mismatch";
+    constructor() {
+        super("Command idempotency replay payload does not match the original request");
+        this.name = "CommandReplayMismatchError";
+    }
+}
+export function createCommandRequestHash(input) {
+    const canonicalInput = createCommandRequestCanonicalInput(input);
+    const digest = createHash("sha256").update(canonicalInput, "utf8").digest("hex");
+    return `sha256:${digest}`;
+}
+export function decideCommandIdempotencyReplay(record, input) {
+    return decideCommandReplay(record, createCommandRequestHash(input));
+}
+function parseDisposition(json) {
+    if (json === null) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readCommandIdempotencyRecord(db, commandId) {
+    const row = db
+        .prepare(`
+        SELECT
+          command_id,
+          command_name,
+          target_ref,
+          request_hash,
+          status,
+          disposition_json
+        FROM command_idempotency_records
+        WHERE command_id = ?
+      `)
+        .get(commandId);
+    if (row === undefined) {
+        return null;
+    }
+    return {
+        command_id: row.command_id,
+        command_name: row.command_name,
+        target_ref: row.target_ref,
+        request_hash: row.request_hash,
+        status: row.status,
+        disposition: parseDisposition(row.disposition_json),
+    };
+}
+function startCommandIdempotencyRecord(options) {
+    options.db
+        .prepare(`
+        INSERT INTO command_idempotency_records (
+          command_id,
+          command_name,
+          target_ref,
+          request_hash,
+          status,
+          created_at,
+          updated_at
+        )
+        VALUES (?, ?, ?, ?, 'in_progress', ?, ?)
+      `)
+        .run(options.command_id, options.command_name, options.target_ref ?? null, options.request_hash, options.now, options.now);
+}
+function completeCommandIdempotencyRecord(options) {
+    options.db
+        .prepare(`
+        UPDATE command_idempotency_records
+        SET status = 'completed',
+            disposition_json = ?,
+            updated_at = ?,
+            completed_at = ?
+        WHERE command_id = ?
+          AND status = 'in_progress'
+      `)
+        .run(JSON.stringify(redactCommandDisposition(options.disposition)), options.now, options.now, options.command_id);
+}
+function interruptCommandIdempotencyRecord(options) {
+    const disposition = createInterruptedCommandDisposition();
+    options.db
+        .prepare(`
+        UPDATE command_idempotency_records
+        SET status = 'failed',
+            disposition_json = ?,
+            updated_at = ?,
+            completed_at = ?
+        WHERE command_id = ?
+          AND status = 'in_progress'
+      `)
+        .run(JSON.stringify(disposition), options.now, options.now, options.command_id);
+}
+export function executeIdempotentCommand(options) {
+    const now = (options.now ?? (() => new Date()))().toISOString();
+    const request = {
+        command_name: options.command_name,
+        target_ref: options.target_ref ?? null,
+        payload: options.payload,
+    };
+    const requestHash = createCommandRequestHash(request);
+    return withHostStoreTransaction(options.db, (tx) => {
+        const replay = decideCommandReplay(readCommandIdempotencyRecord(tx, options.command_id), requestHash);
+        if (replay.kind === "mismatch") {
+            throw new CommandReplayMismatchError();
+        }
+        if (replay.kind === "replay") {
+            return {
+                command_id: options.command_id,
+                disposition: replay.disposition,
+                replayed: true,
+            };
+        }
+        if (replay.kind === "in_progress") {
+            interruptCommandIdempotencyRecord({
+                db: tx,
+                command_id: options.command_id,
+                now,
+            });
+            return {
+                command_id: options.command_id,
+                disposition: replay.disposition,
+                replayed: true,
+            };
+        }
+        startCommandIdempotencyRecord({
+            db: tx,
+            command_id: options.command_id,
+            command_name: options.command_name,
+            target_ref: options.target_ref,
+            request_hash: requestHash,
+            now,
+        });
+        const executed = options.execute(tx);
+        completeCommandIdempotencyRecord({
+            db: tx,
+            command_id: options.command_id,
+            disposition: executed.disposition,
+            now,
+        });
+        return {
+            command_id: options.command_id,
+            disposition: executed.disposition,
+            ...(executed.result === undefined ? {} : { result: executed.result }),
+            replayed: false,
+        };
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/server-shell/dev-runner/cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/server-shell/dev-runner/cli.js

@@ -0,0 +1,10 @@
+import { redactError } from "@tutti/shared/utils";
+import { runDevRunner } from "./runner.js";
+try {
+    await runDevRunner();
+}
+catch (error) {
+    console.error(redactError(error));
+    process.exitCode = 1;
+}
+//# sourceMappingURL=cli.js.map

package/dist/server-shell/dev-runner/config.d.ts

@@ -0,0 +1,38 @@
+export type DevRunnerR2Config = {
+    endpoint: string;
+    bucket: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    region?: string;
+    uploadTtlSeconds?: number;
+    hostReadTtlSeconds?: number;
+};
+export type DevRunnerConfig = {
+    repoRoot: string;
+    tuttiHome: string;
+    targetWorkspaceRoot: string;
+    targetSource: "default_dummy" | "env_override";
+    r2?: DevRunnerR2Config;
+    relayUrl: string;
+    relayHost: string;
+    relayPort: number;
+    hostEndpointHost: string;
+    hostEndpointPort: number;
+    webHost: string;
+    webPort: number;
+    webUrl: string;
+};
+export type ResolveDevRunnerConfigOptions = {
+    env?: NodeJS.ProcessEnv;
+    repoRoot?: string;
+    userHome?: string;
+};
+export declare class DevRunnerConfigError extends Error {
+    readonly code: "invalid_port" | "invalid_r2_config" | "target_inside_repo";
+    constructor(code: "invalid_port" | "invalid_r2_config" | "target_inside_repo", message: string);
+}
+export declare function resolveDevRunnerConfig(options?: ResolveDevRunnerConfigOptions): DevRunnerConfig;
+export declare function ensureDevRunnerState(config: DevRunnerConfig): void;
+export declare function createDevProcessEnv(config: DevRunnerConfig, sourceEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function createDevRelayProcessEnv(config: DevRunnerConfig, sourceEnv?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+//# sourceMappingURL=config.d.ts.map