@adecore/agents 0.0.1 → 0.17.0-beta.1

package/dist/providers/accounts/accounts.js

@@ -0,0 +1,158 @@
+import { homedir } from 'node:os';
+import { isAbsolute, join, resolve } from 'node:path';
+import { AgentKindSchema, ProviderAccountSchema } from '@adecore/agent-contracts';
+import { DEFAULT_ACCOUNTS_HOST, variablesProblem } from './variables.js';
+const KNOWN_KINDS = AgentKindSchema.options;
+export function isKnownKind(kind) {
+    return KNOWN_KINDS.includes(kind);
+}
+/* The default account of a CLI is the folder the CLI uses without being told, and its id is the CLI's kind. */
+export function isDefaultAccount(id, account) {
+    return id === account.kind;
+}
+export function expandHome(path, env) {
+    const home = env.HOME ?? homedir();
+    if (path === '~') {
+        return home;
+    }
+    if (path.startsWith('~/')) {
+        return join(home, path.slice(2));
+    }
+    return resolve(path);
+}
+/* A folder the host can resolve the same way whatever folder it was started in. */
+function isRootedPath(path) {
+    return path === '~' || path.startsWith('~/') || isAbsolute(path);
+}
+/*
+ * What is wrong with an account of a CLI this version knows, or null when nothing is. An account of
+ * an unknown kind is never judged: it is kept the way it was written, for a version that knows it.
+ */
+export function accountProblem(id, account, provider, env, reserved = { host: DEFAULT_ACCOUNTS_HOST, folderVariables: [] }) {
+    if (isKnownKind(id) && id !== account.kind) {
+        return `"${id}" is the id of the default ${id} account`;
+    }
+    const variables = variablesProblem(account.env ?? [], reserved);
+    if (variables !== null) {
+        return variables;
+    }
+    if (isDefaultAccount(id, account)) {
+        return account.home !== undefined || account.shadowHome !== undefined ? 'The default account uses the folder of the CLI itself' : null;
+    }
+    if (provider.home === undefined) {
+        return null;
+    }
+    if (account.home === undefined) {
+        return 'An account needs a config folder';
+    }
+    if (!isRootedPath(account.home)) {
+        return 'A config folder is an absolute path or starts with ~';
+    }
+    if (account.shadowHome === undefined) {
+        return null;
+    }
+    if (account.kind !== 'codex') {
+        return 'Only a Codex account has a shadow home';
+    }
+    if (!isRootedPath(account.shadowHome)) {
+        return 'A shadow home is an absolute path or starts with ~';
+    }
+    if (expandHome(account.shadowHome, env) === expandHome(account.home, env)) {
+        return 'The shadow home has to be another folder than the config folder';
+    }
+    return null;
+}
+/* The variables that point a CLI at its folder, which no account may set by hand. */
+export function folderVariablesOf(providerOf) {
+    return AgentKindSchema.options.flatMap((kind) => {
+        const home = providerOf(kind).home;
+        return home === undefined ? [] : [home.env];
+    });
+}
+/* The map with a default account for every CLI this version knows, those first and in catalog order. */
+export function withDefaults(accounts) {
+    const complete = {};
+    for (const kind of KNOWN_KINDS) {
+        complete[kind] = accounts[kind] ?? { kind };
+    }
+    for (const [id, account] of Object.entries(accounts)) {
+        complete[id] ??= account;
+    }
+    return complete;
+}
+/* The folder the CLI itself falls back on, as the host's own environment sets it. */
+export function defaultFolder(provider, env) {
+    if (provider.home === undefined) {
+        return '';
+    }
+    return env[provider.home.env] ?? join(env.HOME ?? homedir(), provider.home.fallback);
+}
+/* The folder a CLI of this account is started with: for a Codex account with a shadow home, that one. */
+export function accountFolder(id, account, provider, env) {
+    if (isDefaultAccount(id, account) || provider.home === undefined || account.home === undefined) {
+        return defaultFolder(provider, env);
+    }
+    return expandHome(account.shadowHome ?? account.home, env);
+}
+/* Where the account's conversations are written, which a shadow home shares with its `home`. */
+export function transcriptFolder(id, account, provider, env) {
+    if (isDefaultAccount(id, account) || provider.home === undefined || account.home === undefined) {
+        return defaultFolder(provider, env);
+    }
+    return expandHome(account.home, env);
+}
+/*
+ * The environment of a CLI process of this account. The default account runs in the host's own. Any
+ * other gets its folder in the CLI's variable, and loses the variables that would sign the CLI in over
+ * that folder's login: an inherited key would win, and only the bill would tell. Never HOME, which
+ * moves where Claude Code looks in the keychain. The account's own variables come last, so a key a
+ * person set there is the one that counts.
+ */
+export function accountEnv(id, account, provider, baseEnv, variables = {}) {
+    const withVariables = (env) => (Object.keys(variables).length === 0 ? env : { ...env, ...variables });
+    if (isDefaultAccount(id, account) || provider.home === undefined || account.home === undefined) {
+        return withVariables(baseEnv);
+    }
+    const env = { ...baseEnv };
+    for (const name of provider.home.loginEnv) {
+        delete env[name];
+    }
+    env[provider.home.env] = accountFolder(id, account, provider, baseEnv);
+    return withVariables(env);
+}
+/*
+ * Whether a conversation of one account can go on under the other: the same CLI, reading the same
+ * transcripts. Two Codex accounts over one `home` can, shadow home or not; two Claude folders never.
+ */
+export function canContinue(from, to, providerOf, env) {
+    if (from.id === to.id) {
+        return true;
+    }
+    const kind = from.account.kind;
+    if (kind !== to.account.kind || !isKnownKind(kind)) {
+        return false;
+    }
+    const provider = providerOf(kind);
+    return transcriptFolder(from.id, from.account, provider, env) === transcriptFolder(to.id, to.account, provider, env);
+}
+/*
+ * An account as the file holds it, or null for one to drop. An unknown kind comes back as it was
+ * read, extra fields included; a known kind has to parse and make sense.
+ */
+export function readAccount(id, raw, providerOf, env, host = DEFAULT_ACCOUNTS_HOST) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        return null;
+    }
+    const kind = raw.kind;
+    if (typeof kind !== 'string' || kind === '') {
+        return null;
+    }
+    if (!isKnownKind(kind)) {
+        return isKnownKind(id) ? null : raw;
+    }
+    const parsed = ProviderAccountSchema.safeParse(raw);
+    if (!parsed.success || accountProblem(id, parsed.data, providerOf(kind), env, { host, folderVariables: folderVariablesOf(providerOf) }) !== null) {
+        return null;
+    }
+    return parsed.data;
+}

