@agent-api/cli 0.2.1 → 0.3.0

package/dist/config.js

@@ -1,201 +0,0 @@
-import { z } from "zod";
-import { ensureRuntime, runtime } from "./runtime/index.js";
-export const defaultBaseURL = "https://api.agentsway.dev";
-export const configFile = "profiles.json";
-export const appConfigurationFile = "configuration.json";
-export const conversationsFile = "conversations.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(),
-    isolation: z.object({
-        mode: z.enum(["none", "auto", "required"]).optional(),
-        executablePath: z.string().nullable().optional(),
-        version: z.string().nullable().optional(),
-        sourceURL: z.string().nullable().optional(),
-        sha256: z.string().nullable().optional(),
-        installSkipped: z.boolean().nullable().optional(),
-    }).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({}),
-});
-const appConfigurationSchema = z.object({
-    workbench: workbenchPreferencesSchema,
-});
-const conversationConfigurationSchema = z.object({
-    conversations: z.record(z.string(), conversationSchema).default({}),
-});
-export async function loadConfig() {
-    await ensureRuntime();
-    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 ensureRuntime();
-    await runtime.config.write(configFile, {
-        activeProfile: config.activeProfile,
-        profiles: config.profiles,
-    });
-}
-export async function loadAppConfiguration() {
-    await ensureRuntime();
-    const loaded = await runtime.config.read(appConfigurationFile, emptyAppConfiguration());
-    const parsed = appConfigurationSchema.safeParse(loaded);
-    if (!parsed.success) {
-        throw new Error(`Invalid app configuration: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
-    }
-    return parsed.data;
-}
-export async function saveAppConfiguration(config) {
-    await ensureRuntime();
-    await runtime.config.write(appConfigurationFile, config);
-}
-export async function loadConversationConfiguration() {
-    await ensureRuntime();
-    const loaded = await runtime.config.read(conversationsFile, emptyConversationConfiguration());
-    const parsed = conversationConfigurationSchema.safeParse(loaded);
-    if (!parsed.success) {
-        throw new Error(`Invalid conversation configuration: ${parsed.error.issues.map((issue) => issue.message).join("; ")}`);
-    }
-    return parsed.data;
-}
-export async function saveConversationConfiguration(config) {
-    await ensureRuntime();
-    await runtime.config.write(conversationsFile, 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: {} };
-}
-export function emptyAppConfiguration() {
-    return { workbench: {} };
-}
-export function emptyConversationConfiguration() {
-    return { conversations: {} };
-}
-export async function loadWorkbenchPreferences() {
-    const appConfig = await loadAppConfiguration();
-    return appConfig.workbench;
-}
-export async function updateWorkbenchPreferences(patch) {
-    const appConfig = await loadAppConfiguration();
-    const next = { ...appConfig.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;
-            }
-        }
-    }
-    if ("isolation" in patch) {
-        next.isolation = updateIsolationPreferences(next.isolation, patch.isolation);
-    }
-    appConfig.workbench = next;
-    await saveAppConfiguration(appConfig);
-    return next;
-}
-function updateIsolationPreferences(current, patch) {
-    const next = { ...(current ?? {}) };
-    if (!patch)
-        return Object.keys(next).length > 0 ? next : undefined;
-    if ("mode" in patch) {
-        if (patch.mode === null || patch.mode === undefined) {
-            delete next.mode;
-        }
-        else {
-            next.mode = patch.mode;
-        }
-    }
-    for (const key of ["executablePath", "version", "sourceURL", "sha256"]) {
-        if (key in patch) {
-            const value = patch[key];
-            if (value === undefined || value === null) {
-                delete next[key];
-            }
-            else {
-                const trimmed = value.trim();
-                if (trimmed)
-                    next[key] = trimmed;
-                else
-                    delete next[key];
-            }
-        }
-    }
-    if ("installSkipped" in patch) {
-        if (patch.installSkipped === undefined || patch.installSkipped === null) {
-            delete next.installSkipped;
-        }
-        else {
-            next.installSkipped = patch.installSkipped;
-        }
-    }
-    return Object.keys(next).length > 0 ? next : undefined;
-}
-export function redactSecret(value) {
-    if (value.length <= 10)
-        return "***";
-    return `${value.slice(0, 6)}…${value.slice(-4)}`;
-}

package/dist/conversation/index.d.ts

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

@@ -1,54 +0,0 @@
-import { activeProfile, loadConversationConfiguration, saveConversationConfiguration } 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 loadConversationConfiguration();
-    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 loadConversationConfiguration();
-    config.conversations[conversationKey(profile.name, options.conversation)] = {
-        name: options.conversation,
-        profile: profile.name,
-        previousResponseId: responseID,
-        updatedAt: Math.floor(Date.now() / 1000),
-    };
-    await saveConversationConfiguration(config);
-}
-export async function listConversations(profileName) {
-    const profile = await activeProfile(profileName);
-    const config = await loadConversationConfiguration();
-    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 loadConversationConfiguration();
-    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 loadConversationConfiguration();
-    delete config.conversations[conversationKey(profile.name, name)];
-    await saveConversationConfiguration(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/profile.d.ts

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

package/dist/profile.js

@@ -1,211 +0,0 @@
-import { AgentAPI, browserAuthSessionExpiresWithin } from "@agent-api/sdk";
-import { execFile } from "node:child_process";
-import { platform } from "node:os";
-import { promisify } from "node:util";
-import { activeProfile, defaultBaseURL, loadConfig, redactSecret, saveConfig, upsertProfile, } from "./config.js";
-const execFileAsync = promisify(execFile);
-export class AuthSessionExpiredError extends Error {
-    profile;
-    baseURL;
-    constructor(profile, message = "browser session refresh failed") {
-        super([
-            "Browser session expired or could not be refreshed.",
-            `Run: agent-api auth login --profile ${profile.name} --base-url ${profile.baseURL}`,
-            `Details: ${message}`,
-        ].join("\n"));
-        this.name = "AuthSessionExpiredError";
-        this.profile = profile.name;
-        this.baseURL = profile.baseURL;
-    }
-}
-export async function loginWithAPIKey(options) {
-    const profile = await upsertProfile({
-        name: options.profile,
-        baseURL: normalizeBaseURL(options.baseURL),
-        auth: { type: "api_key", apiKey: options.apiKey.trim() },
-    });
-    return profile;
-}
-export async function loginWithBrowser(options) {
-    const baseURL = normalizeBaseURL(options.baseURL);
-    const challenge = await startBrowserAuthChallenge({ baseURL, clientName: options.clientName });
-    console.log(`Open this URL to authorize the CLI:\n${challenge.verification_uri_complete}\n`);
-    console.log(`Code: ${formatDeviceUserCode(challenge.user_code)}\n`);
-    if (options.openBrowser !== false) {
-        await openBrowserURL(challenge.verification_uri_complete).catch((error) => {
-            console.warn(`Could not open browser automatically: ${error instanceof Error ? error.message : String(error)}`);
-        });
-    }
-    console.log("Waiting for browser approval...");
-    const session = await waitForBrowserAuthChallenge({
-        baseURL,
-        challenge,
-        on_poll(result) {
-            if (result.status && result.status !== "pending") {
-                console.log(`Status: ${result.status}`);
-            }
-        },
-    });
-    const profile = await saveBrowserProfile(options.profile, baseURL, session);
-    console.log(`Signed in as profile "${profile.name}".`);
-    return profile;
-}
-export async function startBrowserAuthChallenge(options) {
-    const baseURL = normalizeBaseURL(options.baseURL);
-    const client = new AgentAPI({ baseURL });
-    return await client.auth.startDeviceAuth({ client_name: options.clientName || "Agent API CLI" });
-}
-export async function waitForBrowserAuthChallenge(options) {
-    const baseURL = normalizeBaseURL(options.baseURL);
-    const client = new AgentAPI({ baseURL });
-    return await client.auth.waitForDeviceAuth({
-        device_code: options.challenge.device_code,
-        interval_seconds: options.challenge.interval_seconds,
-        timeout_ms: Math.max(0, options.challenge.expires_at * 1000 - Date.now()),
-        on_poll: options.on_poll,
-    });
-}
-export async function saveBrowserProfile(name, baseURL, session) {
-    return await upsertProfile({
-        name,
-        baseURL,
-        auth: {
-            type: "browser",
-            accessToken: session.access_token,
-            refreshToken: session.refresh_token,
-            accessTokenExpiresAt: session.access_token_expires_at,
-            refreshTokenExpiresAt: session.refresh_token_expires_at,
-        },
-    });
-}
-export async function resolveRuntimeProfile(profileName) {
-    const { profile: fresh } = await refreshActiveProfileIfNeeded(profileName);
-    const token = fresh.auth.type === "api_key" ? fresh.auth.apiKey : fresh.auth.accessToken;
-    return {
-        profile: fresh,
-        token,
-        client: new AgentAPI({ apiKey: token, baseURL: fresh.baseURL }),
-    };
-}
-export async function getAuthStatus(profileName) {
-    const runtime = await resolveRuntimeProfile(profileName);
-    const response = await fetch(`${runtime.profile.baseURL}/v1/me`, {
-        headers: { Authorization: `Bearer ${runtime.token}` },
-    });
-    const payload = await response.json().catch(() => undefined);
-    if (!response.ok) {
-        throw new Error(errorMessageFromPayload(payload) || `whoami failed with ${response.status}`);
-    }
-    return {
-        profile: runtime.profile.name,
-        baseURL: runtime.profile.baseURL,
-        authType: runtime.profile.auth.type,
-        me: payload,
-    };
-}
-export async function refreshActiveProfileIfNeeded(profileName, refreshWindowMs = 60_000) {
-    const profile = await activeProfile(profileName);
-    const shouldRefresh = browserAccessTokenExpiresWithin(profile, refreshWindowMs);
-    const fresh = await refreshIfNeeded(profile, refreshWindowMs);
-    return { profile: fresh, refreshed: shouldRefresh && profile.auth.type === "browser" };
-}
-export async function refreshIfNeeded(profile, refreshWindowMs = 60_000) {
-    if (profile.auth.type !== "browser")
-        return profile;
-    const expiresAtMs = profile.auth.accessTokenExpiresAt * 1000;
-    if (expiresAtMs - Date.now() > refreshWindowMs)
-        return profile;
-    const refreshed = await refreshBrowserSession(profile);
-    const config = await loadConfig();
-    config.profiles[profile.name] = refreshed;
-    await saveConfig(config);
-    return refreshed;
-}
-export function browserAccessTokenExpiresWithin(profile, refreshWindowMs, now = Date.now()) {
-    if (profile.auth.type !== "browser")
-        return false;
-    return browserAuthSessionExpiresWithin({ access_token_expires_at: profile.auth.accessTokenExpiresAt }, refreshWindowMs, now);
-}
-export async function refreshBrowserSession(profile) {
-    if (profile.auth.type !== "browser")
-        return profile;
-    const client = new AgentAPI({ baseURL: profile.baseURL });
-    let session;
-    try {
-        session = await client.auth.refreshBrowserSession({ refresh_token: profile.auth.refreshToken });
-    }
-    catch (error) {
-        throw new AuthSessionExpiredError(profile, error instanceof Error ? error.message : String(error));
-    }
-    return {
-        ...profile,
-        auth: {
-            type: "browser",
-            accessToken: session.access_token,
-            refreshToken: session.refresh_token || profile.auth.refreshToken,
-            accessTokenExpiresAt: session.access_token_expires_at,
-            refreshTokenExpiresAt: session.refresh_token_expires_at || profile.auth.refreshTokenExpiresAt,
-        },
-        updatedAt: Math.floor(Date.now() / 1000),
-    };
-}
-export async function listProfiles() {
-    const config = await loadConfig();
-    return { active: config.activeProfile, profiles: Object.values(config.profiles).sort((a, b) => a.name.localeCompare(b.name)) };
-}
-export async function useProfile(name) {
-    const config = await loadConfig();
-    if (!config.profiles[name])
-        throw new Error(`Profile not found: ${name}`);
-    config.activeProfile = name;
-    await saveConfig(config);
-}
-export async function deleteProfile(name) {
-    const config = await loadConfig();
-    delete config.profiles[name];
-    if (config.activeProfile === name) {
-        config.activeProfile = Object.keys(config.profiles).sort()[0] || "default";
-    }
-    await saveConfig(config);
-}
-export function profileSummary(profile, active = false) {
-    const auth = profile.auth.type === "api_key"
-        ? `api_key ${redactSecret(profile.auth.apiKey)}`
-        : `browser ${redactSecret(profile.auth.accessToken)}`;
-    return `${active ? "*" : " "} ${profile.name}\t${profile.baseURL}\t${auth}`;
-}
-function errorMessageFromPayload(payload) {
-    if (payload && typeof payload === "object") {
-        const error = payload.error;
-        if (error && typeof error === "object") {
-            const message = error.message;
-            if (typeof message === "string")
-                return message;
-        }
-        const message = payload.message;
-        if (typeof message === "string")
-            return message;
-    }
-    return "";
-}
-function normalizeBaseURL(baseURL) {
-    return (baseURL || process.env.AGENT_API_BASE_URL || defaultBaseURL).replace(/\/+$/, "");
-}
-export function formatDeviceUserCode(code) {
-    const normalized = code.replace(/[-\s]/g, "").toUpperCase();
-    if (normalized.length <= 4)
-        return normalized;
-    return `${normalized.slice(0, 4)}-${normalized.slice(4)}`;
-}
-export async function openBrowserURL(url) {
-    const current = platform();
-    if (current === "darwin") {
-        await execFileAsync("open", [url]);
-        return;
-    }
-    if (current === "win32") {
-        await execFileAsync("cmd", ["/c", "start", "", url]);
-        return;
-    }
-    await execFileAsync("xdg-open", [url]);
-}

package/dist/runtime/index.d.ts

@@ -1,5 +0,0 @@
-export declare const cliName = "agent-tui";
-export declare const cliAuthor = "AgentsWay";
-export declare const cliVersion = "0.2.1";
-export declare const runtime: import("@agent-api/sdk/local").LocalRuntime;
-export declare function ensureRuntime(): Promise<import("@agent-api/sdk/local").LocalRuntime>;