@kuznai/inception-engine 0.6.2 → 0.8.0

package/README.md

@@ -2,7 +2,7 @@
 
 Plant skills directly into the minds of your installed AI coding agents — Claude Code, Codex, Gemini CLI, Antigravity, OpenCode, and GitHub Copilot. One command. They'll think they thought of it themselves.
 
-Today, inception-engine is a skills deployer. It does not yet manage persistent instruction files, MCP configuration, subagents, or agent-specific config patching.
+Today, inception-engine deploys skills, single files, and JSON config patches to AI coding agents. MCP configuration and agent rules remain unimplemented at the manifest level.
 
 ## Quick Start
 
@@ -40,9 +40,11 @@ Managed skills overwrite their previous version. If a target exists but was not
 
 | Feature | Status |
 |---|---|
-| Skills (SKILL.md) | Supported |
-| MCP Servers | Accepted in manifest, not implemented |
-| Agent Rules | Accepted in manifest, not implemented |
+| Skills (SKILL.md) | Supported via manifest and CLI |
+| File write | Supported via manifest and CLI |
+| Config patch (JSON merge) | Supported via manifest and CLI |
+| MCP Servers | Accepted in manifest for forward compatibility, not implemented |
+| Agent Rules | Accepted in manifest for forward compatibility, not implemented |
 
 ## Manifest Format
 
@@ -57,17 +59,49 @@ Create an `inception.json` file at the root of your skills directory:
       "agents": ["claude-code", "codex", "gemini-cli", "antigravity", "opencode", "github-copilot"]
     }
   ],
+  "files": [
+    {
+      "name": "my-settings",
+      "path": "files/settings.json",
+      "target": "{home}/.claude/settings.json",
+      "agents": ["claude-code"]
+    }
+  ],
+  "configs": [
+    {
+      "name": "enable-feature",
+      "target": "{home}/.claude/settings.json",
+      "patch": { "someFeature": true },
+      "agents": ["claude-code"]
+    }
+  ],
   "mcpServers": [],
   "agentRules": []
 }
 ```
 
-Each skill entry has:
+Each **skill** entry has:
 
-- **name** - Unique skill identifier using letters, digits, dots, underscores, or hyphens; it must not start with a dot
+- **name** - Unique identifier using letters, digits, dots, underscores, or hyphens; must not start with a dot
 - **path** - Relative path to the skill directory within the repo
 - **agents** - Array of agent IDs to deploy this skill to. If an agent isn't installed, it's skipped.
 
+Each **file** entry deploys a single file to an agent's configuration location:
+
+- **name** - Unique identifier (same format as skill names)
+- **path** - Relative path to the source file within the repo
+- **target** - Destination path using a placeholder prefix: `{home}`, `{appdata}` (Windows), or `{xdg_config}` (Linux). For example: `{home}/.claude/settings.json`
+- **agents** - Array of agent IDs to deploy this file to
+
+Each **config** entry applies a [JSON merge patch (RFC 7386)](https://datatracker.ietf.org/doc/html/rfc7386) to an existing agent config file:
+
+- **name** - Unique identifier (same format as skill names)
+- **target** - Config file to patch, using the same placeholder prefix as file entries
+- **patch** - JSON object of keys to set. A `null` value removes the key from the target file. Non-null values are set directly (deep merge is not applied).
+- **agents** - Array of agent IDs to apply this patch to
+
+The engine records an undo-patch for each config-patch deployment so that `revert` can restore the original values.
+
 `mcpServers` and `agentRules` are currently parsed for forward compatibility, but the deployment engine ignores them today.
 
 ## Creating Skills
@@ -165,7 +199,7 @@ inception-engine maintains a centralized deployment registry at `~/.inception-en
 
 - **Registry-based ownership**: On revert, the registry is checked before removing any target. Only targets with a valid registry entry are removed. On redeploy, unmanaged targets are never replaced.
 
-- **Strong binding**: Each registry entry binds a specific target path to its source, skill, agent, and deploy method. A target is only considered managed if all fields match — a stray entry or a different deployment cannot satisfy the check.
+- **Strong binding**: Each registry entry binds a specific target path to its skill, agent, and action kind, with action-specific provenance fields (`source` and `method` for skill-dir and file-write; `patch` and `undoPatch` for config-patch). A target is only considered managed if all relevant fields match — a stray entry or a different deployment cannot satisfy the check.
 
 - **Atomic redeploy**: When overwriting an existing managed target, the engine renames the old target to a backup, creates the new deployment, and only removes the backup on success. If the new deployment fails, the backup is restored.
 
