@agent-api/app-engine 0.0.1

package/dist/workbench/engine.js

@@ -0,0 +1,291 @@
+import { createInitialWorkbenchState, formatTranscript, formatTranscriptPreview, helpText, parsePendingApprovalCommand, parseWorkbenchCommand, workbenchReducer, workdirText, } from "./state.js";
+export function createWorkbenchEngine(options) {
+    let state = createInitialWorkbenchState(options);
+    let pendingApprovalInvalidInputs = 0;
+    const listeners = new Set();
+    const notify = () => {
+        for (const listener of listeners)
+            listener();
+    };
+    const dispatch = (action) => {
+        if (action.type === "local_tool.pending.set" || action.type === "local_tool.pending.clear") {
+            pendingApprovalInvalidInputs = 0;
+        }
+        const next = workbenchReducer(state, action);
+        if (Object.is(next, state))
+            return;
+        state = next;
+        notify();
+    };
+    return {
+        snapshot() {
+            return state;
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        dispatch,
+        handleCommand(command) {
+            switch (command.kind) {
+                case "quit":
+                    return handled({ type: "exit" });
+                case "login":
+                    return handled({ type: "login" });
+                case "logout":
+                    return handled({ type: "logout" });
+                case "delete_profile":
+                    return handled({ type: "delete_profile" });
+                case "switch_profile":
+                    return handled({ type: "switch_profile", name: command.name });
+                case "auth_status":
+                    return handled({ type: "show_auth_status" });
+                case "export":
+                    return handled({
+                        type: "export_transcript",
+                        path: command.path,
+                        transcript: formatTranscript(state.messages),
+                        conversation: state.currentConversation,
+                    });
+                case "refresh_catalog":
+                    dispatch({ type: "activity.add", level: "success", text: "Preset and tool catalogs refreshed" });
+                    dispatch({ type: "message.add", role: "system", text: "Cleared cached preset and server tool catalogs. The next agent turn will fetch fresh platform configuration." });
+                    return handled({ type: "clear_preset_tool_catalog_cache" });
+                case "invalid":
+                    dispatch({
+                        type: "message.add",
+                        role: "system",
+                        text: `Unknown command: /${command.command}\nType /help for supported commands.`,
+                    });
+                    dispatch({ type: "activity.add", level: "warning", text: `Unknown command: /${command.command}` });
+                    return handled();
+                case "help":
+                    dispatch({ type: "message.add", role: "system", text: helpText() });
+                    return handled();
+                case "clear":
+                    dispatch({ type: "messages.clear" });
+                    return handled();
+                case "render":
+                    if (!command.mode) {
+                        dispatch({ type: "message.add", role: "system", text: `Render mode: ${state.renderMode}. Use /render markdown or /render raw.` });
+                        return handled();
+                    }
+                    dispatch({ type: "settings.set", settings: { renderMode: command.mode } });
+                    dispatch({ type: "activity.add", level: "success", text: `Render mode: ${command.mode}` });
+                    dispatch({ type: "message.add", role: "system", text: `Render mode set to ${command.mode}.` });
+                    return handled();
+                case "transcript":
+                    dispatch({ type: "message.add", role: "system", text: formatTranscriptPreview(state.messages) });
+                    dispatch({ type: "activity.add", level: "success", text: "Transcript preview ready" });
+                    return handled();
+                case "context":
+                    dispatch({ type: "context.set", enabled: command.enabled ?? !state.contextEnabled });
+                    return handled();
+                case "access":
+                    if (!command.mode) {
+                        dispatch({ type: "message.add", role: "system", text: `Local access: ${state.accessMode}. Use /access off, /access approval, or /access full.` });
+                        return handled();
+                    }
+                    dispatch({ type: "access.set", mode: command.mode });
+                    return handled();
+                case "model":
+                    if (!command.value) {
+                        dispatch({ type: "message.add", role: "system", text: `Model: ${state.runModel || "auto"}. Use /model <name> or /model auto.` });
+                        return handled();
+                    }
+                    dispatch({ type: "settings.set", settings: { runModel: normalizeOptionalSetting(command.value, ["auto", "none", "off", "clear"]) } });
+                    dispatch({ type: "activity.add", text: `Model: ${normalizeOptionalSetting(command.value, ["auto", "none", "off", "clear"]) || "auto"}` });
+                    return handled();
+                case "workdir":
+                    if (command.enabled === undefined) {
+                        dispatch({
+                            type: "message.add",
+                            role: "system",
+                            text: [
+                                workdirText(state.workdir),
+                                "",
+                                `local_workdir tool: ${state.contextEnabled ? "on" : "off"}`,
+                                `local_shell tool: ${state.contextEnabled ? "on" : "off"}`,
+                                "Use /access approval or /access full to expose local tools, or /access off to hide them.",
+                            ].join("\n"),
+                        });
+                        return handled();
+                    }
+                    dispatch({ type: "context.set", enabled: command.enabled });
+                    dispatch({
+                        type: "activity.add",
+                        level: command.enabled ? "success" : "warning",
+                        text: `local tools ${command.enabled ? "enabled" : "disabled"}`,
+                    });
+                    dispatch({
+                        type: "message.add",
+                        role: "system",
+                        text: command.enabled
+                            ? "local_workdir and local_shell are now available to the model in approval mode. Use /access full to allow execution without prompts."
+                            : "local tools are now hidden from the model.",
+                    });
+                    return handled();
+                default:
+                    return unhandled();
+            }
+        },
+        handleAgentEvent(event) {
+            switch (event.type) {
+                case "text.delta":
+                    return event.delta ? eventResult({ type: "append_text_delta", delta: event.delta }) : eventResult();
+                case "response.started":
+                    if (event.responseID) {
+                        dispatch({ type: "activity.add", text: `Response started: ${event.responseID}` });
+                        return eventResult({ type: "set_active_response_id", responseID: event.responseID });
+                    }
+                    dispatch({ type: "activity.add", text: "Response started" });
+                    return eventResult();
+                case "response.completed":
+                    dispatch({ type: "activity.add", level: "success", text: event.responseID ? `Response completed: ${event.responseID}` : "Response completed" });
+                    return eventResult({ type: "flush_text_delta_buffer" });
+                case "response.failed":
+                    dispatch({ type: "activity.add", level: "error", text: event.message });
+                    return eventResult({ type: "flush_text_delta_buffer" });
+                case "reasoning.started":
+                    dispatch({ type: "activity.add", text: "Reasoning started" });
+                    return eventResult();
+                case "reasoning.stopped":
+                    dispatch({ type: "activity.add", text: event.thought ? `Reasoning stopped: ${event.thought}` : "Reasoning stopped" });
+                    return eventResult();
+                case "reasoning.search_queries":
+                    dispatch({ type: "activity.add", text: `Search queries: ${event.queries.join(", ") || "none"}` });
+                    return eventResult();
+                case "reasoning.search_results":
+                    dispatch({ type: "activity.add", text: `Search results: ${event.count}` });
+                    return eventResult();
+                case "reasoning.fetch_url_queries":
+                    dispatch({ type: "activity.add", text: `Fetch URLs: ${event.urls.join(", ") || "none"}` });
+                    return eventResult();
+                case "reasoning.fetch_url_results":
+                    dispatch({ type: "activity.add", text: `Fetched URL results: ${event.count}` });
+                    return eventResult();
+                case "tool.completed":
+                    dispatch({ type: "activity.add", level: event.status === "failed" ? "error" : "success", text: `Tool completed: ${event.name}${event.status ? ` (${event.status})` : ""}` });
+                    return eventResult();
+                case "local_tool.completed":
+                    dispatch({
+                        type: "activity.add",
+                        level: event.requiresApproval ? "warning" : "success",
+                        text: `Local tool: ${event.name}${event.action ? `.${event.action}` : ""}${event.requiresApproval ? " (approval required)" : ""}`,
+                    });
+                    return eventResult();
+                case "local_tool.approval_requested":
+                    dispatch({
+                        type: "local_tool.pending.set",
+                        approval: {
+                            name: event.name,
+                            action: event.action,
+                            arguments: event.arguments,
+                            preview: event.preview,
+                            callID: event.callID,
+                            responseID: event.responseID,
+                        },
+                    });
+                    dispatch({ type: "message.add", role: "system", text: formatLocalToolApproval(event) });
+                    return eventResult();
+                case "model.requested":
+                    dispatch({ type: "activity.add", text: `Model requested: ${modelLabel(event.model, event.provider)}` });
+                    return eventResult();
+                case "model.completed":
+                    dispatch({ type: "activity.add", level: "success", text: `Model completed: ${modelLabel(event.model, event.provider)}` });
+                    return eventResult();
+                case "model.failed":
+                    dispatch({ type: "activity.add", level: "error", text: `Model failed: ${modelLabel(event.model, event.provider)}` });
+                    return eventResult();
+                case "step.completed":
+                    dispatch({ type: "activity.add", level: "success", text: `Step completed: ${event.stepType || "step"}` });
+                    return eventResult();
+                case "step.failed":
+                    dispatch({ type: "activity.add", level: "error", text: `Step failed: ${event.stepType || "step"}` });
+                    return eventResult();
+                case "raw":
+                    return eventResult();
+            }
+        },
+        submit(input) {
+            const trimmed = input.trim();
+            if (!trimmed)
+                return { kind: "handled" };
+            if (state.pendingLocalTool) {
+                const command = parsePendingApprovalCommand(trimmed);
+                if (command) {
+                    pendingApprovalInvalidInputs = 0;
+                    return { kind: "command", command };
+                }
+                handleInvalidPendingApprovalInput();
+                return { kind: "handled" };
+            }
+            const command = parseWorkbenchCommand(trimmed);
+            if (command)
+                return { kind: "command", command };
+            return { kind: "prompt", prompt: trimmed };
+        },
+    };
+    function handleInvalidPendingApprovalInput() {
+        pendingApprovalInvalidInputs += 1;
+        const attempts = pendingApprovalInvalidInputs;
+        const maxAttempts = 3;
+        if (attempts >= maxAttempts) {
+            dispatch({
+                type: "message.add",
+                role: "system",
+                text: "Local approval aborted after too many invalid inputs. The pending action was not executed.",
+            });
+            dispatch({ type: "activity.add", level: "warning", text: "Local approval aborted" });
+            dispatch({ type: "local_tool.pending.clear" });
+            pendingApprovalInvalidInputs = 0;
+            return;
+        }
+        dispatch({
+            type: "message.add",
+            role: "system",
+            text: `Local approval is pending. Enter /apply or /yes to execute once, /apply-all or /yes-all to allow future local actions, or /reject or /no to discard. Invalid input ${attempts}/${maxAttempts}.`,
+        });
+        dispatch({ type: "activity.add", level: "warning", text: "Waiting for local approval command" });
+    }
+}
+function handled(...effects) {
+    return { handled: true, effects };
+}
+function unhandled() {
+    return { handled: false, effects: [] };
+}
+function eventResult(...effects) {
+    return { effects };
+}
+function modelLabel(model, provider) {
+    if (model && provider)
+        return `${provider}/${model}`;
+    return model || provider || "unknown";
+}
+function formatLocalToolApproval(event) {
+    const label = `${event.name}${event.action ? `.${event.action}` : ""}`;
+    return [
+        `Local action requires approval: ${label}.`,
+        event.preview ? `Preview:\n${formatPreview(event.preview)}` : undefined,
+        "Review it in the workbench, then use /apply to execute once, /apply-all to allow future local actions, or /reject to discard it.",
+    ].filter(Boolean).join("\n\n");
+}
+function formatPreview(preview) {
+    if (typeof preview === "string")
+        return preview;
+    try {
+        return JSON.stringify(preview, null, 2);
+    }
+    catch {
+        return String(preview);
+    }
+}
+function normalizeOptionalSetting(value, clearValues) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    return clearValues.includes(trimmed.toLowerCase()) ? undefined : trimmed;
+}

