impel-cli 0.15.3 → 0.16.1

package/src/installRecovery/actions.js

@@ -1,440 +0,0 @@
-import { spawnSync } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-
-import {
-  environmentValue,
-  findNativeBinary,
-  nativeCommandInvocation,
-  nativeSpawnInvocation,
-} from "../nativeProcess.js";
-import { redactInstallRecoveryText } from "./redact.js";
-
-export const INSTALL_RECOVERY_ACTION_IDS = Object.freeze([
-  "inspect.runtime",
-  "inspect.process_lock",
-  "verify.cli",
-  "verify.gateway",
-  "install.vendor_cli",
-  "install.vendor_app",
-  "repair.user_path",
-  "repair.impel_profile",
-  "cleanup.impel_staging",
-  "retry.step",
-]);
-
-const ACTIONS = Object.freeze({
-  "inspect.runtime": { mutates: false },
-  "inspect.process_lock": { mutates: false },
-  "verify.cli": { mutates: false },
-  "verify.gateway": { mutates: false },
-  "install.vendor_cli": { mutates: true },
-  "install.vendor_app": { mutates: true },
-  "repair.user_path": { mutates: true },
-  "repair.impel_profile": { mutates: true },
-  "cleanup.impel_staging": { mutates: true },
-  "retry.step": { mutates: true },
-});
-
-const ACTION_KEYS = new Set([
-  "id",
-  "reason",
-  "parameters",
-  "requiresConfirmation",
-]);
-const PARAMETER_KEYS = new Set(["tool", "step", "path", "target"]);
-
-function exactKeys(value, allowed) {
-  return Object.keys(value).every((key) => allowed.has(key));
-}
-
-export function validateInstallRecoveryAction(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  if (!exactKeys(value, ACTION_KEYS)) return null;
-  if (!INSTALL_RECOVERY_ACTION_IDS.includes(value.id)) return null;
-  if (typeof value.reason !== "string" || value.reason.length > 2_000) return null;
-  if (typeof value.requiresConfirmation !== "boolean") return null;
-  const parameters = value.parameters;
-  if (!parameters || typeof parameters !== "object" || Array.isArray(parameters)) {
-    return null;
-  }
-  if (!exactKeys(parameters, PARAMETER_KEYS)) return null;
-  for (const key of PARAMETER_KEYS) {
-    if (!(key in parameters)) return null;
-    if (parameters[key] !== null && typeof parameters[key] !== "string") return null;
-    if (typeof parameters[key] === "string" && parameters[key].length > 512) return null;
-  }
-  if (parameters.tool !== null && !["claude", "codex"].includes(parameters.tool)) {
-    return null;
-  }
-  if (ACTIONS[value.id].mutates && value.requiresConfirmation !== true) return null;
-  return {
-    id: value.id,
-    reason: value.reason,
-    parameters: {
-      tool: parameters.tool,
-      step: parameters.step,
-      path: parameters.path,
-      target: parameters.target,
-    },
-    requiresConfirmation: value.requiresConfirmation,
-  };
-}
-
-export function installRecoveryActionMutates(actionId) {
-  return ACTIONS[actionId]?.mutates === true;
-}
-
-function actionResult(outcome, summary, details = {}) {
-  return {
-    outcome,
-    summary: redactInstallRecoveryText(summary).slice(0, 2_000),
-    exitCode: Number.isInteger(details.exitCode) ? details.exitCode : null,
-    ...(details.stdout
-      ? { stdout: redactInstallRecoveryText(details.stdout).slice(0, 8_000) }
-      : {}),
-    ...(details.stderr
-      ? { stderr: redactInstallRecoveryText(details.stderr).slice(0, 8_000) }
-      : {}),
-  };
-}
-
-function inspectRuntime(context) {
-  return actionResult("succeeded", "Collected bounded runtime metadata.", {
-    stdout: JSON.stringify({
-      platform: context.platform,
-      architecture: process.arch,
-      nodeVersion: process.version,
-      pathEntries: String(environmentValue(context.environment, "PATH") || "")
-        .split(context.platform === "win32" ? ";" : path.delimiter)
-        .filter(Boolean).length,
-      tty: Boolean(context.isTTY),
-    }),
-  });
-}
-
-function inspectProcessLock(context, dependencies) {
-  const invocation = context.platform === "win32"
-    ? { command: "tasklist.exe", args: ["/fo", "csv", "/nh"] }
-    : { command: "ps", args: ["-Ao", "comm="] };
-  const result = dependencies.spawnSync(invocation.command, invocation.args, {
-    encoding: "utf8",
-    env: context.environment,
-    stdio: ["ignore", "pipe", "pipe"],
-    timeout: 10_000,
-    windowsHide: true,
-  });
-  if (result?.error || result?.status !== 0) {
-    return actionResult("failed", "Could not inspect running installer processes.", {
-      exitCode: result?.status,
-      stderr: result?.error?.message || result?.stderr,
-    });
-  }
-  const relevant = String(result.stdout || "")
-    .split(/\r?\n/gu)
-    .filter((line) => /claude|chatgpt|codex|impel|node|npm|powershell/iu.test(line))
-    .slice(0, 40)
-    .join("\n");
-  return actionResult(
-    "succeeded",
-    relevant
-      ? "Found potentially relevant running processes."
-      : "No relevant running process was found.",
-    { stdout: relevant || "none" }
-  );
-}
-
-function verifyCli(action, context, dependencies) {
-  const tool = action.parameters.tool;
-  if (!tool) return actionResult("failed", "verify.cli requires a tool parameter.");
-  const binary = dependencies.findNativeBinary(
-    tool,
-    context.environment,
-    context.platform
-  );
-  if (!binary) return actionResult("failed", `${tool} is not installed or discoverable.`);
-  const invocation = nativeSpawnInvocation(
-    binary,
-    ["--version"],
-    context.environment,
-    context.platform
-  );
-  const result = dependencies.spawnSync(invocation.command, invocation.args, {
-    encoding: "utf8",
-    env: context.environment,
-    stdio: ["ignore", "pipe", "pipe"],
-    timeout: 15_000,
-    windowsHide: true,
-    windowsVerbatimArguments: invocation.windowsVerbatimArguments,
-  });
-  return result?.status === 0 && !result?.error
-    ? actionResult("succeeded", `${tool} passed its bounded version check.`, {
-        stdout: String(result.stdout || "").trim(),
-      })
-    : actionResult("failed", `${tool} failed its bounded version check.`, {
-        exitCode: result?.status,
-        stderr: result?.error?.message || result?.stderr,
-      });
-}
-
-async function verifyGateway(context) {
-  if (typeof context.probeGateway !== "function") {
-    return actionResult("failed", "Gateway verification is unavailable in this recovery context.");
-  }
-  const result = await context.probeGateway();
-  return result?.reachable && !result?.rejected
-    ? actionResult("succeeded", `Gateway responded with HTTP ${result.status}.`)
-    : actionResult(
-        "failed",
-        result?.rejected
-          ? `Gateway rejected the credential with HTTP ${result.status}.`
-          : `Gateway could not be reached: ${result?.error || "unknown error"}.`
-      );
-}
-
-async function installVendorCli(action, context) {
-  if (context.platform !== "win32" || typeof context.installVendorClis !== "function") {
-    return actionResult("failed", "Automated vendor CLI installation is unavailable on this platform.");
-  }
-  const tool = action.parameters.tool;
-  if (!tool) return actionResult("failed", "install.vendor_cli requires a tool parameter.");
-  const result = await context.installVendorClis(tool);
-  return result?.binaries?.[tool]
-    ? actionResult("succeeded", `${tool} installed and passed verification.`)
-    : actionResult("failed", `${tool} installation did not reach a verified state.`);
-}
-
-async function installVendorApp(action, context) {
-  if (typeof context.installVendorApp !== "function") {
-    return actionResult("failed", "Vendor app installation is unavailable in this recovery context.");
-  }
-  const target = action.parameters.target;
-  if (!target || !["claude", "codex", "all"].includes(target)) {
-    return actionResult("failed", "install.vendor_app requires claude, codex, or all.");
-  }
-  const installed = await context.installVendorApp(target);
-  return installed === false
-    ? actionResult("failed", `The ${target} vendor app did not install cleanly.`)
-    : actionResult("succeeded", `The ${target} vendor app installation completed.`);
-}
-
-function addWindowsUserPath(action, context, dependencies) {
-  if (context.platform !== "win32") {
-    return actionResult("failed", "User PATH repair is currently available only on Windows.");
-  }
-  const tool = action.parameters.tool;
-  if (!tool) return actionResult("failed", "repair.user_path requires a tool parameter.");
-  const binary = dependencies.findNativeBinary(
-    tool,
-    context.environment,
-    context.platform
-  );
-  if (!binary || !path.win32.isAbsolute(binary)) {
-    return actionResult("failed", `${tool} has no trusted absolute install path to add.`);
-  }
-  const verification = nativeSpawnInvocation(
-    binary,
-    ["--version"],
-    context.environment,
-    "win32"
-  );
-  const verified = dependencies.spawnSync(
-    verification.command,
-    verification.args,
-    {
-      encoding: "utf8",
-      env: context.environment,
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: 15_000,
-      windowsHide: true,
-      windowsVerbatimArguments: verification.windowsVerbatimArguments,
-    }
-  );
-  if (verified?.status !== 0 || verified?.error) {
-    return actionResult(
-      "failed",
-      `${tool}'s discovered install path did not pass its bounded version check.`,
-      {
-        exitCode: verified?.status,
-        stderr: verified?.error?.message || verified?.stderr,
-      }
-    );
-  }
-  const directory = path.win32.dirname(binary);
-  const currentPath = String(environmentValue(context.environment, "PATH") || "");
-  const entries = currentPath.split(";").filter(Boolean);
-  if (!entries.some((entry) => entry.toLowerCase() === directory.toLowerCase())) {
-    context.environment.PATH = [directory, currentPath].filter(Boolean).join(";");
-  }
-  const powershell = nativeCommandInvocation(
-    "powershell",
-    [
-      "-NoLogo",
-      "-NoProfile",
-      "-NonInteractive",
-      "-ExecutionPolicy",
-      "Bypass",
-      "-Command",
-      "$d=$env:IMPEL_RECOVERY_PATH; $p=[Environment]::GetEnvironmentVariable('Path','User'); $a=@($p -split ';' | Where-Object { $_ }); if (-not ($a | Where-Object { $_ -ieq $d })) { [Environment]::SetEnvironmentVariable('Path',(($a + $d) -join ';'),'User') }",
-    ],
-    context.environment,
-    "win32"
-  );
-  const result = dependencies.spawnSync(powershell.command, powershell.args, {
-    encoding: "utf8",
-    env: { ...context.environment, IMPEL_RECOVERY_PATH: directory },
-    stdio: ["ignore", "pipe", "pipe"],
-    timeout: 15_000,
-    windowsHide: true,
-    windowsVerbatimArguments: powershell.windowsVerbatimArguments,
-  });
-  return result?.status === 0 && !result?.error
-    ? actionResult("succeeded", `${tool}'s trusted install directory was added to the user PATH.`)
-    : actionResult("failed", `Could not add ${tool}'s install directory to the user PATH.`, {
-        exitCode: result?.status,
-        stderr: result?.error?.message || result?.stderr,
-      });
-}
-
-async function repairProfile(context) {
-  if (typeof context.repairProfiles !== "function") {
-    return actionResult("failed", "Impel profile repair is unavailable in this recovery context.");
-  }
-  const result = await context.repairProfiles();
-  return result === false
-    ? actionResult("failed", "The Impel profile could not be repaired.")
-    : actionResult("succeeded", "The Impel-managed profile was regenerated.");
-}
-
-function managedStagingPath(candidate, roots) {
-  const resolved = path.resolve(candidate);
-  return roots.some((root) => {
-    const managedRoot = `${path.resolve(root)}${path.sep}`;
-    return (
-      resolved.startsWith(managedRoot) &&
-      /\.tmp-\d+$/u.test(path.basename(resolved))
-    );
-  });
-}
-
-function cleanupStaging(context, dependencies) {
-  const roots = context.managedRoots || [];
-  const candidates = context.stagingPaths || [];
-  const removable = candidates.filter((candidate) =>
-    managedStagingPath(candidate, roots)
-  );
-  for (const candidate of removable) {
-    dependencies.rmSync(candidate, { recursive: true, force: true });
-  }
-  return actionResult(
-    "succeeded",
-    removable.length
-      ? `Removed ${removable.length} stale Impel-owned staging path(s).`
-      : "No validated stale Impel staging path was present."
-  );
-}
-
-async function retryStep(action, context) {
-  if (typeof context.retryStep !== "function") {
-    return actionResult("failed", "The failed setup step cannot be retried in this process.");
-  }
-  const result = await context.retryStep(action.parameters.step);
-  return result === false
-    ? actionResult("failed", "The setup step failed again.")
-    : actionResult("succeeded", "The setup step completed on retry.");
-}
-
-export async function executeInstallRecoveryAction(
-  rawAction,
-  context = {},
-  dependencies = {}
-) {
-  const action = validateInstallRecoveryAction(rawAction);
-  if (!action) {
-    return actionResult("failed", "Refused an unknown or malformed recovery action.");
-  }
-  if (installRecoveryActionMutates(action.id) && context.confirmed !== true) {
-    return actionResult("declined", "The local mutation was not confirmed.");
-  }
-  const resolvedContext = {
-    platform: process.platform,
-    environment: process.env,
-    isTTY: process.stdin.isTTY,
-    ...context,
-  };
-  const io = {
-    spawnSync,
-    findNativeBinary,
-    rmSync: fs.rmSync,
-    ...dependencies,
-  };
-  switch (action.id) {
-    case "inspect.runtime":
-      return inspectRuntime(resolvedContext);
-    case "inspect.process_lock":
-      return inspectProcessLock(resolvedContext, io);
-    case "verify.cli":
-      return verifyCli(action, resolvedContext, io);
-    case "verify.gateway":
-      return verifyGateway(resolvedContext);
-    case "install.vendor_cli":
-      return installVendorCli(action, resolvedContext);
-    case "install.vendor_app":
-      return installVendorApp(action, resolvedContext);
-    case "repair.user_path":
-      return addWindowsUserPath(action, resolvedContext, io);
-    case "repair.impel_profile":
-      return repairProfile(resolvedContext);
-    case "cleanup.impel_staging":
-      return cleanupStaging(resolvedContext, io);
-    case "retry.step":
-      return retryStep(action, resolvedContext);
-    default:
-      return actionResult("failed", "Refused an unregistered recovery action.");
-  }
-}
-
-export function deterministicInstallRecoveryAction(failure) {
-  const text = `${failure.step} ${failure.errorCode || ""} ${failure.message}`.toLowerCase();
-  if (/profile|config\.toml|settings\.json/u.test(text)) {
-    return {
-      id: "repair.impel_profile",
-      reason: "Regenerate only Impel-managed profile files.",
-      parameters: { tool: null, step: failure.step, path: null, target: null },
-      requiresConfirmation: true,
-    };
-  }
-  if (/staging|\.tmp-|incomplete app/u.test(text)) {
-    return {
-      id: "cleanup.impel_staging",
-      reason: "Remove only validated stale Impel staging paths.",
-      parameters: { tool: null, step: failure.step, path: null, target: null },
-      requiresConfirmation: true,
-    };
-  }
-  if (/installer completed.*not.*verif|not discoverable|stale path/u.test(text)) {
-    const tool = /claude/u.test(text) ? "claude" : /codex/u.test(text) ? "codex" : null;
-    if (tool) {
-      return {
-        id: "repair.user_path",
-        reason: "Add the discovered trusted vendor install directory to the user PATH.",
-        parameters: { tool, step: failure.step, path: null, target: null },
-        requiresConfirmation: true,
-      };
-    }
-  }
-  if (/busy|eperm|ebusy|process|running/u.test(text)) {
-    return {
-      id: "inspect.process_lock",
-      reason: "Inspect bounded process names for an installer lock.",
-      parameters: { tool: null, step: failure.step, path: null, target: null },
-      requiresConfirmation: false,
-    };
-  }
-  return {
-    id: "inspect.runtime",
-    reason: "Collect bounded local runtime metadata before asking for help.",
-    parameters: { tool: null, step: failure.step, path: null, target: null },
-    requiresConfirmation: false,
-  };
-}

