@love-moon/ai-sdk 0.3.1 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @love-moon/ai-sdk
 
+## 0.4.0
+
+### Minor Changes
+
+- 4ecc359: Publish the chat-web browser runtime and wire it into the CLI and AI SDK for
+  ChatGPT and Gemini web sessions, including provider error handling and local
+  development installation support.
+
+  Ship app SDK realtime history catch-up and the CLI/AI SDK goal-mode and custom
+  command runtime updates included in this release.
+
+## 0.3.2
+
+### Patch Changes
+
+- 8e1d4a8: Prefer the bundled Copilot platform executable before the JS entrypoint so Node
+  20 installs do not fail with `ERR_UNKNOWN_BUILTIN_MODULE: node:sqlite`.
+
 ## 0.3.1
 
 ### Patch Changes

package/dist/built-in-backends.d.ts

@@ -22,6 +22,7 @@ export const COPILOT_SDK_VARIANT: "copilot-sdk";
 export const KIMI_CLI_WIRE_VARIANT: "kimi-cli-wire";
 export const KIMI_CLI_PRINT_VARIANT: "kimi-cli-print";
 export const OPENCODE_SDK_VARIANT: "opencode-sdk";
+export const CHAT_WEB_SESSION_VARIANT: "chat-web-session";
 /**
  * @typedef {Object} BuiltInBackendEntry
  * @property {string}   backend        Canonical backend name.

package/dist/built-in-backends.js

@@ -18,6 +18,7 @@ export const COPILOT_SDK_VARIANT = "copilot-sdk";
 export const KIMI_CLI_WIRE_VARIANT = "kimi-cli-wire";
 export const KIMI_CLI_PRINT_VARIANT = "kimi-cli-print";
 export const OPENCODE_SDK_VARIANT = "opencode-sdk";
+export const CHAT_WEB_SESSION_VARIANT = "chat-web-session";
 /**
  * @typedef {Object} BuiltInBackendEntry
  * @property {string}   backend        Canonical backend name.
@@ -54,6 +55,11 @@ export const BUILT_IN_BACKENDS = [
         aliases: ["opencode", "open-code", "open_code"],
         defaultVariant: OPENCODE_SDK_VARIANT,
     },
+    {
+        backend: "chat-web",
+        aliases: ["chat-web", "chatweb", "chat_web", "web-chat"],
+        defaultVariant: CHAT_WEB_SESSION_VARIANT,
+    },
 ];
 const ALIAS_TO_BACKEND = new Map();
 for (const entry of BUILT_IN_BACKENDS) {

package/dist/client.d.ts

@@ -16,6 +16,9 @@ export class RemoteAiSession extends EventEmitter<[never]> {
         sessionId: any;
         useSessionFileReplyStream: boolean;
         workerReady: boolean;
+        capabilities: {
+            goal?: boolean | undefined;
+        };
     };
     sessionMessageHandler: any;
     workingStatusHandler: any;
@@ -46,6 +49,9 @@ export class RemoteAiSession extends EventEmitter<[never]> {
         sessionId: any;
         useSessionFileReplyStream: boolean;
         workerReady: boolean;
+        capabilities: {
+            goal?: boolean | undefined;
+        };
     };
     usesSessionFileReplyStream(): boolean;
     getSessionInfo(): any;
@@ -57,6 +63,9 @@ export class RemoteAiSession extends EventEmitter<[never]> {
     getSessionUsageSummary(): Promise<any>;
     interruptCurrentTurn(): Promise<any>;
     runTurn(promptText: any, options?: {}): Promise<any>;
+    runGoal(goal: any, options?: {}): Promise<any>;
+    getGoal(): Promise<any>;
+    clearGoal(): Promise<any>;
     close(): Promise<void>;
     callWorker(method: any, args?: any[], { progressHandler, messageType }?: {
         progressHandler?: null | undefined;
@@ -92,6 +101,9 @@ declare class LocalAiSessionProxy extends EventEmitter<[never]> {
         sessionId: any;
         useSessionFileReplyStream: boolean;
         workerReady: boolean;
+        capabilities: {
+            goal?: boolean | undefined;
+        };
     };
     readyPromise: Promise<any>;
     initializeSession(backend: any, options: any): Promise<any>;
@@ -108,6 +120,9 @@ declare class LocalAiSessionProxy extends EventEmitter<[never]> {
     getSessionUsageSummary(): Promise<any>;
     interruptCurrentTurn(): Promise<any>;
     runTurn(promptText: any, options?: {}): Promise<any>;
+    runGoal(goal: any, options?: {}): Promise<any>;
+    getGoal(): Promise<any>;
+    clearGoal(): Promise<any>;
     close(): Promise<void>;
 }
 import { EventEmitter } from "node:events";

package/dist/client.js

@@ -3,7 +3,12 @@ import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import readline from "node:readline";
 import { assertSupportedBackend, createLocalAiSession, providerVariantForBackend, } from "./session-factory.js";
-import { normalizeLogger, reviveError } from "./shared.js";
+import { DEFAULT_SESSION_CAPABILITIES, normalizeLogger, resolveSessionCapabilities, reviveError, } from "./shared.js";
+function createUnsupportedGoalError(name) {
+    const err = new Error(`runGoal() is not supported by backend session (${name || "unknown"}).`);
+    err.reason = "unsupported_goal";
+    return err;
+}
 const WORKER_PATH = fileURLToPath(new URL("./worker.js", import.meta.url));
 function sanitizeOptionsForWorker(options = {}) {
     const sanitized = {};
@@ -46,6 +51,7 @@ export class RemoteAiSession extends EventEmitter {
             sessionId: this.threadIdValue || undefined,
             useSessionFileReplyStream: this.useSessionFileReplyStreamValue,
             workerReady: false,
+            capabilities: { ...DEFAULT_SESSION_CAPABILITIES },
         };
         this.sessionMessageHandler = null;
         this.workingStatusHandler = null;
@@ -179,6 +185,43 @@ export class RemoteAiSession extends EventEmitter {
             progressHandler: typeof onProgress === "function" ? onProgress : null,
         });
     }
+    async runGoal(goal, options = {}) {
+        // Wait for the worker bootstrap to finish so we can consult the snapshot's
+        // capability flags. Critically, we must NOT swallow a `readyPromise`
+        // rejection: when the worker fails to come up (binary missing, config
+        // error, transport crash on init), the real error has to surface — masking
+        // it as `unsupported_goal` would mislead operators about what's wrong.
+        // See N3 in the review.
+        await this.readyPromise;
+        // Cheap capability gate: when the worker has reported a snapshot with
+        // `capabilities.goal === false`, short-circuit instead of paying for an
+        // IPC round-trip just to surface `unsupported_goal`.
+        if (this.snapshot?.capabilities && this.snapshot.capabilities.goal === false) {
+            throw createUnsupportedGoalError(this.snapshot.provider || this.snapshot.backend);
+        }
+        const { onProgress, ...restOptions } = options || {};
+        return this.callWorker("runGoal", [goal, restOptions], {
+            progressHandler: typeof onProgress === "function" ? onProgress : null,
+        });
+    }
+    async getGoal() {
+        // Propagate worker-creation errors instead of masking them as "no goal".
+        // See N3 in the review.
+        await this.readyPromise;
+        if (this.snapshot?.capabilities && this.snapshot.capabilities.goal === false) {
+            return null;
+        }
+        return this.callWorker("getGoal", []);
+    }
+    async clearGoal() {
+        // Propagate worker-creation errors instead of masking them as "nothing
+        // to clear". See N3 in the review.
+        await this.readyPromise;
+        if (this.snapshot?.capabilities && this.snapshot.capabilities.goal === false) {
+            return false;
+        }
+        return this.callWorker("clearGoal", []);
+    }
     async close() {
         if (this.closed) {
             return;
@@ -298,9 +341,13 @@ export class RemoteAiSession extends EventEmitter {
     }
     applyReadyPayload(payload) {
         const snapshot = payload?.snapshot && typeof payload.snapshot === "object" ? payload.snapshot : {};
+        const capabilities = snapshot && typeof snapshot.capabilities === "object" && snapshot.capabilities !== null
+            ? { ...DEFAULT_SESSION_CAPABILITIES, ...snapshot.capabilities }
+            : { ...DEFAULT_SESSION_CAPABILITIES };
         this.snapshot = {
             ...this.snapshot,
             ...snapshot,
+            capabilities,
             workerReady: true,
             workerPid: payload?.workerPid || undefined,
             workerProcessPid: payload?.workerProcessPid || undefined,
@@ -428,6 +475,7 @@ class LocalAiSessionProxy extends EventEmitter {
             sessionId: this.threadIdValue || undefined,
             useSessionFileReplyStream: this.useSessionFileReplyStreamValue,
             workerReady: false,
+            capabilities: { ...DEFAULT_SESSION_CAPABILITIES },
         };
         this.readyPromise = this.initializeSession(backend, options);
         this.readyPromise.catch(() => {
@@ -482,6 +530,12 @@ class LocalAiSessionProxy extends EventEmitter {
                 : snapshot.sessionInfo && typeof snapshot.sessionInfo === "object"
                     ? { ...snapshot.sessionInfo }
                     : this.sessionInfo;
+        // Capability resolution: prefer the snapshot's `capabilities`, then fall
+        // back to a runtime resolver that checks `session.getCapabilities()` and
+        // `session.constructor.capabilities`.
+        const capabilities = snapshot && typeof snapshot.capabilities === "object" && snapshot.capabilities !== null
+            ? { ...DEFAULT_SESSION_CAPABILITIES, ...snapshot.capabilities }
+            : resolveSessionCapabilities(session);
         this.snapshot = {
             ...this.snapshot,
             ...snapshot,
@@ -491,6 +545,7 @@ class LocalAiSessionProxy extends EventEmitter {
             currentTurnStatus: typeof session.getCurrentTurnStatus === "function" ? session.getCurrentTurnStatus() : this.currentTurnStatus,
             useSessionFileReplyStream: this.useSessionFileReplyStreamValue,
             workerReady: true,
+            capabilities,
         };
         return session;
     }
@@ -503,6 +558,16 @@ class LocalAiSessionProxy extends EventEmitter {
     getSnapshot() {
         const sessionSnapshot = typeof this.session?.getSnapshot === "function" ? this.session.getSnapshot() : null;
         if (sessionSnapshot) {
+            // N5: capabilities were resolved once during `initializeSession` and are
+            // immutable for the lifetime of the underlying session. Reuse the cached
+            // value instead of re-resolving on every `getSnapshot()` call — this
+            // avoids per-call object identity flicker that breaks callers that
+            // memoize on the snapshot reference (e.g. React selectors).
+            const capabilities = this.snapshot?.capabilities
+                ? this.snapshot.capabilities
+                : sessionSnapshot && typeof sessionSnapshot.capabilities === "object" && sessionSnapshot.capabilities !== null
+                    ? { ...DEFAULT_SESSION_CAPABILITIES, ...sessionSnapshot.capabilities }
+                    : resolveSessionCapabilities(this.session);
             return {
                 ...this.snapshot,
                 ...sessionSnapshot,
@@ -514,6 +579,7 @@ class LocalAiSessionProxy extends EventEmitter {
                 sessionInfo: typeof this.session?.getSessionInfo === "function"
                     ? this.session.getSessionInfo()
                     : sessionSnapshot.sessionInfo || this.sessionInfo || null,
+                capabilities,
             };
         }
         return {
@@ -582,6 +648,42 @@ class LocalAiSessionProxy extends EventEmitter {
         const session = await this.readyPromise;
         return await session.runTurn(promptText, options);
     }
+    async runGoal(goal, options = {}) {
+        const session = await this.readyPromise;
+        // Capability check: declarative `capabilities.goal === false` wins over
+        // method presence. This matters because a proxy may unconditionally
+        // forward runGoal and the per-method check would mis-report support.
+        const capabilities = resolveSessionCapabilities(session);
+        if (capabilities.goal === false) {
+            throw createUnsupportedGoalError(session?.constructor?.name);
+        }
+        if (typeof session.runGoal !== "function") {
+            throw createUnsupportedGoalError(session?.constructor?.name);
+        }
+        return await session.runGoal(goal, options);
+    }
+    async getGoal() {
+        const session = await this.readyPromise;
+        const capabilities = resolveSessionCapabilities(session);
+        if (capabilities.goal === false) {
+            return null;
+        }
+        if (typeof session.getGoal !== "function") {
+            return null;
+        }
+        return await session.getGoal();
+    }
+    async clearGoal() {
+        const session = await this.readyPromise;
+        const capabilities = resolveSessionCapabilities(session);
+        if (capabilities.goal === false) {
+            return false;
+        }
+        if (typeof session.clearGoal !== "function") {
+            return false;
+        }
+        return await session.clearGoal();
+    }
     async close() {
         if (this.closed) {
             return;

package/dist/external-provider-registry.js

@@ -133,6 +133,10 @@ function validateDescriptor(descriptor, sourcePath) {
         resolveResumeContext: optionalFn("resolveResumeContext"),
         buildResumeArgs: optionalFn("buildResumeArgs"),
         findSessionPath: optionalFn("findSessionPath"),
+        getQuota: optionalFn("getQuota"),
+        getQuotaList: optionalFn("getQuotaList"),
+        readCachedQuota: optionalFn("readCachedQuota"),
+        readCachedQuotaList: optionalFn("readCachedQuotaList"),
         sourcePath,
     };
 }

package/dist/index.d.ts

@@ -1,3 +1,6 @@
 export { BUILT_IN_BACKENDS } from "./built-in-backends.js";
 export { createAiSession, RemoteAiSession } from "./client.js";
+export { GOAL_STATUSES, TERMINAL_GOAL_STATUSES, isGoalStatus, isTerminalGoalStatus } from "./shared.js";
+export { AiManager, accountNameFromPath, checkInstall, checkInstallAll, checkNetwork, checkNetworkAll, getClaudeQuota, getCodexQuota, getCopilotQuota, getCurrentCodexAccount, getExternalQuota, getExternalQuotaList, getKimiQuota, listCodexAccounts, loadAiManagerConfig, normalizeExternalQuota, normalizeExternalQuotaList, parseAuthFile, parseAuthFileContents, parseCopilotQuotaSnapshots, readCachedCodexQuota, resolveClaudeCredential, switchCodexAccount } from "./manager/index.js";
+export { getExternalProviderDescriptor, getExternalProviderRegistry, resetExternalProviderRegistryForTests, resolveExternalBackend } from "./external-provider-registry.js";
 export { resolveResumeContext, buildResumeArgsForBackend, resumeProviderForBackend, findSessionPath, resolveSessionRunDirectory, inspectResumeTarget } from "./resume/index.js";

package/dist/index.js

@@ -1,3 +1,6 @@
 export { createAiSession, RemoteAiSession } from "./client.js";
 export { BUILT_IN_BACKENDS } from "./built-in-backends.js";
+export { GOAL_STATUSES, TERMINAL_GOAL_STATUSES, isGoalStatus, isTerminalGoalStatus, } from "./shared.js";
+export { AiManager, accountNameFromPath, checkInstall, checkInstallAll, checkNetwork, checkNetworkAll, getClaudeQuota, getCodexQuota, getCopilotQuota, getCurrentCodexAccount, getExternalQuota, getExternalQuotaList, getKimiQuota, listCodexAccounts, loadAiManagerConfig, normalizeExternalQuota, normalizeExternalQuotaList, parseAuthFile, parseAuthFileContents, parseCopilotQuotaSnapshots, readCachedCodexQuota, resolveClaudeCredential, switchCodexAccount, } from "./manager/index.js";
+export { getExternalProviderDescriptor, getExternalProviderRegistry, resetExternalProviderRegistryForTests, resolveExternalBackend, } from "./external-provider-registry.js";
 export { resolveResumeContext, buildResumeArgsForBackend, resumeProviderForBackend, findSessionPath, resolveSessionRunDirectory, inspectResumeTarget, } from "./resume/index.js";

package/dist/manager/account.d.ts

@@ -0,0 +1,6 @@
+import type { AiManagerConfig, CodexAccount, SwitchResult } from "./types.js";
+/** Derive the short account name from the file path. */
+export declare function accountNameFromPath(path: string): string;
+export declare function listCodexAccounts(config: AiManagerConfig, codexAuthPath?: string): Promise<CodexAccount[]>;
+export declare function getCurrentCodexAccount(config: AiManagerConfig, codexAuthPath?: string): Promise<CodexAccount | null>;
+export declare function switchCodexAccount(config: AiManagerConfig, name: string, codexAuthPath?: string): Promise<SwitchResult>;