package/dist/workbench/input-controller.d.ts

@@ -0,0 +1,44 @@
+export interface WorkbenchInputKey {
+    backspace?: boolean;
+    ctrl?: boolean;
+    delete?: boolean;
+    downArrow?: boolean;
+    end?: boolean;
+    escape?: boolean;
+    home?: boolean;
+    meta?: boolean;
+    pageDown?: boolean;
+    pageUp?: boolean;
+    return?: boolean;
+    upArrow?: boolean;
+}
+export type WorkbenchInputEffect = {
+    type: "exit";
+} | {
+    type: "scroll";
+    delta: number;
+} | {
+    type: "scroll_top";
+} | {
+    type: "scroll_bottom";
+} | {
+    type: "abort";
+} | {
+    type: "submit";
+    input: string;
+} | {
+    type: "ignored_busy";
+};
+export interface WorkbenchInputResult {
+    draft: string;
+    effects: WorkbenchInputEffect[];
+}
+export interface WorkbenchInputContext {
+    busy: boolean;
+    draft: string;
+    viewportHeight: number;
+}
+export interface WorkbenchInputController {
+    handle(input: string, key: WorkbenchInputKey, context: WorkbenchInputContext): WorkbenchInputResult;
+}
+export declare function createWorkbenchInputController(): WorkbenchInputController;