package/dist/providers/accounts/launch.d.ts

@@ -0,0 +1,17 @@
+import type { AgentKind } from '@adecore/agent-contracts';
+import { CodedError } from '../../coded-error.ts';
+import type { Env } from './accounts.ts';
+export declare class AccountError extends CodedError<'account-unavailable' | 'account-incompatible'> {
+}
+export interface AccountLaunches {
+    envFor(kind: AgentKind, account: string | undefined, baseEnv: Env): Env;
+    transcriptFolder(kind: AgentKind, account: string | undefined): string | null;
+    homeFolder(kind: AgentKind, account: string | undefined): string | null;
+    canContinue(kind: AgentKind, from: string | undefined, to: string | undefined): boolean;
+    labelOf(account: string): string;
+    launched?(kind: AgentKind, account: string | undefined): void;
+}
+export declare function isDefaultAccountOf(kind: AgentKind, account: string | undefined): boolean;
+export declare function storedAccount(kind: AgentKind, account: string | undefined): string | undefined;
+export declare function launchEnv(accounts: AccountLaunches | null, kind: AgentKind, account: string | undefined, baseEnv: Env): Env;
+export declare function definedEnv(env: Env): Record<string, string>;

package/dist/providers/accounts/launch.js

@@ -0,0 +1,30 @@
+import { CodedError } from '../../coded-error.js';
+export class AccountError extends CodedError {
+}
+export function isDefaultAccountOf(kind, account) {
+    return account === undefined || account === kind;
+}
+/* The id a record or a node keeps: none for the default account, so nothing without accounts changes on disk. */
+export function storedAccount(kind, account) {
+    return isDefaultAccountOf(kind, account) ? undefined : account;
+}
+/* The environment of a launch; without accounts wired only the default account can start, with no variables of its own. */
+export function launchEnv(accounts, kind, account, baseEnv) {
+    if (accounts !== null) {
+        return accounts.envFor(kind, account, baseEnv);
+    }
+    if (isDefaultAccountOf(kind, account)) {
+        return baseEnv;
+    }
+    throw new AccountError('account-unavailable', `The account '${account}' is not available on this machine: it keeps no accounts.`);
+}
+/* An environment without its unset variables, which is what a spawned process is given. */
+export function definedEnv(env) {
+    const defined = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (value !== undefined) {
+            defined[key] = value;
+        }
+    }
+    return defined;
+}

