toolroll 0.5.0

package/dist/coding-provider.d.ts

@@ -0,0 +1,72 @@
+import { type ProcessObservationFailure } from "./process-tree.js";
+/** Read-only recovery witnesses, never authority to signal historical PIDs.
+ * macOS ancestry is observational; a missed/failed observation stays fenced.
+ */
+export type CodingCustody = {
+    pid: number | null;
+    group: boolean;
+    descendants: {
+        pid: number;
+        group: boolean;
+    }[];
+    observationUnknown: boolean;
+    observationFailures?: ProcessObservationFailure[];
+    host: string;
+    bootId: string | null;
+    container?: {
+        backend: string;
+        id: string;
+        identity?: string;
+    };
+};
+export type CodingProviderEvent = {
+    kind: "notification";
+    method: string;
+    params: Record<string, unknown>;
+} | {
+    kind: "request";
+    id: string | number;
+    method: string;
+    params: Record<string, unknown>;
+} | {
+    kind: "custody";
+    custody: CodingCustody;
+} | {
+    kind: "exit";
+    message: string;
+};
+export interface CodingProvider {
+    request(method: string, params: Record<string, unknown>): Promise<unknown>;
+    respond(id: string | number, result: unknown): void;
+    reject(id: string | number, code: number, message: string): void;
+    subscribe(listener: (event: CodingProviderEvent) => void): () => void;
+    /** Retain this witness after disconnect. It is not permission to signal a saved PID. */
+    processId(): number | null;
+    custody(): CodingCustody;
+    /** Resolves only after exit is verified; a rejection must keep session custody fenced. */
+    close(): Promise<void>;
+}
+/** A response from the server, distinct from an ambiguous transport failure. */
+export declare class CodingProviderRequestError extends Error {
+    readonly code: number;
+    readonly data?: unknown;
+    readonly outcomeUnknown = false;
+    constructor(code: number, message: string, data?: unknown);
+}
+export declare class CodingProviderDisconnectedError extends Error {
+    readonly outcomeUnknown = true;
+    constructor(message?: string);
+}
+export declare class CodingProviderShutdownError extends Error {
+    constructor();
+}
+export declare function codingEnvironment(): NodeJS.ProcessEnv;
+/** Native app-server JSONL transport. It keeps Codex's normal config, tools and
+ * approval rules. There are no request/turn deadlines or automatic retries.
+ * Protocol: https://learn.chatgpt.com/docs/app-server (installed CLI schema).
+ */
+export declare function createCodexCodingProvider(options?: {
+    cwd?: string;
+    command?: string;
+    args?: string[];
+}): CodingProvider;

package/dist/coding-provider.js

