impel-cli 0.18.15-beta.1 → 0.18.15-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "impel-cli",
-  "version": "0.18.15-beta.1",
+  "version": "0.18.15-beta.2",
   "description": "Prepare isolated Claude and Codex workspaces for every accessible Impel tenant",
   "type": "module",
   "bin": {

package/src/commands/launch.js

@@ -20,8 +20,9 @@ import { assertProviderScopes, ensureTenantSelection, tenantCredential } from ".
 import { maybePrintUpdateNotice } from "../updates.js";
 import {
   nativeSpawnInvocation,
-  resolveNativeBinary,
 } from "../nativeProcess.js";
+import { resolveReviewedVendorCliBinary } from "../vendorCliBinaries.js";
+import { PINNED_VENDOR_CLI_VERSIONS } from "../vendorCliVersions.js";
 import { RUNTIME_BRAND } from "../runtimeBrand.js";
 import {
   cacheProviderReadiness,
@@ -115,7 +116,15 @@ async function assertLiveProviderReadiness({ config, gatewayUrl, credential, ten
 }
 
 function runNativeCli(tool, argv, environment) {
-  const binary = resolveNativeBinary(tool, environment);
+  const binary = resolveReviewedVendorCliBinary(tool, environment);
+  if (!binary) {
+    const version = PINNED_VENDOR_CLI_VERSIONS[tool];
+    console.error(
+      `impel ${tool}: reviewed ${tool === "claude" ? "Claude Code" : "Codex"} CLI `
+      + `v${version} is not installed. Run \`impel update\` to repair it.`,
+    );
+    return Promise.resolve(127);
+  }
   let invocation;
   try {
     invocation = nativeSpawnInvocation(binary, argv, environment);

package/src/commands/status.js

@@ -4,8 +4,9 @@ import path from "node:path";
 
 import { appPaths, CLAUDE_CONFIG_ID, readTenantManifest } from "../apps.js";
 import { crossAppModelsEnabled, loadConfig, maskSecret } from "../config.js";
-import { environmentValue, findNativeBinary } from "../nativeProcess.js";
+import { environmentValue } from "../nativeProcess.js";
 import { tenantCliClientReadiness } from "../provisioning.js";
+import { findReviewedVendorCliBinary } from "../vendorCliBinaries.js";
 import { windowsTenantShortcutName } from "../shellEntries.js";
 import {
   ensureTenantSelection,
@@ -86,7 +87,7 @@ export async function cmdStatus(overrides = {}) {
     cliReadiness: tenantCliClientReadiness,
     desktopReadiness,
     installedVersion,
-    findNativeBinary,
+    findNativeBinary: findReviewedVendorCliBinary,
     maybePrintUpdateNotice,
     platform: process.platform,
     environment: process.env,

package/src/macSetup.js

@@ -7,12 +7,12 @@ import { spawnSync } from "node:child_process";
 import { ensureImpelClaudeProfile, ensureImpelCodexProfile } from "./cliProfiles.js";
 import { findNativeBinary } from "./nativeProcess.js";
 import { syncSkillsSafe } from "./skills.js";
+import { verifyReviewedMacVendorCli } from "./vendorCliBinaries.js";
 import { PINNED_VENDOR_CLI_VERSIONS } from "./vendorCliVersions.js";
 
 const MAX_INSTALLER_BYTES = 512 * 1024;
 const INSTALLER_DOWNLOAD_TIMEOUT_MS = 30_000;
 const INSTALLER_RUN_TIMEOUT_MS = 10 * 60 * 1_000;
-const MAC_SIGNING_TEAMS = Object.freeze({ claude: "Q6L2SF6YDW", codex: "2DC432GLL2" });
 
 /**
  * The script bytes are pinned per impel-cli release. Both vendor scripts then
@@ -48,36 +48,6 @@ export const MAC_CLI_INSTALLERS = Object.freeze({
   }),
 });
 
-function verifyMacCli(tool, binary, environment, run = spawnSync) {
-  try {
-    const result = run(binary, ["--version"], {
-      encoding: "utf8",
-      env: environment,
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: 15_000,
-    });
-    if (result?.status !== 0 || result?.error) return false;
-    const explicitOverride = tool === "claude" ? environment.IMPEL_CLAUDE_BIN : environment.IMPEL_CODEX_BIN;
-    if (explicitOverride && path.resolve(explicitOverride) === path.resolve(binary)) return true;
-    const resolved = fs.realpathSync(binary);
-    const verified = run("/usr/bin/codesign", ["--verify", "--strict", resolved], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: 15_000,
-    });
-    if (verified?.status !== 0 || verified?.error) return false;
-    const details = run("/usr/bin/codesign", ["-dv", "--verbose=4", resolved], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: 15_000,
-    });
-    return details?.status === 0
-      && String(details.stderr || details.stdout || "").includes(`TeamIdentifier=${MAC_SIGNING_TEAMS[tool]}`);
-  } catch {
-    return false;
-  }
-}
-
 function detectMacClis(find, environment, verify) {
   const detect = (tool) => find(
     tool,
@@ -206,7 +176,7 @@ export async function prepareMacClis({
   const io = {
     environment: process.env,
     find: findNativeBinary,
-    verify: verifyMacCli,
+    verify: verifyReviewedMacVendorCli,
     run: spawnSync,
     fetchImpl: fetch,
     fsImpl: fs,
@@ -258,7 +228,10 @@ export async function prepareMacClis({
     await io.syncSkills({
       client: "claude",
       gatewayUrl,
-      env: { CLAUDE_CONFIG_DIR: claudeProfile.configDir },
+      env: {
+        CLAUDE_CONFIG_DIR: claudeProfile.configDir,
+        IMPEL_CLAUDE_BIN: binaries.claude,
+      },
       label: "Impel isolated Claude (impel claude)",
       // Lets Windows spawns use a git-safe cwd (see skillSyncSpawnDirectory).
       homeDir: os.homedir(),
@@ -268,7 +241,10 @@ export async function prepareMacClis({
     await io.syncSkills({
       client: "codex",
       gatewayUrl,
-      env: { CODEX_HOME: codexProfile.codexHome },
+      env: {
+        CODEX_HOME: codexProfile.codexHome,
+        IMPEL_CODEX_BIN: binaries.codex,
+      },
       label: "Impel isolated Codex (impel codex)",
       homeDir: os.homedir(),
     });

package/src/provisioning.js

@@ -5,7 +5,6 @@ import path from "node:path";
 import { syncAgentProfilesSafe } from "./agents.js";
 import { crossAppModelsEnabled, redactSecretText } from "./config.js";
 import { ensureImpelClaudeProfile, ensureImpelCodexProfile, tenantCliProfilePaths } from "./cliProfiles.js";
-import { findNativeBinary } from "./nativeProcess.js";
 import { mapWithConcurrency } from "./progress.js";
 import { registerTenantShellEntries } from "./shellEntries.js";
 import { resolveSkillsGateway, syncSkillsSafe } from "./skills.js";
@@ -17,6 +16,7 @@ import {
 } from "./tenants.js";
 import { reconcileTenantApps } from "./commands/apps.js";
 import { RUNTIME_BRAND } from "./runtimeBrand.js";
+import { findReviewedVendorCliBinary } from "./vendorCliBinaries.js";
 
 export function selectDefaultTenant(listing, { requested = null, currentTenantId = null } = {}) {
   const normalized = requested ? normalizeTenantId(requested) : null;
@@ -93,13 +93,19 @@ async function prepareTenantCli(config, tenant, io, binaries) {
         crossAppModels: crossAppModelsEnabled(config),
       }),
       root: (profile) => profile.configDir,
-      env: (profile) => ({ CLAUDE_CONFIG_DIR: profile.configDir }),
+      env: (profile) => ({
+        CLAUDE_CONFIG_DIR: profile.configDir,
+        IMPEL_CLAUDE_BIN: binaries.claude,
+      }),
     },
     codex: {
       supported: providerSupported(config.scopes, PAT_SCOPE_CODEX),
       ensure: () => io.ensureCodex(config.gatewayUrl, tenant.id),
       root: (profile) => profile.codexHome,
-      env: (profile) => ({ CODEX_HOME: profile.codexHome }),
+      env: (profile) => ({
+        CODEX_HOME: profile.codexHome,
+        IMPEL_CODEX_BIN: binaries.codex,
+      }),
     },
   };
   const clients = {};
@@ -181,7 +187,7 @@ export async function reconcileAllTenants({
     ensureCodex: ensureImpelCodexProfile,
     syncSkills: syncSkillsSafe,
     syncAgents: syncAgentProfilesSafe,
-    findBinary: findNativeBinary,
+    findBinary: findReviewedVendorCliBinary,
     reconcileApps: reconcileTenantApps,
     registerShellEntries: registerTenantShellEntries,
     knownTenantIds: locallyKnownTenantIds,

package/src/skills.js

@@ -25,6 +25,8 @@ import path from "node:path";
 
 import { resolveDefaultGateway, normalizeGatewayUrl } from "./config.js";
 import { findNativeBinary, nativeCommandInvocation } from "./nativeProcess.js";
+import { findReviewedVendorCliBinary } from "./vendorCliBinaries.js";
+import { PINNED_VENDOR_CLI_VERSIONS } from "./vendorCliVersions.js";
 
 /** The bundled plugin the Bifrost registry publishes; contains every served skill. */
 export const SKILL_PLUGIN_NAME = "bifrost-all-skills";
@@ -499,6 +501,7 @@ export async function syncSkills({
   platform = process.platform,
   findGit = findNativeBinary,
   homeDir = null,
+  findVendorBinary = findReviewedVendorCliBinary,
 } = {}) {
   const spec = CLIENT_SPECS[client];
   if (!spec) {
@@ -512,6 +515,18 @@ export async function syncSkills({
     return { client, label: displayLabel, skipped: true, reason: "disabled" };
   }
 
+  let commandBinary = spec.bin;
+  if (platform === "darwin" && run === runSkillCommand) {
+    commandBinary = findVendorBinary(client, { ...process.env, ...env }, platform);
+    if (!commandBinary) {
+      logger.warn(
+        `impel: skipping skill sync for ${displayLabel} — reviewed ${spec.label} `
+        + `v${PINNED_VENDOR_CLI_VERSIONS[client]} is not installed; run \`impel update\`.`,
+      );
+      return { client, label: displayLabel, skipped: true, reason: "binary-version-mismatch" };
+    }
+  }
+
   // Callers that manage real profiles pass their home directory so Windows
   // spawns happen from a git-safe cwd (see skillSyncSpawnDirectory).
   const spawnDirectory = skillSyncSpawnDirectory({ platform, homeDir });
@@ -521,9 +536,10 @@ export async function syncSkills({
 
   try {
     // Confirm the binary and its `plugin` subcommand exist before doing anything.
-    const help = await runCommand(spec.bin, ["plugin", "--help"], env);
+    const help = await runCommand(commandBinary, ["plugin", "--help"], env);
     if (help.missing) {
-      logger.warn(`impel: skipping skill sync for ${displayLabel} — \`${spec.bin}\` CLI not found on PATH.`);
+      const location = commandBinary === spec.bin ? " on PATH" : "";
+      logger.warn(`impel: skipping skill sync for ${displayLabel} — \`${commandBinary}\` CLI not found${location}.`);
       return { client, label: displayLabel, skipped: true, reason: "binary-missing" };
     }
     if (!help.ok) {
@@ -555,12 +571,12 @@ export async function syncSkills({
     })[0];
     const registerResult = await runSkillCommandWithRetry(
       runCommand,
-      spec.bin,
+      commandBinary,
       registerCommand.args,
       env,
     );
     if (registerResult.missing) {
-      failures.push({ phase: registerCommand.phase, reason: `\`${spec.bin}\` disappeared mid-sync` });
+      failures.push({ phase: registerCommand.phase, reason: `\`${commandBinary}\` disappeared mid-sync` });
     } else if (!isBenign(registerResult)) {
       failures.push({
         phase: registerCommand.phase,
@@ -573,7 +589,7 @@ export async function syncSkills({
     // gives us the same dynamic name so refreshes can still use
     // PLUGIN@MARKETPLACE.
     if (!marketplaceName && !registerResult.missing) {
-      const listed = await runCommand(spec.bin, ["plugin", "marketplace", "list", "--json"], env);
+      const listed = await runCommand(commandBinary, ["plugin", "marketplace", "list", "--json"], env);
       if (listed.ok) marketplaceName = resolveConfiguredMarketplaceName(listed.stdout, sourceUrl);
     }
 
@@ -585,12 +601,12 @@ export async function syncSkills({
     for (const command of commands) {
       const result = await runSkillCommandWithRetry(
         runCommand,
-        spec.bin,
+        commandBinary,
         command.args,
         env,
       );
       if (result.missing) {
-        failures.push({ phase: command.phase, reason: `\`${spec.bin}\` disappeared mid-sync` });
+        failures.push({ phase: command.phase, reason: `\`${commandBinary}\` disappeared mid-sync` });
         break;
       }
       if (isBenign(result)) continue;
@@ -603,7 +619,7 @@ export async function syncSkills({
       ) {
         const repair = await reregisterCodexMarketplace({
           run: runCommand,
-          bin: spec.bin,
+          bin: commandBinary,
           env,
           marketplaceName,
           sourceUrl,

package/src/vendorCliBinaries.js

@@ -0,0 +1,121 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+import {
+  environmentValue,
+  findNativeBinary,
+  resolveNativeBinary,
+} from "./nativeProcess.js";
+import { PINNED_VENDOR_CLI_VERSIONS } from "./vendorCliVersions.js";
+
+export const MAC_VENDOR_SIGNING_TEAMS = Object.freeze({
+  claude: "Q6L2SF6YDW",
+  codex: "2DC432GLL2",
+});
+
+const VERSION_RE = /\b\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?\b/u;
+
+function vendorOverrideName(tool, environmentPrefix = "IMPEL") {
+  if (tool === "claude") return `${environmentPrefix}_CLAUDE_BIN`;
+  if (tool === "codex") return `${environmentPrefix}_CODEX_BIN`;
+  return null;
+}
+
+/** Extract the vendor release from `claude --version` or `codex --version`. */
+export function parseVendorCliVersion(output) {
+  return String(output || "").match(VERSION_RE)?.[0] || null;
+}
+
+/**
+ * Accept only the exact reviewed macOS release and its vendor signature.
+ * Explicit binary overrides remain authoritative for development and recovery.
+ */
+export function verifyReviewedMacVendorCli(
+  tool,
+  binary,
+  environment = process.env,
+  {
+    run = spawnSync,
+    realpath = fs.realpathSync,
+    versions = PINNED_VENDOR_CLI_VERSIONS,
+    signingTeams = MAC_VENDOR_SIGNING_TEAMS,
+    environmentPrefix = "IMPEL",
+  } = {},
+) {
+  if (!versions[tool] || !signingTeams[tool]) return false;
+  try {
+    const override = vendorOverrideName(tool, environmentPrefix);
+    const overriddenBinary = override ? environmentValue(environment, override) : null;
+    if (overriddenBinary && path.resolve(overriddenBinary) === path.resolve(binary)) return true;
+
+    const result = run(binary, ["--version"], {
+      encoding: "utf8",
+      env: environment,
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 15_000,
+    });
+    if (result?.status !== 0 || result?.error) return false;
+
+    const version = parseVendorCliVersion(`${result.stdout || ""}\n${result.stderr || ""}`);
+    if (version !== versions[tool]) return false;
+
+    const resolved = realpath(binary);
+    const verified = run("/usr/bin/codesign", ["--verify", "--strict", resolved], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 15_000,
+    });
+    if (verified?.status !== 0 || verified?.error) return false;
+    const details = run("/usr/bin/codesign", ["-dv", "--verbose=4", resolved], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 15_000,
+    });
+    return details?.status === 0
+      && String(details.stderr || details.stdout || "").includes(`TeamIdentifier=${signingTeams[tool]}`);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Locate the reviewed macOS vendor CLI. On other platforms this intentionally
+ * preserves the existing native resolution behavior.
+ */
+export function findReviewedVendorCliBinary(
+  tool,
+  environment = process.env,
+  platform = process.platform,
+  environmentPrefix = "IMPEL",
+  {
+    find = findNativeBinary,
+    verify = verifyReviewedMacVendorCli,
+  } = {},
+) {
+  if (platform !== "darwin") return find(tool, environment, platform, environmentPrefix);
+  return find(
+    tool,
+    environment,
+    platform,
+    environmentPrefix,
+    (binary) => verify(tool, binary, environment, { environmentPrefix }),
+  );
+}
+
+/**
+ * Resolve a launch target. macOS deliberately returns null when only an
+ * unreviewed or version-drifted binary exists so callers can request repair
+ * instead of silently launching it.
+ */
+export function resolveReviewedVendorCliBinary(
+  tool,
+  environment = process.env,
+  platform = process.platform,
+  environmentPrefix = "IMPEL",
+) {
+  if (platform !== "darwin") {
+    return resolveNativeBinary(tool, environment, platform, environmentPrefix);
+  }
+  return findReviewedVendorCliBinary(tool, environment, platform, environmentPrefix);
+}