package/dist/providers/accounts/service.d.ts

@@ -0,0 +1,87 @@
+import { type AgentKind, type ProviderAccount, type ProviderAccountCreatePayload, type ProviderAccountCreateResult, type ProviderAccountMap, type ProviderAccounts, type ProviderInfo } from '@adecore/agent-contracts';
+import type { AgentSink } from '../../events.ts';
+import type { ChatProvider } from '../provider.ts';
+import { type Env } from './accounts.ts';
+import { type AccountLaunches } from './launch.ts';
+import { type ShadowHomeReport } from './shadow-home.ts';
+import { type AskAccount } from './status.ts';
+import { type AccountsHost, type SecretStore } from './variables.ts';
+import { type CodexClientInfo } from '../../chat/codex-transport.ts';
+export interface ProviderAccountsOptions {
+    home: string;
+    host?: AccountsHost;
+    client?: CodexClientInfo;
+    providers: {
+        list(): Promise<ProviderInfo[]>;
+        get(kind: AgentKind): ChatProvider;
+        enabled?(kind: AgentKind): boolean;
+    };
+    env?: Env;
+    ask?: AskAccount;
+    prepareShadow?: (home: string, shadow: string) => Promise<ShadowHomeReport>;
+    folderExists?: (path: string) => boolean;
+    install?: (kind: AgentKind, folder: string) => Promise<void>;
+    secrets?: SecretStore | null;
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+}
+export declare class ProviderAccountsService implements AccountLaunches {
+    private readonly path;
+    private readonly home;
+    private readonly host;
+    private readonly providers;
+    private readonly env;
+    private readonly ask;
+    private readonly prepareShadow;
+    private readonly folderExists;
+    private readonly install;
+    private readonly secrets;
+    private readonly secretValues;
+    private readonly now;
+    private readonly sleep;
+    private readonly watches;
+    private writes;
+    private readonly sinks;
+    private readonly listeners;
+    private readonly launches;
+    private readonly states;
+    private stored;
+    private accounts;
+    private passes;
+    private timer;
+    constructor(options: ProviderAccountsOptions);
+    load(): Promise<void>;
+    subscribe(clientId: string, sink: AgentSink): () => void;
+    snapshot(): ProviderAccounts;
+    get(id: string): ProviderAccount | null;
+    envFor(kind: AgentKind, id: string | undefined, baseEnv: Env): Env;
+    transcriptFolder(kind: AgentKind, id: string | undefined): string | null;
+    homeFolder(kind: AgentKind, id: string | undefined): string | null;
+    canContinue(kind: AgentKind, from: string | undefined, to: string | undefined): boolean;
+    labelOf(id: string): string;
+    launched(kind: AgentKind, id: string | undefined): void;
+    lastLaunchAt(id: string): number | null;
+    listen(listener: () => void): () => void;
+    start(): void;
+    stop(): void;
+    save(accounts: ProviderAccountMap): Promise<ProviderAccounts>;
+    create(payload: ProviderAccountCreatePayload): Promise<ProviderAccountCreateResult>;
+    watchLogin(id: string): Promise<void>;
+    refresh(): Promise<ProviderAccounts>;
+    private runWatch;
+    private serial;
+    private commit;
+    private planSecrets;
+    private requireSecrets;
+    private readSecrets;
+    private variablesOf;
+    private accountsFolder;
+    private mintId;
+    private queue;
+    private statusOf;
+    private status;
+    private runAll;
+    private check;
+    private prepare;
+    private emit;
+}