@@ -0,0 +1,424 @@
+import { spawn } from "node:child_process";
+import { TextDecoder } from "node:util";
+import { hostname } from "node:os";
+import { currentBootId } from "./boot-identity.js";
+import { createContainer, currentContainment } from "./containment.js";
+import { processMayBeAlive } from "./process-liveness.js";
+import { observeProcessTree, sampleProcessTree, stopProcessTree } from "./process-tree.js";
+import { isOwnEnv } from "./names.js";
+/** A response from the server, distinct from an ambiguous transport failure. */
+export class CodingProviderRequestError extends Error {
+    code;
+    data;
+    outcomeUnknown = false;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = "CodingProviderRequestError";
+    }
+}
+export class CodingProviderDisconnectedError extends Error {
+    outcomeUnknown = true;
+    constructor(message = "Codex disconnected. The last request may have run; inspect the saved session before continuing.") {
+        super(message);
+        this.name = "CodingProviderDisconnectedError";
+    }
+}
+export class CodingProviderShutdownError extends Error {
+    constructor() {
+        super("Codex process cleanup could not be verified. Keep this session paused until its processes are confirmed stopped.");
+        this.name = "CodingProviderShutdownError";
+    }
+}
+// A corrupt/noisy child must never grow an unbounded transcript or write queue.
+// Fail the connection explicitly; never truncate a valid protocol message.
+const MAX_FRAME_BYTES = 16 * 1024 * 1024;
+const MAX_PENDING_REQUESTS = 128;
+const EXIT_GRACE_MS = 1_000;
+const own = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const requestId = (value) => typeof value === "string" || (typeof value === "number" && Number.isSafeInteger(value));
+export function codingEnvironment() {
+    const env = { ...process.env };
+    const invokingSession = new Set([
+        "CODEX_INTERNAL_ORIGINATOR_OVERRIDE", "CODEX_SESSION_ID", "CODEX_THREAD_ID",
+        "CODEX_SHELL", "CODEX_CI", "CODEX_VERSION", "CODEX_SAGE_BACKFILL_TRACKER_TAB_REUSE",
+    ]);
+    for (const key of Object.keys(env)) {
+        // Preserve native Codex auth, HOME, PATH, CODEX_HOME and project config.
+        // A parent desktop session's control pipe and identity do not belong to
+        // this independent native client. Keep install/runtime paths such as
+        // CODEX_MCP_NODE_PATH. Service credentials stay with the web service.
+        if (isOwnEnv(key) || /^(TELEGRAM|SLACK|DISCORD)_.*(TOKEN|SECRET|KEY)$/i.test(key) || /^CODEX_APP_TOOLS_/.test(key) || invokingSession.has(key) || key === "NODE_OPTIONS" || key === "NODE_PATH")
+            delete env[key];
+    }
+    return env;
+}
+/** Native app-server JSONL transport. It keeps Codex's normal config, tools and
+ * approval rules. There are no request/turn deadlines or automatic retries.
+ * Protocol: https://learn.chatgpt.com/docs/app-server (installed CLI schema).
+ */
+export function createCodexCodingProvider(options = {}) {
+    let child = null;
+    let container = null;
+    let initialization = null;
+    let shutdown = null;
+    let disconnected = null;
+    let closing = false;
+    let exited = false;
+    let resolveExit = null;
+    const didExit = new Promise(resolve => { resolveExit = resolve; });
+    const listeners = new Set();
+    const pending = new Map();
+    const incoming = new Set();
+    const descendants = new Map();
+    let ancestryUnknown = false;
+    const observationFailures = [];
+    const host = hostname();
+    // Bind the boot at creation, not when an old snapshot is requested later.
+    const bootId = currentBootId();
+    let nextId = 0;
+    let frameParts = [];
+    let frameBytes = 0;
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    function custody() {
+        const pid = child?.pid ?? null;
+        return {
+            pid, group: pid !== null && process.platform !== "win32",
+            descendants: [...descendants.values()].map(one => ({ ...one })),
+            observationUnknown: ancestryUnknown, host, bootId,
+            ...(observationFailures.length === 0 ? {} : { observationFailures: observationFailures.map(one => ({ ...one })) }),
+            ...(container === null ? {} : { container: { backend: container.backend, id: container.id, ...(container.identity === undefined ? {} : { identity: container.identity }) } }),
+        };
+    }
+    function custodyChanged() { emit({ kind: "custody", custody: custody() }); }
+    function emit(event) {
+        for (const listener of [...listeners]) {
+            try {
+                listener(event);
+            }
+            catch {
+                // A failed persistence/event consumer cannot silently drop an approval
+                // or part of the transcript while the agent continues to mutate files.
+                if (event.kind !== "exit")
+                    fail("Codex updates could not be recorded. The session was disconnected; inspect its saved result.");
+            }
+        }
+    }
+    function disconnect(message) {
+        if (disconnected !== null)
+            return;
+        disconnected = new CodingProviderDisconnectedError(message);
+        for (const one of pending.values())
+            one.reject(disconnected);
+        pending.clear();
+        incoming.clear();
+        frameParts = [];
+        frameBytes = 0;
+        emit({ kind: "exit", message });
+    }
+    function fail(message) {
+        disconnect(message);
+        // Keep the rejected cleanup promise for close() to expose to the owner.
+        // The local catch only prevents an unhandled rejection in an event handler.
+        void close().catch(() => { });
+    }
+    function write(message) {
+        if (disconnected !== null)
+            throw disconnected;
+        if (closing || child?.stdin === null || child === null || child.stdin.destroyed)
+            throw new CodingProviderDisconnectedError();
+        let line;
+        try {
+            line = `${JSON.stringify(message)}\n`;
+        }
+        catch {
+            throw new CodingProviderRequestError(-32602, "Codex request must contain JSON-serializable values.");
+        }
+        if (Buffer.byteLength(line) > MAX_FRAME_BYTES)
+            throw new CodingProviderRequestError(-32602, "Codex request exceeds the 16 MiB message limit.");
+        if (child.stdin.writableLength + Buffer.byteLength(line) > MAX_FRAME_BYTES * 2) {
+            throw new CodingProviderRequestError(-32001, "Codex is still receiving earlier requests. Wait before sending more.");
+        }
+        try {
+            child.stdin.write(line, error => { if (error !== null && error !== undefined)
+                fail("Codex could not receive a request. Its outcome is unknown; inspect the saved session."); });
+        }
+        catch {
+            fail("Codex could not receive a request. Its outcome is unknown; inspect the saved session.");
+            throw disconnected;
+        }
+    }
+    function send(method, params) {
+        if (pending.size >= MAX_PENDING_REQUESTS)
+            return Promise.reject(new CodingProviderRequestError(-32001, "Too many pending Codex requests. Wait for a response."));
+        const id = nextId++;
+        return new Promise((resolve, reject) => {
+            pending.set(id, { resolve, reject });
+            try {
+                write({ id, method, params });
+            }
+            catch (error) {
+                pending.delete(id);
+                reject(error);
+            }
+        });
+    }
+    function receive(frame) {
+        let message;
+        try {
+            message = JSON.parse(decoder.decode(frame));
+        }
+        catch {
+            fail("Codex sent an invalid protocol message. The session was disconnected; inspect its saved result.");
+            return;
+        }
+        if (!object(message)) {
+            fail("Codex sent an invalid protocol message.");
+            return;
+        }
+        if (own(message, "method")) {
+            if (typeof message.method !== "string" || message.method.length === 0 || own(message, "result") || own(message, "error") || (own(message, "params") && !object(message.params))) {
+                fail("Codex sent an invalid request or update.");
+                return;
+            }
+            const params = (message.params ?? {});
+            if (!own(message, "id")) {
+                if (message.method === "serverRequest/resolved" && requestId(params.requestId))
+                    incoming.delete(params.requestId);
+                emit({ kind: "notification", method: message.method, params });
+                return;
+            }
+            if (!requestId(message.id) || incoming.has(message.id)) {
+                fail("Codex sent an invalid or duplicate request identifier.");
+                return;
+            }
+            if (incoming.size >= MAX_PENDING_REQUESTS) {
+                fail("Codex sent too many unanswered requests. Inspect the saved session before continuing.");
+                return;
+            }
+            if (listeners.size === 0) {
+                // An absent UI/consumer must never imply consent or leave a tool waiting
+                // indefinitely for an approval nobody can see.
+                write({ id: message.id, error: { code: -32601, message: "No client is available to handle this request." } });
+                return;
+            }
+            incoming.add(message.id);
+            emit({ kind: "request", id: message.id, method: message.method, params });
+            return;
+        }
+        if (!requestId(message.id) || own(message, "result") === own(message, "error") || own(message, "params")) {
+            fail("Codex sent an invalid response.");
+            return;
+        }
+        const request = pending.get(message.id);
+        if (request === undefined) {
+            fail("Codex sent a response for an unknown request.");
+            return;
+        }
+        if (own(message, "error")) {
+            if (!object(message.error) || !Number.isSafeInteger(message.error.code) || typeof message.error.message !== "string") {
+                fail("Codex sent an invalid error response.");
+                return;
+            }
+            pending.delete(message.id);
+            request.reject(new CodingProviderRequestError(message.error.code, message.error.message, message.error.data));
+        }
+        else {
+            pending.delete(message.id);
+            request.resolve(message.result);
+        }
+    }
+    function read(chunk) {
+        if (disconnected !== null)
+            return;
+        let start = 0;
+        while (start < chunk.length && disconnected === null) {
+            const newline = chunk.indexOf(10, start);
+            const end = newline === -1 ? chunk.length : newline;
+            const part = chunk.subarray(start, end);
+            if (frameBytes + part.length > MAX_FRAME_BYTES) {
+                fail("Codex sent a message exceeding the 16 MiB limit. The session was disconnected; no message was truncated.");
+                return;
+            }
+            if (part.length) {
+                frameParts.push(part);
+                frameBytes += part.length;
+            }
+            if (newline === -1)
+                return;
+            const frame = Buffer.concat(frameParts, frameBytes);
+            frameParts = [];
+            frameBytes = 0;
+            if (frame.length) {
+                try {
+                    receive(frame);
+                }
+                catch {
+                    fail("Codex protocol handling failed. Inspect the saved session before continuing.");
+                }
+            }
+            start = newline + 1;
+        }
+    }
+    async function start() {
+        if (closing || disconnected !== null)
+            throw disconnected ?? new CodingProviderDisconnectedError("This Codex connection is closed.");
+        const made = createContainer(currentContainment(), "coding-session");
+        if ("refused" in made)
+            throw new CodingProviderRequestError(-32000, made.refused);
+        container = made.container;
+        const command = options.command ?? "codex";
+        const args = options.args ?? ["app-server", "--listen", "stdio://"];
+        let launch;
+        try {
+            launch = container?.launch(command, args);
+            child = spawn(launch?.file ?? command, launch?.args ?? args, {
+                ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+                env: codingEnvironment(),
+                shell: false, windowsHide: true, detached: process.platform !== "win32",
+                stdio: ["pipe", "pipe", "pipe", ...(launch?.extraStdio ?? [])],
+            });
+        }
+        catch {
+            container?.release();
+            container = null;
+            throw new CodingProviderRequestError(-32000, "Codex could not start. Check that the Codex CLI is installed and the project directory exists.");
+        }
+        if (container === null) {
+            // The existing observer has no Windows ancestry backend. A plain root
+            // PID there cannot establish tool-process exit without a native job.
+            if (process.platform === "win32")
+                ancestryUnknown = true;
+            observeProcessTree(child, {
+                onDescendant: (pid, group) => { descendants.set(`${pid}:${group}`, { pid, group }); custodyChanged(); },
+                onDescendantExit: (pid, group) => { descendants.delete(`${pid}:${group}`); custodyChanged(); },
+                onObservationFailure: failure => { observationFailures.push({ ...failure }); custodyChanged(); },
+                onUnknown: () => { if (!ancestryUnknown) {
+                    ancestryUnknown = true;
+                    custodyChanged();
+                } },
+            });
+        }
+        child.stdout.on("data", read);
+        child.stdout.once("end", () => {
+            if (disconnected === null && !closing)
+                fail(frameBytes ? "Codex disconnected with an incomplete protocol message. The request outcome is unknown." : "Codex closed its connection. Inspect the saved session before continuing.");
+        });
+        // Drain diagnostics without retaining or forwarding paths, prompts or credentials.
+        child.stderr.resume();
+        child.stdin.on("error", () => fail("Codex input disconnected. The last request may have run; inspect the saved session."));
+        child.stdout.on("error", () => fail("Codex updates disconnected. Inspect the saved session before continuing."));
+        child.stderr.on("error", () => { });
+        child.once("error", () => fail("Codex could not start or its process failed. Check the installed CLI and project directory."));
+        child.once("exit", () => {
+            exited = true;
+            resolveExit();
+            if (!closing)
+                fail("Codex exited. The last request may have run; inspect the saved session before continuing.");
+        });
+        // Failed spawn emits close without exit.
+        child.once("close", () => { exited = true; resolveExit(); });
+        // Publish the owned handle before initialization can start a native task.
+        // Even a failed initialize must leave its process/container witness behind.
+        custodyChanged();
+        if (launch !== undefined && child.pid !== undefined) {
+            const attached = await launch.attach(child);
+            if (!attached.ok)
+                throw new CodingProviderRequestError(-32000, "Codex could not enter the required process container.");
+        }
+        await send("initialize", {
+            clientInfo: { name: "toolroll", title: "Toolroll", version: "0.4.3" },
+            capabilities: { experimentalApi: true },
+        });
+        write({ method: "initialized", params: {} });
+    }
+    async function waitForExit(milliseconds) {
+        if (exited)
+            return true;
+        let timer;
+        await Promise.race([didExit, new Promise(resolve => { timer = setTimeout(resolve, milliseconds); })]);
+        if (timer !== undefined)
+            clearTimeout(timer);
+        return exited;
+    }
+    async function stop() {
+        closing = true;
+        disconnect("Codex connection closed. Pending request outcomes must be checked in the saved session.");
+        const owned = child;
+        if (owned === null)
+            return;
+        sampleProcessTree(owned);
+        owned.stdin?.end();
+        if (!await waitForExit(EXIT_GRACE_MS)) {
+            sampleProcessTree(owned);
+            owned.kill("SIGTERM");
+            if (!await waitForExit(EXIT_GRACE_MS)) {
+                if (container !== null)
+                    await container.kill();
+                else if (!stopProcessTree(owned))
+                    owned.kill("SIGKILL");
+                await waitForExit(EXIT_GRACE_MS);
+            }
+        }
+        let clean = exited;
+        if (container !== null) {
+            clean = await container.kill() && clean;
+            if (clean)
+                container.release();
+        }
+        else {
+            // Root exit cannot prove escaped tool-process exit. Do not signal saved
+            // descendants after ancestry is lost or silently release session custody.
+            const absent = () => (owned.pid === undefined || !processMayBeAlive(owned.pid, process.platform !== "win32")) && [...descendants.values()].every(({ pid, group }) => !processMayBeAlive(pid, group));
+            const until = Date.now() + EXIT_GRACE_MS;
+            while (!ancestryUnknown && !absent() && Date.now() < until)
+                await new Promise(resolve => setTimeout(resolve, 25));
+            clean = clean && !ancestryUnknown && absent();
+        }
+        if (!clean)
+            throw new CodingProviderShutdownError();
+        owned.stdout?.destroy();
+        owned.stderr?.destroy();
+    }
+    function close() {
+        if (shutdown === null) {
+            closing = true;
+            // Assign before invoking callbacks: an exit listener may also call close.
+            shutdown = Promise.resolve().then(stop);
+        }
+        return shutdown;
+    }
+    return {
+        async request(method, params) {
+            if (typeof method !== "string" || method.length === 0 || method === "initialize" || method === "initialized" || !object(params))
+                throw new CodingProviderRequestError(-32602, "Choose a valid Codex request method and parameters.");
+            if (closing || disconnected !== null)
+                throw disconnected ?? new CodingProviderDisconnectedError("This Codex connection is closed.");
+            initialization ??= start().catch(error => { fail("Codex initialization failed. Check the installed CLI before opening another connection."); throw error; });
+            await initialization;
+            return send(method, params);
+        },
+        respond(id, result) {
+            if (!incoming.has(id))
+                throw new CodingProviderRequestError(-32600, "This Codex request is no longer waiting for a response.");
+            if (result === undefined)
+                throw new CodingProviderRequestError(-32602, "A Codex response must contain a result.");
+            write({ id, result });
+            incoming.delete(id);
+        },
+        reject(id, code, message) {
+            if (!incoming.has(id))
+                throw new CodingProviderRequestError(-32600, "This Codex request is no longer waiting for a response.");
+            if (!Number.isSafeInteger(code) || !message.trim())
+                throw new CodingProviderRequestError(-32602, "A Codex rejection must contain an error code and message.");
+            write({ id, error: { code, message } });
+            incoming.delete(id);
+        },
+        subscribe(listener) { listeners.add(listener); return () => { listeners.delete(listener); }; },
+        processId() { return child?.pid ?? null; },
+        custody,
+        close,
+    };
+}

