@agentshouse/kit 0.2.1-c30728be20485 → 0.2.1-c3cf4b145dcda

package/README.md

@@ -37,10 +37,11 @@ them out; running it again without the flag brings them back.
 Environment's credential in `~/.house-kit`, or in `$HOUSE_KIT_HOME` when it is
 set. Pass `--manual` to paste the code by hand on a machine without a browser,
 and `--environment <id>` to reconnect an Environment you already have. It also
-connects your own agent: `house <tool>` run outside an Agent conversation calls
-House as you, until you revoke that connection on Connections. `house help`
-lists the Tools. `kit logout` disconnects this computer and stops House Kit; a
-later `kit login` reconnects the same Environment.
+connects your own agent: outside an Agent conversation, `house <tool>` calls
+House as you and `git` clones and pushes your Apps at `<house>/app/` as you,
+until you revoke that connection on Connections. `house help` lists the Tools.
+`kit logout` disconnects this computer, stops House Kit and ends that Git
+access; a later `kit login` reconnects the same Environment.
 
 `kit resident` keeps the Environment connected, and keeps the Rooms you chose
 for this Environment as Git repositories under `local-copies` in the
@@ -49,11 +50,9 @@ commit to House; in the container, run it through the install command from the
 copy's directory. Inside an Agent conversation the Agent runs `house push`.
 
 House Kit turns each audio file of your message to an Agent into text on this
-computer before the Agent reads the message. The first audio file downloads the
-speech engine and model, about 425 MB, into `~/.house-kit`.
+computer before the Agent reads it. While transcription is on, the speech
+engine and model use about 425 MB in `~/.house-kit`; turning it off deletes them.
 
 ## License
 