package/dist/manager/account.js

@@ -0,0 +1,121 @@
+import { readFile, writeFile, copyFile, chmod, rename, stat } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { parseAuthFile, parseAuthFileContents, } from "./auth-parser.js";
+import { DEFAULT_CODEX_AUTH } from "./paths.js";
+/** Derive the short account name from the file path. */
+export function accountNameFromPath(path) {
+    const base = basename(path);
+    return base.replace(/^auth_/, "").replace(/\.json$/, "");
+}
+async function fileExists(p) {
+    try {
+        await stat(p);
+        return true;
+    }
+    catch (err) {
+        if (err?.code === "ENOENT")
+            return false;
+        throw err;
+    }
+}
+function fingerprintOfPath(p) {
+    try {
+        const data = JSON.parse(readFileSync(p, "utf8"));
+        return parseAuthFileContents(data).identityFingerprint;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readCurrentFingerprint(codexAuthPath) {
+    if (!(await fileExists(codexAuthPath)))
+        return undefined;
+    const info = await parseAuthFile(codexAuthPath);
+    return info.identityFingerprint;
+}
+export async function listCodexAccounts(config, codexAuthPath = DEFAULT_CODEX_AUTH) {
+    const currentFp = await readCurrentFingerprint(codexAuthPath);
+    const out = [];
+    for (const path of config.codex.authJson) {
+        const entry = {
+            name: accountNameFromPath(path),
+            path,
+            isCurrent: false,
+        };
+        try {
+            const info = await parseAuthFile(path);
+            entry.email = info.email;
+            entry.accountId = info.accountId;
+            entry.planType = info.planType;
+            entry.lastRefresh = info.lastRefresh;
+            entry.isCurrent = Boolean(currentFp && info.identityFingerprint && currentFp === info.identityFingerprint);
+        }
+        catch {
+            // leave entry minimal; caller can see that name/path exist but details missing
+        }
+        out.push(entry);
+    }
+    return out;
+}
+export async function getCurrentCodexAccount(config, codexAuthPath = DEFAULT_CODEX_AUTH) {
+    const accounts = await listCodexAccounts(config, codexAuthPath);
+    return accounts.find((a) => a.isCurrent) ?? null;
+}
+function assertValidAuthJson(data) {
+    if (!data || typeof data !== "object") {
+        throw new Error("auth.json is not a JSON object");
+    }
+    const tokens = data.tokens;
+    if (!tokens || typeof tokens.access_token !== "string" || tokens.access_token.length < 20) {
+        throw new Error("auth.json is missing a valid tokens.access_token");
+    }
+}
+function nameForFingerprint(config, fingerprint) {
+    if (!fingerprint)
+        return undefined;
+    for (const p of config.codex.authJson) {
+        if (fingerprintOfPath(p) === fingerprint)
+            return accountNameFromPath(p);
+    }
+    return undefined;
+}
+export async function switchCodexAccount(config, name, codexAuthPath = DEFAULT_CODEX_AUTH) {
+    const match = config.codex.authJson.find((p) => accountNameFromPath(p) === name);
+    if (!match) {
+        const available = config.codex.authJson.map(accountNameFromPath).join(", ") || "<none>";
+        throw new Error(`codex account "${name}" not found in config (available: ${available})`);
+    }
+    const raw = await readFile(match, "utf8");
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`target auth.json is not valid JSON: ${err.message}`);
+    }
+    assertValidAuthJson(data);
+    const targetInfo = parseAuthFileContents(data);
+    const backupPath = `${codexAuthPath}.bak`;
+    let previousName;
+    if (await fileExists(codexAuthPath)) {
+        try {
+            const prevInfo = await parseAuthFile(codexAuthPath);
+            previousName = nameForFingerprint(config, prevInfo.identityFingerprint);
+            if (prevInfo.identityFingerprint &&
+                targetInfo.identityFingerprint &&
+                prevInfo.identityFingerprint === targetInfo.identityFingerprint) {
+                return { previousName, newName: name, backupPath };
+            }
+        }
+        catch {
+            // Best-effort; still back up raw contents below
+        }
+        await copyFile(codexAuthPath, backupPath);
+    }
+    const tmp = `${codexAuthPath}.tmp`;
+    await writeFile(tmp, raw, { mode: 0o600 });
+    await rename(tmp, codexAuthPath);
+    await chmod(codexAuthPath, 0o600).catch(() => { });
+    return { previousName, newName: name, backupPath };
+}

