@agent-api/cli 0.0.3 → 0.1.0

package/dist/tui/ink/app.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+import { type AgentRunOptions } from "../../agent.js";
+export declare function ChatApp({ options }: {
+    options: AgentRunOptions;
+}): React.JSX.Element;

package/dist/tui/ink/app.js

@@ -0,0 +1,308 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { useApp, useInput, useStdout } from "ink";
+import { defaultBaseURL } from "../../config.js";
+import { createWorkbenchAuthController } from "../../workbench/auth-controller.js";
+import { createWorkbenchAuthGateController, } from "../../workbench/auth-gate-controller.js";
+import { createWorkbenchCommandController } from "../../workbench/command-controller.js";
+import { buildWorkbenchRenderModel, } from "../../workbench/render-model.js";
+import { createWorkbenchSession } from "../../workbench/session.js";
+import { InkAuthGate, InkWorkbenchScreen } from "./components.js";
+export function ChatApp({ options }) {
+    return _jsx(AuthenticatedChatApp, { options: options });
+}
+function AuthenticatedChatApp({ options }) {
+    const app = useApp();
+    const busyRef = useRef(false);
+    const authControllerRef = useRef(null);
+    const authGateControllerRef = useRef(null);
+    if (!authControllerRef.current) {
+        authControllerRef.current = createWorkbenchAuthController();
+    }
+    const authController = authControllerRef.current;
+    if (!authGateControllerRef.current) {
+        authGateControllerRef.current = createWorkbenchAuthGateController({ authController });
+    }
+    const authGateController = authGateControllerRef.current;
+    const [currentProfile, setCurrentProfile] = useState(options.profile || "default");
+    const [auth, setAuth] = useState(() => authGateController.initialState({
+        apiKey: process.env.AGENT_API_KEY || "",
+        baseURL: process.env.AGENT_API_BASE_URL || defaultBaseURL,
+        profile: options.profile || "default",
+    }));
+    useEffect(() => {
+        let mounted = true;
+        authGateController.check(options.profile)
+            .then((result) => {
+            if (!mounted)
+                return;
+            if (result.profileName)
+                setCurrentProfile(result.profileName);
+            setAuth(result.state);
+        });
+        return () => {
+            mounted = false;
+        };
+    }, [authGateController, options.profile]);
+    useInput((input, key) => {
+        const result = authGateController.handleInput(input, key, auth);
+        if (result.state !== auth)
+            setAuth(result.state);
+        for (const effect of result.effects) {
+            switch (effect.type) {
+                case "exit":
+                    app.exit();
+                    break;
+                case "submit":
+                    void submitAuthField();
+                    break;
+            }
+        }
+    });
+    async function submitAuthField() {
+        if (busyRef.current)
+            return;
+        busyRef.current = true;
+        try {
+            const result = await authGateController.submit(auth, {
+                onState: setAuth,
+            });
+            if (result.profileName)
+                setCurrentProfile(result.profileName);
+            setAuth(result.state);
+        }
+        finally {
+            busyRef.current = false;
+        }
+    }
+    if (auth.status === "ready") {
+        return (_jsx(WorkbenchApp, { onLogin: () => {
+                setAuth((current) => authGateController.requestLogin(current, currentProfile));
+            }, onLogout: () => {
+                setAuth((current) => authGateController.requestLogout(current, currentProfile));
+            }, onDeleteProfile: async () => {
+                await authController.deleteProfile(currentProfile);
+                setAuth((current) => authGateController.deletedProfile(current, currentProfile));
+            }, onSwitchProfile: (name) => {
+                setAuth((current) => authGateController.requestSwitchProfile(current, currentProfile, name));
+            }, options: { ...options, profile: currentProfile }, profileName: currentProfile, authController: authController }));
+    }
+    return _jsx(InkAuthGate, { state: auth });
+}
+function WorkbenchApp({ authController, onLogin, onLogout, onDeleteProfile, onSwitchProfile, options, profileName, }) {
+    const app = useApp();
+    const { stdout } = useStdout();
+    const [draft, setDraft] = useState("");
+    const [spinnerFrame, setSpinnerFrame] = useState(0);
+    const [transcriptOffset, setTranscriptOffset] = useState(0);
+    const sessionRef = useRef(null);
+    if (!sessionRef.current) {
+        sessionRef.current = createWorkbenchSession({
+            authController,
+            baseOptions: options,
+        });
+    }
+    const session = sessionRef.current;
+    const engine = session.engine;
+    const conversationController = session.conversation;
+    const inputController = session.input;
+    const lifecycleController = session.lifecycle;
+    const localController = session.local;
+    const settingsController = session.settings;
+    const turnController = session.turn;
+    const state = useSyncExternalStore(engine.subscribe, engine.snapshot, engine.snapshot);
+    const dispatch = engine.dispatch;
+    const commandController = createWorkbenchCommandController({
+        authController,
+        conversationController,
+        engine,
+        localController,
+        options,
+        profileName,
+        settingsController,
+        turnController,
+        onDeleteProfile,
+        onExit: app.exit,
+        onLogin,
+        onLogout,
+        onSwitchProfile,
+    });
+    const renderModel = useMemo(() => buildWorkbenchRenderModel({
+        draft,
+        profileName,
+        spinnerFrame,
+        state,
+        transcriptOffset,
+        viewport: {
+            rows: stdout.rows || process.stdout.rows,
+            columns: stdout.columns || process.stdout.columns,
+        },
+        workdirFallback: options.workdir || process.cwd(),
+    }), [draft, options.workdir, profileName, spinnerFrame, state, stdout.columns, stdout.rows, transcriptOffset]);
+    useEffect(() => {
+        setTranscriptOffset((offset) => Math.min(offset, renderModel.transcript.maxOffset));
+    }, [renderModel.transcript.maxOffset]);
+    function scrollTranscript(delta) {
+        setTranscriptOffset((offset) => Math.max(0, Math.min(renderModel.transcript.maxOffset, offset + delta)));
+    }
+    function scrollTranscriptToTop() {
+        setTranscriptOffset(renderModel.transcript.maxOffset);
+    }
+    function scrollTranscriptToBottom() {
+        setTranscriptOffset(0);
+    }
+    useEffect(() => {
+        let mounted = true;
+        lifecycleController.maybeCheckForUpdate()
+            .then((effects) => {
+            if (mounted)
+                runLifecycleEffects(effects, () => mounted);
+        });
+        settingsController.loadInitial({
+            modelExplicit: options.modelExplicit,
+            preset: options.preset,
+            presetExplicit: options.presetExplicit,
+        })
+            .then((settings) => {
+            if (!mounted)
+                return;
+            dispatch({ type: "settings.set", settings });
+        })
+            .catch((error) => {
+            if (!mounted)
+                return;
+            dispatch({ type: "activity.add", level: "warning", text: `Config preferences unavailable: ${userFacingError(error)}` });
+        });
+        return () => {
+            mounted = false;
+        };
+    }, [dispatch, lifecycleController, options.modelExplicit, options.preset, options.presetExplicit, settingsController]);
+    useEffect(() => {
+        let mounted = true;
+        dispatch({ type: "activity.add", text: "Loading workdir" });
+        localController.load(options.workdir || process.cwd())
+            .then((workdir) => {
+            if (!mounted)
+                return;
+            dispatch({
+                type: "workdir.set",
+                workdir,
+            });
+        })
+            .catch((error) => {
+            if (!mounted)
+                return;
+            dispatch({
+                type: "activity.add",
+                level: "error",
+                text: `Workdir unavailable: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        });
+        return () => {
+            mounted = false;
+        };
+    }, [dispatch, localController, options.workdir]);
+    useEffect(() => {
+        let mounted = true;
+        const refreshIntervalMs = 60_000;
+        const refreshAuth = async () => {
+            const effects = await lifecycleController.refreshAuth(options.profile);
+            if (mounted)
+                runLifecycleEffects(effects, () => mounted);
+        };
+        void refreshAuth();
+        const interval = setInterval(refreshAuth, refreshIntervalMs);
+        return () => {
+            mounted = false;
+            clearInterval(interval);
+        };
+    }, [lifecycleController, options.profile]);
+    useInput((input, key) => {
+        const result = inputController.handle(input, key, {
+            busy: state.busy,
+            draft,
+            viewportHeight: renderModel.viewportHeight,
+        });
+        if (result.draft !== draft)
+            setDraft(result.draft);
+        for (const effect of result.effects) {
+            switch (effect.type) {
+                case "exit":
+                    app.exit();
+                    break;
+                case "scroll":
+                    scrollTranscript(effect.delta);
+                    break;
+                case "scroll_top":
+                    scrollTranscriptToTop();
+                    break;
+                case "scroll_bottom":
+                    scrollTranscriptToBottom();
+                    break;
+                case "abort":
+                    void turnController.abort("Abort requested.");
+                    break;
+                case "submit":
+                    void submit(effect.input);
+                    break;
+                case "ignored_busy":
+                    dispatch({ type: "message.add", role: "system", text: "Agent turn is running. Use /abort or Esc to cancel it." });
+                    dispatch({ type: "activity.add", level: "warning", text: "Input ignored while agent is running" });
+                    break;
+            }
+        }
+    });
+    useEffect(() => {
+        const initialPrompt = lifecycleController.initialPrompt({
+            busy: state.busy,
+            promptParts: options.promptParts,
+            workdir: state.workdir,
+        });
+        if (initialPrompt)
+            void turnController.startPrompt(initialPrompt);
+    }, [lifecycleController, options.promptParts, state.busy, state.workdir, turnController]);
+    useEffect(() => {
+        if (!state.busy) {
+            setSpinnerFrame(0);
+            return;
+        }
+        const interval = setInterval(() => {
+            setSpinnerFrame((frame) => frame + 1);
+        }, 120);
+        return () => clearInterval(interval);
+    }, [state.busy]);
+    useEffect(() => {
+        return () => session.runtime.dispose();
+    }, [session.runtime]);
+    function runLifecycleEffects(effects, isMounted) {
+        for (const effect of effects) {
+            switch (effect.type) {
+                case "dispatch":
+                    dispatch(effect.action);
+                    break;
+                case "close":
+                    setTimeout(() => {
+                        if (isMounted())
+                            app.exit();
+                    }, effect.delayMs);
+                    break;
+            }
+        }
+    }
+    async function submit(input) {
+        const submission = engine.submit(input);
+        if (submission.kind === "command") {
+            await commandController.run(submission.command);
+            return;
+        }
+        if (submission.kind === "prompt") {
+            await turnController.startPrompt(submission.prompt);
+        }
+    }
+    return _jsx(InkWorkbenchScreen, { renderModel: renderModel, spinnerFrame: spinnerFrame });
+}
+function userFacingError(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}

package/dist/tui/ink/components.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import { type AuthGateState } from "../../workbench/auth-gate-controller.js";
+import { type WorkbenchRenderModel } from "../../workbench/render-model.js";
+export declare function InkWorkbenchScreen({ renderModel, spinnerFrame, }: {
+    renderModel: WorkbenchRenderModel;
+    spinnerFrame: number;
+}): React.JSX.Element;
+export declare function InkAuthGate({ state }: {
+    state: AuthGateState;
+}): React.JSX.Element;

package/dist/tui/ink/components.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { authMethods } from "../../workbench/auth-gate-controller.js";
+import { busySpinner } from "../../workbench/render-model.js";
+import { activityColor, } from "../workbench.js";
+export function InkWorkbenchScreen({ renderModel, spinnerFrame, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { contextEnabled: renderModel.header.contextEnabled, conversation: renderModel.header.conversation, model: renderModel.header.model, accessMode: renderModel.header.accessMode, pendingLocalLabel: renderModel.header.pendingLocalLabel, preset: renderModel.header.preset, profile: renderModel.header.profile, renderMode: renderModel.header.renderMode, workdir: renderModel.header.workdir }), _jsxs(Box, { marginTop: 1, height: renderModel.viewportHeight, children: [_jsxs(Box, { flexDirection: "column", width: "72%", paddingRight: 1, children: [renderModel.transcript.visibleLines.map((line) => (_jsx(Text, { bold: line.bold, color: line.color, inverse: line.inverse, children: line.text || " " }, line.id))), renderModel.transcript.visibleLines.length === 0 && _jsx(Text, { color: "gray", children: "No transcript lines." })] }), _jsxs(Box, { flexDirection: "column", width: "28%", height: renderModel.activityHeight, borderStyle: "single", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Activity" }), renderModel.visibleActivities.map((activity) => (_jsxs(Text, { color: activityColor(activity.level), children: [new Date(activity.timestamp).toLocaleTimeString(), " ", activity.text] }, activity.id)))] })] }), _jsxs(Box, { borderStyle: "single", borderColor: renderModel.input.busy ? "yellow" : "green", paddingX: 1, children: [renderModel.input.fullAccess && (_jsx(Text, { color: "red", bold: true, inverse: true, children: "FULL ACCESS" })), renderModel.input.fullAccess && _jsx(Text, { children: " " }), _jsxs(Text, { color: renderModel.input.busy ? "yellow" : "green", children: [renderModel.input.label, " "] }), renderModel.input.busy ? (_jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: busySpinner(spinnerFrame) }), " ", renderModel.input.waitingText] })) : (_jsxs(Text, { children: [renderModel.input.draft, _jsx(Cursor, { visible: true })] }))] }), _jsx(Box, { paddingX: 1, children: _jsx(Text, { color: "gray", children: renderModel.footerText }) })] }));
+}
+export function InkAuthGate({ state }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Agent API Workbench" }), _jsx(Text, { color: "gray", children: "Authentication required before starting the conversation UI." })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: state.error ? "red" : "gray", children: state.error || state.message }), state.status === "checking" && _jsx(Text, { color: "yellow", children: "Checking..." }), state.status === "select" && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [authMethods.map((method, index) => (_jsxs(Text, { color: index === state.selectedMethod ? "green" : "gray", children: [index === state.selectedMethod ? "›" : " ", " ", method.label, " - ", method.description] }, method.method))), _jsx(Text, { color: "gray", children: "Use \u2191/\u2193 and Enter." })] })), state.status === "api_profile" && _jsx(AuthPrompt, { label: "Profile", value: state.profile }), state.status === "api_base_url" && _jsx(AuthPrompt, { label: "Base URL", value: state.baseURL }), state.status === "api_key" && _jsx(AuthPrompt, { label: "API key", value: state.apiKey ? "•".repeat(Math.min(state.apiKey.length, 32)) : "" }), state.status === "browser_profile" && _jsx(AuthPrompt, { label: "Profile", value: state.profile }), state.status === "browser_base_url" && _jsx(AuthPrompt, { label: "Base URL", value: state.baseURL }), state.status === "browser_waiting" && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [state.browserURL && _jsxs(Text, { children: ["URL: ", state.browserURL] }), state.browserCode && _jsxs(Text, { children: ["Code: ", state.browserCode] }), _jsx(Text, { color: "yellow", children: "Waiting for browser approval..." })] }))] })] }));
+}
+function AuthPrompt({ label, value }) {
+    return (_jsxs(Box, { borderStyle: "single", borderColor: "green", paddingX: 1, marginTop: 1, children: [_jsxs(Text, { color: "green", children: [label, ": "] }), _jsx(Text, { children: value })] }));
+}
+function Header({ contextEnabled, conversation, accessMode, model, pendingLocalLabel, preset, profile, renderMode, workdir, }) {
+    return (_jsxs(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Agent API Workbench" }), _jsxs(Text, { color: "gray", children: ["profile=", profile, " conversation=", conversation, " preset=", preset, " model=", model] }), _jsxs(Text, { color: "gray", children: ["workdir=", workdir, " access=", accessMode, " local_tools=", contextEnabled ? "on" : "off", " render=", renderMode, " pending=", pendingLocalLabel] })] }));
+}
+function Cursor({ visible }) {
+    return visible ? _jsx(Text, { inverse: true, children: " " }) : _jsx(Text, { children: " " });
+}

package/dist/tui/workbench.d.ts

@@ -23,6 +23,7 @@ export interface LocalToolApproval extends LocalToolApprovalRequest {
     id: string;
     createdAt: number;
 }
+export type RenderMode = "markdown" | "raw";
 export interface WorkbenchState {
     messages: WorkbenchMessage[];
     activities: WorkbenchActivity[];
@@ -33,6 +34,10 @@ export interface WorkbenchState {
     pendingLocalTool: LocalToolApproval | null;
     accessMode: WorkdirAccessMode;
     currentConversation: string;
+    runPreset?: string;
+    runModel?: string;
+    renderMode: RenderMode;
+    defaultPreset?: string | null;
 }
 export interface InputHistory {
     record(value: string): void;
@@ -81,6 +86,9 @@ export type WorkbenchAction = {
 } | {
     type: "conversation.set";
     name: string;
+} | {
+    type: "settings.set";
+    settings: Partial<Pick<WorkbenchState, "runPreset" | "runModel" | "renderMode" | "defaultPreset">>;
 };
 export type WorkbenchCommand = {
     kind: "invalid";
@@ -108,6 +116,14 @@ export type WorkbenchCommand = {
     kind: "config";
     field?: "preset";
     value?: string;
+} | {
+    kind: "render";
+    mode?: RenderMode;
+} | {
+    kind: "transcript";
+} | {
+    kind: "export";
+    path?: string;
 } | {
     kind: "context";
     enabled?: boolean;
@@ -151,12 +167,18 @@ export declare function createInitialWorkbenchState(options: {
     contextEnabled: boolean;
     accessMode?: WorkdirAccessMode;
     conversation?: string;
+    preset?: string;
+    model?: string;
+    renderMode?: RenderMode;
+    defaultPreset?: string | null;
 }): 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";

package/dist/tui/workbench.js

@@ -14,6 +14,10 @@ export function createInitialWorkbenchState(options) {
         pendingLocalTool: null,
         accessMode,
         currentConversation: options.conversation || "default",
+        runPreset: options.preset,
+        runModel: options.model,
+        renderMode: options.renderMode ?? "markdown",
+        defaultPreset: options.defaultPreset,
     };
 }
 export function createInputHistory(limit = 100) {
@@ -130,6 +134,11 @@ export function workbenchReducer(state, action) {
                 currentConversation: action.name,
                 activities: [...state.activities, newActivity("info", `Conversation: ${action.name}`)].slice(-20),
             };
+        case "settings.set":
+            return {
+                ...state,
+                ...action.settings,
+            };
         default:
             return state;
     }
@@ -184,6 +193,18 @@ export function parseWorkbenchCommand(input) {
             }
             return { kind: "invalid", command: `${name} ${field}` };
         }
+        case "render":
+        case "display":
+        case "view": {
+            const mode = rest[0];
+            if (mode === "raw" || mode === "markdown")
+                return { kind: "render", mode };
+            return { kind: "render" };
+        }
+        case "transcript":
+            return { kind: "transcript" };
+        case "export":
+            return { kind: "export", path: rest.join(" ").trim() || undefined };
         case "context":
             return { kind: "context", enabled: parseOnOff(rest[0]) };
         case "access": {
@@ -265,6 +286,9 @@ export function helpText() {
         "/switch-profile  switch/sign in with a different profile",
         "/delete-profile  delete current saved profile and return to auth",
         "/config          show current run configuration and saved defaults",
+        "/render [mode]   show or set output rendering: markdown or raw",
+        "/transcript      show a plain-text transcript preview",
+        "/export [file]   save the plain-text transcript to a file",
         "/config preset   save default preset; use none/off for no preset, reset for built-in",
         "/preset [name]   show or set preset; use none/off to clear",
         "/model [name]    show or set explicit model; use auto/none/off to clear",
@@ -286,6 +310,26 @@ export function helpText() {
         "/quit            leave the workbench",
     ].join("\n");
 }
+export function formatTranscript(messages) {
+    return messages
+        .map((message) => {
+        const body = message.text.trimEnd();
+        return body ? `${roleLabel(message.role)}:\n${body}` : `${roleLabel(message.role)}:`;
+    })
+        .join("\n\n")
+        .trimEnd() + "\n";
+}
+export function formatTranscriptPreview(messages, maxLines = 80) {
+    const lines = formatTranscript(messages).trimEnd().split(/\r?\n/);
+    if (lines.length <= maxLines) {
+        return ["Transcript preview:", "", ...lines].join("\n");
+    }
+    return [
+        `Transcript preview: showing last ${maxLines} lines of ${lines.length}. Use /export [file] for the full transcript.`,
+        "",
+        ...lines.slice(-maxLines),
+    ].join("\n");
+}
 function parseOnOff(value) {
     if (!value)
         return undefined;
@@ -325,6 +369,13 @@ export function activityColor(level) {
 function newMessage(role, text, id = randomId()) {
     return { id, role, text };
 }
+function roleLabel(role) {
+    if (role === "user")
+        return "You";
+    if (role === "assistant")
+        return "Agent";
+    return "System";
+}
 function newActivity(level, text) {
     return {
         id: randomId(),

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

@@ -0,0 +1,43 @@
+import { deleteProfile, getAuthStatus, loginWithAPIKey, openBrowserURL, refreshActiveProfileIfNeeded, saveBrowserProfile, startBrowserAuthChallenge, waitForBrowserAuthChallenge, type AuthStatus } from "../profile.js";
+export interface WorkbenchAuthController {
+    check(profile?: string, refreshWindowMs?: number): Promise<{
+        profileName: string;
+        refreshed: boolean;
+    }>;
+    loginAPIKey(input: {
+        profile: string;
+        baseURL: string;
+        apiKey: string;
+    }): Promise<{
+        profileName: string;
+    }>;
+    loginBrowser(input: {
+        profile: string;
+        baseURL: string;
+        clientName?: string;
+        onChallenge?: (challenge: {
+            url: string;
+            code: string;
+        }) => void;
+        onStatus?: (status: string) => void;
+    }): Promise<{
+        profileName: string;
+    }>;
+    deleteProfile(name: string): Promise<void>;
+    statusText(profile?: string): Promise<string>;
+    refresh(profile?: string, refreshWindowMs?: number): Promise<{
+        refreshed: boolean;
+    }>;
+}
+export interface WorkbenchAuthControllerOptions {
+    refreshActiveProfileIfNeededImpl?: typeof refreshActiveProfileIfNeeded;
+    loginWithAPIKeyImpl?: typeof loginWithAPIKey;
+    startBrowserAuthChallengeImpl?: typeof startBrowserAuthChallenge;
+    openBrowserURLImpl?: typeof openBrowserURL;
+    waitForBrowserAuthChallengeImpl?: typeof waitForBrowserAuthChallenge;
+    saveBrowserProfileImpl?: typeof saveBrowserProfile;
+    deleteProfileImpl?: typeof deleteProfile;
+    getAuthStatusImpl?: typeof getAuthStatus;
+}
+export declare function createWorkbenchAuthController(options?: WorkbenchAuthControllerOptions): WorkbenchAuthController;
+export declare function authStatusText(status: AuthStatus): string;

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;
+}