-MIT
-
-The skills come from [mattpocock/skills](https://github.com/mattpocock/skills); thank you, Matt Pocock.
+MIT. The skills come from [mattpocock/skills](https://github.com/mattpocock/skills); thank you, Matt Pocock.

package/dist/acp.js

@@ -3,9 +3,7 @@ import { execFileSync, spawn } from 'node:child_process';
 import { readdirSync, readFileSync } from 'node:fs';
 import { Readable, Writable } from 'node:stream';
 import { CLIS, KIT_VERSION, adapterCommand, withoutProxy } from './clis.js';
-export const TURN_STARTED = 'kit/turn_started';
-export const TURN_ENDED = 'kit/turn_ended';
-export async function startAdapter(kind, cli, cwd, app, jobs = () => undefined, added = {}) {
+export async function startAdapter(kind, cli, cwd, app, events = () => undefined, added = {}, signal) {
     const adapter = CLIS[kind].adapter;
     const child = spawn(adapter === null ? cli : adapterCommand(kind), CLIS[kind].args, {
         cwd,
@@ -13,6 +11,9 @@ export async function startAdapter(kind, cli, cwd, app, jobs = () => undefined,
         stdio: ['pipe', 'pipe', 'pipe'],
         detached: true,
     });
+    const stop = () => killTree(child);
+    signal?.addEventListener('abort', stop, { once: true });
+    child.on('exit', () => signal?.removeEventListener('abort', stop));
     let stderr = '';
     child.stderr.on('data', (chunk) => {
         stderr = (stderr + chunk.toString('utf8')).slice(-4000);
@@ -29,16 +30,11 @@ export async function startAdapter(kind, cli, cwd, app, jobs = () => undefined,
         writable: stream.writable,
         readable: stream.readable.pipeThrough(new TransformStream({
             transform(message, controller) {
-                const notice = message;
-                const job = CLIS[kind].job(notice);
-                if (job !== null)
-                    jobs(job);
-                if (!notice.params?.update?.sessionUpdate?.startsWith('async_task_'))
+                const read = message;
+                events(read);
+                if (read.id !== undefined || (read.method !== 'session/update' && !read.method.startsWith('_'))) {
                     controller.enqueue(message);
-                if (CLIS[kind].turnStarted(notice))
-                    controller.enqueue({ jsonrpc: '2.0', method: TURN_STARTED });
-                if (CLIS[kind].turnEnded(notice))
-                    controller.enqueue({ jsonrpc: '2.0', method: TURN_ENDED });
+                }
             },
         })),
     });
@@ -50,7 +46,8 @@ export async function startAdapter(kind, cli, cwd, app, jobs = () => undefined,
                 fs: { readTextFile: false, writeTextFile: false },
                 terminal: false,
                 elicitation: { form: {} },
-                _meta: { jetbrains: { air: { version: 1, capabilities: ['asyncTasks'] } } },
+                session: { compaction: {}, notices: {} },
+                _meta: { jetbrains: { air: { version: 1, capabilities: CLIS[kind].air } } },
             },
             clientInfo: { name: '@agentshouse/kit', version: KIT_VERSION },
         });
@@ -127,6 +124,22 @@ function marked(marker) {
     })
         .map(Number);
 }
+function commandLine(pid) {
+    try {
+        return readFileSync(`/proc/${pid}/cmdline`, 'utf8').split('\0').join(' ').trim();
+    }
+    catch {
+        return '';
+    }
+}
+export function processes(marker) {
+    const pids = marked(marker);
+    const tree = [...pids, ...descendants(pids)];
+    const commands = process.platform === 'darwin'
+        ? new Map(listed('-Aww').map(([pid, , command]) => [pid, command]))
+        : new Map(tree.map((pid) => [pid, commandLine(pid)]));
+    return new Set(tree.flatMap((pid) => (commands.get(pid) ? [`${pid} ${commands.get(pid)}`] : [])));
+}
 export function killTree(child) {
     killAll([child.pid, ...descendants([child.pid])]);
 }

package/dist/agents.js

@@ -3,6 +3,7 @@ import { readFile, realpath } from 'node:fs/promises';
 import { killTree, startAdapter } from './acp.js';
 import { CLIS, KIT_VERSION, below, installAdapter, installCli, locate, run, versionOf } from './clis.js';
 import { agentBase, kitHome } from './home.js';
+import { holdTranscription, transcriptionReport } from './transcription.js';
 const SIGNED_OUT = { signed_in: false, models: [], modes: [] };
 function select(options, category) {
     const option = options.find((candidate) => candidate.category === category);
@@ -46,21 +47,29 @@ async function models(kind, adapter, known) {
     }
     return { models: offered, modes };
 }
-async function signedIn(kind, cli, known) {
+async function signedIn(kind, cli, known, signal) {
     const probe = CLIS[kind].signedIn;
     // A sign-in check that has not answered in half a minute counts as signed out rather than stalling the report.
     if ('command' in probe)
-        return (await run(cli, probe.command, 30_000)).status === 0;
-    return (await offer(kind, cli, known)).signed_in;
+        return (await run(cli, probe.command, 30_000, false, signal)).status === 0;
+    return (await offer(kind, cli, known, signal)).signed_in;
 }
-async function offer(kind, cli, known) {
+function ended(signal) {
+    return new Promise((_, reject) => {
+        if (signal.aborted)
+            reject(signal.reason);
+        signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+    });
+}
+async function offer(kind, cli, known, signal) {
     const probe = CLIS[kind].signedIn;
     // A sign-in check that has not answered in half a minute counts as signed out rather than stalling the report.
-    if ('command' in probe && (await run(cli, probe.command, 30_000)).status !== 0)
+    if ('command' in probe && (await run(cli, probe.command, 30_000, false, signal)).status !== 0)
         return SIGNED_OUT;
     let adapter;
     try {
-        adapter = await startAdapter(kind, cli, kitHome(), client({ name: '@agentshouse/kit' }));
+        adapter = await startAdapter(kind, cli, kitHome(), client({ name: '@agentshouse/kit' }), () => undefined, {}, signal);
+        signal?.throwIfAborted();
         if ('initializeMeta' in probe) {
             const method = adapter.initialized._meta?.[probe.initializeMeta];
             if (typeof method !== 'string' || method.length === 0)
@@ -69,7 +78,8 @@ async function offer(kind, cli, known) {
         return { signed_in: true, ...(await models(kind, adapter, known.models)) };
     }
     catch (error) {
-        process.stderr.write(`kit: ${kind} did not offer its models: ${causeOf(error)}\n`);
+        if (!signal?.aborted)
+            process.stderr.write(`kit: ${kind} did not offer its models: ${causeOf(error)}\n`);
         return {
             signed_in: adapter === undefined && 'initializeMeta' in probe ? known.signed_in : true,
             models: known.models,
@@ -110,7 +120,7 @@ async function operatingSystem() {
     return /^PRETTY_NAME="?([^"\n]*)"?$/m.exec(release)?.[1] ?? release;
 }
 export class Agents {
-    desired = { agents: [], routes: [] };
+    desired = { agents: [], routes: [], transcribe: false };
     house;
     reading = Promise.resolve();
     queues = new Map();
@@ -134,7 +144,10 @@ export class Agents {
             return this.desired;
         });
         this.reading = reading;
-        return reading.then(({ agents }) => {
+        return reading.then(({ agents, transcribe }) => {
+            holdTranscription(transcribe)
+                .then((changed) => (changed ? this.report() : undefined))
+                .catch(logged);
             Promise.all(agents.map((kind) => this.load(kind)))
                 .then(() => this.report())
                 .catch(logged);
@@ -164,17 +177,18 @@ export class Agents {
             return cli;
         });
     }
-    located(kind) {
-        return this.queue(kind, () => this.ensure(kind));
+    located(kind, signal) {
+        return this.queue(kind, () => this.ensure(kind, signal), signal);
     }
     async reread(kind) {
         await this.examine(kind, this.readings.get(kind) ?? SIGNED_OUT, offer);
         await this.report();
     }
-    async recheck(kind) {
+    async recheck(kind, signal) {
         const known = this.readings.get(kind) ?? SIGNED_OUT;
-        await this.examine(kind, known, async (kind, cli) => (await signedIn(kind, cli, known)) ? { ...known, signed_in: true } : SIGNED_OUT);
-        await this.report();
+        await this.examine(kind, known, async (kind, cli) => ((await signedIn(kind, cli, known, signal)) ? { ...known, signed_in: true } : SIGNED_OUT), signal);
+        if (!signal.aborted)
+            await this.report();
     }
     report() {
         const sending = this.sending.catch(() => undefined).then(() => this.send());
@@ -190,39 +204,42 @@ export class Agents {
         this.readings.set(kind, reading);
         this.report().catch(logged);
     }
-    queue(kind, work) {
-        const queued = (this.queues.get(kind) ?? Promise.resolve()).then(work);
+    queue(kind, work, signal) {
+        const queued = (this.queues.get(kind) ?? Promise.resolve()).then(() => {
+            signal?.throwIfAborted();
+            return work();
+        });
         this.queues.set(kind, queued.catch(() => undefined));
-        return queued;
+        return signal === undefined ? queued : Promise.race([queued, ended(signal)]);
     }
-    async ensure(kind) {
-        const failed = await installAdapter(kind);
+    async ensure(kind, signal) {
+        const failed = await installAdapter(kind, signal);
         if (failed !== null)
             throw new Error(failed);
-        const found = await locate(kind);
+        const found = await locate(kind, signal);
         if (found !== null)
             return found;
-        const installing = this.installing.catch(() => undefined).then(() => installCli(kind));
+        const installing = this.installing.catch(() => undefined).then(() => installCli(kind, signal));
         this.installing = installing;
         const failure = await installing;
         if (failure !== null)
             throw new Error(failure);
-        const installed = await locate(kind);
+        const installed = await locate(kind, signal);
         if (installed === null)
             throw new Error(`the login shell does not find ${CLIS[kind].bin} after its install`);
         return installed;
     }
-    async resolve(kind) {
+    async resolve(kind, signal) {
         let cli;
         try {
-            cli = await realpath(await this.ensure(kind));
+            cli = await realpath(await this.ensure(kind, signal));
         }
         catch (error) {
             const failure = causeOf(error);
             process.stderr.write(`kit: ${kind} did not install: ${failure}\n`);
             return { release: null, failure, ...SIGNED_OUT };
         }
-        const release = await versionOf(cli);
+        const release = await versionOf(cli, signal);
         if (release === null)
             return { release: null, failure: `${cli} --version names no version`, ...SIGNED_OUT };
         const minimum = CLIS[kind].minimum;
@@ -230,11 +247,11 @@ export class Agents {
             return { release, minimum, failure: null, ...SIGNED_OUT };
         return { cli, release };
     }
-    async examine(kind, known, read) {
+    async examine(kind, known, read, signal) {
         const current = this.nextRead(kind);
-        const resolved = await this.queue(kind, () => this.resolve(kind));
+        const resolved = await this.queue(kind, () => this.resolve(kind, signal), signal);
         const reading = 'cli' in resolved ? { release: resolved.release, failure: null, ...(await read(kind, resolved.cli, known)) } : resolved;
-        if (this.reads.get(kind) === current)
+        if (this.reads.get(kind) === current && !signal?.aborted)
             this.readings.set(kind, reading);
     }
     async load(kind) {
@@ -254,6 +271,7 @@ export class Agents {
             kit_version: KIT_VERSION,
             agent_base: agentBase(),
             agents,
+            transcription: transcriptionReport(),
             ...(hostKey === null ? {} : { ssh_host_key: hostKey }),
         };
         const state = JSON.stringify(body);

package/dist/app-git.js

@@ -0,0 +1,64 @@
+import { extname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { run } from './git.js';
+import { kitHome, readOwnAgent } from './home.js';
+import { quoted } from './shell.js';
+function section(house) {
+    return `credential.${new URL('/app/', house).href}`;
+}
+function helper() {
+    const main = fileURLToPath(new URL(`./kit-main${extname(fileURLToPath(import.meta.url))}`, import.meta.url));
+    return `!HOUSE_KIT_HOME=${quoted(resolve(kitHome()))} ${quoted(process.execPath)} ${quoted(main)} git-credential`;
+}
+async function configured(args) {
+    try {
+        return await run(kitHome(), ['config', '--global', ...args]);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+async function forget(house) {
+    await configured(['--remove-section', section(house)]);
+}
+async function register(house) {
+    await forget(house);
+    for (const value of ['', helper()]) {
+        const ran = await configured(['--add', `${section(house)}.helper`, value]);
+        if (ran === null)
+            return;
+        if (ran.status !== 0)
+            throw new Error(`git config failed: ${ran.stderr.trim()}`);
+    }
+}
+export async function placeAppGit(before, after) {
+    if (before !== null && before.house !== after?.house)
+        await forget(before.house);
+    if (after !== null)
+        await register(after.house);
+}
+export async function forgetAppGit() {
+    const ownAgent = await readOwnAgent();
+    if (ownAgent !== null)
+        await forget(ownAgent.house);
+}
+export async function answerGitCredential(operation) {
+    let asked = '';
+    for await (const chunk of process.stdin)
+        asked += String(chunk);
+    if (operation !== 'get')
+        return;
+    const attributes = new Map(asked
+        .split('\n')
+        .filter((line) => line.includes('='))
+        .map((line) => [line.slice(0, line.indexOf('=')), line.slice(line.indexOf('=') + 1)]));
+    const ownAgent = await readOwnAgent();
+    if (ownAgent === null)
+        return;
+    const house = new URL(ownAgent.house);
+    if (attributes.get('protocol') !== house.protocol.slice(0, -1) || attributes.get('host') !== house.host)
+        return;
+    process.stdout.write(`username=house\npassword=${ownAgent.credential}\n`);
+}

package/dist/bootstrap.json

@@ -1,23 +1,23 @@
 {
   "schemaVersion": 2,
-  "version": "0.2.1-c30728be20485",
+  "version": "0.2.1-c3cf4b145dcda",
   "hosts": {
     "macos": {
       "asset": {
         "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c30728be20485/connect-linux.sh"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c3cf4b145dcda/connect-linux.sh"
       }
     },
     "linux": {
       "asset": {
         "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c30728be20485/connect-linux.sh"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c3cf4b145dcda/connect-linux.sh"
       }
     },
     "windows": {
       "asset": {
         "name": "connect-windows.ps1",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c30728be20485/connect-windows.ps1"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c3cf4b145dcda/connect-windows.ps1"
       }
     }
   }

package/dist/clis.js

@@ -4,37 +4,12 @@ import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { homedir, userInfo } from 'node:os';
 import { join } from 'node:path';
 import { kitHome } from './home.js';
-const RUNNING_JOB = new Set(['running', 'paused']);
 async function allowHouseInCodex() {
     const rules = join(process.env.CODEX_HOME || join(homedir(), '.codex'), 'rules');
     await mkdir(rules, { recursive: true });
     await writeFile(join(rules, 'house.rules'), 'prefix_rule(pattern = ["house"], decision = "allow")\n');
 }
 async function nothing() { }
-function threadStatus({ method, params }) {
-    if (method !== 'session/update' || params?.update?.sessionUpdate !== 'session_info_update')
-        return undefined;
-    return params.update._meta?.codex?.threadStatus?.type;
-}
-function asyncTask({ method, params }) {
-    const update = params?.update;
-    if (method !== 'session/update' || update?.asyncTaskId === undefined)
-        return null;
-    if (update.sessionUpdate === 'async_task_spawned')
-        return { id: update.asyncTaskId, running: true };
-    if (update.sessionUpdate === 'async_task_state_update' && !RUNNING_JOB.has(update.state ?? '')) {
-        return { id: update.asyncTaskId, running: false };
-    }
-    return null;
-}
-function airPhase({ _meta }) {
-    const phase = _meta?.jetbrains?.air?.phase;
-    if (phase === 'commentary')
-        return 'note';
-    if (phase === 'final_answer')
-        return 'answer';
-    return null;
-}
 export const CLIS = {
     'codex-acp': {
         bin: 'codex',
@@ -47,11 +22,7 @@ export const CLIS = {
         allowHouse: allowHouseInCodex,
         signedIn: { command: ['login', 'status'] },
         login: { args: ['login', '--device-auth'], code: 'show' },
-        queues: false,
-        turnStarted: (notice) => threadStatus(notice) === 'active',
-        turnEnded: (notice) => threadStatus(notice) === 'idle',
-        job: asyncTask,
-        phase: airPhase,
+        air: ['asyncTasks', 'nativeSubagentSessions'],
     },
     'claude-agent-acp': {
         bin: 'claude',
@@ -65,17 +36,16 @@ export const CLIS = {
         },
         args: [],
         fullAccess: 'bypassPermissions',
-        sessionMeta: { claudeCode: { options: { allowedTools: ['Bash(house:*)'] } } },
+        sessionMeta: {
+            claudeCode: {
+                options: { allowedTools: ['Bash(house:*)'] },
+                emitRawSDKMessages: ['background_tasks_changed', 'session_state_changed', 'task_started', 'task_notification'].map((subtype) => ({ type: 'system', subtype })),
+            },
+        },
         allowHouse: nothing,
         signedIn: { command: ['auth', 'status'] },
         login: { args: ['auth', 'login', '--claudeai'], code: 'collect', rejected: 'Invalid code' },
-        queues: false,
-        turnStarted: () => false,
-        turnEnded: ({ method, params }) => method === 'session/update' &&
-            params?.update?.sessionUpdate === 'usage_update' &&
-            params.update._meta?.['_claude/origin'] !== undefined,
-        job: asyncTask,
-        phase: () => null,
+        air: ['asyncTasks', 'sessionFailure'],
     },
     'grok-build': {
         bin: 'grok',
@@ -88,17 +58,7 @@ export const CLIS = {
         allowHouse: nothing,
         signedIn: { initializeMeta: 'defaultAuthMethodId' },
         login: { args: ['login', '--device-auth'], code: 'show' },
-        queues: true,
-        turnStarted: ({ method, params }) => method === '_x.ai/queue/changed' && params?.runningPromptId !== undefined,
-        turnEnded: ({ method, params }) => method === '_x.ai/session_notification' && params?.update?.sessionUpdate === 'turn_completed',
-        job: ({ method, params }) => {
-            if (method === '_x.ai/task_backgrounded')
-                return { id: params.update.task_id, running: true };
-            if (method === '_x.ai/task_completed')
-                return { id: params.update.task_snapshot.task_id, running: false };
-            return null;
-        },
-        phase: () => null,
+        air: ['asyncTasks'],
     },
 };
 const KIT_PACKAGE = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
@@ -135,8 +95,22 @@ export function run(command, args, timeoutMs, detached = false, signal) {
             timeout: timeoutMs,
             env: withoutProxy(),
             detached,
-            signal,
+            signal: detached ? undefined : signal,
         });
+        const stop = () => {
+            try {
+                process.kill(-child.pid, 'SIGKILL');
+            }
+            catch { }
+        };
+        if (detached && signal?.aborted)
+            stop();
+        if (detached)
+            signal?.addEventListener('abort', stop, { once: true });
+        const ended = (ran) => {
+            signal?.removeEventListener('abort', stop);
+            resolve(ran);
+        };
         let stdout = '';
         let output = '';
         child.stdout.setEncoding('utf8').on('data', (chunk) => {
@@ -146,25 +120,25 @@ export function run(command, args, timeoutMs, detached = false, signal) {
         child.stderr.setEncoding('utf8').on('data', (chunk) => {
             output += chunk;
         });
-        child.on('error', (error) => resolve({ status: null, stdout, output: error.message }));
-        child.on('close', (status) => resolve({ status, stdout, output }));
+        child.on('error', (error) => ended({ status: null, stdout, output: error.message }));
+        child.on('close', (status) => ended({ status, stdout, output }));
     });
 }
 export function failureOf(ran, program) {
     return ran.output.trim().slice(-CAUSE_CHARACTERS) || `${program} exited with ${ran.status ?? 'a signal'}`;
 }
-export async function installAdapter(kind) {
+export async function installAdapter(kind, signal) {
     const adapter = CLIS[kind].adapter;
     if (adapter === null)
         return null;
     const release = KIT_PACKAGE.peerDependencies[adapter.package];
     if ((await installedAdapter(kind)) === release)
         return null;
-    const ran = await run('npm', ['install', '--prefix', prefix(kind), '--no-save', '--no-audit', '--no-fund', '--omit=optional', `${adapter.package}@${release}`], INSTALL_MS);
+    const ran = await run('npm', ['install', '--prefix', prefix(kind), '--no-save', '--no-audit', '--no-fund', '--omit=optional', `${adapter.package}@${release}`], INSTALL_MS, true, signal);
     return ran.status === 0 ? null : failureOf(ran, 'npm');
 }
-export async function installCli(kind) {
-    const ran = await run('bash', ['-o', 'pipefail', '-c', CLIS[kind].install], INSTALL_MS, true);
+export async function installCli(kind, signal) {
+    const ran = await run('bash', ['-o', 'pipefail', '-c', CLIS[kind].install], INSTALL_MS, true, signal);
     return ran.status === 0 ? null : failureOf(ran, 'the install');
 }
 function loginShell() {
@@ -173,11 +147,11 @@ function loginShell() {
 const FOUND = 'house-kit-cli ';
 const LOOKUP = `found=$(command -v "$1") || exit 0; case $found in /*) ;; *) found=$(pwd -P)/$found ;; esac; printf "${FOUND}%s\\n" "$found"`;
 const USER_BIN = 'case ":$PATH:" in *":$HOME/.local/bin:"*) ;; *) PATH="$PATH:$HOME/.local/bin" ;; esac; export PATH';
-function inLoginShell(script, argument = '') {
-    return run(loginShell(), ['-l', '-i', '-c', `exec /bin/sh -c '${USER_BIN}; ${script}' sh ${argument}`], READ_MS, true);
+function inLoginShell(script, argument = '', signal) {
+    return run(loginShell(), ['-l', '-i', '-c', `exec /bin/sh -c '${USER_BIN}; ${script}' sh ${argument}`], READ_MS, true, signal);
 }
-export async function locate(kind) {
-    const ran = await inLoginShell(LOOKUP, CLIS[kind].bin);
+export async function locate(kind, signal) {
+    const ran = await inLoginShell(LOOKUP, CLIS[kind].bin, signal);
     return ran.stdout.split('\n').findLast((line) => line.startsWith(FOUND))?.slice(FOUND.length) ?? null;
 }
 export async function loginPath() {
@@ -185,8 +159,8 @@ export async function loginPath() {
     const ran = await inLoginShell(`printf "${marker}%s\\n" "$PATH"`);
     return ran.stdout.split('\n').findLast((line) => line.startsWith(marker)).slice(marker.length);
 }
-export async function versionOf(path) {
-    return VERSION.exec((await run(path, ['--version'], READ_MS)).stdout)?.[0] ?? null;
+export async function versionOf(path, signal) {
+    return VERSION.exec((await run(path, ['--version'], READ_MS, false, signal)).stdout)?.[0] ?? null;
 }
 function numbers(version) {
     return version.split(/[.-]/, 3).map(Number);