package/dist/manager/auth-parser.d.ts

@@ -0,0 +1,27 @@
+export interface CodexAuthFile {
+    auth_mode?: string;
+    OPENAI_API_KEY?: string | null;
+    tokens?: {
+        id_token?: string;
+        access_token?: string;
+        refresh_token?: string;
+        account_id?: string;
+    };
+    last_refresh?: string;
+}
+export interface CodexAuthInfo {
+    email?: string;
+    accountId?: string;
+    planType?: string;
+    userId?: string;
+    name?: string;
+    lastRefresh?: string;
+    accessToken?: string;
+    /**
+     * Stable identity fingerprint across auth files.
+     * Prefers `email|account_id` from the id_token; falls back to a hash of access_token.
+     */
+    identityFingerprint?: string;
+}
+export declare function parseAuthFileContents(data: CodexAuthFile): CodexAuthInfo;
+export declare function parseAuthFile(path: string): Promise<CodexAuthInfo>;

package/dist/manager/auth-parser.js

@@ -0,0 +1,54 @@
+import { readFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+/** Decode the JWT payload segment (no signature verification). */
+function decodeJwtPayload(token) {
+    const parts = token.split(".");
+    if (parts.length !== 3)
+        throw new Error("Invalid JWT");
+    const b64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    const padded = b64 + "===".slice((b64.length + 3) % 4);
+    const json = Buffer.from(padded, "base64").toString("utf8");
+    return JSON.parse(json);
+}
+export function parseAuthFileContents(data) {
+    const info = {};
+    const tokens = data.tokens;
+    if (!tokens)
+        return info;
+    info.accountId = tokens.account_id;
+    info.accessToken = tokens.access_token;
+    info.lastRefresh = data.last_refresh;
+    if (tokens.id_token) {
+        try {
+            const payload = decodeJwtPayload(tokens.id_token);
+            info.email = payload.email;
+            info.name = payload.name;
+            info.userId = payload.user_id ?? payload.sub;
+            const ext = payload["https://api.openai.com/auth"];
+            if (ext && typeof ext === "object") {
+                info.planType = ext.chatgpt_plan_type;
+                if (!info.accountId)
+                    info.accountId = ext.chatgpt_account_id;
+            }
+        }
+        catch {
+            // ignore malformed id_token; caller may still have an access_token
+        }
+    }
+    info.identityFingerprint = computeIdentityFingerprint(info);
+    return info;
+}
+function computeIdentityFingerprint(info) {
+    if (info.email || info.accountId) {
+        return `${(info.email ?? "").toLowerCase()}|${info.accountId ?? ""}`;
+    }
+    if (info.accessToken) {
+        return "tok:" + createHash("sha1").update(info.accessToken).digest("hex").slice(0, 16);
+    }
+    return undefined;
+}
+export async function parseAuthFile(path) {
+    const raw = await readFile(path, "utf8");
+    const data = JSON.parse(raw);
+    return parseAuthFileContents(data);
+}

package/dist/manager/config.d.ts

@@ -0,0 +1,6 @@
+import type { AiManagerConfig } from "./types.js";
+/**
+ * Load the `ai_manager` section from a conductor config file.
+ * Returns an empty config if the file does not exist or the section is missing.
+ */
+export declare function loadAiManagerConfig(configPath?: string): Promise<AiManagerConfig>;

package/dist/manager/config.js

@@ -0,0 +1,32 @@
+import { readFile } from "node:fs/promises";
+import { parse as parseYaml } from "yaml";
+import { DEFAULT_CONDUCTOR_CONFIG, expandHome } from "./paths.js";
+const EMPTY = { codex: { authJson: [] } };
+/**
+ * Load the `ai_manager` section from a conductor config file.
+ * Returns an empty config if the file does not exist or the section is missing.
+ */
+export async function loadAiManagerConfig(configPath = DEFAULT_CONDUCTOR_CONFIG) {
+    let raw;
+    try {
+        raw = await readFile(configPath, "utf8");
+    }
+    catch (err) {
+        if (err?.code === "ENOENT")
+            return EMPTY;
+        throw err;
+    }
+    const doc = parseYaml(raw);
+    const section = doc?.ai_manager;
+    if (!section || typeof section !== "object")
+        return EMPTY;
+    const codexSection = section.codex ?? {};
+    const rawList = codexSection.auth_json ?? [];
+    if (!Array.isArray(rawList)) {
+        throw new Error(`ai_manager.codex.auth_json must be a list of paths, got ${typeof rawList}`);
+    }
+    const authJson = rawList
+        .filter((x) => typeof x === "string" && x.length > 0)
+        .map(expandHome);
+    return { codex: { authJson } };
+}

package/dist/manager/index.d.ts

@@ -0,0 +1,12 @@
+export { AiManager, type AiManagerOptions } from "./manager.js";
+export { loadAiManagerConfig } from "./config.js";
+export { parseAuthFile, parseAuthFileContents, type CodexAuthFile, type CodexAuthInfo, } from "./auth-parser.js";
+export { accountNameFromPath, listCodexAccounts, getCurrentCodexAccount, switchCodexAccount, } from "./account.js";
+export { checkInstall, checkInstallAll } from "./install.js";
+export { checkNetwork, checkNetworkAll } from "./network.js";
+export { getCodexQuota, readCachedCodexQuota, type GetCodexQuotaOptions, } from "./quota/codex.js";
+export { getClaudeQuota, resolveClaudeCredential, type GetClaudeQuotaOptions, type ClaudeCredential, } from "./quota/claude.js";
+export { getKimiQuota, type GetKimiQuotaOptions } from "./quota/kimi.js";
+export { getCopilotQuota, parseCopilotQuotaSnapshots, type GetCopilotQuotaOptions, } from "./quota/copilot.js";
+export { getExternalQuota, getExternalQuotaList, normalizeExternalQuota, normalizeExternalQuotaList, type GetExternalQuotaListOptions, type GetExternalQuotaOptions, } from "./quota/external.js";
+export type { AiManagerConfig, CodexAccount, CodexQuota, ClaudeQuota, ExternalQuota, ExternalQuotaList, KimiQuota, CopilotQuota, CopilotQuotaSnapshot, InstallStatus, NetworkStatus, QuotaSource, QuotaWindow, SwitchResult, Tool, } from "./types.js";

package/dist/manager/index.js

@@ -0,0 +1,11 @@
+export { AiManager } from "./manager.js";
+export { loadAiManagerConfig } from "./config.js";
+export { parseAuthFile, parseAuthFileContents, } from "./auth-parser.js";
+export { accountNameFromPath, listCodexAccounts, getCurrentCodexAccount, switchCodexAccount, } from "./account.js";
+export { checkInstall, checkInstallAll } from "./install.js";
+export { checkNetwork, checkNetworkAll } from "./network.js";
+export { getCodexQuota, readCachedCodexQuota, } from "./quota/codex.js";
+export { getClaudeQuota, resolveClaudeCredential, } from "./quota/claude.js";
+export { getKimiQuota } from "./quota/kimi.js";
+export { getCopilotQuota, parseCopilotQuotaSnapshots, } from "./quota/copilot.js";
+export { getExternalQuota, getExternalQuotaList, normalizeExternalQuota, normalizeExternalQuotaList, } from "./quota/external.js";

package/dist/manager/install.d.ts

@@ -0,0 +1,9 @@
+import type { InstallStatus, Tool } from "./types.js";
+export declare function checkInstall(tool: Tool, opts?: {
+    timeoutMs?: number;
+}): Promise<InstallStatus>;
+export declare function checkInstallAll(opts?: {
+    timeoutMs?: number;
+}): Promise<Record<Tool, InstallStatus>>;
+/** Exported for tests. */
+export declare function findPackageVersionForEntry(entryPath: string, packageName: string): Promise<string | undefined>;