@agent-api/cli 0.2.1 → 0.3.1

package/dist/workbench/auth-gate-controller.js

@@ -1,231 +0,0 @@
-import { defaultBaseURL } from "../config.js";
-import { createWorkbenchAuthController, } from "./auth-controller.js";
-export const authMethods = [
-    { method: "browser", label: "Browser session", description: "Interactive login with refreshable local session." },
-    { method: "api_key", label: "API key", description: "Paste a static API key for shell-only environments." },
-    { method: "exit", label: "Exit", description: "Leave without signing in." },
-];
-export function createWorkbenchAuthGateController(options = {}) {
-    const authController = options.authController ?? createWorkbenchAuthController();
-    const formatError = options.formatError ?? userFacingError;
-    return {
-        authMethods,
-        initialState(input) {
-            return {
-                status: "checking",
-                selectedMethod: 0,
-                profile: input.profile || "default",
-                baseURL: input.baseURL || process.env.AGENT_API_BASE_URL || defaultBaseURL,
-                apiKey: input.apiKey || process.env.AGENT_API_KEY || "",
-                message: "Checking local auth profile...",
-                error: "",
-                browserURL: "",
-                browserCode: "",
-            };
-        },
-        async check(profile) {
-            try {
-                const result = await authController.check(profile);
-                return {
-                    profileName: result.profileName,
-                    state: readyState(profile || result.profileName, `Authenticated.`),
-                };
-            }
-            catch (error) {
-                return {
-                    state: selectState(profile || "default", "Choose an auth method to continue into the workbench.", formatError(error)),
-                };
-            }
-        },
-        handleInput(input, key, state) {
-            if (key.ctrl && input === "c")
-                return inputResult(state, { type: "exit" });
-            if (state.status === "ready" || state.status === "checking" || state.status === "browser_waiting")
-                return inputResult(state);
-            if (state.status === "select")
-                return handleSelectInput(key, state);
-            if (key.return)
-                return inputResult(state, { type: "submit" });
-            if (key.backspace || key.delete)
-                return inputResult(editAuthField(state, (value) => value.slice(0, -1)));
-            if (input && !key.ctrl && !key.meta)
-                return inputResult(editAuthField(state, (value) => value + input));
-            return inputResult(state);
-        },
-        async submit(state, submitOptions = {}) {
-            const profile = state.profile.trim() || "default";
-            const baseURL = state.baseURL.trim() || defaultBaseURL;
-            switch (state.status) {
-                case "api_profile":
-                    return { state: { ...state, profile, status: "api_base_url", error: "" } };
-                case "api_base_url":
-                    return { state: { ...state, baseURL, status: "api_key", error: "" } };
-                case "api_key":
-                    return loginWithAPIKey(authController, state, { baseURL, formatError, profile });
-                case "browser_profile":
-                    return { state: { ...state, profile, status: "browser_base_url", error: "" } };
-                case "browser_base_url":
-                    return loginWithBrowser(authController, state, { baseURL, formatError, onState: submitOptions.onState, profile });
-                default:
-                    return { state };
-            }
-        },
-        requestLogin(state, profileName) {
-            return {
-                ...state,
-                profile: profileName,
-                status: "select",
-                message: "Choose an auth method to continue into the workbench.",
-                error: "",
-            };
-        },
-        requestLogout(state, profileName) {
-            return {
-                ...state,
-                profile: profileName,
-                status: "select",
-                message: `Logged out of profile "${profileName}" for this app session. Choose an auth method to continue.`,
-                error: "",
-            };
-        },
-        requestSwitchProfile(state, currentProfile, nextProfile) {
-            return {
-                ...state,
-                profile: nextProfile || currentProfile,
-                status: "select",
-                message: nextProfile ? `Choose an auth method for profile "${nextProfile}".` : "Choose an auth method for another profile.",
-                error: "",
-            };
-        },
-        deletedProfile(state, profileName) {
-            return {
-                ...state,
-                status: "select",
-                message: `Deleted profile "${profileName}". Choose an auth method to continue.`,
-                error: "",
-            };
-        },
-    };
-}
-function handleSelectInput(key, state) {
-    if (key.upArrow) {
-        return inputResult({ ...state, selectedMethod: Math.max(0, state.selectedMethod - 1) });
-    }
-    if (key.downArrow) {
-        return inputResult({ ...state, selectedMethod: Math.min(authMethods.length - 1, state.selectedMethod + 1) });
-    }
-    if (key.return) {
-        const method = authMethods[state.selectedMethod]?.method;
-        if (method === "exit")
-            return inputResult(state, { type: "exit" });
-        return inputResult({
-            ...state,
-            status: method === "api_key" ? "api_profile" : "browser_profile",
-            message: method === "api_key" ? "Save an API key profile." : "Create a browser session profile.",
-            error: "",
-        });
-    }
-    return inputResult(state);
-}
-async function loginWithAPIKey(authController, state, input) {
-    const apiKey = state.apiKey.trim();
-    if (!apiKey)
-        return { state: { ...state, error: "API key is required." } };
-    const saving = { ...state, message: "Saving API key profile...", error: "" };
-    try {
-        const saved = await authController.loginAPIKey({ profile: input.profile, baseURL: input.baseURL, apiKey });
-        return {
-            profileName: saved.profileName,
-            state: { ...saving, status: "ready", message: `Signed in as profile "${input.profile}".`, error: "" },
-        };
-    }
-    catch (error) {
-        return { state: { ...saving, error: input.formatError(error) } };
-    }
-}
-async function loginWithBrowser(authController, state, input) {
-    const waiting = {
-        ...state,
-        profile: input.profile,
-        baseURL: input.baseURL,
-        status: "browser_waiting",
-        message: "Starting browser auth challenge...",
-        error: "",
-        browserURL: "",
-        browserCode: "",
-    };
-    input.onState?.(waiting);
-    try {
-        const saved = await authController.loginBrowser({
-            profile: input.profile,
-            baseURL: input.baseURL,
-            onChallenge(challenge) {
-                input.onState?.({
-                    ...waiting,
-                    message: "Open the URL to approve this terminal session.",
-                    browserURL: challenge.url,
-                    browserCode: challenge.code,
-                });
-            },
-            onStatus(status) {
-                input.onState?.({ ...waiting, message: `Browser auth status: ${status}` });
-            },
-        });
-        return {
-            profileName: saved.profileName,
-            state: { ...waiting, status: "ready", message: `Signed in as profile "${input.profile}".`, error: "" },
-        };
-    }
-    catch (error) {
-        return {
-            state: {
-                ...waiting,
-                status: "select",
-                message: "Browser auth did not complete. Choose an auth method to continue.",
-                error: input.formatError(error),
-            },
-        };
-    }
-}
-function editAuthField(state, update) {
-    switch (state.status) {
-        case "api_profile":
-        case "browser_profile":
-            return { ...state, profile: update(state.profile), error: "" };
-        case "api_base_url":
-        case "browser_base_url":
-            return { ...state, baseURL: update(state.baseURL), error: "" };
-        case "api_key":
-            return { ...state, apiKey: update(state.apiKey), error: "" };
-        default:
-            return state;
-    }
-}
-function readyState(profile, message) {
-    return {
-        status: "ready",
-        selectedMethod: 0,
-        profile,
-        baseURL: process.env.AGENT_API_BASE_URL || defaultBaseURL,
-        apiKey: process.env.AGENT_API_KEY || "",
-        message,
-        error: "",
-        browserURL: "",
-        browserCode: "",
-    };
-}
-function selectState(profile, message, error = "") {
-    return {
-        ...readyState(profile, message),
-        status: "select",
-        error,
-    };
-}
-function inputResult(state, ...effects) {
-    return { state, effects };
-}
-function userFacingError(error) {
-    if (error instanceof Error)
-        return error.message;
-    return String(error);
-}

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