package/dist/workbench/input-controller.js

@@ -0,0 +1,71 @@
+import { createInputHistory } from "./state.js";
+export function createWorkbenchInputController() {
+    const history = createInputHistory();
+    return {
+        handle(input, key, context) {
+            if (key.ctrl && input === "c")
+                return result(context.draft, { type: "exit" });
+            if (key.pageUp || (key.ctrl && input === "u")) {
+                return result(context.draft, { type: "scroll", delta: Math.max(1, Math.floor(context.viewportHeight / 2)) });
+            }
+            if (key.pageDown || (key.ctrl && input === "d")) {
+                return result(context.draft, { type: "scroll", delta: -Math.max(1, Math.floor(context.viewportHeight / 2)) });
+            }
+            if (key.home)
+                return result(context.draft, { type: "scroll_top" });
+            if (key.end)
+                return result(context.draft, { type: "scroll_bottom" });
+            if (key.upArrow)
+                return result(history.previous(context.draft));
+            if (key.downArrow)
+                return result(history.next(context.draft));
+            if (context.busy) {
+                return handleBusyInput(input, key, context.draft, history);
+            }
+            return handleReadyInput(input, key, context.draft, history);
+        },
+    };
+}
+function handleBusyInput(input, key, draft, history) {
+    if (key.escape)
+        return result(draft, { type: "abort" });
+    if (key.return) {
+        const command = draft.trim();
+        history.record(command);
+        if (command === "/abort" || command === "/cancel")
+            return result("", { type: "abort" });
+        if (command)
+            return result("", { type: "ignored_busy" });
+        return result("");
+    }
+    if (key.backspace || key.delete) {
+        history.reset();
+        return result(draft.slice(0, -1));
+    }
+    if (input && !key.ctrl && !key.meta) {
+        history.reset();
+        return result(draft + input);
+    }
+    return result(draft);
+}
+function handleReadyInput(input, key, draft, history) {
+    if (key.return) {
+        const prompt = draft.trim();
+        if (!prompt)
+            return result(draft);
+        history.record(prompt);
+        return result("", { type: "submit", input: prompt });
+    }
+    if (key.backspace || key.delete) {
+        history.reset();
+        return result(draft.slice(0, -1));
+    }
+    if (input && !key.ctrl && !key.meta) {
+        history.reset();
+        return result(draft + input);
+    }
+    return result(draft);
+}
+function result(draft, ...effects) {
+    return { draft, effects };
+}