@@ -201,7 +235,10 @@ Windows deployment currently uses directory-level copy (one `cp -r` per skill).
 
 ## Requirements
 
-- Node.js >= 23.6.0
+- Published CLI runtime: Node.js >= 22.3.0
+- Direct TypeScript execution in this repo (`npm run dev`, `npm test`): Node.js >= 22.18.0
+
+`inception-engine` publishes compiled JavaScript from `dist/`, so end users do not need the newer Node version required for this repository's direct `.ts` workflows. The higher contributor floor exists only because this repo intentionally runs TypeScript straight through `node` for local development and tests, with no `tsx`, `ts-node`, or experimental TypeScript flags.
 
 ## License
 

package/dist/config/agents.js

@@ -106,6 +106,7 @@ export const AGENT_REGISTRY = [
             detectPaths: "documented",
             detectBinary: "documented",
         },
+        policyNote: "Organization policies may override locally deployed skills. Verify with your GitHub org admin if deployed skills are not active.",
     },
 ];
 export const AGENT_REGISTRY_BY_ID = Object.fromEntries(AGENT_REGISTRY.map((a) => [a.id, a]));

package/dist/config/manifest.js

@@ -1,8 +1,8 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
+import { UserError } from "../errors.js";
 import { formatZodPath } from "../schemas/errors.js";
 import { ManifestSchema } from "../schemas/manifest.js";