package/dist/coding-shipping-ui.d.ts

@@ -0,0 +1,4 @@
+import type { CodingHandoffPreview } from './coding-handoff.js';
+/** A reviewable handoff. The next screen retains the existing approval terms. */
+export declare function codingShippingHtml(preview: CodingHandoffPreview, csrf: string, values?: URLSearchParams, error?: string): string;
+export declare const CODING_SHIPPING_CSS = ".coding-workspace.coding-handoff{display:block;max-width:780px}.coding-handoff h1{margin-bottom:12px}.coding-handoff>p{margin-top:12px}.coding-workspace .coding-check{display:flex;align-items:center;gap:10px;min-height:44px}.coding-workspace .coding-check input{width:20px;height:20px;flex:0 0 20px}";

package/dist/coding-shipping-ui.js

@@ -0,0 +1,12 @@
+const escape = (value) => value.replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+/** A reviewable handoff. The next screen retains the existing approval terms. */
+export function codingShippingHtml(preview, csrf, values, error) {
+    const hidden = (name, value) => `<input type="hidden" name="${name}" value="${escape(value)}">`;
+    const goal = values?.get('goal') ?? preview.title;
+    const criteria = values?.get('acceptance') ?? '';
+    const notice = error?.startsWith('Review screenshots are not ready.')
+        ? `<p class="coding-notice" role="alert">Screenshots needed. Ask Codex to capture and commit them, then try again.</p><details><summary>Technical details</summary><p>${escape(error)}</p></details>`
+        : error ? `<p class="coding-notice" role="alert">${escape(error)}</p>` : '';
+    return `<section class="coding-workspace coding-handoff" data-coding-session=""><h1>Review for shipping</h1><p>${escape(preview.title)}</p>${notice}<form method="post" action="/code/${escape(preview.sessionId)}/ship" class="coding-start">${hidden('csrf', csrf)}${hidden('base', preview.base)}${hidden('candidate', preview.candidate)}${hidden('title', preview.title)}<label>Outcome<textarea name="goal" rows="4" required maxlength="16000">${escape(goal)}</textarea></label><label>Checks for review<textarea name="acceptance" rows="4" required maxlength="16000" placeholder="One observable result per line">${escape(criteria)}</textarea></label><label class="coding-check"><input type="checkbox" name="visual" value="yes"${values?.get('visual') === 'yes' ? ' checked' : ''}>Include desktop and phone screenshots</label><details><summary>${preview.changedPaths.length} changed files · commit ${escape(preview.candidate.slice(0, 8))}</summary><ul>${preview.changedPaths.map(path => `<li><code>${escape(path)}</code></li>`).join('')}</ul><p class="coding-meta">Review covers the complete change from ${escape(preview.base)} to ${escape(preview.candidate)}.</p></details><p class="coding-terms">Verification and publication use this project’s existing approval process.</p><button type="submit">Create review task</button></form><p><a href="/code/${escape(preview.sessionId)}">Back to coding</a></p></section>`;
+}
+export const CODING_SHIPPING_CSS = `.coding-workspace.coding-handoff{display:block;max-width:780px}.coding-handoff h1{margin-bottom:12px}.coding-handoff>p{margin-top:12px}.coding-workspace .coding-check{display:flex;align-items:center;gap:10px;min-height:44px}.coding-workspace .coding-check input{width:20px;height:20px;flex:0 0 20px}`;

