@adecore/agents 0.39.0 → 0.40.1

package/src/providers/registry.ts

@@ -59,9 +59,7 @@ export interface ProviderRegistryOptions {
     providers?: ChatProvider[];
     // The executables to probe, when they are not the ones the providers name.
     commands?: Partial<Record<AgentKind, string>>;
-    // How to probe; a test answers without spawning anything.
     detect?: (command: string) => Promise<CliDetection>;
-    // The environment a probe runs in.
     env?: Record<string, string | undefined>;
 }
 
@@ -89,25 +87,31 @@ export class ProviderRegistry {
      */
     add(provider: ChatProvider): void {
         const index = this.providers.findIndex((entry) => entry.kind === provider.kind);
+
         if (index === -1) {
             this.providers.push(provider);
         } else {
             this.unfollow(this.providers[index]!);
             this.providers[index] = provider;
         }
+
         this.cache.delete(provider.kind);
+
         if (this.listeners.size > 0) {
             this.follow(provider);
         }
+
         this.changed(provider.kind);
     }
 
     /* Stops offering a kind; a record that names it gets the stand-in `get` answers for a kind the host does not offer. */
     remove(kind: AgentKind): void {
         const index = this.providers.findIndex((entry) => entry.kind === kind);
+
         if (index === -1) {
             return;
         }
+
         this.unfollow(this.providers[index]!);
         this.providers.splice(index, 1);
         this.cache.delete(kind);
@@ -146,11 +150,13 @@ export class ProviderRegistry {
      */
     async oneShotProvider(preferred?: AgentKind): Promise<ChatProvider | null> {
         const order = preferred ? [this.get(preferred), ...this.providers] : this.providers;
+
         for (const provider of order) {
             if (provider.oneShotArgs && (await this.detection(provider)).installed) {
                 return provider;
             }
         }
+
         return null;
     }
 
@@ -172,13 +178,17 @@ export class ProviderRegistry {
                 this.follow(provider);
             }
         }
+
         this.listeners.add(listener);
+
         return () => {
             this.listeners.delete(listener);
+
             if (this.listeners.size === 0) {
                 for (const stop of this.stops.values()) {
                     stop();
                 }
+
                 this.stops.clear();
             }
         };
@@ -216,17 +226,23 @@ export class ProviderRegistry {
         if (provider.enabled?.() === false) {
             return DISABLED;
         }
+
         const cached = this.cache.get(provider.kind);
+
         if (cached && Date.now() - cached.at < DETECTION_TTL_MS) {
             return cached.detection;
         }
+
         const command = this.commands[provider.kind] ?? provider.command[0]!;
         const detection = this.detect ? await this.detect(command) : await provider.detect(command, this.env);
+
         // Turned off while the probe ran.
         if (provider.enabled?.() === false) {
             return DISABLED;
         }
+
         this.cache.set(provider.kind, { at: Date.now(), detection });
+
         return detection;
     }
 }

package/src/providers/shell-commands.ts

@@ -5,8 +5,7 @@ const REFUSED = new Set(['|', '>', '<', '$', '`', '(', ')', '{', '}', '*', '?',
 /*
  * Whether a shell command line is only simple commands, joined by `&&`, `||`, `;` or newlines, each of
  * which starts with one of `allowed`. Anything the tokenizer cannot prove simple answers false, so a
- * true is safe to act on without a person: a pipe, a redirect, an expansion, a subshell, a background
- * `&`, an unquoted glob or an unbalanced quote all refuse the whole line.
+ * true is safe to act on without a person.
  */
 export function isOnlyCommands(command: string, allowed: readonly string[]): boolean {
     let word = '';
@@ -20,103 +19,139 @@ export function isOnlyCommands(command: string, allowed: readonly string[]): boo
         if (inWord) {
             words.push(word);
         }
+
         word = '';
         inWord = false;
     };
 
     const endCommand = (separator: string): boolean => {
         endWord();
+
         if (words.length === 0) {
             // Blank lines are fine, and so is a newline after `&&` or `||`; an empty command before any other separator is not.
             return separator === '\n';
         }
+
         if (!allowed.includes(words[0]!)) {
             return false;
         }
+
         commands++;
         words = [];
         dangling = separator === '&&' || separator === '||';
+
         return true;
     };
 
     for (let i = 0; i < command.length; i++) {
         const char = command[i]!;
         const next = command[i + 1];
+
         if (char === ' ' || char === '\t') {
             endWord();
+
             continue;
         }
+
         if (char === '\n' || char === ';') {
             if (!endCommand(char)) {
                 return false;
             }
+
             continue;
         }
+
         if ((char === '&' || char === '|') && next === char) {
             if (!endCommand(char + next)) {
                 return false;
             }
+
             i++;
+
             continue;
         }
+
         if (char === '&' || REFUSED.has(char)) {
             return false;
         }
+
         if (char === '\\') {
             if (next === undefined) {
                 return false;
             }
+
             i++;
+
             if (next !== '\n') {
                 word += next;
                 inWord = true;
             }
+
             continue;
         }
+
         if (char === "'") {
             const close = command.indexOf("'", i + 1);
+
             if (close === -1) {
                 return false;
             }
+
             word += command.slice(i + 1, close);
             inWord = true;
             i = close;
+
             continue;
         }
+
         if (char === '"') {
             inWord = true;
             let closed = false;
+
             for (i++; i < command.length; i++) {
                 const quoted = command[i]!;
+
                 if (quoted === '"') {
                     closed = true;
+
                     break;
                 }
+
                 if (quoted === '$' || quoted === '`') {
                     return false;
                 }
+
                 if (quoted === '\\') {
                     const escaped = command[i + 1];
+
                     if (escaped === undefined) {
                         return false;
                     }
+
                     i++;
+
                     if (escaped === '"' || escaped === '\\' || escaped === '$' || escaped === '`') {
                         word += escaped;
                     } else if (escaped !== '\n') {
                         word += quoted + escaped;
                     }
+
                     continue;
                 }
+
                 word += quoted;
             }
+
             if (!closed) {
                 return false;
             }
+
             continue;
         }
+
         word += char;
         inWord = true;
     }
+
     return endCommand('\n') && commands > 0 && !dangling;
 }

package/src/record-directory.ts

@@ -54,36 +54,48 @@ export class RecordDirectory<T> {
     /* Reads what an earlier run of the host wrote down. Call before anything can ask. */
     async load(): Promise<void> {
         let names: string[];
+
         try {
             names = await readdir(this.dir);
         } catch (e) {
             if (isNotFound(e)) {
                 return;
             }
+
             throw e;
         }
+
         for (const name of names) {
             if (!name.endsWith('.json')) {
                 continue;
             }
+
             const raw = await readFile(join(this.dir, name), 'utf8').catch(() => null);
+
             if (raw === null) {
                 continue;
             }
+
             let parsed: ReturnType<typeof this.schema.safeParse>;
+
             try {
                 parsed = this.schema.safeParse(JSON.parse(raw));
             } catch {
                 continue;
             }
+
             if (!parsed.success) {
                 continue;
             }
+
             const record = this.keep === null ? parsed.data : this.keep(parsed.data);
+
             if (record === null) {
                 await this.removeFile(join(this.dir, name));
+
                 continue;
             }
+
             this.records.set(this.idOf(record), record);
         }
     }
@@ -109,18 +121,23 @@ export class RecordDirectory<T> {
     write(record: T): Promise<boolean> {
         const id = this.idOf(record);
         this.records.set(id, record);
+
         return this.files.run(id, async () => {
             if (this.records.get(id) !== record) {
                 return false;
             }
+
             await mkdir(this.dir, { recursive: true, mode: 0o700 });
             await this.writeFile(this.pathOf(id), JSON.stringify(record));
+
             if (this.records.get(id) === record) {
                 return true;
             }
+
             if (!this.records.has(id)) {
                 await this.removeFile(this.pathOf(id));
             }
+
             return false;
         });
     }
@@ -128,6 +145,7 @@ export class RecordDirectory<T> {
     /* Forgets a record here and now; its file follows, after what is queued for it. */
     remove(id: string): Promise<void> {
         this.records.delete(id);
+
         return this.files.run(id, () => this.removeFile(this.pathOf(id)));
     }
 
@@ -136,6 +154,7 @@ export class RecordDirectory<T> {
             const id = this.idOf(listed);
             // Read again after each await: a record written meanwhile may no longer be one to drop.
             const current = this.records.get(id);
+
             if (current !== undefined && drop(current)) {
                 await this.remove(id);
             }

package/src/run-process.ts

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { killProcessTree } from './chat/chat-process.ts';
+import { KILL_GRACE_MS, killProcessTree } from './chat/chat-process.ts';
 import { spawnTarget } from './windows-command.ts';
 
 export interface ProcessResult {
@@ -19,8 +19,6 @@ export interface RunProcessOptions {
     timeoutMessage?: string;
 }
 
-// What a command and everything it started get between the SIGTERM and the SIGKILL.
-const KILL_GRACE_MS = 2000;
 // Stdout and stderr together; a short command that prints more is ended and fails instead of filling memory.
 const MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
 
@@ -28,11 +26,15 @@ const MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
 export function runProcess(command: readonly string[], options: RunProcessOptions = {}): Promise<ProcessResult> {
     return new Promise((resolve, reject) => {
         const [executable, ...args] = command;
+
         if (executable === undefined) {
             reject(new Error('No command to run'));
+
             return;
         }
+
         const target = spawnTarget(executable, args, options.env === undefined ? {} : { env: options.env });
+
         const child = spawn(target.file, target.args, {
             ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
             ...(options.env === undefined ? {} : { env: options.env }),
@@ -42,60 +44,79 @@ export function runProcess(command: readonly string[], options: RunProcessOption
             detached: process.platform !== 'win32',
             windowsHide: true
         });
+
         const stdout: Buffer[] = [];
         const stderr: Buffer[] = [];
         let printed = 0;
         let settled = false;
         let timer: ReturnType<typeof setTimeout> | null = null;
+
         const settle = (): boolean => {
             if (settled) {
                 return false;
             }
+
             settled = true;
+
             if (timer !== null) {
                 clearTimeout(timer);
             }
+
             return true;
         };
+
         const end = (message: string): void => {
             if (!settle()) {
                 return;
             }
+
             const pid = child.pid;
+
             if (pid !== undefined) {
                 killProcessTree(pid, 'SIGTERM');
                 // Sent even when the command left in time: what it started may still ignore the SIGTERM.
                 setTimeout(() => killProcessTree(pid, 'SIGKILL'), KILL_GRACE_MS).unref?.();
             }
+
             reject(new Error(message));
         };
+
         const collect = (into: Buffer[]) => (chunk: Buffer) => {
             if (settled) {
                 return;
             }
+
             printed += chunk.length;
+
             if (printed > MAX_OUTPUT_BYTES) {
                 end(`${executable} printed more than ${MAX_OUTPUT_BYTES / 1024 / 1024} MB`);
+
                 return;
             }
+
             into.push(chunk);
         };
+
         child.stdout?.on('data', collect(stdout));
         child.stderr?.on('data', collect(stderr));
+
         if (options.timeoutMs !== undefined) {
             const message = options.timeoutMessage ?? `${executable} did not finish in time`;
             timer = setTimeout(() => end(message), options.timeoutMs);
         }
+
         child.on('error', (error) => {
             if (settle()) {
                 reject(error);
             }
         });
+
         child.on('close', (exitCode) => {
             if (settle()) {
                 resolve({ exitCode, stdout: Buffer.concat(stdout).toString('utf8'), stderr: Buffer.concat(stderr).toString('utf8') });
             }
         });
+
         if (options.stdin !== undefined && child.stdin) {
             child.stdin.on('error', () => undefined);
             child.stdin.end(options.stdin);

package/src/serializer.ts

@@ -9,6 +9,7 @@ export class Serializer {
     run<T>(work: () => Promise<T>): Promise<T> {
         const next = this.chain.then(work, work);
         this.chain = next.catch(() => undefined);
+
         return next;
     }
 
@@ -30,12 +31,14 @@ export class KeyedSerializer {
         const next = previous.then(work, work);
         const settled = next.catch(() => undefined);
         this.chains.set(key, settled);
+
         // A key whose chain ran out leaves nothing behind, or the map grows with every id ever written.
         void settled.then(() => {
             if (this.chains.get(key) === settled) {
                 this.chains.delete(key);
             }
         });
+
         return next;
     }
 }