package/dist/workbench/isolator-installer.d.ts

@@ -0,0 +1,29 @@
+export interface IsolatorInstallConfig {
+    sourceURL?: string | null;
+    executablePath?: string | null;
+    sha256?: string | null;
+}
+export interface IsolatorInstallResult {
+    executablePath: string;
+    sourceURL: string;
+    bytes: number;
+    sha256: string;
+    replaced: boolean;
+}
+export interface IsolatorEnsureResult {
+    executablePath: string;
+    sourceURL: string;
+    sha256?: string | null;
+    repaired: boolean;
+}
+export interface IsolatorInstallOptions {
+    fetchImpl?: typeof fetch;
+    probeTimeoutMs?: number;
+}
+export declare function installConfiguredIsolator(config: IsolatorInstallConfig, options?: IsolatorInstallOptions): Promise<IsolatorInstallResult>;
+export declare function validateInstalledIsolator(executablePath: string, options?: Pick<IsolatorInstallOptions, "probeTimeoutMs">): Promise<string>;
+export declare function ensureConfiguredIsolator(config: IsolatorInstallConfig, options?: IsolatorInstallOptions): Promise<IsolatorEnsureResult>;
+export declare function relocateInstalledIsolator(fromPath: string, toPath: string, options?: Pick<IsolatorInstallOptions, "probeTimeoutMs">): Promise<string>;
+export declare function defaultIsolatorInstallPath(): string;
+export declare function normalizeSourceURL(value: string | null | undefined): string;
+export declare function normalizeInstallPath(value: string | null | undefined): string;

package/dist/workbench/isolator-installer.js