package/dist/coding-types.d.ts

@@ -0,0 +1,62 @@
+import type { CodingContext } from './coding-context.js';
+export type CodingStatus = 'starting' | 'ready' | 'working' | 'needs-input' | 'stopping' | 'interrupted' | 'failed' | 'uncertain' | 'closed';
+export type CodingSession = {
+    id: string;
+    owner: string;
+    generation: number;
+    repo: string;
+    title: string;
+    provider: 'codex';
+    model: string | null;
+    branch: string;
+    base: string;
+    worktree: string;
+    nativeThreadId: string | null;
+    turnId: string | null;
+    status: CodingStatus;
+    error: string | null;
+    createdAt: string;
+    updatedAt: string;
+    deliveryReviewRequired?: boolean;
+    initialRequest?: {
+        requestId: string;
+        prompt: string;
+    };
+    context?: CodingContext;
+};
+export type CodingItem = {
+    id: string;
+    type: string;
+    text: string;
+    status: string | null;
+    clientId?: string;
+};
+export type CodingQuestion = {
+    id: string;
+    header: string;
+    question: string;
+    options: {
+        label: string;
+        description: string;
+    }[];
+};
+export type CodingRequest = {
+    id: string;
+    kind: 'command' | 'files' | 'questions';
+    method: string;
+    title: string;
+    detail: string;
+    questions: CodingQuestion[];
+};
+export type CodingSnapshot = {
+    session: CodingSession;
+    items: CodingItem[];
+    requests: CodingRequest[];
+    revision: number;
+};
+export type CodingChanges = {
+    head: string;
+    status: string;
+    diff: string;
+    truncated: boolean;
+};

