@dinoxx/dinox-cli 2.10.0 → 2.11.0

package/README.md

@@ -103,7 +103,7 @@ winget install OpenJS.NodeJS.LTS
 dino update
 ```
 
-它会自动根据你当前的安装方式选择合适的包管理器执行更新。
+它会自动根据你当前的安装方式选择合适的包管理器执行更新。升级完成后会检查本机已安装的 Agent：有 `claude` 但没有 ACP 命令时安装 `@agentclientprotocol/claude-agent-acp`，有 `codex` 时安装 `@agentclientprotocol/codex-acp`，有 `zcode` 时安装 `zcode-acp`。已经装过的适配器会跳过；某个适配器安装失败只给出警告，不影响 CLI 升级本身。
 
 ---
 
@@ -947,7 +947,7 @@ dino gateway reload
 dino gateway remove Hermes
 ```
 
-`detect` 会在 `PATH` 上查找 ACP agent，并用真实握手确认能否启动。`--add` 把已确认的 agent 写入当前账号的 gateway 配置，并由 daemon 托管。`gateway list` 只显示环境变量名，不显示值。`dino gateway mcp` 由这些 agent 拉起，对外提供只读的 Dinox 知识工具。
+`detect` 会在 `PATH` 上查找 ACP agent，并用真实握手确认能否启动。覆盖范围与 [Paseo 的 ACP catalog](https://github.com/getpaseo/paseo/blob/main/packages/app/src/data/acp-provider-catalog.ts) 对齐，只认本机已经装好的命令，不会为了探测去 `npx -y` 下载。每个 agent 一握手完就打印，不用等最慢的那个。某个启动方式一直不应答时，不再换参数重试。`--add` 把已确认的 agent 写入当前账号的 gateway 配置，并由 daemon 托管。`gateway list` 只显示环境变量名，不显示值。`dino gateway mcp` 由这些 agent 拉起，对外提供只读的 Dinox 知识工具。
 
 ### 6.16 `info`：查看版本与技能仓库地址
 
@@ -961,6 +961,8 @@ dino info
 dino update
 ```
 
+升级 CLI 之后，会为本机已有、但还没有 ACP 命令的 Agent 安装适配器（Claude Code、Codex、ZCode）。`--format json` 的 `acpAdapters` 返回每一项的 `installed` 或 `failed`。
+
 ---
 
 ## 7. AI / 脚本自动化

package/dist/commands/gateway/index.js

@@ -116,8 +116,23 @@ async function runAdd(context) {
     printHumanReadableLine(`Added gateway "${gateway.name}" as device ${gateway.deviceId}.`);
     printStatuses(statuses);
 }
+function formatDetectedAgent(agent) {
+    const launch = [agent.command, ...agent.args].join(' ');
+    const label = agent.verified
+        ? `ready${agent.agentVersion ? ` (${agent.agentName ?? agent.name} ${agent.agentVersion})` : ''}`
+        : agent.installHint
+            ? `installed, needs its ACP adapter: ${agent.installHint}`
+            : `not responding: ${agent.error ?? 'unknown'}`;
+    return `${agent.name}: ${label} · ${launch}`;
+}
 async function runDetect(context) {
-    const detected = await detectAcpAgents({ probe: true });
+    const structured = Boolean(getRequestedStructuredOutputFormat());
+    if (!structured)
+        printHumanReadableLine('Checking installed ACP agents...');
+    const detected = await detectAcpAgents({
+        probe: true,
+        onDetected: structured ? undefined : (agent) => printHumanReadableLine(formatDetectedAgent(agent)),
+    });
     const added = [];
     const updated = [];
     if (context.options.add) {
@@ -146,15 +161,6 @@ async function runDetect(context) {
         printHumanReadableLine('No ACP agents found on PATH.');
         return;
     }
-    for (const agent of detected) {
-        const launch = [agent.command, ...agent.args].join(' ');
-        const label = agent.verified
-            ? `ready${agent.agentVersion ? ` (${agent.agentName ?? agent.name} ${agent.agentVersion})` : ''}`
-            : agent.installHint
-                ? `installed, needs its ACP adapter: ${agent.installHint}`
-                : `not responding: ${agent.error ?? 'unknown'}`;
-        printHumanReadableLine(`${agent.name}: ${label} · ${launch}`);
-    }
     for (const gateway of added)
         printHumanReadableLine(`Added gateway "${gateway.name}" (${gateway.deviceId}).`);
     for (const gateway of updated) {

package/dist/commands/update.d.ts

@@ -1,12 +1,23 @@
 import { Command } from 'commander';
 import type { CommandDescriptor } from './descriptor/types.js';
+import { type MissingAcpAdapter } from '../gateway/detect.js';
 type PackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun';
 type LogFn = (...parts: unknown[]) => void;
+export type AcpAdapterInstallResult = {
+    id: string;
+    name: string;
+    package: string;
+    status: 'installed' | 'failed';
+    error: string | null;
+};
 type UpdateCommandDeps = {
     detectPackageManager: () => PackageManager;
     runUpdate: (pm: PackageManager, options: {
         structuredOutput: boolean;
     }) => Promise<void>;
+    installAcpAdapters: (pm: PackageManager, options: {
+        structuredOutput: boolean;
+    }) => Promise<AcpAdapterInstallResult[]>;
     getVersion: () => string;
     getLatestVersion: () => Promise<string | null>;
     log: LogFn;
@@ -20,7 +31,12 @@ type UpdateSpawnSpec = {
     args: string[];
     shell: boolean;
 };
+export declare function resolvePackageManagerSpawn(pm: PackageManager, args: string[], platform?: NodeJS.Platform): UpdateSpawnSpec;
 export declare function resolveUpdateSpawnSpec(pm: PackageManager, platform?: NodeJS.Platform): UpdateSpawnSpec;
+/** Installs ACP adapters for local agent CLIs that do not already have one. */
+export declare function installMissingAcpAdapters(pm: PackageManager, options: {
+    structuredOutput: boolean;
+}, missing?: MissingAcpAdapter[]): Promise<AcpAdapterInstallResult[]>;
 export declare function createUpdateCommandDescriptor(overrides?: Partial<UpdateCommandDeps>): CommandDescriptor;
 export declare const updateCommandDescriptor: CommandDescriptor;
 export declare function registerUpdateCommand(program: Command, overrides?: Partial<UpdateCommandDeps>): void;

package/dist/commands/update.js

@@ -6,6 +6,7 @@ import { getSkillsReleaseMetadata } from '../constants/links.js';
 import { RETIRED_SKILLS, RETIRED_SKILLS_CLEANUP, formatRetiredSkillsSummary, } from '../skills/retired.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../utils/output.js';
 import { DinoxError } from '../utils/errors.js';
+import { findMissingAcpAdapters } from '../gateway/detect.js';
 import { fetchLatestPublishedVersion } from '../utils/updateNotice.js';
 import { getPackageVersion } from '../utils/version.js';
 const PACKAGE_NAME = '@dinoxx/dinox-cli';
@@ -51,21 +52,31 @@ const PM_COMMANDS = {
     yarn: { bin: 'yarn', args: ['global', 'add', `${PACKAGE_NAME}@latest`] },
     bun: { bin: 'bun', args: ['add', '--global', `${PACKAGE_NAME}@latest`] },
 };
-export function resolveUpdateSpawnSpec(pm, platform = process.platform) {
-    const { bin, args } = PM_COMMANDS[pm];
-    const usesWindowsCommandShim = platform === 'win32' && bin !== 'bun';
+export function resolvePackageManagerSpawn(pm, args, platform = process.platform) {
+    const usesWindowsCommandShim = platform === 'win32' && pm !== 'bun';
     if (usesWindowsCommandShim) {
         return {
-            command: [`${bin}.cmd`, ...args].join(' '),
+            command: [`${pm}.cmd`, ...args].join(' '),
             args: [],
             shell: true,
         };
     }
-    return {
-        command: bin,
-        args: [...args],
-        shell: false,
-    };
+    return { command: pm, args: [...args], shell: false };
+}
+export function resolveUpdateSpawnSpec(pm, platform = process.platform) {
+    return resolvePackageManagerSpawn(pm, PM_COMMANDS[pm].args, platform);
+}
+function globalInstallArgs(pm, packageName) {
+    switch (pm) {
+        case 'npm':
+            return ['install', '--global', packageName];
+        case 'pnpm':
+            return ['add', '--global', packageName];
+        case 'yarn':
+            return ['global', 'add', packageName];
+        case 'bun':
+            return ['add', '--global', packageName];
+    }
 }
 function appendBoundedOutput(current, chunk) {
     if (Buffer.byteLength(current, 'utf8') >= MAX_CAPTURED_UPDATE_OUTPUT_BYTES) {
@@ -74,8 +85,8 @@ function appendBoundedOutput(current, chunk) {
     const remaining = MAX_CAPTURED_UPDATE_OUTPUT_BYTES - Buffer.byteLength(current, 'utf8');
     return current + chunk.subarray(0, remaining).toString('utf8');
 }
-function runUpdate(pm, options) {
-    const { command, args, shell } = resolveUpdateSpawnSpec(pm);
+function runPackageManager(pm, packageArgs, options) {
+    const { command, args, shell } = resolvePackageManagerSpawn(pm, packageArgs);
     const invocation = [command, ...args].join(' ');
     return new Promise((resolve, reject) => {
         let stdout = '';
@@ -120,10 +131,38 @@ function runUpdate(pm, options) {
         });
     });
 }
+function runUpdate(pm, options) {
+    return runPackageManager(pm, PM_COMMANDS[pm].args, options);
+}
+function adapterErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Installs ACP adapters for local agent CLIs that do not already have one. */
+export async function installMissingAcpAdapters(pm, options, missing) {
+    const adapters = missing ?? await findMissingAcpAdapters();
+    const results = [];
+    for (const adapter of adapters) {
+        try {
+            await runPackageManager(pm, globalInstallArgs(pm, adapter.packageName), options);
+            results.push({ id: adapter.id, name: adapter.name, package: adapter.packageName, status: 'installed', error: null });
+        }
+        catch (error) {
+            results.push({
+                id: adapter.id,
+                name: adapter.name,
+                package: adapter.packageName,
+                status: 'failed',
+                error: adapterErrorMessage(error),
+            });
+        }
+    }
+    return results;
+}
 function resolveDeps(overrides) {
     return {
         detectPackageManager,
         runUpdate,
+        installAcpAdapters: (pm, options) => installMissingAcpAdapters(pm, options),
         getVersion: getPackageVersion,
         getLatestVersion: fetchLatestPublishedVersion,
         log: logHumanReadable,
@@ -185,6 +224,7 @@ export function createUpdateCommandDescriptor(overrides = {}) {
                     'skillsInstallCommand',
                     'retiredSkills',
                     'retiredSkillsCleanup',
+                    'acpAdapters',
                 ],
             },
             examples: ['dino update', 'dino update --package-manager pnpm --format json'],
@@ -199,6 +239,7 @@ export function createUpdateCommandDescriptor(overrides = {}) {
                 deps.log(`updating ${PACKAGE_NAME} via ${pm}...`);
             }
             await deps.runUpdate(pm, { structuredOutput });
+            const acpAdapters = await deps.installAcpAdapters(pm, { structuredOutput });
             const observedVersion = deps.getVersion();
             const version = observedVersion !== previousVersion
                 ? observedVersion
@@ -219,10 +260,19 @@ export function createUpdateCommandDescriptor(overrides = {}) {
                     skillsInstallCommand: skills.installCommand,
                     retiredSkills: RETIRED_SKILLS,
                     retiredSkillsCleanup: RETIRED_SKILLS_CLEANUP,
+                    acpAdapters,
                 });
                 return;
             }
             deps.log(`done: ${version}`);
+            for (const adapter of acpAdapters) {
+                if (adapter.status === 'installed') {
+                    deps.log(`installed ACP adapter ${adapter.package} for ${adapter.name}`);
+                }
+                else {
+                    deps.log(`warning: could not install ACP adapter ${adapter.package} for ${adapter.name} (${adapter.error})`);
+                }
+            }
             printSkillsReminder(deps.log, version);
         },
     };

package/dist/gateway/config.d.ts

@@ -32,16 +32,12 @@ export declare function addGateway(userId: string, input: {
     cwd?: string;
     env?: Record<string, string>;
 }): Promise<GatewayDefinition>;
-/**
- * Hosts a detected agent once. An agent already hosted, matched by type (or, for
- * gateways from before types were recorded, by executable name and arguments),
- * is updated in place when its executable moved, e.g. after a Node upgrade.
- */
 export declare function adoptDetectedAgent(userId: string, agent: {
     id: string;
     name: string;
     command: string;
     args: string[];
+    env?: Record<string, string>;
 }): Promise<{
     gateway: GatewayDefinition;
     change: 'added' | 'updated' | 'unchanged';

package/dist/gateway/config.js

@@ -214,6 +214,19 @@ function sameLaunch(a, b) {
  * gateways from before types were recorded, by executable name and arguments),
  * is updated in place when its executable moved, e.g. after a Node upgrade.
  */
+function mergeRequiredEnv(existing, required) {
+    if (!required)
+        return { env: existing, changed: false };
+    const env = { ...(existing ?? {}) };
+    let changed = false;
+    for (const [key, value] of Object.entries(required)) {
+        if (env[key] === undefined) {
+            env[key] = value;
+            changed = true;
+        }
+    }
+    return { env, changed };
+}
 export async function adoptDetectedAgent(userId, agent) {
     const gateways = await loadGateways(userId);
     const existing = gateways.find((gateway) => gateway.agentId === agent.id) ??
@@ -223,10 +236,17 @@ export async function adoptDetectedAgent(userId, agent) {
             path.basename(gateway.command) === path.basename(agent.command) &&
             JSON.stringify(gateway.args ?? []) === JSON.stringify(agent.args));
     if (existing) {
-        if (existing.agentId === agent.id && sameLaunch(existing, agent)) {
+        const requiredEnv = mergeRequiredEnv(existing.env, agent.env);
+        if (existing.agentId === agent.id && sameLaunch(existing, agent) && !requiredEnv.changed) {
             return { gateway: existing, change: 'unchanged' };
         }
-        const updated = { ...existing, agentId: agent.id, command: agent.command, args: agent.args };
+        const updated = {
+            ...existing,
+            agentId: agent.id,
+            command: agent.command,
+            args: agent.args,
+            ...(requiredEnv.env ? { env: requiredEnv.env } : {}),
+        };
         await saveGateways(userId, gateways.map((gateway) => (gateway.id === existing.id ? updated : gateway)));
         return { gateway: updated, change: 'updated' };
     }
@@ -240,6 +260,7 @@ export async function adoptDetectedAgent(userId, agent) {
         agentId: agent.id,
         command: agent.command,
         args: agent.args,
+        ...(agent.env ? { env: agent.env } : {}),
     });
     return { gateway, change: 'added' };
 }

package/dist/gateway/detect.d.ts

@@ -7,14 +7,22 @@ export declare const KNOWN_ACP_AGENTS: ReadonlyArray<{
     id: string;
     name: string;
     candidates: string[][];
-    /** The agent's own CLI and the ACP adapter to install when only the CLI is present. */
+    /** Passed to the agent process. Saved on the gateway when this launch is adopted. */
+    env?: Record<string, string>;
+    /** The agent's own CLI, and the global package that provides ACP when that CLI has none. */
     adapter?: {
         baseBinary: string;
-        install: string;
+        packageName: string;
     };
 }>;
 /** The known agent a manual launch command starts, by executable name and arguments. */
 export declare function inferAgentId(command: string | undefined, args?: string[]): string | undefined;
+/** A launch stayed up but never completed the ACP handshake. Further flags of that agent are not tried. */
+export declare class AcpProbeTimeoutError extends Error {
+    constructor();
+}
+/** A quick failure can be a wrong flag. A timeout means that agent is not going to answer. */
+export declare function shouldTryNextAcpCandidate(error: unknown): boolean;
 export type DetectedAgent = {
     id: string;
     name: string;
@@ -27,14 +35,29 @@ export type DetectedAgent = {
     error?: string;
     /** Set when the agent's CLI is installed but its ACP adapter is not. */
     installHint?: string;
+    /** Environment the handshake needed. Stored on the gateway when adopted. */
+    env?: Record<string, string>;
 };
 export declare function findExecutable(name: string, envPath?: string): Promise<string | null>;
 /** Starts the agent, runs `initialize`, and stops it. Never leaves the process running. */
-export declare function probeAcpAgent(command: string, args: string[], timeoutMs?: number): Promise<{
+export declare function probeAcpAgent(command: string, args: string[], timeoutMs?: number, env?: Record<string, string>): Promise<{
     agentName: string | null;
     agentVersion: string | null;
 }>;
 /** Finds installed ACP agents; with `probe`, keeps only launch variants that handshake. */
 export declare function detectAcpAgents(options?: {
     probe?: boolean;
+    timeoutMs?: number;
+    /** Called as soon as one agent finishes, so a slow handshake does not hide the ones already done. */
+    onDetected?: (agent: DetectedAgent) => void;
 }): Promise<DetectedAgent[]>;
+export type MissingAcpAdapter = {
+    id: string;
+    name: string;
+    packageName: string;
+};
+/**
+ * Agents whose own CLI is on PATH but none of the ACP launch commands are.
+ * Those need a global adapter package before a gateway can start them.
+ */
+export declare function findMissingAcpAdapters(envPath?: string): Promise<MissingAcpAdapter[]>;

package/dist/gateway/detect.js

@@ -17,13 +17,13 @@ export const KNOWN_ACP_AGENTS = [
         id: 'claude',
         name: 'Claude Code',
         candidates: [['claude-agent-acp'], ['claude-code-acp']],
-        adapter: { baseBinary: 'claude', install: 'npm install -g @agentclientprotocol/claude-agent-acp' },
+        adapter: { baseBinary: 'claude', packageName: '@agentclientprotocol/claude-agent-acp' },
     },
     {
         id: 'codex',
         name: 'Codex',
         candidates: [['codex-acp']],
-        adapter: { baseBinary: 'codex', install: 'npm install -g @agentclientprotocol/codex-acp' },
+        adapter: { baseBinary: 'codex', packageName: '@agentclientprotocol/codex-acp' },
     },
     { id: 'gemini', name: 'Gemini CLI', candidates: [['gemini', '--acp'], ['gemini', '--experimental-acp']] },
     { id: 'copilot', name: 'GitHub Copilot', candidates: [['copilot', '--acp']] },
@@ -31,8 +31,8 @@ export const KNOWN_ACP_AGENTS = [
     { id: 'opencode', name: 'OpenCode', candidates: [['opencode', 'acp']] },
     { id: 'pi', name: 'pi', candidates: [['pi-acp']] },
     { id: 'goose', name: 'Goose', candidates: [['goose', 'acp']] },
-    { id: 'qwen', name: 'Qwen Code', candidates: [['qwen', '--acp'], ['qwen', '--experimental-acp']] },
-    { id: 'kimi', name: 'Kimi CLI', candidates: [['kimi', 'acp'], ['kimi', '--acp']] },
+    { id: 'qwen', name: 'Qwen Code', candidates: [['qwen', '--acp'], ['qwen', '--acp', '--experimental-skills'], ['qwen', '--experimental-acp']] },
+    { id: 'kimi', name: 'Kimi Code CLI', candidates: [['kimi', 'acp'], ['kimi', '--acp']] },
     // DeepSeek Harness: ACP is a dsh profile; the model key comes from DEEPSEEK_API_KEY.
     { id: 'deepseek', name: 'DeepSeek Harness', candidates: [['dsh', '--profile', 'acp']] },
     { id: 'qoder', name: 'Qoder CLI', candidates: [['qodercli', '--acp'], ['qoderclicn', '--acp']] },
@@ -40,7 +40,56 @@ export const KNOWN_ACP_AGENTS = [
         id: 'zcode',
         name: 'ZCode',
         candidates: [['zcode-acp']],
-        adapter: { baseBinary: 'zcode', install: 'npm install -g zcode-acp' },
+        adapter: { baseBinary: 'zcode', packageName: 'zcode-acp' },
+    },
+    // Launch lines follow Paseo's ACP catalog (packages/app/src/data/acp-provider-catalog.ts).
+    // Local binaries only: detect must not run `npx -y`, which would download a package just to probe it.
+    { id: 'amp', name: 'Amp', candidates: [['amp-acp']] },
+    {
+        id: 'auggie',
+        name: 'Auggie CLI',
+        candidates: [['auggie', '--acp']],
+        env: { AUGMENT_DISABLE_AUTO_UPDATE: '1' },
+    },
+    { id: 'autohand', name: 'Autohand Code', candidates: [['autohand-acp']] },
+    { id: 'cline', name: 'Cline', candidates: [['cline', '--acp']] },
+    { id: 'codebuddy', name: 'Codebuddy Code', candidates: [['codebuddy', '--acp']] },
+    { id: 'codewhale', name: 'CodeWhale', candidates: [['codewhale', 'serve', '--acp']] },
+    { id: 'cortex', name: 'Cortex Code', candidates: [['cortex', 'acp', 'serve']] },
+    { id: 'corust', name: 'Corust Agent', candidates: [['corust-agent-acp']] },
+    { id: 'crow', name: 'crow-cli', candidates: [['crow-cli', 'acp']] },
+    { id: 'deepagents', name: 'DeepAgents', candidates: [['deepagents-acp']] },
+    { id: 'devin', name: 'Devin CLI', candidates: [['devin', 'acp']] },
+    { id: 'dimcode', name: 'DimCode', candidates: [['dimcode', 'acp'], ['dim', 'acp']] },
+    { id: 'dirac', name: 'Dirac', candidates: [['dirac', '--acp']] },
+    {
+        id: 'droid',
+        name: 'Factory Droid',
+        candidates: [['droid', 'exec', '--output-format', 'acp-daemon']],
+        env: { DROID_DISABLE_AUTO_UPDATE: 'true', FACTORY_DROID_AUTO_UPDATE_ENABLED: 'false' },
+    },
+    { id: 'fast-agent', name: 'fast-agent', candidates: [['fast-agent-acp', '-x']] },
+    { id: 'gjc', name: 'Gajae Code', candidates: [['gjc', 'acp']], env: { GJC_ACP_PERMISSION_MODE: 'prompt' } },
+    { id: 'glm', name: 'GLM Agent', candidates: [['glm-acp-agent']] },
+    { id: 'grok', name: 'Grok', candidates: [['grok', 'agent', 'stdio']] },
+    { id: 'hoplite', name: 'Hoplite', candidates: [['hoplite', 'acp']] },
+    { id: 'junie', name: 'Junie', candidates: [['junie', '--acp', 'true']] },
+    { id: 'kilo', name: 'Kilo Code', candidates: [['kilo', 'acp']] },
+    { id: 'kiro', name: 'Kiro CLI', candidates: [['kiro-cli', 'acp']] },
+    { id: 'minimax', name: 'MiniMax Code', candidates: [['mcode', 'acp']] },
+    { id: 'minion', name: 'Minion Code', candidates: [['minion-code', 'acp']] },
+    { id: 'vibe', name: 'Mistral Vibe', candidates: [['vibe-acp']] },
+    { id: 'nova', name: 'Nova', candidates: [['nova', 'acp']] },
+    { id: 'poolside', name: 'Poolside', candidates: [['pool', 'acp']] },
+    { id: 'agoragentic', name: 'Agoragentic', candidates: [['agoragentic-mcp', '--acp']] },
+    { id: 'sigit', name: 'siGit Code', candidates: [['sigit']] },
+    { id: 'stakpak', name: 'Stakpak', candidates: [['stakpak', 'acp']] },
+    { id: 'trae', name: 'TRAE CLI', candidates: [['traecli', 'acp', 'serve']] },
+    {
+        id: 'vtcode',
+        name: 'VT Code',
+        candidates: [['vtcode', 'acp']],
+        env: { VT_ACP_ENABLED: '1', VT_ACP_ZED_ENABLED: '1' },
     },
 ];
 /** The known agent a manual launch command starts, by executable name and arguments. */
@@ -52,6 +101,17 @@ export function inferAgentId(command, args = []) {
 }
 // Some agents cold-start slowly (OpenCode boots a local server: ~40s on first run).
 const PROBE_TIMEOUT_MS = 45_000;
+/** A launch stayed up but never completed the ACP handshake. Further flags of that agent are not tried. */
+export class AcpProbeTimeoutError extends Error {
+    constructor() {
+        super('no ACP handshake within timeout');
+        this.name = 'AcpProbeTimeoutError';
+    }
+}
+/** A quick failure can be a wrong flag. A timeout means that agent is not going to answer. */
+export function shouldTryNextAcpCandidate(error) {
+    return !(error instanceof AcpProbeTimeoutError);
+}
 export async function findExecutable(name, envPath = process.env.PATH ?? '') {
     const extensions = process.platform === 'win32' ? (process.env.PATHEXT ?? '.EXE;.CMD;.BAT').split(';') : [''];
     for (const dir of envPath.split(path.delimiter).filter(Boolean)) {
@@ -70,8 +130,12 @@ export async function findExecutable(name, envPath = process.env.PATH ?? '') {
     return null;
 }
 /** Starts the agent, runs `initialize`, and stops it. Never leaves the process running. */
-export async function probeAcpAgent(command, args, timeoutMs = PROBE_TIMEOUT_MS) {
-    const launch = agentLaunch(command, args, { stdio: ['pipe', 'pipe', 'ignore'], env: process.env, windowsHide: true });
+export async function probeAcpAgent(command, args, timeoutMs = PROBE_TIMEOUT_MS, env) {
+    const launch = agentLaunch(command, args, {
+        stdio: ['pipe', 'pipe', 'ignore'],
+        env: env ? { ...process.env, ...env } : process.env,
+        windowsHide: true,
+    });
     const child = spawn(launch.command, launch.args, launch.options);
     if (!child.stdin || !child.stdout)
         throw new Error('ACP probe stdio was not piped');
@@ -82,7 +146,7 @@ export async function probeAcpAgent(command, args, timeoutMs = PROBE_TIMEOUT_MS)
             child.once('exit', (code) => reject(new Error(`exited before handshake (code ${code})`)));
         });
         const timedOut = new Promise((_, reject) => {
-            timer = setTimeout(() => reject(new Error('no ACP handshake within timeout')), timeoutMs);
+            timer = setTimeout(() => reject(new AcpProbeTimeoutError()), timeoutMs);
         });
         const connection = new ClientSideConnection(() => ({
             sessionUpdate: async () => { },
@@ -118,17 +182,29 @@ export async function detectAcpAgents(options = {}) {
                 return { id: agent.id, name: agent.name, command, args, verified: false, agentName: null, agentVersion: null };
             }
             try {
-                const info = await probeAcpAgent(command, args);
-                return { id: agent.id, name: agent.name, command, args, verified: true, ...info };
+                const info = await probeAcpAgent(command, args, options.timeoutMs, agent.env);
+                const detected = {
+                    id: agent.id,
+                    name: agent.name,
+                    command,
+                    args,
+                    verified: true,
+                    ...info,
+                    ...(agent.env ? { env: agent.env } : {}),
+                };
+                options.onDetected?.(detected);
+                return detected;
             }
             catch (error) {
                 lastError = error instanceof Error ? error.message : String(error);
+                if (!shouldTryNextAcpCandidate(error))
+                    break;
             }
         }
         if (!lastError) {
             if (agent.adapter && (await findExecutable(agent.adapter.baseBinary))) {
                 const [binary, ...args] = agent.candidates[0];
-                return {
+                const detected = {
                     id: agent.id,
                     name: agent.name,
                     command: binary,
@@ -136,14 +212,51 @@ export async function detectAcpAgents(options = {}) {
                     verified: false,
                     agentName: null,
                     agentVersion: null,
-                    installHint: agent.adapter.install,
+                    installHint: `npm install -g ${agent.adapter.packageName}`,
                 };
+                options.onDetected?.(detected);
+                return detected;
             }
             return null;
         }
         const [binary, ...args] = agent.candidates[0];
         const command = (await findExecutable(binary)) ?? binary;
-        return { id: agent.id, name: agent.name, command, args, verified: false, agentName: null, agentVersion: null, error: lastError };
+        const detected = {
+            id: agent.id,
+            name: agent.name,
+            command,
+            args,
+            verified: false,
+            agentName: null,
+            agentVersion: null,
+            error: lastError,
+        };
+        options.onDetected?.(detected);
+        return detected;
     }));
     return results.filter((agent) => agent !== null);
 }
+/**
+ * Agents whose own CLI is on PATH but none of the ACP launch commands are.
+ * Those need a global adapter package before a gateway can start them.
+ */
+export async function findMissingAcpAdapters(envPath = process.env.PATH ?? '') {
+    const missing = [];
+    for (const agent of KNOWN_ACP_AGENTS) {
+        if (!agent.adapter)
+            continue;
+        if (!(await findExecutable(agent.adapter.baseBinary, envPath)))
+            continue;
+        let adapterPresent = false;
+        for (const [binary] of agent.candidates) {
+            if (await findExecutable(binary, envPath)) {
+                adapterPresent = true;
+                break;
+            }
+        }
+        if (!adapterPresent) {
+            missing.push({ id: agent.id, name: agent.name, packageName: agent.adapter.packageName });
+        }
+    }
+    return missing;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dinoxx/dinox-cli",
-  "version": "2.10.0",
+  "version": "2.11.0",
   "description": "Dinox CLI",
   "main": "dist/dinox.js",
   "scripts": {