@@ -0,0 +1,208 @@
+import { createHash } from "node:crypto";
+import { constants as fsConstants } from "node:fs";
+import { access, chmod, copyFile, mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { runtime } from "../runtime/index.js";
+export async function installConfiguredIsolator(config, options = {}) {
+    const sourceURL = normalizeSourceURL(config.sourceURL);
+    const executablePath = normalizeInstallPath(config.executablePath);
+    const targetDir = path.dirname(executablePath);
+    const existing = await existingTargetState(executablePath);
+    await mkdir(targetDir, { recursive: true });
+    await ensureWritableDirectory(targetDir);
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const response = await fetchImpl(sourceURL);
+    if (!response.ok) {
+        throw new Error(`isolator download failed: HTTP ${response.status}`);
+    }
+    const body = new Uint8Array(await response.arrayBuffer());
+    if (body.length === 0) {
+        throw new Error("isolator download failed: empty response body");
+    }
+    const actualSha256 = createHash("sha256").update(body).digest("hex");
+    const expectedSha256 = config.sha256?.trim().toLowerCase();
+    if (expectedSha256 && actualSha256 !== expectedSha256) {
+        throw new Error(`isolator checksum mismatch: expected ${expectedSha256}, got ${actualSha256}`);
+    }
+    const tempPath = path.join(targetDir, `.${path.basename(executablePath)}.${process.pid}.${Date.now()}.tmp`);
+    try {
+        await writeFile(tempPath, body, { mode: 0o700 });
+        if (process.platform !== "win32") {
+            await chmod(tempPath, 0o700);
+        }
+        await probeIsolator(tempPath, options.probeTimeoutMs ?? 10_000);
+        await rename(tempPath, executablePath);
+    }
+    catch (error) {
+        await rm(tempPath, { force: true });
+        throw error;
+    }
+    return {
+        executablePath,
+        sourceURL,
+        bytes: body.length,
+        sha256: actualSha256,
+        replaced: existing === "file",
+    };
+}
+export async function validateInstalledIsolator(executablePath, options = {}) {
+    const normalized = normalizeInstallPath(executablePath);
+    const state = await existingTargetState(normalized);
+    if (state !== "file") {
+        throw new Error(`isolator executable does not exist: ${normalized}`);
+    }
+    await probeIsolator(normalized, options.probeTimeoutMs ?? 10_000);
+    return normalized;
+}
+export async function ensureConfiguredIsolator(config, options = {}) {
+    const sourceURL = normalizeSourceURL(config.sourceURL);
+    const executablePath = normalizeInstallPath(config.executablePath);
+    try {
+        await validateInstalledIsolator(executablePath, options);
+        return {
+            executablePath,
+            sourceURL,
+            sha256: config.sha256,
+            repaired: false,
+        };
+    }
+    catch {
+        const result = await installConfiguredIsolator({ sourceURL, executablePath, sha256: config.sha256 }, options);
+        return {
+            executablePath: result.executablePath,
+            sourceURL: result.sourceURL,
+            sha256: result.sha256,
+            repaired: true,
+        };
+    }
+}
+export async function relocateInstalledIsolator(fromPath, toPath, options = {}) {
+    const source = await validateInstalledIsolator(fromPath, options);
+    const target = normalizeInstallPath(toPath);
+    if (source === target)
+        return target;
+    const targetDir = path.dirname(target);
+    await existingTargetState(target);
+    await mkdir(targetDir, { recursive: true });
+    await ensureWritableDirectory(targetDir);
+    const tempPath = path.join(targetDir, `.${path.basename(target)}.${process.pid}.${Date.now()}.tmp`);
+    try {
+        await copyFile(source, tempPath);
+        if (process.platform !== "win32") {
+            await chmod(tempPath, 0o700);
+        }
+        await probeIsolator(tempPath, options.probeTimeoutMs ?? 10_000);
+        await rename(tempPath, target);
+    }
+    catch (error) {
+        await rm(tempPath, { force: true });
+        throw error;
+    }
+    return target;
+}
+export function defaultIsolatorInstallPath() {
+    return path.join(runtime.dirs.data, "bin", process.platform === "win32" ? "agent-isolator.exe" : "agent-isolator");
+}
+export function normalizeSourceURL(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        throw new Error("isolator sourceURL is required");
+    let url;
+    try {
+        url = new URL(trimmed);
+    }
+    catch {
+        throw new Error("isolator sourceURL must be a valid URL");
+    }
+    if (url.protocol !== "https:") {
+        throw new Error("isolator sourceURL must use https");
+    }
+    return url.toString();
+}
+export function normalizeInstallPath(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        throw new Error("isolator executablePath is required");
+    if (!path.isAbsolute(trimmed)) {
+        throw new Error("isolator executablePath must be absolute");
+    }
+    const normalized = path.normalize(trimmed);
+    const root = path.parse(normalized).root;
+    if (normalized === root) {
+        throw new Error("isolator executablePath cannot be a filesystem root");
+    }
+    if (path.basename(normalized).startsWith(".")) {
+        throw new Error("isolator executablePath must not be a hidden temp-style filename");
+    }
+    return normalized;
+}
+async function existingTargetState(file) {
+    try {
+        const info = await stat(file);
+        if (!info.isFile()) {
+            throw new Error(`isolator executablePath exists but is not a file: ${file}`);
+        }
+        return "file";
+    }
+    catch (error) {
+        if (error?.code === "ENOENT")
+            return "missing";
+        throw error;
+    }
+}
+async function ensureWritableDirectory(dir) {
+    try {
+        await access(dir, fsConstants.W_OK);
+    }
+    catch {
+        throw new Error(`isolator target directory is not writable: ${dir}`);
+    }
+}
+async function probeIsolator(executablePath, timeoutMs) {
+    const request = JSON.stringify({ id: "status", method: "status", params: {} });
+    const child = spawn(executablePath, ["--once", "--driver=auto"], {
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+    });
+    const chunks = [];
+    const errors = [];
+    child.stdout.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+    child.stderr.on("data", (chunk) => errors.push(Buffer.from(chunk)));
+    child.stdin.end(`${request}\n`);
+    const code = await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            child.kill();
+            reject(new Error("isolator probe timed out"));
+        }, timeoutMs);
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on("close", (exitCode) => {
+            clearTimeout(timer);
+            resolve(exitCode);
+        });
+    });
+    const stdout = Buffer.concat(chunks).toString("utf8").trim();
+    const stderr = Buffer.concat(errors).toString("utf8").trim();
+    if (code !== 0) {
+        throw new Error(stderr || stdout || `isolator probe failed with exit code ${code}`);
+    }
+    const line = stdout.split(/\r?\n/).find(Boolean);
+    if (!line)
+        throw new Error("isolator probe returned no response");
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        throw new Error("isolator probe returned invalid JSON");
+    }
+    if (parsed?.error) {
+        throw new Error(parsed.error.message || parsed.error.code || "isolator probe failed");
+    }
+    if (!parsed?.result?.status?.driver) {
+        throw new Error("isolator probe response did not include shell isolation status");
+    }
+}

