@agent-api/cli 0.0.1

package/dist/config.js

@@ -0,0 +1,111 @@
+import { z } from "zod";
+import { runtime } from "./runtime/index.js";
+export const defaultBaseURL = "https://api.agentsway.dev";
+export const configFile = "profiles.json";
+const authProfileSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("api_key"),
+        apiKey: z.string(),
+    }),
+    z.object({
+        type: z.literal("browser"),
+        accessToken: z.string(),
+        refreshToken: z.string(),
+        accessTokenExpiresAt: z.number(),
+        refreshTokenExpiresAt: z.number().optional(),
+    }),
+]);
+const profileSchema = z.object({
+    name: z.string(),
+    baseURL: z.string(),
+    auth: authProfileSchema,
+    createdAt: z.number(),
+    updatedAt: z.number(),
+});
+const conversationSchema = z.object({
+    name: z.string(),
+    profile: z.string(),
+    previousResponseId: z.string().optional(),
+    updatedAt: z.number(),
+});
+const workbenchPreferencesSchema = z.object({
+    defaultPreset: z.string().nullable().optional(),
+}).default({});
+const cliConfigSchema = z.object({
+    activeProfile: z.string().default("default"),
+    profiles: z.record(z.string(), profileSchema).default({}),
+    conversations: z.record(z.string(), conversationSchema).default({}),
+    workbench: workbenchPreferencesSchema,
+});
+export async function loadConfig() {
+    await runtime.ensure();
+    const loaded = await runtime.config.read(configFile, emptyConfig());
+    const parsed = cliConfigSchema.safeParse(loaded);
+    if (!parsed.success) {
+        throw new Error(`Invalid CLI config: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
+    }
+    return parsed.data;
+}
+export async function saveConfig(config) {
+    await runtime.ensure();
+    await runtime.config.write(configFile, config);
+}
+export async function upsertProfile(profile) {
+    const config = await loadConfig();
+    const now = Math.floor(Date.now() / 1000);
+    const existing = config.profiles[profile.name];
+    const next = {
+        ...profile,
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
+    };
+    config.profiles[profile.name] = next;
+    config.activeProfile = profile.name;
+    await saveConfig(config);
+    return next;
+}
+export async function activeProfile(profileName) {
+    const config = await loadConfig();
+    const name = profileName || config.activeProfile || "default";
+    const profile = config.profiles[name];
+    if (!profile) {
+        throw new Error(`Profile not found: ${name}. Run agent-api login first.`);
+    }
+    return profile;
+}
+export function emptyConfig() {
+    return { activeProfile: "default", profiles: {}, conversations: {}, workbench: {} };
+}
+export async function loadWorkbenchPreferences() {
+    const config = await loadConfig();
+    return config.workbench;
+}
+export async function updateWorkbenchPreferences(patch) {
+    const config = await loadConfig();
+    const next = { ...config.workbench };
+    if ("defaultPreset" in patch) {
+        if (patch.defaultPreset === undefined) {
+            delete next.defaultPreset;
+        }
+        else if (patch.defaultPreset === null) {
+            next.defaultPreset = null;
+        }
+        else {
+            const value = patch.defaultPreset.trim();
+            if (value) {
+                next.defaultPreset = value;
+            }
+            else {
+                delete next.defaultPreset;
+            }
+        }
+    }
+    config.workbench = next;
+    await saveConfig(config);
+    return next;
+}
+export function redactSecret(value) {
+    if (value.length <= 10)
+        return "***";
+    return `${value.slice(0, 6)}…${value.slice(-4)}`;
+}

package/dist/conversation/index.d.ts

@@ -0,0 +1,17 @@
+import type { ConversationState } from "../config.js";
+export declare function conversationKey(profile: string, name: string): string;
+export declare function resolvePreviousResponseID(options: {
+    profile?: string;
+    conversation?: string;
+    continueConversation?: boolean;
+    restartConversation?: boolean;
+    previousResponseId?: string;
+}): Promise<string | undefined>;
+export declare function updateConversation(options: {
+    profile?: string;
+    conversation?: string;
+}, responseID: string): Promise<void>;
+export declare function listConversations(profileName?: string): Promise<ConversationState[]>;
+export declare function getConversation(name: string, profileName?: string): Promise<ConversationState>;
+export declare function deleteConversation(name: string, profileName?: string): Promise<void>;
+export declare function conversationSummary(conversation: ConversationState): string;

package/dist/conversation/index.js

@@ -0,0 +1,54 @@
+import { activeProfile, loadConfig, saveConfig } from "../config.js";
+export function conversationKey(profile, name) {
+    return `${profile}:${name}`;
+}
+export async function resolvePreviousResponseID(options) {
+    if (options.previousResponseId)
+        return options.previousResponseId;
+    if (options.restartConversation || !options.conversation)
+        return undefined;
+    if (!options.continueConversation)
+        return undefined;
+    const profile = await activeProfile(options.profile);
+    const config = await loadConfig();
+    return config.conversations[conversationKey(profile.name, options.conversation)]?.previousResponseId;
+}
+export async function updateConversation(options, responseID) {
+    if (!options.conversation)
+        return;
+    const profile = await activeProfile(options.profile);
+    const config = await loadConfig();
+    config.conversations[conversationKey(profile.name, options.conversation)] = {
+        name: options.conversation,
+        profile: profile.name,
+        previousResponseId: responseID,
+        updatedAt: Math.floor(Date.now() / 1000),
+    };
+    await saveConfig(config);
+}
+export async function listConversations(profileName) {
+    const profile = await activeProfile(profileName);
+    const config = await loadConfig();
+    return Object.values(config.conversations)
+        .filter((conversation) => conversation.profile === profile.name)
+        .sort((a, b) => b.updatedAt - a.updatedAt);
+}
+export async function getConversation(name, profileName) {
+    const profile = await activeProfile(profileName);
+    const config = await loadConfig();
+    const conversation = config.conversations[conversationKey(profile.name, name)];
+    if (!conversation)
+        throw new Error(`Conversation not found: ${name}`);
+    return conversation;
+}
+export async function deleteConversation(name, profileName) {
+    const profile = await activeProfile(profileName);
+    const config = await loadConfig();
+    delete config.conversations[conversationKey(profile.name, name)];
+    await saveConfig(config);
+}
+export function conversationSummary(conversation) {
+    const updated = new Date(conversation.updatedAt * 1000).toISOString();
+    const response = conversation.previousResponseId ? ` response=${conversation.previousResponseId}` : "";
+    return `${conversation.name}\t${conversation.profile}\t${updated}${response}`;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+import { Command, Option } from "commander";
+import { render } from "ink";
+import React from "react";
+import { conversationSummary, deleteConversation, getConversation, listConversations, runAgent } from "./agent.js";
+import { normalizeChatOptions } from "./chat-options.js";
+import { ChatApp } from "./tui/chat.js";
+import { activeProfile, loadConfig, redactSecret } from "./config.js";
+import { cliVersion, runtime } from "./runtime/index.js";
+import { openWorkdir } from "./workdir/index.js";
+import { deleteProfile, listProfiles, loginWithAPIKey, loginWithBrowser, profileSummary, resolveRuntimeProfile, useProfile, } from "./profile.js";
+const program = new Command();
+program
+    .name("agent-api")
+    .alias("agentsway")
+    .alias("agent-tui")
+    .description("First-class command line interface for Agent API")
+    .version(cliVersion)
+    .showHelpAfterError()
+    .showSuggestionAfterError();
+program.action(async () => {
+    if (!process.stdin.isTTY) {
+        program.help();
+        return;
+    }
+    const options = normalizeChatOptions([], {});
+    const app = render(React.createElement(ChatApp, { options }));
+    await app.waitUntilExit();
+});
+program
+    .command("auth")
+    .description("Manage authentication")
+    .addCommand(authLoginCommand())
+    .addCommand(authWhoamiCommand())
+    .addCommand(authLogoutCommand());
+program
+    .command("profiles")
+    .alias("profile")
+    .description("Manage local auth profiles")
+    .addCommand(profilesListCommand())
+    .addCommand(profilesUseCommand())
+    .addCommand(profilesShowCommand())
+    .addCommand(profilesDeleteCommand());
+program
+    .command("agent")
+    .description("Chat with and manage remote agent conversations")
+    .addCommand(agentChatCommand())
+    .addCommand(agentListCommand())
+    .addCommand(agentShowCommand())
+    .addCommand(agentDeleteCommand());
+program
+    .command("workdir")
+    .alias("ws")
+    .description("Inspect and package local workdir context")
+    .addCommand(workdirStatusCommand())
+    .addCommand(workdirSummaryCommand())
+    .addCommand(workdirContextCommand());
+program
+    .command("doctor")
+    .description("Print local CLI diagnostics")
+    .action(async () => {
+    const config = await loadConfig();
+    const { profiles } = await listProfiles();
+    console.log(JSON.stringify({
+        version: cliVersion,
+        activeProfile: config.activeProfile,
+        profileCount: profiles.length,
+        conversationCount: Object.keys(config.conversations).length,
+        configDir: runtime.dirs.config,
+        dataDir: runtime.dirs.data,
+        node: process.version,
+        platform: process.platform,
+    }, null, 2));
+});
+program.exitOverride();
+program.parseAsync(process.argv).catch((error) => {
+    if (error?.code === "commander.helpDisplayed" || error?.code === "commander.version")
+        return;
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});
+function authLoginCommand() {
+    return new Command("login")
+        .description("Sign in with browser auth or save an API key profile")
+        .option("-p, --profile <name>", "profile name", "default")
+        .option("--base-url <url>", "Agent API base URL")
+        .option("--api-key <key>", "API key; defaults to AGENT_API_KEY")
+        .option("--no-browser", "print browser URL without opening it")
+        .option("--client-name <name>", "device auth client name", "Agent API CLI")
+        .action(async (options) => {
+        const apiKey = options.apiKey || process.env.AGENT_API_KEY;
+        if (apiKey) {
+            const saved = await loginWithAPIKey({ profile: options.profile, baseURL: options.baseUrl, apiKey });
+            console.log(`Saved API key profile "${saved.name}" (${saved.baseURL}).`);
+            return;
+        }
+        await loginWithBrowser({
+            profile: options.profile,
+            baseURL: options.baseUrl,
+            openBrowser: options.browser,
+            clientName: options.clientName,
+        });
+    });
+}
+function authWhoamiCommand() {
+    return new Command("whoami")
+        .alias("status")
+        .description("Show the authenticated account for a profile")
+        .option("-p, --profile <name>", "profile name")
+        .action(async (options) => {
+        const runtime = await resolveRuntimeProfile(options.profile);
+        const response = await fetch(`${runtime.profile.baseURL}/v1/me`, {
+            headers: { Authorization: `Bearer ${runtime.token}` },
+        });
+        const payload = await response.json().catch(() => ({}));
+        if (!response.ok)
+            throw new Error(payload?.error?.message || `whoami failed with ${response.status}`);
+        console.log(JSON.stringify({ profile: runtime.profile.name, ...payload }, null, 2));
+    });
+}
+function authLogoutCommand() {
+    return new Command("logout")
+        .description("Delete a local auth profile")
+        .option("-p, --profile <name>", "profile name")
+        .action(async (options) => {
+        const profile = options.profile || (await loadConfig()).activeProfile;
+        await deleteProfile(profile);
+        console.log(`Deleted profile "${profile}".`);
+    });
+}
+function profilesListCommand() {
+    return new Command("list")
+        .description("List local auth profiles")
+        .action(async () => {
+        const { active, profiles } = await listProfiles();
+        if (profiles.length === 0) {
+            console.log("No profiles configured. Run agent-api auth login.");
+            return;
+        }
+        for (const profile of profiles) {
+            console.log(profileSummary(profile, profile.name === active));
+        }
+    });
+}
+function profilesUseCommand() {
+    return new Command("use")
+        .description("Set the active profile")
+        .argument("<name>", "profile name")
+        .action(async (name) => {
+        await useProfile(name);
+        console.log(`Active profile: ${name}`);
+    });
+}
+function profilesShowCommand() {
+    return new Command("show")
+        .description("Show a profile without secrets")
+        .argument("[name]", "profile name")
+        .action(async (name) => {
+        const profile = await activeProfile(name);
+        console.log(JSON.stringify({
+            name: profile.name,
+            baseURL: profile.baseURL,
+            auth: profile.auth.type === "api_key"
+                ? { type: "api_key", apiKey: redactSecret(profile.auth.apiKey) }
+                : {
+                    type: "browser",
+                    accessToken: redactSecret(profile.auth.accessToken),
+                    accessTokenExpiresAt: profile.auth.accessTokenExpiresAt,
+                    refreshTokenExpiresAt: profile.auth.refreshTokenExpiresAt,
+                },
+            createdAt: profile.createdAt,
+            updatedAt: profile.updatedAt,
+        }, null, 2));
+    });
+}
+function profilesDeleteCommand() {
+    return new Command("delete")
+        .alias("rm")
+        .description("Delete a local auth profile")
+        .argument("<name>", "profile name")
+        .action(async (name) => {
+        await deleteProfile(name);
+        console.log(`Deleted profile "${name}".`);
+    });
+}
+function agentChatCommand() {
+    return new Command("chat")
+        .description("Start an interactive chat, or send one message when prompt text is provided")
+        .argument("[prompt...]", "prompt text")
+        .option("-p, --profile <name>", "profile name")
+        .option("-c, --conversation <name>", "conversation name", "default")
+        .option("--preset <name>", "agent preset")
+        .option("--model <name>", "explicit model")
+        .option("--file <path>", "read prompt text from file")
+        .option("--stdin", "read prompt text from stdin")
+        .option("--workdir <path>", "attach local workdir context")
+        .option("--local-context", "attach current directory context")
+        .option("--context-query <text>", "include local search matches in context")
+        .option("--max-context-files <n>", "local context file limit")
+        .option("--max-context-bytes <n>", "local context byte limit")
+        .option("--access <mode>", "local tool access mode: off, approval, or full")
+        .option("--restart", "start the conversation from a fresh response")
+        .addOption(new Option("--no-stream", "wait for final response instead of streaming"))
+        .action(async (prompt, options) => {
+        const promptParts = prompt ?? [];
+        const hasOneShotInput = promptParts.length > 0 || options.file || options.stdin;
+        const normalized = normalizeChatOptions(promptParts, options);
+        const shouldUseWorkbench = process.stdin.isTTY && (!hasOneShotInput ||
+            Boolean(normalized.workdir && normalized.accessMode === "approval" && promptParts.length > 0 && !options.file && !options.stdin));
+        if (shouldUseWorkbench) {
+            const app = render(React.createElement(ChatApp, { options: normalized }));
+            await app.waitUntilExit();
+            return;
+        }
+        await runAgent(normalized);
+    });
+}
+function agentListCommand() {
+    return new Command("list")
+        .alias("conversations")
+        .description("List local conversation handles")
+        .option("-p, --profile <name>", "profile name")
+        .action(async (options) => {
+        const conversations = await listConversations(options.profile);
+        if (conversations.length === 0) {
+            console.log("No agent conversations yet.");
+            return;
+        }
+        for (const conversation of conversations)
+            console.log(conversationSummary(conversation));
+    });
+}
+function agentShowCommand() {
+    return new Command("show")
+        .description("Show a local conversation handle")
+        .argument("[name]", "conversation name", "default")
+        .option("-p, --profile <name>", "profile name")
+        .action(async (name, options) => {
+        console.log(JSON.stringify(await getConversation(name, options.profile), null, 2));
+    });
+}
+function agentDeleteCommand() {
+    return new Command("delete")
+        .alias("rm")
+        .description("Delete a local conversation handle")
+        .argument("<name>", "conversation name")
+        .option("-p, --profile <name>", "profile name")
+        .action(async (name, options) => {
+        await deleteConversation(name, options.profile);
+        console.log(`Deleted conversation "${name}".`);
+    });
+}
+function workdirStatusCommand() {
+    return new Command("status")
+        .description("Show local workdir status")
+        .option("--path <path>", "workdir path", process.cwd())
+        .action(async (options) => {
+        const workdir = await openWorkdir({ path: options.path });
+        const [summary, snapshot] = await Promise.all([
+            workdir.summarize(),
+            workdir.snapshot(),
+        ]);
+        console.log(JSON.stringify({
+            root: workdir.root,
+            name: workdir.name,
+            fileCount: summary.file_count,
+            totalBytes: summary.total_bytes,
+            snapshotFiles: snapshot.files.length,
+            scanTruncated: summary.scan_truncated,
+        }, null, 2));
+    });
+}
+function workdirSummaryCommand() {
+    return new Command("summary")
+        .description("Summarize local workdir files")
+        .option("--path <path>", "workdir path", process.cwd())
+        .action(async (options) => {
+        const workdir = await openWorkdir({ path: options.path });
+        console.log(JSON.stringify(await workdir.summarize(), null, 2));
+    });
+}
+function workdirContextCommand() {
+    return new Command("context")
+        .description("Build the local context package that can be sent to the agent")
+        .option("--path <path>", "workdir path", process.cwd())
+        .option("--query <text>", "include local search matches")
+        .option("--max-files <n>", "maximum files to include")
+        .option("--max-bytes <n>", "maximum bytes to include")
+        .option("--no-content", "omit file contents")
+        .action(async (options) => {
+        const workdir = await openWorkdir({ path: options.path });
+        const context = await workdir.packageContext({
+            query: options.query,
+            maxFiles: optionalNumber(options.maxFiles, "--max-files"),
+            maxBytes: optionalNumber(options.maxBytes, "--max-bytes"),
+            includeContent: options.content !== false,
+        });
+        console.log(JSON.stringify(context, null, 2));
+    });
+}
+function optionalNumber(value, label) {
+    if (value == null || value === "")
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        throw new Error(`${label} must be a number`);
+    return parsed;
+}

package/dist/profile.d.ts

@@ -0,0 +1,57 @@
+import { AgentAPI, type ApprovedDeviceAuth } from "@agent-api/sdk";
+import { Profile } from "./config.js";
+export interface RuntimeProfile {
+    profile: Profile;
+    token: string;
+    client: AgentAPI;
+}
+export interface AuthStatus {
+    profile: string;
+    baseURL: string;
+    authType: Profile["auth"]["type"];
+    me?: unknown;
+}
+export declare class AuthSessionExpiredError extends Error {
+    readonly profile: string;
+    readonly baseURL: string;
+    constructor(profile: Profile, message?: string);
+}
+export declare function loginWithAPIKey(options: {
+    profile: string;
+    baseURL?: string;
+    apiKey: string;
+}): Promise<Profile>;
+export declare function loginWithBrowser(options: {
+    profile: string;
+    baseURL?: string;
+    clientName?: string;
+    openBrowser?: boolean;
+}): Promise<Profile>;
+export declare function startBrowserAuthChallenge(options: {
+    baseURL?: string;
+    clientName?: string;
+}): Promise<import("@agent-api/sdk").DeviceAuthStart>;
+export declare function waitForBrowserAuthChallenge(options: {
+    baseURL?: string;
+    challenge: Awaited<ReturnType<typeof startBrowserAuthChallenge>>;
+    on_poll?: Parameters<AgentAPI["auth"]["waitForDeviceAuth"]>[0]["on_poll"];
+}): Promise<ApprovedDeviceAuth>;
+export declare function saveBrowserProfile(name: string, baseURL: string, session: ApprovedDeviceAuth): Promise<Profile>;
+export declare function resolveRuntimeProfile(profileName?: string): Promise<RuntimeProfile>;
+export declare function getAuthStatus(profileName?: string): Promise<AuthStatus>;
+export declare function refreshActiveProfileIfNeeded(profileName?: string, refreshWindowMs?: number): Promise<{
+    profile: Profile;
+    refreshed: boolean;
+}>;
+export declare function refreshIfNeeded(profile: Profile, refreshWindowMs?: number): Promise<Profile>;
+export declare function browserAccessTokenExpiresWithin(profile: Profile, refreshWindowMs: number, now?: number): boolean;
+export declare function refreshBrowserSession(profile: Profile): Promise<Profile>;
+export declare function listProfiles(): Promise<{
+    active: string;
+    profiles: Profile[];
+}>;
+export declare function useProfile(name: string): Promise<void>;
+export declare function deleteProfile(name: string): Promise<void>;
+export declare function profileSummary(profile: Profile, active?: boolean): string;
+export declare function formatDeviceUserCode(code: string): string;
+export declare function openBrowserURL(url: string): Promise<void>;