@agent-api/app-engine 0.0.1

package/dist/workbench/settings-controller.js

@@ -0,0 +1,309 @@
+import { clearPresetToolCatalogCache, isAvailablePreset, listAvailablePresets, } from "../agent.js";
+import { loadWorkbenchPreferences, updateWorkbenchPreferences, } from "../config.js";
+import { ensureConfiguredIsolator, installConfiguredIsolator, normalizeSourceURL, relocateInstalledIsolator, validateInstalledIsolator, } from "./isolator-installer.js";
+export function createWorkbenchSettingsController(options = {}) {
+    const loadWorkbenchPreferencesImpl = options.loadWorkbenchPreferencesImpl ?? loadWorkbenchPreferences;
+    const updateWorkbenchPreferencesImpl = options.updateWorkbenchPreferencesImpl ?? updateWorkbenchPreferences;
+    const isAvailablePresetImpl = options.isAvailablePresetImpl ?? isAvailablePreset;
+    const listAvailablePresetsImpl = options.listAvailablePresetsImpl ?? listAvailablePresets;
+    const clearPresetToolCatalogCacheImpl = options.clearPresetToolCatalogCacheImpl ?? clearPresetToolCatalogCache;
+    const isolatorInstallOptions = options.isolatorInstallOptions ?? {};
+    const formatError = options.formatError ?? userFacingError;
+    return {
+        async loadInitial(agentOptions) {
+            const loadedPreferences = await loadWorkbenchPreferencesImpl();
+            const { preferences, activity, warning } = await reconcileConfiguredIsolator(loadedPreferences, updateWorkbenchPreferencesImpl, isolatorInstallOptions, formatError);
+            return {
+                defaultPreset: preferences.defaultPreset,
+                ...(preferences.isolation ? { shellIsolation: preferences.isolation } : {}),
+                ...(activity ? { activity } : {}),
+                ...(isolatorSetupNotice(preferences.isolation) ? { notice: isolatorSetupNotice(preferences.isolation) } : {}),
+                ...(warning ? { warning } : {}),
+                runPreset: shouldApplyDefaultPreset(agentOptions)
+                    ? effectiveDefaultPreset(preferences, agentOptions.preset)
+                    : undefined,
+            };
+        },
+        async saveShellIsolationMode(value) {
+            const mode = normalizeShellIsolationMode(value);
+            const preferences = await updateWorkbenchPreferencesImpl({
+                isolation: {
+                    mode,
+                    installSkipped: mode === "none" ? true : false,
+                },
+            });
+            return {
+                ...settingsSnapshot(preferences),
+                message: `Saved shell isolation mode: ${formatShellIsolation(preferences.isolation)}.`,
+                activity: `Shell isolation mode saved: ${preferences.isolation?.mode ?? "auto"}`,
+            };
+        },
+        async saveIsolatorPath(value) {
+            const executablePath = normalizeIsolatorPath(value);
+            if (!executablePath) {
+                const preferences = await updateWorkbenchPreferencesImpl({ isolation: { executablePath } });
+                return {
+                    ...settingsSnapshot(preferences),
+                    message: `Saved isolator path: ${formatIsolatorPath(preferences.isolation)}.`,
+                    activity: "Isolator path cleared",
+                };
+            }
+            const current = (await loadWorkbenchPreferencesImpl()).isolation;
+            if (current?.sourceURL) {
+                const result = await installConfiguredIsolator({
+                    sourceURL: current.sourceURL,
+                    executablePath,
+                    sha256: current.sha256,
+                }, isolatorInstallOptions);
+                const preferences = await updateWorkbenchPreferencesImpl({
+                    isolation: { executablePath: result.executablePath, sourceURL: result.sourceURL, sha256: result.sha256, installSkipped: false },
+                });
+                return {
+                    ...settingsSnapshot(preferences),
+                    message: `Installed isolator to ${result.executablePath}.`,
+                    activity: result.replaced ? "Isolator refreshed" : "Isolator installed",
+                };
+            }
+            const validatedPath = current?.executablePath
+                ? await relocateInstalledIsolator(current.executablePath, executablePath, isolatorInstallOptions)
+                : await validateInstalledIsolator(executablePath, isolatorInstallOptions);
+            const preferences = await updateWorkbenchPreferencesImpl({ isolation: { executablePath: validatedPath, installSkipped: false } });
+            return {
+                ...settingsSnapshot(preferences),
+                message: `Saved verified isolator path: ${formatIsolatorPath(preferences.isolation)}.`,
+                activity: "Isolator path verified",
+            };
+        },
+        async saveIsolatorSource(value) {
+            const sourceURL = normalizeIsolatorSource(value);
+            const current = (await loadWorkbenchPreferencesImpl()).isolation;
+            if (!sourceURL) {
+                const preferences = await updateWorkbenchPreferencesImpl({ isolation: { sourceURL, sha256: null } });
+                return {
+                    ...settingsSnapshot(preferences),
+                    message: "Cleared isolator source URL.",
+                    activity: "Isolator source cleared",
+                };
+            }
+            if (!current?.executablePath) {
+                throw new Error("Set a verified isolator path before saving a source URL.");
+            }
+            const result = await installConfiguredIsolator({
+                sourceURL,
+                executablePath: current.executablePath,
+                sha256: current.sha256,
+            }, isolatorInstallOptions);
+            const preferences = await updateWorkbenchPreferencesImpl({
+                isolation: { sourceURL: result.sourceURL, executablePath: result.executablePath, sha256: result.sha256, installSkipped: false },
+            });
+            return {
+                ...settingsSnapshot(preferences),
+                message: `Installed isolator from ${result.sourceURL}.`,
+                activity: result.replaced ? "Isolator refreshed from source" : "Isolator installed from source",
+            };
+        },
+        async saveDefaultPreset(input) {
+            const normalized = normalizeDefaultPreset(input.value);
+            if (typeof normalized === "string" && !(await isAvailablePresetImpl(input.profileName, normalized))) {
+                throw new UnknownPresetError(normalized);
+            }
+            const preferences = await updateWorkbenchPreferencesImpl({ defaultPreset: normalized });
+            return {
+                defaultPreset: preferences.defaultPreset,
+                ...(preferences.isolation ? { shellIsolation: preferences.isolation } : {}),
+                runPreset: shouldApplyDefaultPreset(input.options)
+                    ? effectiveDefaultPreset(preferences, input.options.preset)
+                    : undefined,
+                message: `Saved default preset: ${formatDefaultPreset(preferences.defaultPreset)}.`,
+                activity: `Default preset saved: ${formatDefaultPreset(preferences.defaultPreset)}`,
+            };
+        },
+        async validatePreset(profileName, preset) {
+            return isAvailablePresetImpl(profileName, preset);
+        },
+        async presetListText(input) {
+            try {
+                const presets = await listAvailablePresetsImpl(input.profileName);
+                return [
+                    input.prefix,
+                    "",
+                    "Available presets:",
+                    ...formatPresetList(presets, input.currentPreset),
+                ].join("\n");
+            }
+            catch (error) {
+                return [
+                    input.prefix,
+                    "",
+                    `Available presets could not be loaded: ${formatError(error)}`,
+                ].join("\n");
+            }
+        },
+        configText: runConfigText,
+        defaultPresetHelp(defaultPreset) {
+            return `Default preset: ${formatDefaultPreset(defaultPreset)}. Use /config preset <name>, /config preset none, or /config preset reset.`;
+        },
+        shellIsolationHelp(shellIsolation) {
+            return `Shell isolation: ${formatShellIsolation(shellIsolation)}. Use /config isolation none, /config isolation auto, or /config isolation required.`;
+        },
+        isolatorPathHelp(shellIsolation) {
+            return [
+                `Isolator path: ${formatIsolatorPath(shellIsolation)}`,
+                `Isolator source: ${formatIsolatorSource(shellIsolation)}`,
+                "Use /config isolator path <absolute-path>, /config isolator source <https-url>, or /config isolator none to clear the path.",
+            ].join("\n");
+        },
+        clearPresetToolCatalogCache(baseURL) {
+            clearPresetToolCatalogCacheImpl(baseURL);
+        },
+    };
+}
+export class UnknownPresetError extends Error {
+    preset;
+    constructor(preset) {
+        super(`Unknown preset: ${preset}`);
+        this.preset = preset;
+        this.name = "UnknownPresetError";
+    }
+}
+export function normalizeDefaultPreset(value) {
+    const trimmed = value.trim();
+    const lowered = trimmed.toLowerCase();
+    if (!trimmed || lowered === "reset" || lowered === "default" || lowered === "builtin")
+        return undefined;
+    if (["none", "off", "disable", "disabled"].includes(lowered))
+        return null;
+    return trimmed;
+}
+export function formatDefaultPreset(value) {
+    if (value === undefined)
+        return "built-in (pro-search)";
+    return value ?? "none";
+}
+function settingsSnapshot(preferences) {
+    return {
+        ...("defaultPreset" in preferences ? { defaultPreset: preferences.defaultPreset } : {}),
+        ...(preferences.isolation ? { shellIsolation: preferences.isolation } : {}),
+    };
+}
+export function normalizeShellIsolationMode(value) {
+    const lowered = value.trim().toLowerCase();
+    if (lowered === "none" || lowered === "off" || lowered === "disable" || lowered === "disabled")
+        return "none";
+    if (lowered === "auto" || lowered === "default")
+        return "auto";
+    if (lowered === "required" || lowered === "require" || lowered === "strict")
+        return "required";
+    throw new Error("Unknown shell isolation mode. Use none, auto, or required.");
+}
+export function normalizeIsolatorPath(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new Error("Usage: /config isolator <path>, or /config isolator none.");
+    const lowered = trimmed.toLowerCase();
+    if (["none", "off", "disable", "disabled", "clear", "reset"].includes(lowered))
+        return null;
+    return trimmed;
+}
+export function normalizeIsolatorSource(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new Error("Usage: /config isolator source <https-url>, or /config isolator source none.");
+    const lowered = trimmed.toLowerCase();
+    if (["none", "off", "disable", "disabled", "clear", "reset"].includes(lowered))
+        return null;
+    return normalizeSourceURL(trimmed);
+}
+export function formatShellIsolation(value) {
+    return value?.mode ?? "auto";
+}
+export function formatIsolatorPath(value) {
+    return value?.executablePath || process.env.AGENT_ISOLATOR_PATH || "not configured";
+}
+export function formatIsolatorSource(value) {
+    return value?.sourceURL || "not configured";
+}
+export function effectiveDefaultPreset(preferences, builtInPreset) {
+    if ("defaultPreset" in preferences)
+        return preferences.defaultPreset ?? undefined;
+    return builtInPreset;
+}
+export function formatPresetList(presets, currentPreset) {
+    if (presets.length === 0)
+        return ["- none returned by this endpoint"];
+    return presets.map((preset) => {
+        const description = preset.description ? ` - ${preset.description}` : "";
+        const current = currentPreset && preset.preset === currentPreset;
+        return `${current ? "*" : "-"} ${preset.preset}${current ? " (current)" : ""}${description}`;
+    });
+}
+function shouldApplyDefaultPreset(options) {
+    return !options.presetExplicit && !options.modelExplicit;
+}
+function runConfigText({ accessMode, contextEnabled, defaultPreset, profileName, runModel, runPreset, renderMode, shellIsolation, }) {
+    return [
+        `Profile: ${profileName}`,
+        `Preset: ${runPreset || "none"}`,
+        `Default preset: ${formatDefaultPreset(defaultPreset)}`,
+        `Model: ${runModel || "auto"}`,
+        `Render mode: ${renderMode}`,
+        `Shell isolation: ${formatShellIsolation(shellIsolation)}`,
+        `Isolator path: ${formatIsolatorPath(shellIsolation)}`,
+        `Isolator source: ${formatIsolatorSource(shellIsolation)}`,
+        `local_workdir tool: ${contextEnabled ? "on" : "off"}`,
+        `local_shell tool: ${contextEnabled ? "on" : "off"}`,
+        `Local access: ${accessMode}`,
+    ].join("\n");
+}
+function userFacingError(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+function isolatorSetupNotice(shellIsolation) {
+    if (process.env.AGENT_ISOLATOR_PATH)
+        return "";
+    if (shellIsolation?.installSkipped || shellIsolation?.mode === "none" || shellIsolation?.executablePath)
+        return "";
+    return [
+        "Local shell isolation is not configured yet.",
+        "",
+        "To enable it, set a verified target path and downloadable source URL:",
+        "/config isolator path <absolute-path>",
+        "/config isolator source <https-url>",
+        "",
+        "To skip this setup for future starts, use /config isolation none.",
+    ].join("\n");
+}
+async function reconcileConfiguredIsolator(preferences, updatePreferences, installOptions, formatError) {
+    const isolation = preferences.isolation;
+    if (!isolation?.sourceURL || !isolation.executablePath)
+        return { preferences };
+    try {
+        const result = await ensureConfiguredIsolator({
+            sourceURL: isolation.sourceURL,
+            executablePath: isolation.executablePath,
+            sha256: isolation.sha256,
+        }, installOptions);
+        if (!result.repaired)
+            return { preferences };
+        const updated = await updatePreferences({
+            isolation: {
+                sourceURL: result.sourceURL,
+                executablePath: result.executablePath,
+                sha256: result.sha256,
+                installSkipped: false,
+            },
+        });
+        return {
+            preferences: updated,
+            activity: `Reinstalled isolator: ${result.executablePath}`,
+        };
+    }
+    catch (error) {
+        return {
+            preferences,
+            warning: `Configured isolator is unavailable: ${formatError(error)}`,
+        };
+    }
+}

package/dist/workbench/shell-isolation.d.ts

@@ -0,0 +1,20 @@
+export type ShellIsolationMode = "none" | "auto" | "required";
+export interface ShellIsolationPreferences {
+    mode?: ShellIsolationMode;
+    executablePath?: string | null;
+    version?: string | null;
+    sourceURL?: string | null;
+    sha256?: string | null;
+    installSkipped?: boolean | null;
+}
+export declare function localShellIsolationOptions(preferences?: ShellIsolationPreferences): {
+    readonly isolator?: {
+        executablePath: string;
+    } | undefined;
+    readonly isolation: ShellIsolationMode;
+    readonly isolationOptions: {
+        readonly filesystem: "workdir-readwrite";
+        readonly network: "allowed";
+        readonly env: "inherit";
+    };
+};

package/dist/workbench/shell-isolation.js

@@ -0,0 +1,13 @@
+export function localShellIsolationOptions(preferences = {}) {
+    const executablePath = preferences.executablePath?.trim() || process.env.AGENT_ISOLATOR_PATH?.trim();
+    const isolation = preferences.mode ?? "auto";
+    return {
+        isolation,
+        isolationOptions: {
+            filesystem: "workdir-readwrite",
+            network: "allowed",
+            env: "inherit",
+        },
+        ...(executablePath ? { isolator: { executablePath } } : {}),
+    };
+}

package/dist/workbench/state.d.ts

@@ -0,0 +1,187 @@
+import type { LocalToolApprovalRequest, WorkdirAccessMode } from "../agent.js";
+import type { ShellIsolationPreferences } from "../workbench/shell-isolation.js";
+export type WorkbenchRole = "user" | "assistant" | "system";
+export interface WorkbenchMessage {
+    id: string;
+    role: WorkbenchRole;
+    text: string;
+}
+export type ActivityLevel = "info" | "success" | "warning" | "error";
+export interface WorkbenchActivity {
+    id: string;
+    level: ActivityLevel;
+    text: string;
+    timestamp: number;
+}
+export interface WorkbenchWorkdirStatus {
+    root: string;
+    name: string;
+    fileCount: number;
+    totalBytes: number;
+    scanTruncated: boolean;
+}
+export interface LocalToolApproval extends LocalToolApprovalRequest {
+    id: string;
+    createdAt: number;
+}
+export type RenderMode = "markdown" | "raw";
+export interface WorkbenchState {
+    messages: WorkbenchMessage[];
+    activities: WorkbenchActivity[];
+    busy: boolean;
+    contextEnabled: boolean;
+    workdir: WorkbenchWorkdirStatus | null;
+    activeAssistantMessageId: string | null;
+    pendingLocalTool: LocalToolApproval | null;
+    accessMode: WorkdirAccessMode;
+    currentConversation: string;
+    runPreset?: string;
+    runModel?: string;
+    renderMode: RenderMode;
+    defaultPreset?: string | null;
+    shellIsolation?: ShellIsolationPreferences;
+}
+export interface InputHistory {
+    record(value: string): void;
+    previous(currentDraft: string): string;
+    next(currentDraft: string): string;
+    reset(): void;
+    values(): string[];
+}
+export type WorkbenchAction = {
+    type: "message.add";
+    role: WorkbenchRole;
+    text: string;
+    id?: string;
+} | {
+    type: "message.append";
+    id: string;
+    delta: string;
+} | {
+    type: "messages.clear";
+} | {
+    type: "activity.add";
+    level?: ActivityLevel;
+    text: string;
+} | {
+    type: "busy.set";
+    busy: boolean;
+} | {
+    type: "context.toggle";
+} | {
+    type: "context.set";
+    enabled: boolean;
+} | {
+    type: "workdir.set";
+    workdir: WorkbenchWorkdirStatus;
+} | {
+    type: "assistant.active";
+    id: string | null;
+} | {
+    type: "local_tool.pending.set";
+    approval: LocalToolApprovalRequest;
+} | {
+    type: "local_tool.pending.clear";
+} | {
+    type: "access.set";
+    mode: WorkdirAccessMode;
+} | {
+    type: "conversation.set";
+    name: string;
+} | {
+    type: "settings.set";
+    settings: Partial<Pick<WorkbenchState, "runPreset" | "runModel" | "renderMode" | "defaultPreset" | "shellIsolation">>;
+};
+export type WorkbenchCommand = {
+    kind: "invalid";
+    command: string;
+} | {
+    kind: "abort";
+} | {
+    kind: "quit";
+} | {
+    kind: "help";
+} | {
+    kind: "clear";
+} | {
+    kind: "login";
+} | {
+    kind: "logout";
+} | {
+    kind: "delete_profile";
+} | {
+    kind: "switch_profile";
+    name?: string;
+} | {
+    kind: "auth_status";
+} | {
+    kind: "config";
+    field?: "preset" | "isolation" | "isolator";
+    value?: string;
+} | {
+    kind: "render";
+    mode?: RenderMode;
+} | {
+    kind: "transcript";
+} | {
+    kind: "export";
+    path?: string;
+} | {
+    kind: "context";
+    enabled?: boolean;
+} | {
+    kind: "workdir";
+    enabled?: boolean;
+} | {
+    kind: "access";
+    mode?: WorkdirAccessMode;
+} | {
+    kind: "preset";
+    value?: string;
+} | {
+    kind: "model";
+    value?: string;
+} | {
+    kind: "summary";
+} | {
+    kind: "search";
+    query: string;
+} | {
+    kind: "new_conversation";
+    name?: string;
+} | {
+    kind: "switch_conversation";
+    name: string;
+} | {
+    kind: "list_conversations";
+} | {
+    kind: "refresh_catalog";
+} | {
+    kind: "preview";
+} | {
+    kind: "apply";
+} | {
+    kind: "apply_all";
+} | {
+    kind: "reject";
+};
+export declare function createInitialWorkbenchState(options: {
+    contextEnabled: boolean;
+    accessMode?: WorkdirAccessMode;
+    conversation?: string;
+    preset?: string;
+    model?: string;
+    renderMode?: RenderMode;
+    defaultPreset?: string | null;
+    shellIsolation?: ShellIsolationPreferences;
+}): WorkbenchState;
+export declare function createInputHistory(limit?: number): InputHistory;
+export declare function workbenchReducer(state: WorkbenchState, action: WorkbenchAction): WorkbenchState;
+export declare function parseWorkbenchCommand(input: string): WorkbenchCommand | null;
+export declare function parsePendingApprovalCommand(input: string): WorkbenchCommand | null;
+export declare function helpText(): string;
+export declare function formatTranscript(messages: WorkbenchMessage[]): string;
+export declare function formatTranscriptPreview(messages: WorkbenchMessage[], maxLines?: number): string;
+export declare function workdirText(status: WorkbenchWorkdirStatus | null): string;
+export declare function formatBytes(bytes: number): string;
+export declare function activityColor(level: ActivityLevel): "green" | "yellow" | "red" | "gray";