package/dist/workbench/lifecycle-controller.d.ts

@@ -0,0 +1,30 @@
+import type { WorkbenchAuthController } from "./auth-controller.js";
+import type { WorkbenchAction, WorkbenchWorkdirStatus } from "./state.js";
+import { checkForUpdate, formatUpdateNotice, type UpdateCheckResult } from "../update.js";
+export type WorkbenchLifecycleEffect = {
+    type: "dispatch";
+    action: WorkbenchAction;
+} | {
+    type: "close";
+    delayMs: number;
+};
+export interface WorkbenchLifecycleController {
+    maybeCheckForUpdate(): Promise<WorkbenchLifecycleEffect[]>;
+    refreshAuth(profile?: string): Promise<WorkbenchLifecycleEffect[]>;
+    initialPrompt(input: {
+        busy: boolean;
+        promptParts: string[];
+        requiresWorkdir?: boolean;
+        workdir: WorkbenchWorkdirStatus | null;
+    }): string | undefined;
+}
+export interface WorkbenchLifecycleControllerOptions {
+    authController: WorkbenchAuthController;
+    checkForUpdateImpl?: typeof checkForUpdate;
+    formatUpdateNoticeImpl?: typeof formatUpdateNotice;
+    formatError?: (error: unknown) => string;
+    refreshWindowMs?: number;
+    updateCheckEnabled?: boolean;
+}
+export declare function createWorkbenchLifecycleController(options: WorkbenchLifecycleControllerOptions): WorkbenchLifecycleController;
+export declare function updateNoticeEffects(result: UpdateCheckResult | null | undefined, formatNotice?: typeof formatUpdateNotice): WorkbenchLifecycleEffect[];