impel-cli 0.17.12 → 0.17.13

package/package.json

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

package/src/commands/apps.js

@@ -43,7 +43,7 @@ import { syncAgentProfilesSafe } from "../agents.js";
 import { secureManagedCodexHome } from "../codexSecurity.js";
 import { impelCliInvocation } from "../selfInvocation.js";
 import { createProgressLogger, withProgress } from "../progress.js";
-import { findNativeBinary } from "../nativeProcess.js";
+import { environmentValue, findNativeBinary } from "../nativeProcess.js";
 import {
   ensureWindowsClaudeApp,
   ensureWindowsChatGPTApp,
@@ -56,6 +56,7 @@ import {
   stageWindowsChatGPTApp,
   windowsChatGPTStageIsCurrent,
   windowsClaudeUserData,
+  windowsManagedChatGPTRoot,
 } from "../windowsApps.js";
 
 const CLAUDE_KEYCHAIN_NOTICE = "Claude Keychain: enter your Mac login password and choose Always Allow on the first prompt for this tenant; Allow is temporary.";
@@ -112,11 +113,26 @@ function appTargetLabel(displayName) {
 // Each isolated desktop app maps to a client CLI + the env override that points
 // that CLI at the app's private profile, so skill syncing lands in the app's
 // installation rather than a global one.
-function appSkillTarget(target, paths) {
+function appSkillTarget(target, paths, {
+  platform = process.platform,
+  existsSync = fs.existsSync,
+  environment = process.env,
+} = {}) {
   if (target === "claude") {
     return { client: "claude", env: { CLAUDE_CONFIG_DIR: paths.claude.userData }, label: appTargetLabel(paths.claude.displayName) };
   }
-  return { client: "codex", env: { CODEX_HOME: paths.chatgpt.codexHome }, label: appTargetLabel(paths.chatgpt.displayName) };
+  const env = { CODEX_HOME: paths.chatgpt.codexHome };
+  // The staged Windows app ships the exact codex.exe the app itself runs, so
+  // plugin sync uses it instead of requiring a separately installed Codex CLI
+  // (a box without one would otherwise get no app skills at all) and the
+  // plugin state is always written by the same codex version that reads it.
+  // An operator's explicit IMPEL_CODEX_BIN stays authoritative — it is an
+  // override everywhere else the CLI resolves codex.
+  if (platform === "win32" && !environmentValue(environment, "IMPEL_CODEX_BIN")) {
+    const embedded = path.join(windowsManagedChatGPTRoot(paths.root), "resources", "codex.exe");
+    if (existsSync(embedded)) env.IMPEL_CODEX_BIN = embedded;
+  }
+  return { client: "codex", env, label: appTargetLabel(paths.chatgpt.displayName) };
 }
 
 function appAgentProfile(target, paths) {
@@ -335,6 +351,7 @@ export async function reconcileWindowsTenantApps({
     installFiles: installManagedAppFiles,
     syncSkills: syncSkillsSafe,
     syncAgents: syncAgentProfilesSafe,
+    secureCodexHome: secureManagedCodexHome,
     existsSync: fs.existsSync,
     findBinary: findNativeBinary,
     log: (message) => console.log(message),
@@ -389,12 +406,20 @@ export async function reconcileWindowsTenantApps({
   });
   const agentTargets = [];
   for (const target of actionTargets) {
-    const { client, env, label } = appSkillTarget(target, paths);
-    if (io.findBinary(client, environment, "win32")) {
+    const { client, env, label } = appSkillTarget(target, paths, {
+      platform: "win32",
+      existsSync: io.existsSync,
+      environment,
+    });
+    // Merge the sync env so an app-embedded binary (IMPEL_CODEX_BIN) satisfies
+    // the availability check even when no standalone CLI is installed.
+    if (io.findBinary(client, { ...environment, ...env }, "win32")) {
       await io.syncSkills({ client, gatewayUrl: resolveSkillsGateway(config.gatewayUrl), env, label });
       agentTargets.push(target);
+    } else {
+      io.log(`Skipping skill/agent sync for ${label} — no ${client === "claude" ? "Claude Code" : "Codex"} binary is available to run plugin commands.`);
     }
-    if (target === "chatgpt") secureManagedCodexHome(paths.chatgpt.codexHome);
+    if (target === "chatgpt") io.secureCodexHome(paths.chatgpt.codexHome);
   }
   if (agentTargets.length) {
     await io.syncAgents({
@@ -719,7 +744,7 @@ export async function cmdWindowsApps(argv, overrides = {}) {
       for (const target of configuredTargets) {
         const profile = target === "claude" ? tenantPaths.claude.userData : tenantPaths.chatgpt.root;
         console.log(`${verb} Impel ${target === "claude" ? "Claude" : "ChatGPT"} profile at ${profile}`);
-        const { client, env, label } = appSkillTarget(target, tenantPaths);
+        const { client, env, label } = appSkillTarget(target, tenantPaths, { platform: "win32" });
         if (!flags["skip-skills"]) {
           await withProgress(`Syncing skills for ${label}`, (spinner) => (
             io.syncSkills({

package/src/commands/skills.js

@@ -13,9 +13,10 @@ import { loadConfig } from "../config.js";
 import { CODEX_HOME } from "../codexSetup.js";
 import { tenantCliProfilePaths } from "../cliProfiles.js";
 import { CLAUDE_CONFIG_ID, appPaths } from "../apps.js";
+import { environmentValue } from "../nativeProcess.js";
 import { resolveSkillsGateway, syncSkillsSafe } from "../skills.js";
 import { ensureTenantSelection } from "../tenants.js";
-import { windowsClaudeUserData } from "../windowsApps.js";
+import { windowsClaudeUserData, windowsManagedChatGPTRoot } from "../windowsApps.js";
 import { createProgressLogger, mapWithConcurrency, withProgress } from "../progress.js";
 
 const VALID_TARGETS = ["claude", "codex", "all"];
@@ -74,7 +75,16 @@ export function managedSkillProfiles(
       ? existsSync(path.join(paths.chatgpt.codexHome, "config.toml"))
       : existsSync(paths.chatgpt.launcher);
     if (includeApps && appInstalled) {
-      profiles.push({ label: "Impel ChatGPT app", env: { CODEX_HOME: paths.chatgpt.codexHome } });
+      const env = { CODEX_HOME: paths.chatgpt.codexHome };
+      // Mirror appSkillTarget (commands/apps.js): the staged Windows app
+      // bundles the codex.exe that reads this profile, so `impel skills sync`
+      // works on boxes without a standalone Codex CLI too. An operator's
+      // explicit IMPEL_CODEX_BIN stays authoritative.
+      if (platform === "win32" && !environmentValue(environment, "IMPEL_CODEX_BIN")) {
+        const embedded = path.join(windowsManagedChatGPTRoot(paths.root), "resources", "codex.exe");
+        if (existsSync(embedded)) env.IMPEL_CODEX_BIN = embedded;
+      }
+      profiles.push({ label: "Impel ChatGPT app", env });
     }
   }
 

package/src/nativeProcess.js

@@ -118,6 +118,15 @@ function commonCandidates(tool, environment, platform) {
     if (tool === "powershell" && systemRoot) {
       locations.push([paths.join(systemRoot, "System32", "WindowsPowerShell", "v1.0"), "powershell"]);
     }
+
+    // Git for Windows standard install roots; `cmd` holds the PATH-safe
+    // git.exe. Codex shells out to git for marketplace clones, so skill
+    // syncing must find git even when the parent shell's PATH predates the
+    // Git installation.
+    if (tool === "git") {
+      if (programFiles) locations.push([paths.join(programFiles, "Git", "cmd"), "git"]);
+      if (localAppData) locations.push([paths.join(localAppData, "Programs", "Git", "cmd"), "git"]);
+    }
   }
 
   return locations.flatMap(([directory, name]) => binaryCandidates(directory, name, environment, platform));

package/src/skills.js

@@ -20,9 +20,10 @@
 // so we keep a per-client command table rather than assuming one shape.
 
 import { spawn } from "node:child_process";
+import path from "node:path";
 
 import { resolveDefaultGateway, normalizeGatewayUrl } from "./config.js";
-import { nativeCommandInvocation } from "./nativeProcess.js";
+import { findNativeBinary, nativeCommandInvocation } from "./nativeProcess.js";
 
 /** The bundled plugin the Bifrost registry publishes; contains every served skill. */
 export const SKILL_PLUGIN_NAME = "bifrost-all-skills";
@@ -183,18 +184,56 @@ export function buildSkillCommands({ client, marketplaceSourceUrl: sourceUrl, ma
   return commands;
 }
 
+/**
+ * Codex registers marketplaces by shelling out to `git clone` (Claude fetches
+ * its manifest over plain HTTP), so a Windows machine without git breaks
+ * exactly the Codex half of skill syncing. Resolve git up front: when a
+ * standard Git for Windows install exists but the inherited PATH cannot see
+ * it, prepend its directory for the child commands; when git is genuinely
+ * absent, report that so the caller can skip with an actionable message
+ * instead of surfacing codex's raw "failed to run git clone" error.
+ */
+export function withCodexGitEnvironment(env = {}, {
+  platform = process.platform,
+  baseEnvironment = process.env,
+  find = findNativeBinary,
+} = {}) {
+  if (platform !== "win32") return { env, gitAvailable: true };
+  const merged = { ...baseEnvironment, ...env };
+  const git = find("git", merged, platform);
+  if (!git) return { env, gitAvailable: false };
+  const gitDirectory = path.win32.dirname(git);
+  const normalize = (entry) => entry.trim().replace(/[\\/]+$/u, "").toLowerCase();
+  const pathKey = Object.keys(merged).find((key) => key.toLowerCase() === "path") || "Path";
+  const currentPath = String(merged[pathKey] || "");
+  if (currentPath.split(";").some((entry) => normalize(entry) === normalize(gitDirectory))) {
+    return { env, gitAvailable: true };
+  }
+  return {
+    env: { ...env, [pathKey]: currentPath ? `${gitDirectory};${currentPath}` : gitDirectory },
+    gitAvailable: true,
+  };
+}
+
 const SKILL_COMMAND_TIMEOUT_MS = 120_000;
 const SKILL_COMMAND_OUTPUT_LIMIT = 10 * 1024 * 1024;
 
+// cmd.exe reports a nonexistent command with exit code 9009 (and this stderr
+// line on English installs); the spawn itself succeeds, so without this check
+// a missing CLI is misreported as "has no plugin command".
+const WINDOWS_COMMAND_NOT_FOUND_STATUS = 9009;
+const WINDOWS_COMMAND_NOT_FOUND_RE = /is not recognized as an internal or external command/iu;
+
 /** Default async command runner: keeps progress timers responsive while plugins sync. */
 export function runSkillCommand(bin, args, env, {
   spawnImpl = spawn,
   timeoutMs = SKILL_COMMAND_TIMEOUT_MS,
+  platform = process.platform,
 } = {}) {
   const environment = { ...process.env, ...env };
   let invocation;
   try {
-    invocation = nativeCommandInvocation(bin, args, environment);
+    invocation = nativeCommandInvocation(bin, args, environment, platform);
   } catch (error) {
     return Promise.resolve({
       ok: false,
@@ -269,7 +308,14 @@ export function runSkillCommand(bin, args, env, {
     }));
     child.on("close", (status) => finish({
       ok: !timedOut && status === 0,
-      missing: false,
+      // Only a FAILED cmd.exe-wrapped launch can mean "the CLI itself was not
+      // found"; a successful run owns its own stderr, and a directly spawned
+      // binary owns its exit codes, where the same phrasing could describe
+      // some inner command instead.
+      missing: status !== 0
+        && invocation.windowsVerbatimArguments
+        && (status === WINDOWS_COMMAND_NOT_FOUND_STATUS
+          || WINDOWS_COMMAND_NOT_FOUND_RE.test(stderr)),
       status,
       stdout,
       stderr: timedOut ? `skill command timed out after ${timeoutMs}ms` : stderr,
@@ -357,6 +403,8 @@ export async function syncSkills({
   fetchImpl = fetch,
   run = runSkillCommand,
   logger = console,
+  platform = process.platform,
+  findGit = findNativeBinary,
 } = {}) {
   const spec = CLIENT_SPECS[client];
   if (!spec) {
@@ -382,6 +430,19 @@ export async function syncSkills({
       return { client, label: displayLabel, skipped: true, reason: "no-plugin-subcommand" };
     }
 
+    if (client === "codex") {
+      const gitReady = withCodexGitEnvironment(env, { platform, find: findGit });
+      if (!gitReady.gitAvailable) {
+        logger.warn(
+          `impel: skipping skill sync for ${displayLabel} — Codex fetches its skills marketplace with \`git\`, `
+            + "which is not installed. Install Git for Windows (https://git-scm.com/download/win), "
+            + "then re-run `impel update`."
+        );
+        return { client, label: displayLabel, skipped: true, reason: "git-missing" };
+      }
+      env = gitReady.env;
+    }
+
     const manifestUrl = marketplaceUrl(gatewayUrl, client);
     const sourceUrl = marketplaceSourceUrl(gatewayUrl, client);
     let marketplaceName = await fetchMarketplaceName(manifestUrl, fetchImpl);