package/src/installRecovery/client.js

@@ -1,84 +0,0 @@
-import { normalizeGatewayUrl, redactSecretText } from "../config.js";
-
-const REQUEST_TIMEOUT_MS = 30_000;
-
-async function requestJson(url, options, fetchImpl = fetch) {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
-  try {
-    const response = await fetchImpl(url, {
-      ...options,
-      headers: {
-        accept: "application/json",
-        "content-type": "application/json",
-        ...(options.headers || {}),
-      },
-      signal: controller.signal,
-    });
-    const body = await response.json().catch(() => ({}));
-    if (!response.ok) {
-      const message = body?.error || `HTTP ${response.status}`;
-      const error = new Error(redactSecretText(message));
-      error.status = response.status;
-      error.code = body?.code;
-      throw error;
-    }
-    return body;
-  } catch (error) {
-    if (error?.name === "AbortError") {
-      throw new Error("install recovery request timed out after 30s");
-    }
-    throw error;
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-export function createInstallRecoveryClient({ appUrl, fetchImpl = fetch }) {
-  const baseUrl = `${normalizeGatewayUrl(appUrl)}/api/cli/install-recovery/sessions`;
-  return {
-    create(pat, input) {
-      return requestJson(
-        baseUrl,
-        {
-          method: "POST",
-          headers: { authorization: `Bearer ${pat}` },
-          body: JSON.stringify(input),
-        },
-        fetchImpl
-      );
-    },
-    read(sessionId, recoveryToken) {
-      return requestJson(
-        `${baseUrl}/${encodeURIComponent(sessionId)}`,
-        {
-          method: "GET",
-          headers: { authorization: `Bearer ${recoveryToken}` },
-        },
-        fetchImpl
-      );
-    },
-    submitResult(sessionId, recoveryToken, result) {
-      return requestJson(
-        `${baseUrl}/${encodeURIComponent(sessionId)}/results`,
-        {
-          method: "POST",
-          headers: { authorization: `Bearer ${recoveryToken}` },
-          body: JSON.stringify(result),
-        },
-        fetchImpl
-      );
-    },
-    complete(sessionId, recoveryToken, result) {
-      return requestJson(
-        `${baseUrl}/${encodeURIComponent(sessionId)}/complete`,
-        {
-          method: "POST",
-          headers: { authorization: `Bearer ${recoveryToken}` },
-          body: JSON.stringify(result),
-        },
-        fetchImpl
-      );
-    },
-  };
-}