@agent-api/app-engine 0.0.1

package/dist/workbench/auth-controller.js

@@ -0,0 +1,84 @@
+import { deleteProfile, formatDeviceUserCode, getAuthStatus, loginWithAPIKey, openBrowserURL, refreshActiveProfileIfNeeded, saveBrowserProfile, startBrowserAuthChallenge, waitForBrowserAuthChallenge, } from "../profile.js";
+export function createWorkbenchAuthController(options = {}) {
+    const refreshActiveProfileIfNeededImpl = options.refreshActiveProfileIfNeededImpl ?? refreshActiveProfileIfNeeded;
+    const loginWithAPIKeyImpl = options.loginWithAPIKeyImpl ?? loginWithAPIKey;
+    const startBrowserAuthChallengeImpl = options.startBrowserAuthChallengeImpl ?? startBrowserAuthChallenge;
+    const openBrowserURLImpl = options.openBrowserURLImpl ?? openBrowserURL;
+    const waitForBrowserAuthChallengeImpl = options.waitForBrowserAuthChallengeImpl ?? waitForBrowserAuthChallenge;
+    const saveBrowserProfileImpl = options.saveBrowserProfileImpl ?? saveBrowserProfile;
+    const deleteProfileImpl = options.deleteProfileImpl ?? deleteProfile;
+    const getAuthStatusImpl = options.getAuthStatusImpl ?? getAuthStatus;
+    return {
+        async check(profile, refreshWindowMs = 5 * 60_000) {
+            const result = await refreshActiveProfileIfNeededImpl(profile, refreshWindowMs);
+            return { profileName: result.profile.name, refreshed: result.refreshed };
+        },
+        async loginAPIKey(input) {
+            const saved = await loginWithAPIKeyImpl(input);
+            return { profileName: saved.name };
+        },
+        async loginBrowser(input) {
+            const challenge = await startBrowserAuthChallengeImpl({
+                baseURL: input.baseURL,
+                clientName: input.clientName || "Agent API TUI",
+            });
+            input.onChallenge?.({
+                url: challenge.verification_uri_complete,
+                code: formatDeviceUserCode(challenge.user_code),
+            });
+            await openBrowserURLImpl(challenge.verification_uri_complete).catch(() => undefined);
+            const session = await waitForBrowserAuthChallengeImpl({
+                baseURL: input.baseURL,
+                challenge,
+                on_poll(result) {
+                    if (result.status && result.status !== "pending") {
+                        input.onStatus?.(result.status);
+                    }
+                },
+            });
+            const saved = await saveBrowserProfileImpl(input.profile, input.baseURL, session);
+            return { profileName: saved.name };
+        },
+        async deleteProfile(name) {
+            await deleteProfileImpl(name);
+        },
+        async statusText(profile) {
+            return authStatusText(await getAuthStatusImpl(profile));
+        },
+        async refresh(profile, refreshWindowMs = 5 * 60_000) {
+            const result = await refreshActiveProfileIfNeededImpl(profile, refreshWindowMs);
+            return { refreshed: result.refreshed };
+        },
+    };
+}
+export function authStatusText(status) {
+    return [
+        `Profile: ${status.profile}`,
+        `Endpoint: ${status.baseURL}`,
+        `Auth: ${status.authType === "api_key" ? "API key" : "Browser session"}`,
+        `Account: ${summarizeMe(status.me)}`,
+    ].join("\n");
+}
+function summarizeMe(me) {
+    if (!me || typeof me !== "object")
+        return "available";
+    const obj = me;
+    const candidates = [
+        obj.email,
+        obj.name,
+        obj.username,
+        obj.user_id,
+        obj.id,
+        nestedString(obj.user, "email"),
+        nestedString(obj.user, "name"),
+        nestedString(obj.user, "id"),
+    ];
+    const picked = candidates.find((value) => typeof value === "string" && value.trim() !== "");
+    return picked || "available";
+}
+function nestedString(value, key) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const nested = value[key];
+    return typeof nested === "string" ? nested : undefined;
+}

package/dist/workbench/auth-gate-controller.d.ts

@@ -0,0 +1,62 @@
+import { type WorkbenchAuthController } from "./auth-controller.js";
+export type AuthMethod = "browser" | "api_key" | "exit";
+export type AuthGateState = {
+    status: "checking" | "select" | "api_profile" | "api_base_url" | "api_key" | "browser_profile" | "browser_base_url" | "browser_waiting" | "ready";
+    selectedMethod: number;
+    profile: string;
+    baseURL: string;
+    apiKey: string;
+    message: string;
+    error: string;
+    browserURL: string;
+    browserCode: string;
+};
+export interface AuthGateInputKey {
+    backspace?: boolean;
+    ctrl?: boolean;
+    delete?: boolean;
+    downArrow?: boolean;
+    meta?: boolean;
+    return?: boolean;
+    upArrow?: boolean;
+}
+export type AuthGateInputEffect = {
+    type: "exit";
+} | {
+    type: "submit";
+};
+export interface AuthGateInputResult {
+    state: AuthGateState;
+    effects: AuthGateInputEffect[];
+}
+export interface AuthGateSubmitResult {
+    state: AuthGateState;
+    profileName?: string;
+}
+export interface WorkbenchAuthGateController {
+    authMethods: typeof authMethods;
+    initialState(input: {
+        profile?: string;
+        baseURL?: string;
+        apiKey?: string;
+    }): AuthGateState;
+    check(profile?: string): Promise<AuthGateSubmitResult>;
+    handleInput(input: string, key: AuthGateInputKey, state: AuthGateState): AuthGateInputResult;
+    submit(state: AuthGateState, options?: {
+        onState?: (state: AuthGateState) => void;
+    }): Promise<AuthGateSubmitResult>;
+    requestLogin(state: AuthGateState, profileName: string): AuthGateState;
+    requestLogout(state: AuthGateState, profileName: string): AuthGateState;
+    requestSwitchProfile(state: AuthGateState, currentProfile: string, nextProfile?: string): AuthGateState;
+    deletedProfile(state: AuthGateState, profileName: string): AuthGateState;
+}
+export interface WorkbenchAuthGateControllerOptions {
+    authController?: WorkbenchAuthController;
+    formatError?: (error: unknown) => string;
+}
+export declare const authMethods: Array<{
+    method: AuthMethod;
+    label: string;
+    description: string;
+}>;
+export declare function createWorkbenchAuthGateController(options?: WorkbenchAuthGateControllerOptions): WorkbenchAuthGateController;

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

@@ -0,0 +1,231 @@
+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

@@ -0,0 +1,29 @@
+import type { AgentRunOptions } from "../agent.js";
+import type { WorkbenchCommand } from "./state.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;