@@ -1,29 +0,0 @@
-import type { AgentRunOptions } from "../agent.js";
-import type { WorkbenchCommand } from "../tui/workbench.js";
-import type { WorkbenchAuthController } from "./auth-controller.js";
-import type { WorkbenchConversationController } from "./conversation-controller.js";
-import type { WorkbenchEffect, WorkbenchEngine } from "./engine.js";
-import type { WorkbenchLocalController } from "./local-controller.js";
-import type { WorkbenchSettingsController } from "./settings-controller.js";
-import type { WorkbenchTurnController } from "./turn-controller.js";
-export interface WorkbenchCommandController {
-    run(command: WorkbenchCommand): Promise<void>;
-    runEffects(effects: WorkbenchEffect[]): Promise<void>;
-}
-export interface WorkbenchCommandControllerOptions {
-    authController: WorkbenchAuthController;
-    conversationController: WorkbenchConversationController;
-    engine: WorkbenchEngine;
-    localController: WorkbenchLocalController;
-    options: AgentRunOptions;
-    profileName: string;
-    settingsController: WorkbenchSettingsController;
-    turnController: WorkbenchTurnController;
-    onDeleteProfile(): Promise<void>;
-    onExit(): void;
-    onLogin(): void;
-    onLogout(): void;
-    onSwitchProfile(name?: string): void;
-}
-export declare function createWorkbenchCommandController(options: WorkbenchCommandControllerOptions): WorkbenchCommandController;
-export declare function normalizeOptionalSetting(value: string, clearValues: string[]): string | undefined;

