@adecore/agents 0.38.0 → 0.40.0

package/src/providers/accounts/accounts.ts

@@ -26,12 +26,15 @@ export function isDefaultAccount(id: string, account: Pick<ProviderAccount, 'kin
 
 export function expandHome(path: string, env: Env): string {
     const home = homeFolder(env);
+
     if (path === '~') {
         return home;
     }
+
     if (path.startsWith('~/') || (process.platform === 'win32' && path.startsWith('~\\'))) {
         return join(home, path.slice(2));
     }
+
     return resolve(path);
 }
 
@@ -55,34 +58,45 @@ export function accountProblem(
     if (isOfferedKind(id, kinds) && 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;
 }
 
@@ -90,6 +104,7 @@ export function accountProblem(
 export function folderVariablesOf(providers: AccountProviders): string[] {
     return providers.kinds.flatMap((kind) => {
         const home = providers.get(kind).home;
+
         return home === undefined ? [] : [home.env];
     });
 }
@@ -97,12 +112,15 @@ export function folderVariablesOf(providers: AccountProviders): string[] {
 /* The map with a default account for every CLI the host offers, those first and in catalog order. */
 export function withDefaults(accounts: ProviderAccountMap, kinds: readonly AgentKind[]): ProviderAccountMap {
     const complete: ProviderAccountMap = {};
+
     for (const kind of kinds) {
         complete[kind] = accounts[kind] ?? { kind };
     }
+
     for (const [id, account] of Object.entries(accounts)) {
         complete[id] ??= account;
     }
+
     return complete;
 }
 
@@ -111,6 +129,7 @@ export function defaultFolder(provider: ChatProvider, env: Env): string {
     if (provider.home === undefined) {
         return '';
     }
+
     return env[provider.home.env] ?? join(homeFolder(env), provider.home.fallback);
 }
 
@@ -119,6 +138,7 @@ export function accountFolder(id: string, account: ProviderAccount, provider: Ch
     if (isDefaultAccount(id, account) || provider.home === undefined || account.home === undefined) {
         return defaultFolder(provider, env);
     }
+
     return expandHome(account.shadowHome ?? account.home, env);
 }
 
@@ -127,6 +147,7 @@ export function transcriptFolder(id: string, account: ProviderAccount, provider:
     if (isDefaultAccount(id, account) || provider.home === undefined || account.home === undefined) {
         return defaultFolder(provider, env);
     }
+
     return expandHome(account.home, env);
 }
 
@@ -139,14 +160,19 @@ export function transcriptFolder(id: string, account: ProviderAccount, provider:
  */
 export function accountEnv(id: string, account: ProviderAccount, provider: ChatProvider, baseEnv: Env, variables: Record<string, string> = {}): Env {
     const withVariables = (env: Env): 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);
 }
 
@@ -163,11 +189,15 @@ export function canContinue(from: NamedAccount, to: NamedAccount, providers: Acc
     if (from.id === to.id) {
         return true;
     }
+
     const kind = from.account.kind;
+
     if (kind !== to.account.kind || !isOfferedKind(kind, providers.kinds)) {
         return false;
     }
+
     const provider = providers.get(kind);
+
     return transcriptFolder(from.id, from.account, provider, env) === transcriptFolder(to.id, to.account, provider, env);
 }
 
@@ -179,17 +209,23 @@ export function readAccount(id: string, raw: unknown, providers: AccountProvider
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
         return null;
     }
+
     const kind = (raw as { kind?: unknown }).kind;
+
     if (typeof kind !== 'string' || kind === '') {
         return null;
     }
+
     if (!isOfferedKind(kind, providers.kinds)) {
         return isOfferedKind(id, providers.kinds) ? null : raw;
     }
+
     const parsed = ProviderAccountSchema.safeParse(raw);
     const reserved = { host, folderVariables: folderVariablesOf(providers) };
+
     if (!parsed.success || accountProblem(id, parsed.data, providers.get(kind), env, reserved, providers.kinds) !== null) {
         return null;
     }
+
     return parsed.data;
 }

package/src/providers/accounts/acp-account.ts

@@ -1,6 +1,7 @@
 import { mkdtemp, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { withDeadline } from '../../async.ts';
 import { DEFAULT_ACP_CLIENT, type AcpClientInfo } from '../../chat/acp-backend.ts';
 import {
     ACP_AUTH_REQUIRED,
@@ -13,9 +14,10 @@ import {
 } from '../../chat/acp-protocol.ts';
 import type { SpawnChatProcess } from '../../chat/chat-process.ts';
 import { JsonRpcError, JsonRpcTransport, type JsonRpcFrame } from '../../chat/json-rpc-transport.ts';
+import { definedEnv } from './launch.ts';
 import { ASK_TIMEOUT_MS, type AccountReading } from './status.ts';
 
-/* The clock the probe's deadline runs on; a test hands in one it moves itself. */
+/* The clock the probe's deadline runs on. */
 export interface ProbeTimer {
     setTimeout(run: () => void, ms: number): unknown;
     clearTimeout(handle: unknown): void;
@@ -39,31 +41,6 @@ export interface AcpAccountProbe {
 const SIGNED_OUT: AccountReading = { signedIn: false, email: null, plan: null, organization: null };
 const SIGNED_IN: AccountReading = { signedIn: true, email: null, plan: null, organization: null };
 
-const REAL_TIMER: ProbeTimer = {
-    setTimeout: (run, ms) => setTimeout(run, ms),
-    clearTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>)
-};
-
-function definedEnv(env: Record<string, string | undefined>): Record<string, string> {
-    return Object.fromEntries(Object.entries(env).filter((entry): entry is [string, string] => entry[1] !== undefined));
-}
-
-function withDeadline<T>(work: Promise<T>, ms: number, timer: ProbeTimer, message: string): Promise<T> {
-    return new Promise((resolve, reject) => {
-        const handle = timer.setTimeout(() => reject(new Error(message)), ms);
-        work.then(
-            (value) => {
-                timer.clearTimeout(handle);
-                resolve(value);
-            },
-            (e: unknown) => {
-                timer.clearTimeout(handle);
-                reject(e instanceof Error ? e : new Error(String(e)));
-            }
-        );
-    });
-}
-
 /*
  * Asks an ACP agent whether the account's environment is signed in: a session it opens means yes, "authentication
  * required" means no. ACP has no request that says who, so a reading carries no email or plan. The session is opened
@@ -76,17 +53,21 @@ export async function askAcpAccount(probe: AcpAccountProbe): Promise<AccountRead
     // An agent may list its commands before it answers with the session's id.
     const listed = new Map<string, string[]>();
     let sessionId: string | null = null;
+
     const noteCommands = (frame: JsonRpcFrame): void => {
         const update = frame.method === 'session/update' && (frame.id === undefined || frame.id === null) ? sessionUpdateOf(frame.params) : null;
+
         if (update === null || update.commands === null) {
             return;
         }
+
         if (sessionId === null) {
             listed.set(update.sessionId, update.commands);
         } else if (update.sessionId === sessionId) {
             probe.onCommands?.(update.commands);
         }
     };
+
     try {
         const started = new JsonRpcTransport({
             command: [...probe.command],
@@ -104,7 +85,9 @@ export async function askAcpAccount(probe: AcpAccountProbe): Promise<AccountRead
             },
             onExit: () => undefined
         });
+
         transport = started;
+
         const reading = async (): Promise<AccountReading> => {
             const capabilities = parseInitialize(
                 await started.request('initialize', {
@@ -113,34 +96,45 @@ export async function askAcpAccount(probe: AcpAccountProbe): Promise<AccountRead
                     clientInfo: { name: client.name, title: client.title ?? client.name, version: client.version }
                 })
             );
+
             if (capabilities.protocolVersion !== ACP_PROTOCOL_VERSION) {
                 throw new Error(`${probe.name} speaks ACP version ${capabilities.protocolVersion}; only version ${ACP_PROTOCOL_VERSION} is supported`);
             }
+
             let result: unknown;
+
             try {
                 result = await started.request('session/new', { cwd: folder, mcpServers: [] });
             } catch (error) {
                 if (error instanceof JsonRpcError && error.code === ACP_AUTH_REQUIRED) {
                     return SIGNED_OUT;
                 }
+
                 throw error;
             }
+
             sessionId = sessionIdOf(result);
+
             if (sessionId === null) {
                 throw new Error(`${probe.name} opened a session without an id`);
             }
+
             probe.onSession?.(parseSessionInfo(result, sessionId, capabilities.agent));
             const commands = listed.get(sessionId);
+
             if (commands !== undefined) {
                 probe.onCommands?.(commands);
             }
+
             if (capabilities.closeSession) {
                 // The answer is known by now; an agent that cannot close it keeps an empty session, nothing worse.
                 await started.request('session/close', { sessionId }).catch(() => undefined);
             }
+
             return SIGNED_IN;
         };
-        return await withDeadline(reading(), probe.timeoutMs ?? ASK_TIMEOUT_MS, probe.timer ?? REAL_TIMER, `${probe.name} did not answer in time`);
+
+        return await withDeadline(reading(), probe.timeoutMs ?? ASK_TIMEOUT_MS, `${probe.name} did not answer in time`, probe.timer);
     } finally {
         await transport?.dispose();
         await rm(folder, { recursive: true, force: true });
@@ -152,6 +146,7 @@ function refuseRequest(transport: JsonRpcTransport, frame: JsonRpcFrame): void {
     if (frame.id === undefined || frame.id === null || !transport.alive) {
         return;
     }
+
     try {
         transport.respondError(frame.id as number | string, -32601, `Method not found: ${String(frame.method)}`);
     } catch {

package/src/providers/accounts/launch.ts

@@ -37,19 +37,23 @@ export function launchEnv(accounts: AccountLaunches | null, kind: AgentKind, acc
     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: Env): Record<string, string> {
     const defined: Record<string, string> = {};
+
     for (const [key, value] of Object.entries(env)) {
         if (value !== undefined) {
             defined[key] = value;
         }
     }
+
     return defined;
 }