impel-cli 0.7.0

package/src/windowsApps.js

@@ -0,0 +1,439 @@
+import { spawn, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { environmentValue, nativeCommandInvocation } from "./nativeProcess.js";
+import { normalizeTenantId } from "./tenants.js";
+
+export const WINDOWS_CLAUDE_PACKAGE = "Anthropic.Claude";
+export const WINDOWS_CHATGPT_PACKAGE = "9PLM9XGG6VKS";
+export const WINDOWS_CHATGPT_PACKAGE_NAME = "OpenAI.Codex";
+export const WINDOWS_CHATGPT_PUBLISHER_ID = "2p2nqsd0c76g0";
+
+export function windowsClaudeUserData(environment = process.env, tenantId = null) {
+  const localAppData = environmentValue(environment, "LOCALAPPDATA")
+    || path.win32.join(environmentValue(environment, "USERPROFILE") || os.homedir(), "AppData", "Local");
+  return path.win32.join(
+    localAppData,
+    "Claude-3p",
+    "Impel",
+    normalizeTenantId(tenantId || "default"),
+  );
+}
+
+function isFile(filePath) {
+  try {
+    return fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function versionedSquirrelCandidates(root, readDirectory = fs.readdirSync) {
+  try {
+    return readDirectory(root, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && entry.name.toLowerCase().startsWith("app-"))
+      .sort((left, right) => right.name.localeCompare(left.name, undefined, { numeric: true }))
+      .flatMap((entry) => [
+        path.win32.join(root, entry.name, "Claude.exe"),
+        path.win32.join(root, entry.name, "claude.exe"),
+      ]);
+  } catch {
+    return [];
+  }
+}
+
+function installedMsixClaude(environment, run = spawnSync) {
+  const script = [
+    "$package = Get-AppxPackage -Name Claude | Sort-Object Version -Descending | Select-Object -First 1",
+    "if ($package) { Join-Path $package.InstallLocation 'app\\Claude.exe' }",
+  ].join("; ");
+  try {
+    const result = run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+      encoding: "utf8",
+      env: environment,
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true,
+    });
+    return result?.status === 0 ? String(result.stdout || "").trim() || null : null;
+  } catch {
+    return null;
+  }
+}
+
+function installedMsixChatGPT(environment, run = spawnSync) {
+  const script = [
+    `$package = Get-AppxPackage -Name '${WINDOWS_CHATGPT_PACKAGE_NAME}' -ErrorAction SilentlyContinue`,
+    `$package = $package | Where-Object PublisherId -eq '${WINDOWS_CHATGPT_PUBLISHER_ID}' | Sort-Object Version -Descending | Select-Object -First 1`,
+    "if ($package) {",
+    "  $manifest = Get-AppxPackageManifest -Package $package",
+    "  $relative = $manifest.Package.Applications.Application | Where-Object Id -eq 'App' | Select-Object -First 1 -ExpandProperty Executable",
+    "  if ($relative) { Join-Path $package.InstallLocation $relative }",
+    "}",
+  ].join("; ");
+  try {
+    const result = run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
+      encoding: "utf8",
+      env: environment,
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true,
+    });
+    return result?.status === 0 ? String(result.stdout || "").trim() || null : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Candidate paths for Anthropic's signed per-user Windows desktop install. */
+export function windowsClaudeAppCandidates(environment = process.env, dependencies = {}) {
+  const io = { readDirectory: fs.readdirSync, ...dependencies };
+  const overridden = environmentValue(environment, "IMPEL_CLAUDE_APP_BIN");
+  const localAppData = environmentValue(environment, "LOCALAPPDATA")
+    || path.win32.join(environmentValue(environment, "USERPROFILE") || os.homedir(), "AppData", "Local");
+  const programFiles = environmentValue(environment, "ProgramFiles");
+  const squirrelRoot = path.win32.join(localAppData, "AnthropicClaude");
+  const candidates = [
+    overridden,
+    path.win32.join(squirrelRoot, "Claude.exe"),
+    path.win32.join(squirrelRoot, "claude.exe"),
+    ...versionedSquirrelCandidates(squirrelRoot, io.readDirectory),
+    path.win32.join(localAppData, "Programs", "Claude", "Claude.exe"),
+    path.win32.join(localAppData, "Programs", "AnthropicClaude", "Claude.exe"),
+    path.win32.join(localAppData, "Claude", "Claude.exe"),
+    programFiles ? path.win32.join(programFiles, "Claude", "Claude.exe") : null,
+  ].filter(Boolean);
+  return [...new Set(candidates.map((candidate) => path.win32.normalize(candidate)))];
+}
+
+export function findWindowsClaudeApp(environment = process.env, dependencies = {}) {
+  const exists = dependencies.isFile || isFile;
+  const unpackaged = windowsClaudeAppCandidates(environment, dependencies).find((candidate) => exists(candidate));
+  if (unpackaged) return unpackaged;
+  const msix = (dependencies.queryMsix || installedMsixClaude)(environment, dependencies.run);
+  return msix && exists(msix) ? path.win32.normalize(msix) : null;
+}
+
+/** Candidate paths for an unpackaged OpenAI ChatGPT/Codex desktop install. */
+export function windowsChatGPTAppCandidates(environment = process.env) {
+  const overridden = environmentValue(environment, "IMPEL_CHATGPT_APP_BIN")
+    || environmentValue(environment, "IMPEL_CODEX_APP_BIN");
+  const localAppData = environmentValue(environment, "LOCALAPPDATA")
+    || path.win32.join(environmentValue(environment, "USERPROFILE") || os.homedir(), "AppData", "Local");
+  const programFiles = environmentValue(environment, "ProgramFiles");
+  const candidates = [
+    overridden,
+    path.win32.join(localAppData, "Programs", "OpenAI", "ChatGPT", "ChatGPT.exe"),
+    path.win32.join(localAppData, "Programs", "OpenAI", "Codex", "ChatGPT.exe"),
+    path.win32.join(localAppData, "Programs", "OpenAI", "Codex", "Codex.exe"),
+    path.win32.join(localAppData, "Programs", "ChatGPT", "ChatGPT.exe"),
+    path.win32.join(localAppData, "Programs", "Codex", "Codex.exe"),
+    programFiles ? path.win32.join(programFiles, "OpenAI", "ChatGPT", "ChatGPT.exe") : null,
+    programFiles ? path.win32.join(programFiles, "OpenAI", "Codex", "Codex.exe") : null,
+  ].filter(Boolean);
+  return [...new Set(candidates.map((candidate) => path.win32.normalize(candidate)))];
+}
+
+export function findWindowsChatGPTApp(environment = process.env, dependencies = {}) {
+  const exists = dependencies.isFile || isFile;
+  const unpackaged = windowsChatGPTAppCandidates(environment).find((candidate) => exists(candidate));
+  if (unpackaged) return unpackaged;
+  const msix = (dependencies.queryMsix || installedMsixChatGPT)(environment, dependencies.run);
+  return msix && exists(msix) ? path.win32.normalize(msix) : null;
+}
+
+function wingetInvocation(action, environment, { packageId, source = "winget", scope = "user" }) {
+  const verb = action === "update" ? "upgrade" : "install";
+  const scopeArgs = scope ? ["--scope", scope] : [];
+  return nativeCommandInvocation(
+    "winget",
+    [
+      verb,
+      "--id",
+      packageId,
+      "--exact",
+      "--source",
+      source,
+      ...scopeArgs,
+      "--silent",
+      "--disable-interactivity",
+      "--accept-package-agreements",
+      "--accept-source-agreements",
+    ],
+    environment,
+    "win32",
+  );
+}
+
+/** Install/update Anthropic's signed per-user app without modifying its files. */
+export function ensureWindowsClaudeApp({ update = false } = {}, dependencies = {}) {
+  const io = {
+    environment: process.env,
+    find: findWindowsClaudeApp,
+    run: spawnSync,
+    ...dependencies,
+  };
+  const before = io.find(io.environment);
+  if (before && !update) return { binary: before, action: "existing", result: null };
+
+  const invocation = wingetInvocation(update ? "update" : "install", io.environment, {
+    packageId: WINDOWS_CLAUDE_PACKAGE,
+  });
+  let result;
+  try {
+    result = io.run(invocation.command, invocation.args, {
+      env: io.environment,
+      stdio: "inherit",
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+    });
+  } catch (error) {
+    result = { status: null, error };
+  }
+  const binary = io.find(io.environment) || before;
+  const succeeded = result?.status === 0 && !result?.error;
+  return {
+    binary,
+    action: succeeded ? (update ? "updated" : "installed") : (before ? "existing" : "install-failed"),
+    result,
+  };
+}
+
+/** Install/update OpenAI's official ChatGPT/Codex Store package. */
+export function ensureWindowsChatGPTApp({ update = false } = {}, dependencies = {}) {
+  const io = {
+    environment: process.env,
+    find: findWindowsChatGPTApp,
+    run: spawnSync,
+    ...dependencies,
+  };
+  const before = io.find(io.environment);
+  if (before && !update) return { binary: before, action: "existing", result: null };
+
+  const invocation = wingetInvocation(update ? "update" : "install", io.environment, {
+    packageId: WINDOWS_CHATGPT_PACKAGE,
+    source: "msstore",
+    scope: null,
+  });
+  let result;
+  try {
+    result = io.run(invocation.command, invocation.args, {
+      env: io.environment,
+      stdio: "inherit",
+      windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+    });
+  } catch (error) {
+    result = { status: null, error };
+  }
+  const binary = io.find(io.environment) || before;
+  const succeeded = result?.status === 0 && !result?.error;
+  return {
+    binary,
+    action: succeeded ? (update ? "updated" : "installed") : (before ? "existing" : "install-failed"),
+    result,
+  };
+}
+
+function windowsChatGPTCacheRoot(appsRoot) {
+  return path.join(appsRoot, "windows-apps", "chatgpt");
+}
+
+export function windowsManagedChatGPTRoot(appsRoot) {
+  return path.join(windowsChatGPTCacheRoot(appsRoot), "current");
+}
+
+export function findManagedWindowsChatGPTApp(appsRoot, dependencies = {}) {
+  const exists = dependencies.isFile || isFile;
+  const root = windowsManagedChatGPTRoot(appsRoot);
+  for (const name of ["ChatGPT.exe", "Codex.exe"]) {
+    const candidate = path.join(root, name);
+    if (exists(candidate)) return candidate;
+  }
+  return null;
+}
+
+export function windowsChatGPTStageIsCurrent(binary, appsRoot) {
+  if (!binary || !findManagedWindowsChatGPTApp(appsRoot)) return false;
+  try {
+    const record = JSON.parse(
+      fs.readFileSync(path.join(windowsChatGPTCacheRoot(appsRoot), "source.json"), "utf8"),
+    );
+    return path.win32.normalize(record.sourceBinary || "").toLowerCase()
+      === path.win32.normalize(binary).toLowerCase();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Copy the signed Electron payload out of WindowsApps into an Impel-owned
+ * location. Windows blocks direct execution from another package's protected
+ * install directory; the copied files remain byte-for-byte vendor files and
+ * can inherit the tenant-scoped environment supplied by the Impel launcher.
+ */
+export function stageWindowsChatGPTApp(binary, appsRoot, dependencies = {}) {
+  const io = {
+    copyDirectory: (source, destination) => fs.cpSync(source, destination, {
+      recursive: true,
+      preserveTimestamps: true,
+    }),
+    remove: (target) => fs.rmSync(target, { recursive: true, force: true }),
+    rename: fs.renameSync,
+    isFile,
+    ...dependencies,
+  };
+  const sourceRoot = path.dirname(binary);
+  const executableName = path.basename(binary);
+  const sourceAsar = path.join(sourceRoot, "resources", "app.asar");
+  const sourceCodex = path.join(sourceRoot, "resources", "codex.exe");
+  if (!io.isFile(binary) || !io.isFile(sourceAsar) || !io.isFile(sourceCodex)) {
+    throw new Error(`unsupported ChatGPT/Codex Windows app layout at ${sourceRoot}`);
+  }
+
+  const cacheRoot = windowsChatGPTCacheRoot(appsRoot);
+  const destination = windowsManagedChatGPTRoot(appsRoot);
+  const staging = `${destination}.tmp-${process.pid}`;
+  const backup = `${destination}.previous-${process.pid}`;
+  io.remove(staging);
+  io.remove(backup);
+  io.copyDirectory(sourceRoot, staging);
+  const stagedBinary = path.join(staging, executableName);
+  if (!io.isFile(stagedBinary)
+    || !io.isFile(path.join(staging, "resources", "app.asar"))
+    || !io.isFile(path.join(staging, "resources", "codex.exe"))) {
+    io.remove(staging);
+    throw new Error("the staged ChatGPT/Codex Windows app is incomplete");
+  }
+
+  fs.mkdirSync(path.dirname(destination), { recursive: true, mode: 0o700 });
+  if (fs.existsSync(destination)) io.rename(destination, backup);
+  try {
+    io.rename(staging, destination);
+    fs.writeFileSync(path.join(cacheRoot, "source.json"), `${JSON.stringify({
+      schemaVersion: 1,
+      sourceBinary: path.win32.normalize(binary),
+      stagedAt: new Date().toISOString(),
+    }, null, 2)}\n`, { mode: 0o600 });
+    io.remove(backup);
+  } catch (error) {
+    if (fs.existsSync(backup)) {
+      io.remove(destination);
+      io.rename(backup, destination);
+    }
+    io.remove(staging);
+    throw error;
+  }
+  return path.join(destination, executableName);
+}
+
+export function removeManagedWindowsChatGPTApp(appsRoot) {
+  fs.rmSync(windowsChatGPTCacheRoot(appsRoot), { recursive: true, force: true });
+}
+
+/** Launch the signed vendor app with only its profile root redirected to Impel. */
+export function launchWindowsClaudeApp(binary, userData, dependencies = {}) {
+  const io = {
+    environment: process.env,
+    makeDirectory: fs.mkdirSync,
+    spawnProcess: spawn,
+    ...dependencies,
+  };
+  io.makeDirectory(userData, { recursive: true, mode: 0o700 });
+  const environment = { ...io.environment };
+  // These developer-only overrides require a signed CDP token and must never
+  // bleed from an unrelated native Claude session into the managed app.
+  const managedKeys = new Set(["CLAUDE_USER_DATA_DIR", "CLAUDE_CDP_AUTH", "CLAUDE_AI_URL"]);
+  for (const key of Object.keys(environment)) {
+    if (managedKeys.has(key.toUpperCase())) delete environment[key];
+  }
+  environment.CLAUDE_USER_DATA_DIR = userData;
+
+  return new Promise((resolve, reject) => {
+    const child = io.spawnProcess(binary, [], {
+      detached: true,
+      env: environment,
+      stdio: "ignore",
+      windowsHide: false,
+    });
+    child.once("error", reject);
+    child.once("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
+}
+
+/** Launch the staged OpenAI app with isolated Codex and Electron state. */
+export function launchWindowsChatGPTApp(binary, {
+  browserData,
+  codexHome,
+  credential,
+  gatewayUrl,
+}, dependencies = {}) {
+  const io = {
+    environment: process.env,
+    makeDirectory: fs.mkdirSync,
+    run: spawnSync,
+    spawnProcess: spawn,
+    ...dependencies,
+  };
+  io.makeDirectory(codexHome, { recursive: true, mode: 0o700 });
+  io.makeDirectory(browserData, { recursive: true, mode: 0o700 });
+  const environment = { ...io.environment };
+  const managedKeys = new Set([
+    "CODEX_ACCESS_TOKEN",
+    "CODEX_API_KEY",
+    "CODEX_AUTHAPI_BASE_URL",
+    "CODEX_ELECTRON_USER_DATA_PATH",
+    "CODEX_HOME",
+    "OPENAI_API_KEY",
+    "OPENAI_BASE_URL",
+  ]);
+  for (const key of Object.keys(environment)) {
+    if (managedKeys.has(key.toUpperCase())) delete environment[key];
+  }
+  environment.CODEX_HOME = codexHome;
+  environment.CODEX_AUTHAPI_BASE_URL = `${gatewayUrl}/chatgpt_passthrough/backend-api`;
+  // Codex Desktop resolves this before acquiring Electron's single-instance
+  // lock. Keep --user-data-dir below as a compatibility fallback for builds
+  // that predate the dedicated desktop override.
+  environment.CODEX_ELECTRON_USER_DATA_PATH = browserData;
+
+  const appRoot = path.win32.dirname(binary);
+  const codex = path.win32.join(appRoot, "resources", "codex.exe");
+  io.run(codex, ["features", "disable", "shell_snapshot"], {
+    env: environment,
+    stdio: "ignore",
+    windowsHide: true,
+  });
+  const login = io.run(codex, ["login", "--with-access-token"], {
+    encoding: "utf8",
+    env: environment,
+    input: `at-${credential}\n`,
+    stdio: ["pipe", "ignore", "pipe"],
+    windowsHide: true,
+  });
+  if (login?.error || login?.status !== 0) {
+    const failure = login?.error?.message || (Number.isInteger(login?.status)
+      ? `exit code ${login.status}`
+      : "no exit status");
+    throw new Error(`ChatGPT/Codex login helper failed (${failure})`);
+  }
+
+  return new Promise((resolve, reject) => {
+    const child = io.spawnProcess(binary, [
+      `--user-data-dir=${browserData}`,
+      path.win32.join("resources", "app.asar"),
+    ], {
+      cwd: appRoot,
+      detached: true,
+      env: environment,
+      stdio: "ignore",
+      windowsHide: false,
+    });
+    child.once("error", reject);
+    child.once("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
+}

package/src/windowsSetup.js

@@ -0,0 +1,122 @@
+import { spawnSync } from "node:child_process";
+
+import { ensureImpelClaudeProfile, ensureImpelCodexProfile } from "./cliProfiles.js";
+import { findNativeBinary, nativeCommandInvocation } from "./nativeProcess.js";
+import { syncSkillsSafe } from "./skills.js";
+
+export const WINDOWS_CLI_PACKAGES = {
+  claude: "@anthropic-ai/claude-code@latest",
+  codex: "@openai/codex@latest",
+};
+
+export function windowsCliInstallCommand(tools = Object.keys(WINDOWS_CLI_PACKAGES)) {
+  return `npm install --global ${tools.map((tool) => WINDOWS_CLI_PACKAGES[tool]).join(" ")}`;
+}
+
+function detectWindowsClis(find, environment) {
+  return {
+    claude: find("claude", environment, "win32"),
+    codex: find("codex", environment, "win32"),
+  };
+}
+
+function installMissingClis(missing, { environment, run }) {
+  const invocation = nativeCommandInvocation(
+    "npm",
+    ["install", "--global", ...missing.map((tool) => WINDOWS_CLI_PACKAGES[tool])],
+    environment,
+    "win32",
+  );
+  return run(invocation.command, invocation.args, {
+    env: environment,
+    stdio: "inherit",
+    windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+  });
+}
+
+function installationFailure(result, thrown = null) {
+  const error = thrown || result?.error;
+  if (error) {
+    return {
+      code: error.code || null,
+      message: error.message || String(error),
+      status: null,
+      signal: null,
+    };
+  }
+  return {
+    code: null,
+    message: null,
+    status: Number.isInteger(result?.status) ? result.status : null,
+    signal: result?.signal || null,
+  };
+}
+
+/**
+ * Make `impel setup` self-contained on Windows: install only missing official
+ * vendor CLIs, create the same tenant-isolated profiles used at launch time,
+ * and sync the shared Impel skill bundle into each available client.
+ */
+export async function prepareWindowsClis({ gatewayUrl, tenantId, skipInstall = false } = {}, dependencies = {}) {
+  const io = {
+    environment: process.env,
+    find: findNativeBinary,
+    run: spawnSync,
+    ensureClaudeProfile: ensureImpelClaudeProfile,
+    ensureCodexProfile: ensureImpelCodexProfile,
+    syncSkills: syncSkillsSafe,
+    ...dependencies,
+  };
+
+  const before = detectWindowsClis(io.find, io.environment);
+  const missingBefore = Object.entries(before)
+    .filter(([, binary]) => !binary)
+    .map(([tool]) => tool);
+  let installAttempted = false;
+  let installSucceeded = null;
+  let installFailure = null;
+
+  if (missingBefore.length > 0 && !skipInstall) {
+    installAttempted = true;
+    try {
+      const result = installMissingClis(missingBefore, io);
+      installSucceeded = result?.status === 0 && !result?.error;
+      if (!installSucceeded) installFailure = installationFailure(result);
+    } catch (error) {
+      installSucceeded = false;
+      installFailure = installationFailure(null, error);
+    }
+  }
+
+  const binaries = installAttempted ? detectWindowsClis(io.find, io.environment) : before;
+  const claudeProfile = io.ensureClaudeProfile(gatewayUrl, tenantId);
+  const codexProfile = io.ensureCodexProfile(gatewayUrl, tenantId);
+
+  if (binaries.claude) {
+    await io.syncSkills({
+      client: "claude",
+      gatewayUrl,
+      env: { CLAUDE_CONFIG_DIR: claudeProfile.configDir },
+      label: "Impel isolated Claude (impel claude)",
+    });
+  }
+  if (binaries.codex) {
+    await io.syncSkills({
+      client: "codex",
+      gatewayUrl,
+      env: { CODEX_HOME: codexProfile.codexHome },
+      label: "Impel isolated Codex (impel codex)",
+    });
+  }
+
+  return {
+    binaries,
+    missingBefore,
+    missingAfter: Object.entries(binaries).filter(([, binary]) => !binary).map(([tool]) => tool),
+    installAttempted,
+    installSucceeded,
+    installFailure,
+    installCommand: windowsCliInstallCommand(missingBefore),
+    profiles: { claude: claudeProfile.configDir, codex: codexProfile.codexHome },
+  };
+}