package/dist/workbench/command-controller.js

@@ -1,426 +0,0 @@
-import { UnknownPresetError } from "./settings-controller.js";
-export function createWorkbenchCommandController(options) {
-    const dispatch = options.engine.dispatch;
-    return {
-        async run(command) {
-            const commandResult = options.engine.handleCommand(command);
-            if (commandResult.handled) {
-                await runEffects(commandResult.effects);
-                return;
-            }
-            switch (command.kind) {
-                case "abort":
-                    if (!options.engine.snapshot().busy) {
-                        dispatch({ type: "message.add", role: "system", text: "No agent turn is running." });
-                        return;
-                    }
-                    await options.turnController.abort("Abort requested.");
-                    return;
-                case "config":
-                    await runConfigCommand(command);
-                    return;
-                case "preset":
-                    await runPresetCommand(command.value);
-                    return;
-                case "summary":
-                    await showSummary();
-                    return;
-                case "search":
-                    await searchWorkdir(command.query);
-                    return;
-                case "new_conversation":
-                    await startNewConversation(command.name);
-                    return;
-                case "switch_conversation":
-                    switchConversation(command.name);
-                    return;
-                case "list_conversations":
-                    await showConversations();
-                    return;
-                case "preview":
-                    showEditPreview();
-                    return;
-                case "apply":
-                    await applyPendingEdit(false);
-                    return;
-                case "apply_all":
-                    await applyPendingEdit(true);
-                    return;
-                case "reject":
-                    rejectPendingEdit();
-                    return;
-            }
-        },
-        runEffects,
-    };
-    async function runEffects(effects) {
-        for (const effect of effects) {
-            switch (effect.type) {
-                case "exit":
-                    options.onExit();
-                    break;
-                case "login":
-                    options.onLogin();
-                    break;
-                case "logout":
-                    dispatch({ type: "activity.add", text: `Logged out: ${options.profileName}` });
-                    options.onLogout();
-                    break;
-                case "delete_profile":
-                    dispatch({ type: "activity.add", level: "warning", text: `Deleting profile: ${options.profileName}` });
-                    await options.onDeleteProfile();
-                    break;
-                case "switch_profile":
-                    options.onSwitchProfile(effect.name);
-                    break;
-                case "show_auth_status":
-                    await showAuthStatus();
-                    break;
-                case "export_transcript":
-                    await exportTranscript(effect);
-                    break;
-                case "clear_preset_tool_catalog_cache":
-                    options.settingsController.clearPresetToolCatalogCache();
-                    break;
-            }
-        }
-    }
-    async function runConfigCommand(command) {
-        const state = options.engine.snapshot();
-        if (!command.field) {
-            dispatch({
-                type: "message.add",
-                role: "system",
-                text: options.settingsController.configText({
-                    profileName: options.profileName,
-                    runPreset: state.runPreset,
-                    runModel: state.runModel,
-                    accessMode: state.accessMode,
-                    contextEnabled: state.contextEnabled,
-                    defaultPreset: state.defaultPreset,
-                    renderMode: state.renderMode,
-                    shellIsolation: state.shellIsolation,
-                }),
-            });
-            return;
-        }
-        if (command.field === "preset") {
-            if (!command.value) {
-                dispatch({
-                    type: "message.add",
-                    role: "system",
-                    text: options.settingsController.defaultPresetHelp(state.defaultPreset),
-                });
-                return;
-            }
-            try {
-                const settings = await options.settingsController.saveDefaultPreset({
-                    value: command.value,
-                    profileName: options.profileName,
-                    options: options.options,
-                });
-                dispatch({ type: "settings.set", settings: { defaultPreset: settings.defaultPreset, runPreset: settings.runPreset } });
-                dispatch({
-                    type: "message.add",
-                    role: "system",
-                    text: settings.message,
-                });
-                dispatch({ type: "activity.add", level: "success", text: settings.activity });
-            }
-            catch (error) {
-                if (error instanceof UnknownPresetError) {
-                    dispatch({
-                        type: "message.add",
-                        role: "system",
-                        text: await presetListText(`Unknown preset: ${error.preset}`),
-                    });
-                    dispatch({ type: "activity.add", level: "warning", text: `Unknown preset: ${error.preset}` });
-                    return;
-                }
-                dispatch({ type: "message.add", role: "system", text: `Could not save default preset: ${userFacingError(error)}` });
-                dispatch({ type: "activity.add", level: "error", text: "Default preset save failed" });
-            }
-        }
-        if (command.field === "isolation") {
-            if (!command.value) {
-                dispatch({
-                    type: "message.add",
-                    role: "system",
-                    text: options.settingsController.shellIsolationHelp(state.shellIsolation),
-                });
-                return;
-            }
-            try {
-                const settings = await options.settingsController.saveShellIsolationMode(command.value);
-                dispatch({ type: "settings.set", settings: { shellIsolation: settings.shellIsolation } });
-                dispatch({ type: "message.add", role: "system", text: settings.message });
-                dispatch({ type: "activity.add", level: "success", text: settings.activity });
-            }
-            catch (error) {
-                dispatch({ type: "message.add", role: "system", text: `Could not save shell isolation mode: ${userFacingError(error)}` });
-                dispatch({ type: "activity.add", level: "error", text: "Shell isolation save failed" });
-            }
-            return;
-        }
-        if (command.field === "isolator") {
-            if (!command.value) {
-                dispatch({
-                    type: "message.add",
-                    role: "system",
-                    text: options.settingsController.isolatorPathHelp(state.shellIsolation),
-                });
-                return;
-            }
-            try {
-                const [subcommand = "", ...rest] = command.value.split(/\s+/);
-                const value = rest.join(" ").trim();
-                const settings = subcommand === "source"
-                    ? await options.settingsController.saveIsolatorSource(value)
-                    : subcommand === "path"
-                        ? await options.settingsController.saveIsolatorPath(value)
-                        : await options.settingsController.saveIsolatorPath(command.value);
-                dispatch({ type: "settings.set", settings: { shellIsolation: settings.shellIsolation } });
-                dispatch({ type: "message.add", role: "system", text: settings.message });
-                dispatch({ type: "activity.add", level: "success", text: settings.activity });
-            }
-            catch (error) {
-                dispatch({ type: "message.add", role: "system", text: `Could not save isolator path: ${userFacingError(error)}` });
-                dispatch({ type: "activity.add", level: "error", text: "Isolator path save failed" });
-            }
-        }
-    }
-    async function runPresetCommand(value) {
-        const state = options.engine.snapshot();
-        if (!value) {
-            dispatch({
-                type: "message.add",
-                role: "system",
-                text: await presetListText(`Preset: ${state.runPreset || "none"}. Use /preset <name> or /preset none.`),
-            });
-            return;
-        }
-        const normalized = normalizeOptionalSetting(value, ["none", "off", "clear"]);
-        if (normalized && !(await validatePresetName(normalized))) {
-            return;
-        }
-        dispatch({ type: "settings.set", settings: { runPreset: normalized } });
-        dispatch({ type: "activity.add", text: `Preset: ${normalized || "none"}` });
-    }
-    async function validatePresetName(preset) {
-        try {
-            if (await options.settingsController.validatePreset(options.profileName, preset))
-                return true;
-            dispatch({
-                type: "message.add",
-                role: "system",
-                text: await presetListText(`Unknown preset: ${preset}`),
-            });
-            dispatch({ type: "activity.add", level: "warning", text: `Unknown preset: ${preset}` });
-            return false;
-        }
-        catch (error) {
-            dispatch({ type: "message.add", role: "system", text: `Could not validate preset "${preset}": ${userFacingError(error)}` });
-            dispatch({ type: "activity.add", level: "error", text: "Preset catalog unavailable" });
-            return false;
-        }
-    }
-    async function presetListText(prefix) {
-        return options.settingsController.presetListText({
-            profileName: options.profileName,
-            currentPreset: options.engine.snapshot().runPreset,
-            prefix,
-        });
-    }
-    async function showAuthStatus() {
-        dispatch({ type: "activity.add", text: "Checking auth status" });
-        try {
-            dispatch({ type: "message.add", role: "system", text: await options.authController.statusText(options.profileName) });
-            dispatch({ type: "activity.add", level: "success", text: "Auth status ready" });
-        }
-        catch (error) {
-            dispatch({ type: "message.add", role: "system", text: userFacingError(error) });
-            dispatch({ type: "activity.add", level: "error", text: "Auth status failed" });
-        }
-    }
-    async function exportTranscript(effect) {
-        try {
-            const file = await options.conversationController.exportTranscript(effect);
-            dispatch({ type: "message.add", role: "system", text: `Transcript exported:\n${file}` });
-            dispatch({ type: "activity.add", level: "success", text: "Transcript exported" });
-        }
-        catch (error) {
-            dispatch({ type: "message.add", role: "system", text: `Transcript export failed: ${userFacingError(error)}` });
-            dispatch({ type: "activity.add", level: "error", text: "Transcript export failed" });
-        }
-    }
-    async function showSummary() {
-        if (!options.localController.isLoaded()) {
-            dispatch({ type: "message.add", role: "system", text: unavailableWorkdirText() });
-            return;
-        }
-        dispatch({ type: "activity.add", text: "Summarizing workdir" });
-        try {
-            dispatch({
-                type: "message.add",
-                role: "system",
-                text: await options.localController.summaryText(),
-            });
-            dispatch({ type: "activity.add", level: "success", text: "Workdir summary ready" });
-        }
-        catch (error) {
-            dispatch({
-                type: "activity.add",
-                level: "error",
-                text: userFacingError(error),
-            });
-        }
-    }
-    async function startNewConversation(name) {
-        const conversation = await options.conversationController.startNewConversation(name, options.options.profile);
-        dispatch({ type: "messages.clear" });
-        dispatch({ type: "conversation.set", name: conversation.name });
-        dispatch({
-            type: "message.add",
-            role: "system",
-            text: conversation.message,
-        });
-    }
-    function switchConversation(name) {
-        const conversation = options.conversationController.switchConversation(name);
-        dispatch({ type: "messages.clear" });
-        dispatch({ type: "conversation.set", name: conversation.name });
-        dispatch({
-            type: "message.add",
-            role: "system",
-            text: conversation.message,
-        });
-    }
-    async function showConversations() {
-        try {
-            dispatch({
-                type: "message.add",
-                role: "system",
-                text: await options.conversationController.listConversations(options.options.profile),
-            });
-        }
-        catch (error) {
-            dispatch({ type: "message.add", role: "system", text: userFacingError(error) });
-        }
-    }
-    async function searchWorkdir(query) {
-        if (!query) {
-            dispatch({ type: "message.add", role: "system", text: "Usage: /search <query>" });
-            return;
-        }
-        if (!options.localController.isLoaded()) {
-            dispatch({ type: "message.add", role: "system", text: unavailableWorkdirText() });
-            return;
-        }
-        dispatch({ type: "activity.add", text: `Searching workdir: ${query}` });
-        try {
-            const result = await options.localController.searchText(query);
-            dispatch({
-                type: "message.add",
-                role: "system",
-                text: result.text,
-            });
-            dispatch({
-                type: "activity.add",
-                level: "success",
-                text: `Search complete: ${result.count} matches`,
-            });
-        }
-        catch (error) {
-            dispatch({
-                type: "activity.add",
-                level: "error",
-                text: userFacingError(error),
-            });
-        }
-    }
-    function showEditPreview() {
-        const state = options.engine.snapshot();
-        if (state.pendingLocalTool) {
-            dispatch({ type: "message.add", role: "system", text: options.localController.approvalPreview(state.pendingLocalTool) });
-            return;
-        }
-        dispatch({ type: "message.add", role: "system", text: "No pending local action." });
-    }
-    async function applyPendingEdit(allowFutureLocalActions) {
-        const state = options.engine.snapshot();
-        if (!options.localController.isLoaded()) {
-            dispatch({ type: "message.add", role: "system", text: unavailableWorkdirText() });
-            return;
-        }
-        if (state.pendingLocalTool) {
-            dispatch({
-                type: "activity.add",
-                level: "warning",
-                text: `Applying local action: ${state.pendingLocalTool.name}${state.pendingLocalTool.action ? `.${state.pendingLocalTool.action}` : ""}`,
-            });
-            try {
-                const result = await options.localController.applyApproval(state.pendingLocalTool);
-                const nextAccessMode = allowFutureLocalActions ? "full" : state.accessMode;
-                if (allowFutureLocalActions) {
-                    dispatch({ type: "access.set", mode: "full" });
-                }
-                dispatch({
-                    type: "message.add",
-                    role: "system",
-                    text: [
-                        allowFutureLocalActions
-                            ? "Applied local action. Future local actions in this workbench conversation are now allowed."
-                            : "Applied local action once. Future local actions still require approval.",
-                        "Continuing agent turn with the local result.",
-                        "Result:",
-                        JSON.stringify(result, null, 2),
-                    ].join("\n"),
-                });
-                dispatch({ type: "activity.add", level: "success", text: "Local action applied" });
-                const approval = state.pendingLocalTool;
-                dispatch({ type: "local_tool.pending.clear" });
-                await options.turnController.continueAfterLocalApproval({
-                    approval,
-                    result,
-                    accessMode: nextAccessMode,
-                });
-            }
-            catch (error) {
-                dispatch({ type: "message.add", role: "system", text: userFacingError(error) });
-                dispatch({ type: "activity.add", level: "error", text: userFacingError(error) });
-            }
-            return;
-        }
-        dispatch({ type: "message.add", role: "system", text: "No pending local action." });
-    }
-    function rejectPendingEdit() {
-        const state = options.engine.snapshot();
-        if (state.pendingLocalTool) {
-            dispatch({
-                type: "activity.add",
-                text: `Rejected local action: ${state.pendingLocalTool.name}${state.pendingLocalTool.action ? `.${state.pendingLocalTool.action}` : ""}`,
-            });
-            dispatch({ type: "local_tool.pending.clear" });
-            return;
-        }
-        dispatch({ type: "message.add", role: "system", text: "No pending local action." });
-    }
-    function unavailableWorkdirText() {
-        const state = options.engine.snapshot();
-        if (!state.contextEnabled || state.accessMode === "off") {
-            return "Local workdir tools are off. Use /workdir on, /access approval, or /access full to load and expose the current workdir.";
-        }
-        return "Workdir is still loading.";
-    }
-}
-export function normalizeOptionalSetting(value, clearValues) {
-    const trimmed = value.trim();
-    if (!trimmed)
-        return undefined;
-    return clearValues.includes(trimmed.toLowerCase()) ? undefined : trimmed;
-}
-function userFacingError(error) {
-    if (error instanceof Error)
-        return error.message;
-    return String(error);
-}