-import { UserError } from "../errors.js";
 export async function loadManifest(directory) {
     const manifestPath = path.join(directory, "inception.json");
     let raw;
@@ -38,9 +38,12 @@ function validateManifest(data, filePath) {
         if (issuePath.length === 1 && issuePath[0] === "skills") {
             throw new UserError("MANIFEST_INVALID", `${filePath}: "skills" must be an array`);
         }
-        // Top-level "mcpServers" or "agentRules": wrong type → uniform message
+        // Top-level array fields with wrong type → uniform message
         if (issuePath.length === 1 &&
-            (issuePath[0] === "mcpServers" || issuePath[0] === "agentRules")) {
+            (issuePath[0] === "mcpServers" ||
+                issuePath[0] === "agentRules" ||
+                issuePath[0] === "files" ||
+                issuePath[0] === "configs")) {
             throw new UserError("MANIFEST_INVALID", `${filePath}: "${issuePath[0]}" must be an array`);
         }
         throw new UserError("MANIFEST_INVALID", `${filePath}: ${formatZodPath(issuePath)}${issue.message}`);

package/dist/core/deploy.d.ts

@@ -1,9 +1,13 @@
-import type { AgentId, DeployAction, Manifest } from "../types.ts";
-export declare function planDeploy(manifest: Manifest, sourceDir: string, detectedAgents: AgentId[], home: string): Promise<DeployAction[]>;
+import type { AgentId, DeployAction, Manifest, PlannedChange, PlanWarning } from "../types.ts";
+export declare function planDeploy(manifest: Manifest, sourceDir: string, detectedAgents: AgentId[], home: string): Promise<{
+    actions: DeployAction[];
+    warnings: PlanWarning[];
+}>;
 export declare function executeDeploy(actions: DeployAction[], dryRun: boolean, verbose: boolean, home: string): Promise<{
     succeeded: number;
     failed: Array<{
         action: DeployAction;
         error: string;
     }>;
+    planned: PlannedChange[];
 }>;

package/dist/core/deploy.js

@@ -1,10 +1,56 @@
-import { access, cp, lstat, mkdir, realpath, rename, rm, symlink, unlink, } from "node:fs/promises";
+import { constants } from "node:fs";
+import { access, copyFile, cp, lstat, mkdir, readFile, realpath, rename, rm, symlink, unlink, writeFile, } from "node:fs/promises";
 import path from "node:path";
 import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { UserError } from "../errors.js";
 import { logger } from "../logger.js";
-import { registerDeployment, verifyDeployment } from "./ownership.js";
+import { lookupDeployment, registerDeployment, verifyDeployment, } from "./ownership.js";
 import { getDeployMethod, resolveAgentSkillPath } from "./resolve.js";
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+async function readJsonConfig(filePath) {
+    let rawContent;
+    try {
+        rawContent = await readFile(filePath, "utf-8");
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            throw new Error(`Config file not found: ${filePath}`);
+        throw err;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(rawContent);
+    }
+    catch {
+        throw new Error(`Config file is not valid JSON: ${filePath}`);
+    }
+    if (!isPlainObject(parsed)) {
+        throw new Error(`Config file is not a JSON object: ${filePath}`);
+    }
+    return parsed;
+}
+function computeUndoPatch(original, patch) {
+    const undoPatch = {};
+    for (const key of Object.keys(patch)) {
+        undoPatch[key] = key in original ? original[key] : null;
+    }
+    return undoPatch;
+}
+function applyMergePatch(original, patch) {
+    const patched = { ...original };
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === null) {
+            delete patched[key];
+        }
+        else {
+            patched[key] = value;
+        }
+    }
+    return patched;
+}
 function sourceAccessError(err, sourcePath) {
     const code = err.code;
     if (code === "ENOENT")
@@ -14,17 +60,58 @@ function sourceAccessError(err, sourcePath) {
     const detail = err instanceof Error ? err.message : String(err);
     return `Failed to access source ${sourcePath}: ${detail}`;
 }
-export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
-    const method = getDeployMethod();
-    const actions = [];
-    const resolvedSourceDir = path.resolve(sourceDir);
-    let realRoot;
+function resolveTargetTemplate(template, home) {
+    const appdata = process.env.APPDATA ?? path.join(home, "AppData", "Roaming");
+    const xdgRaw = process.env.XDG_CONFIG_HOME;
+    const xdgConfig = xdgRaw && path.isAbsolute(xdgRaw) ? xdgRaw : path.join(home, ".config");
+    return template
+        .replace("{home}", home)
+        .replace("{appdata}", appdata)
+        .replace("{xdg_config}", xdgConfig);
+}
+async function validateSourceFile(sourcePath, manifestPath) {
+    let stat;
     try {
-        realRoot = await realpath(resolvedSourceDir);
+        stat = await lstat(sourcePath);
     }
-    catch {
-        realRoot = resolvedSourceDir;
+    catch (err) {
+        throw new UserError("DEPLOY_FAILED", sourceAccessError(err, manifestPath));
+    }
+    if (!stat.isFile()) {
+        throw new UserError("DEPLOY_FAILED", `Source is not a file: ${manifestPath}`);
     }
+}
+function detectCollisions(actions) {
+    const seen = new Map();
+    const warnings = [];
+    for (const action of actions) {
+        const prev = seen.get(action.target);
+        if (prev) {
+            warnings.push({
+                kind: "collision",
+                message: `Skill "${action.skill}" for agent "${action.agent}" and skill "${prev.skill}" for agent "${prev.agent}" both resolve to the same target: ${action.target}`,
+            });
+        }
+        else {
+            seen.set(action.target, { skill: action.skill, agent: action.agent });
+        }
+    }
+    return warnings;
+}
+function detectAmbiguities(detectedAgents) {
+    const warnings = [];
+    if (detectedAgents.includes("gemini-cli") &&
+        detectedAgents.includes("antigravity")) {
+        warnings.push({
+            kind: "ambiguity",
+            message: 'Both "gemini-cli" and "antigravity" share the ~/.gemini/ base directory. antigravity skill support is implementation-only. Verify that deployed skill paths do not conflict.',
+        });
+    }
+    return warnings;
+}
+async function planSkillDirActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home) {
+    const method = getDeployMethod();
+    const actions = [];
     for (const skill of manifest.skills) {
         const source = path.resolve(sourceDir, skill.path);
         await validateSourcePath(source, skill.path, resolvedSourceDir, realRoot);
@@ -35,26 +122,112 @@ export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
             const agent = AGENT_REGISTRY_BY_ID[agentId];
             if (!agent)
                 continue;
-            const target = resolveAgentSkillPath(agent, skill.name, home);
             actions.push({
                 kind: "skill-dir",
                 skill: skill.name,
                 agent: agentId,
                 source,
-                target,
+                target: resolveAgentSkillPath(agent, skill.name, home),
                 method,
+                confidence: agent.provenance.skills,
+            });
+        }
+    }
+    return actions;
+}
+async function planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home) {
+    const actions = [];
+    for (const fileEntry of manifest.files ?? []) {
+        const source = path.resolve(sourceDir, fileEntry.path);
+        await validateSourcePath(source, fileEntry.path, resolvedSourceDir, realRoot);
+        await validateSourceFile(source, fileEntry.path);
+        for (const agentId of fileEntry.agents) {
+            if (!detectedAgents.includes(agentId))
+                continue;
+            const agent = AGENT_REGISTRY_BY_ID[agentId];
+            if (!agent)
+                continue;
+            actions.push({
+                kind: "file-write",
+                skill: fileEntry.name,
+                agent: agentId,
+                source,
+                target: resolveTargetTemplate(fileEntry.target, home),
+                confidence: agent.provenance.skills,
             });
         }
     }
     return actions;
 }