package/dist/coding-types.js

@@ -0,0 +1 @@
+export {};

package/dist/coding-ui.d.ts

@@ -0,0 +1,17 @@
+import type { CodingSession, CodingSnapshot } from './coding-types.js';
+export declare function codingWorkspaceHtml(input: {
+    projects: {
+        path: string;
+        name: string;
+    }[];
+    sessions: CodingSession[];
+    selected: CodingSnapshot | null;
+    csrf: string;
+    project: string | null;
+    error?: string;
+    draft?: string;
+    available: boolean;
+    owner?: string;
+}): string;
+export declare const CODING_CSS = "\n.coding-workspace{display:grid;grid-template-columns:224px minmax(0,1fr);gap:24px;max-width:1220px;min-width:0;margin:0 auto;overflow-wrap:anywhere}\n.coding-workspace *{box-sizing:border-box}.coding-workspace [hidden]{display:none!important}.coding-workspace h1{font-size:1.45rem;line-height:1.25;margin:0}.coding-workspace h2{font-size:1rem;margin:0}.coding-workspace h3{font-size:1rem;margin:0 0 12px}.coding-workspace p{margin:0 0 12px}.coding-main,.coding-sidebar{min-width:0}.coding-meta,.coding-workspace small{font-size:.83rem;color:var(--muted-foreground,#747981)}\n.coding-sidebar-top,.coding-header,.coding-state-row,.coding-actions{display:flex;align-items:center;gap:12px;justify-content:space-between}.coding-sidebar-top{margin-bottom:12px}.coding-header{align-items:flex-start;margin-bottom:16px}.coding-header .coding-meta{margin:6px 0 0}.coding-session-detail{max-width:220px}.coding-session-detail summary{font-size:.82rem}.coding-session-detail dl{font-size:.82rem}.coding-session-detail dt{font-weight:600;margin-top:8px}.coding-session-detail dd{margin:2px 0 0}.coding-state-row{flex-wrap:wrap;padding:10px 0;border-bottom:1px solid var(--border,#353940);margin-bottom:12px}.coding-state-row p{margin:0;font-weight:600}.coding-state-row form{margin:0}\n.coding-session-list{max-height:74vh;overflow:auto}.coding-sidebar ul{list-style:none;margin:0;padding:0;display:grid;gap:4px}.coding-sidebar nav a{display:block;padding:12px;border-radius:10px;text-decoration:none;color:inherit}.coding-sidebar nav a:hover,.coding-sidebar nav a[aria-current]{background:var(--muted,#22252a)}.coding-sidebar nav a[aria-current]{box-shadow:inset 3px 0 var(--primary,#90bfa7)}.coding-sidebar nav span,.coding-sidebar nav small{display:block}.coding-sidebar nav [data-coding-status-for]{display:inline}.coding-sidebar nav small{margin-top:5px}.coding-mobile-sessions{display:none}\n.coding-workspace form:not(.coding-state-row form){display:grid;gap:12px;margin:0}.coding-workspace label{display:grid;gap:6px;font-size:.9rem;font-weight:500}.coding-workspace input,.coding-workspace textarea,.coding-workspace select{width:100%;min-width:0;max-width:100%;font-size:16px;border:1px solid var(--border,#353940);border-radius:8px;padding:11px 12px;background:var(--background,#14161a);color:var(--foreground,#f0f1f3)}.coding-workspace textarea{resize:vertical;line-height:1.5}.coding-workspace input:focus-visible,.coding-workspace textarea:focus-visible,.coding-workspace select:focus-visible,.coding-workspace button:focus-visible,.coding-workspace summary:focus-visible,.coding-workspace a:focus-visible{outline:2px solid var(--ring,#79acff);outline-offset:3px}.coding-workspace button,.coding-link-button{min-height:44px;padding:10px 15px;white-space:nowrap;border-radius:8px;max-width:100%;font-size:.9rem}.coding-workspace button{justify-self:start;cursor:pointer}.coding-workspace button:disabled{cursor:default;opacity:.55}.coding-workspace .coding-secondary{background:transparent;color:inherit;border:1px solid var(--border,#353940)}.coding-link-button{display:inline-flex;align-items:center;justify-content:center;text-decoration:none;color:inherit;border:1px solid var(--border,#353940)}.coding-workspace summary{cursor:pointer;min-height:44px;padding:12px 0}.coding-actions{justify-content:flex-start;flex-wrap:wrap}.coding-start{max-width:680px}.coding-options label+label{margin-top:12px}.coding-terms{font-size:.9rem;line-height:1.6;margin:0!important}.coding-empty{padding:28px 0}\n.coding-notice{border:1px solid var(--destructive,#bd7674);border-radius:10px;padding:12px;line-height:1.5;margin-bottom:16px}.coding-conversation{max-height:min(58vh,640px);min-height:140px;overflow:auto;overscroll-behavior:contain;scrollbar-gutter:stable;padding:4px 10px 12px 0}.coding-message{padding:14px 0}.coding-message strong{display:block;font-size:.78rem;margin-bottom:7px;color:var(--muted-foreground,#747981)}.coding-user{margin:8px 0 8px 32px;padding:14px 16px;border-radius:12px;background:var(--muted,#22252a)}.coding-text{white-space:pre-wrap;line-height:1.6;overflow-wrap:anywhere}.coding-tool{border-bottom:1px solid var(--border,#353940);font-size:.88rem}.coding-workspace pre{white-space:pre-wrap;overflow-wrap:anywhere;max-width:100%;font-size:.8rem;line-height:1.5;margin:0 0 12px}.coding-tool summary{display:list-item}.coding-tool summary span{margin-left:6px}.coding-composer{border-top:1px solid var(--border,#353940);padding-top:14px;margin-top:8px!important}.coding-composer label{font-size:.83rem}.coding-request{border:1px solid var(--border,#353940);border-radius:12px;padding:16px;margin:12px 0}.coding-permission-detail{max-height:240px;overflow:auto}.coding-changes{margin-top:20px;border-top:1px solid var(--border,#353940)}.coding-changes pre{max-height:min(50dvh,480px);overflow:auto}.coding-change-meta{font-size:.8rem}.coding-workspace #coding-latest{margin:8px 0}.coding-workspace #coding-connection{line-height:1.4}\n.coding-workspace .coding-start>button[type=\"submit\"],.coding-workspace .coding-composer button[type=\"submit\"]{background:var(--primary,#171717);color:var(--primary-foreground,#fff);border:1px solid var(--primary,#171717);font-weight:600;box-shadow:none}.coding-workspace .coding-start>button[type=\"submit\"]:not(:disabled):hover,.coding-workspace .coding-composer button[type=\"submit\"]:not(:disabled):hover{filter:brightness(.9)}\n.coding-workspace:not([data-coding-session=\"\"]) .coding-main{display:flex;flex-direction:column;min-height:calc(100dvh - 180px)}.coding-main>.coding-header,.coding-main>.coding-state-row,.coding-main>#coding-requests,.coding-main>.coding-composer,.coding-main>.coding-changes,.coding-main>.coding-notice,.coding-main>#coding-connection{flex-shrink:0}.coding-workspace:not([data-coding-session=\"\"]) .coding-conversation{flex:1 1 120px;min-height:100px;max-height:min(58dvh,640px)}.coding-workspace .coding-tool{margin:4px 0;padding:0 10px;border-radius:8px}.coding-workspace .coding-session-detail{margin:0;padding:0 10px;flex-shrink:0}.coding-workspace .coding-changes{padding:0 12px;margin-top:12px}.coding-text strong{display:inline;font-size:inherit;color:inherit;margin:0;font-weight:600}.coding-composer textarea{min-height:72px;max-height:180px}\n@media(max-width:760px){.coding-workspace{grid-template-columns:minmax(0,1fr);gap:16px}.coding-sidebar{border-bottom:1px solid var(--border,#353940);padding-bottom:12px}.coding-sidebar-top h2,.coding-session-list{display:none}.coding-sidebar-top{float:right;margin:0 0 8px 12px}.coding-mobile-sessions{display:block;max-width:100%;margin:0}.coding-mobile-sessions>nav{max-height:260px;overflow:auto;clear:both}.coding-mobile-sessions>summary{min-height:44px}.coding-header{display:block}.coding-session-detail{max-width:none;margin-top:4px}.coding-session-detail summary{padding:10px 0}.coding-conversation{max-height:52vh;min-height:100px;padding-right:4px}.coding-user{margin-left:16px}.coding-workspace h1{font-size:1.25rem}.coding-workspace button,.coding-link-button{padding:10px 12px}.coding-start{max-width:none}}\n@media(max-width:760px){.coding-workspace:not([data-coding-session=\"\"]) .coding-main{min-height:calc(100dvh - 245px - env(safe-area-inset-bottom,0px))}.coding-workspace:not([data-coding-session=\"\"]) .coding-conversation{min-height:80px}.coding-header{display:flex;gap:12px}.coding-header>div{min-width:0;flex:1}.coding-header:has(.coding-session-detail[open]){flex-wrap:wrap}.coding-workspace .coding-session-detail{max-width:100px}.coding-workspace .coding-session-detail[open]{max-width:100%;flex-basis:100%}.coding-session-detail summary{white-space:nowrap}.coding-workspace .coding-mobile-sessions{padding:0 12px}.coding-composer{gap:8px!important}.coding-composer textarea{height:72px}.coding-state-row{padding:8px 0;margin-bottom:8px}}\n@media(prefers-reduced-motion:reduce){.coding-workspace *{scroll-behavior:auto!important}}\n";
+export declare function codingWorkspaceScript(): string;