+function planConfigPatchActions(manifest, detectedAgents, home) {
+    const actions = [];
+    for (const configEntry of manifest.configs ?? []) {
+        for (const agentId of configEntry.agents) {
+            if (!detectedAgents.includes(agentId))
+                continue;
+            const agent = AGENT_REGISTRY_BY_ID[agentId];
+            if (!agent)
+                continue;
+            actions.push({
+                kind: "config-patch",
+                skill: configEntry.name,
+                agent: agentId,
+                target: resolveTargetTemplate(configEntry.target, home),
+                patch: configEntry.patch,
+                confidence: agent.provenance.skills,
+            });
+        }
+    }
+    return actions;
+}
+export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
+    const resolvedSourceDir = path.resolve(sourceDir);
+    let realRoot;
+    try {
+        realRoot = await realpath(resolvedSourceDir);
+    }
+    catch {
+        realRoot = resolvedSourceDir;
+    }
+    const actions = [
+        ...(await planSkillDirActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home)),
+        ...(await planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home)),
+        ...planConfigPatchActions(manifest, detectedAgents, home),
+    ];
+    const warnings = [
+        ...detectAmbiguities(detectedAgents),
+        ...detectCollisions(actions),
+    ];
+    return { actions, warnings };
+}
 export async function executeDeploy(actions, dryRun, verbose, home) {
     let succeeded = 0;
     const failed = [];
+    const planned = [];
     for (const action of actions) {
         switch (action.kind) {
             case "skill-dir": {
-                const result = await deploySkillDir(action, dryRun, verbose, home);
+                const result = await deploySkillDir(action, dryRun, verbose, home, planned);
+                if (result.error === null) {
+                    succeeded++;
+                }
+                else {
+                    failed.push({ action, error: result.error });
+                }
+                break;
+            }
+            case "file-write": {
+                const result = await deployFileWrite(action, dryRun, verbose, home, planned);
+                if (result.error === null) {
+                    succeeded++;
+                }
+                else {
+                    failed.push({ action, error: result.error });
+                }
+                break;
+            }
+            case "config-patch": {
+                const result = await deployConfigPatch(action, dryRun, verbose, home, planned);
                 if (result.error === null) {
                     succeeded++;
                 }
@@ -64,14 +237,13 @@ export async function executeDeploy(actions, dryRun, verbose, home) {
                 break;
             }
             default: {
-                const _ = action.kind;
-                throw new Error(`Unhandled deploy action kind: ${_}`);
+                throw new Error(`Unhandled deploy action kind: ${action}`);
             }
         }
     }
-    return { succeeded, failed };
+    return { succeeded, failed, planned };
 }
-async function deploySkillDir(action, dryRun, verbose, home) {
+async function deploySkillDir(action, dryRun, verbose, home, planned) {
     const label = `${action.skill} -> ${action.agent}`;
     try {
         await access(action.source);
@@ -82,14 +254,130 @@ async function deploySkillDir(action, dryRun, verbose, home) {
         return { error: msg };
     }
     if (dryRun) {
-        logger.plan(label);
+        planned.push({
+            verb: action.method === "symlink" ? "create-symlink" : "copy-dir",
+            kind: "skill-dir",
+            skill: action.skill,
+            agent: action.agent,
+            source: action.source,
+            target: action.target,
+            method: action.method,
+            confidence: action.confidence,
+        });
+        return { error: null };
+    }
+    try {
+        await executeDeployAction(action, verbose, home);
+        return { error: null };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return { error: msg };
+    }
+}
+async function deployFileWrite(action, dryRun, verbose, home, planned) {
+    const label = `${action.skill} -> ${action.agent}`;
+    try {
+        await access(action.source);
+    }
+    catch (err) {
+        const msg = sourceAccessError(err, action.source);
+        logger.fail(label, msg);
+        return { error: msg };
+    }
+    if (dryRun) {
+        planned.push({
+            verb: "write-file",
+            kind: "file-write",
+            skill: action.skill,
+            agent: action.agent,
+            source: action.source,
+            target: action.target,
+        });
+        return { error: null };
+    }
+    try {
+        // Check if target exists — only allow overwrite if we own it
+        try {
+            await lstat(action.target);
+            const isOwned = await verifyDeployment(home, action.target, {
+                kind: "file-write",
+                source: action.source,
+                skill: action.skill,
+                agent: action.agent,
+            });
+            if (!isOwned) {
+                throw new Error(`Target "${action.target}" exists but is not managed by inception-engine — refusing to overwrite`);
+            }
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("refusing to overwrite"))
+                throw err;
+            // ENOENT — target doesn't exist, fine to create
+        }
+        await mkdir(path.dirname(action.target), { recursive: true });
+        await copyFile(action.source, action.target);
+        await registerDeployment(home, action.target, {
+            kind: "file-write",
+            source: action.source,
+            skill: action.skill,
+            agent: action.agent,
+        });
+        logger.ok(label);
         if (verbose) {
-            logger.detail(`${action.method}: ${action.source} -> ${action.target}`);
+            logger.detail(`write-file: ${action.source} -> ${action.target}`);
         }
         return { error: null };
     }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return { error: msg };
+    }
+}
+async function deployConfigPatch(action, dryRun, verbose, home, planned) {
+    const label = `${action.skill} -> ${action.agent}`;
+    if (!isPlainObject(action.patch)) {
+        const msg = `Config patch for skill "${action.skill}" must be a plain object`;
+        logger.fail(label, msg);
+        return { error: msg };
+    }
+    const patch = action.patch;
+    if (dryRun) {
+        planned.push({
+            verb: "patch-config",
+            kind: "config-patch",
+            skill: action.skill,
+            agent: action.agent,
+            target: action.target,
+            patch,
+        });
+        return { error: null };
+    }
     try {
-        await executeDeployAction(action, verbose, home);
+        // Guard against double-patching by a different skill/agent
+        const existingEntry = await lookupDeployment(home, action.target);
+        if (existingEntry &&
+            (existingEntry.skill !== action.skill ||
+                existingEntry.agent !== action.agent)) {
+            throw new Error(`Config "${action.target}" is already patched by skill "${existingEntry.skill}" for agent "${existingEntry.agent}" — refusing to double-patch`);
+        }
+        const original = await readJsonConfig(action.target);
+        const undoPatch = computeUndoPatch(original, patch);
+        const patched = applyMergePatch(original, patch);
+        await writeFile(action.target, `${JSON.stringify(patched, null, 2)}\n`, "utf-8");
+        await registerDeployment(home, action.target, {
+            kind: "config-patch",
+            patch,
+            undoPatch,
+            skill: action.skill,
+            agent: action.agent,
+        });
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(`patch-config: applied ${Object.keys(patch).length} key(s) to ${action.target}`);
+        }
         return { error: null };
     }
     catch (err) {
@@ -134,9 +422,23 @@ async function validateSkillContract(source, skillPath) {
         throw new UserError("DEPLOY_FAILED", `Skill "${skillPath}" source is not a directory: ${source}`);
     }
     try {
-        await access(path.join(source, "SKILL.md"));
+        await access(source, constants.R_OK);
     }
-    catch {
+    catch (err) {
+        const code = err.code;
+        if (code === "EACCES" || code === "EPERM") {
+            throw new UserError("DEPLOY_FAILED", `Permission denied reading skill directory "${skillPath}": ${source}`);
+        }
+        throw new UserError("DEPLOY_FAILED", `Cannot read skill directory "${skillPath}": ${source}`);
+    }
+    try {
+        await access(path.join(source, "SKILL.md"), constants.R_OK);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "EACCES" || code === "EPERM") {
+            throw new UserError("DEPLOY_FAILED", `Permission denied reading SKILL.md in skill "${skillPath}": ${source}`);
+        }
         throw new UserError("DEPLOY_FAILED", `Skill "${skillPath}" source is missing SKILL.md: ${source}`);
     }
 }
@@ -159,6 +461,7 @@ async function createDeployTarget(action, home) {
         await cp(action.source, action.target, { recursive: true });
     }
     await registerDeployment(home, action.target, {
+        kind: action.kind,
         source: action.source,
         skill: action.skill,
         agent: action.agent,
@@ -168,6 +471,7 @@ async function createDeployTarget(action, home) {
 async function executeDeployAction(action, verbose, home) {
     const label = `${action.skill} -> ${action.agent}`;
     const backupPath = await backupExisting(action.target, verbose, home, {
+        kind: action.kind,
         source: action.source,
         skill: action.skill,
         agent: action.agent,
@@ -180,6 +484,9 @@ async function executeDeployAction(action, verbose, home) {
     catch (createErr) {
         if (backupPath) {
             try {
+                await removeTarget(action.target).catch(() => {
+                    /* best-effort cleanup */
+                });
                 await rename(backupPath, action.target);
             }
             catch {
@@ -203,21 +510,24 @@ async function backupExisting(targetPath, verbose, home, expected) {
     catch {
         return null;
     }
-    if (!(await verifyDeployment(home, targetPath, expected))) {
+    if (!(await verifyDeployment(home, targetPath, {
+        kind: "skill-dir",
+        source: expected.source,
+        skill: expected.skill,
+        agent: expected.agent,
+    }))) {
         throw new Error(`Target "${targetPath}" exists but is not managed by inception-engine — refusing to overwrite`);
     }
     const backupPath = `${targetPath}.inception-backup`;
-    // Clean up any stale backup from a previous failed attempt
-    try {
-        await lstat(backupPath);
-        await removeTarget(backupPath);
-    }
-    catch {
-        // No stale backup — expected
-    }
     if (verbose) {
         logger.detail(`backing up existing target: ${targetPath}`);
     }
+    // Remove any stale backup from a previous failed attempt. Using rm with
+    // { force: true } avoids a separate lstat existence check and handles
+    // the case where the stale backup is a directory (which rename cannot
+    // atomically replace on POSIX). This reduces the window between the
+    // stale-backup removal and the rename to a single step.
+    await rm(backupPath, { recursive: true, force: true });
     await rename(targetPath, backupPath);
     return backupPath;
 }

package/dist/core/detect.d.ts

@@ -1,7 +1,7 @@
 import type { AgentId } from "../types.ts";
 export type ExecFn = (cmd: string, args: readonly string[]) => Promise<void>;
 export declare function detectInstalledAgents(home: string): Promise<AgentId[]>;
-export declare function isBinaryInPath(binary: string, execFn?: ExecFn): Promise<boolean>;
+export declare function isBinaryInPath(binary: string, execFn?: ExecFn, platform?: NodeJS.Platform): Promise<boolean>;
 export declare function isBinaryViaWhereExe(binary: string, execFn?: ExecFn): Promise<boolean>;
-export declare function isBinaryViaCommandV(binary: string): Promise<boolean>;
+export declare function isBinaryViaCommandV(binary: string, execFn?: ExecFn): Promise<boolean>;
 export declare function isBinaryViaWhich(binary: string, execFn?: ExecFn): Promise<boolean>;

package/dist/core/detect.js

@@ -30,8 +30,8 @@ async function isAgentInstalled(agent, home) {
     }
     return false;
 }
-export async function isBinaryInPath(binary, execFn = defaultExecFn) {
-    if (process.platform === "win32") {
+export async function isBinaryInPath(binary, execFn = defaultExecFn, platform = process.platform) {
+    if (platform === "win32") {
         return isBinaryViaWhereExe(binary, execFn);
     }
     try {
@@ -41,7 +41,7 @@ export async function isBinaryInPath(binary, execFn = defaultExecFn) {
     catch (err) {
         // `which` itself is not installed — fall back to the POSIX shell built-in
         if (isENOENT(err)) {
-            return isBinaryViaCommandV(binary);
+            return isBinaryViaCommandV(binary, execFn);
         }
         return false;
     }
@@ -58,10 +58,10 @@ export async function isBinaryViaWhereExe(binary, execFn = defaultExecFn) {
 }
 // Used only when `which` is absent (e.g. minimal Alpine containers).
 // `command -v` is a POSIX shell built-in available wherever /bin/sh is.
-export async function isBinaryViaCommandV(binary) {
+export async function isBinaryViaCommandV(binary, execFn = defaultExecFn) {
     try {
         // Pass binary as a positional arg ($1) to avoid any shell-injection risk.
-        await execFileAsync("sh", ["-c", 'command -v "$1"', "--", binary]);
+        await execFn("sh", ["-c", 'command -v "$1"', "--", binary]);
         return true;
     }
     catch {