impel-cli 0.7.0

package/src/commands/setup.js

@@ -0,0 +1,350 @@
+// `impel setup` — end-to-end onboarding: token → tenant → platform clients →
+// verify. macOS installs the isolated desktop apps; Windows ensures the two
+// official vendor CLIs exist and prepares isolated CLI + desktop app profiles.
+// Native Claude Code/Codex profiles are never touched.
+
+import { parseFlags } from "../args.js";
+import {
+  loadConfig,
+  saveConfig,
+  normalizeGatewayUrl,
+  resolveDefaultGateway,
+  resolveDefaultAppUrl,
+  maskSecret,
+  redactSecretText,
+} from "../config.js";
+import { promptSecret, promptText } from "../prompt.js";
+import { fetchTenants, normalizeTenantId, tenantCredential } from "../tenants.js";
+import { cmdApps } from "./apps.js";
+import { prepareWindowsClis, windowsCliInstallCommand } from "../windowsSetup.js";
+
+const HELP = `impel setup - guided end-to-end gateway setup
+
+Runs the whole onboarding in one command: store your Personal Access Token,
+pick your organization, prepare the Impel clients for this platform, and verify
+the gateway. On macOS this installs isolated desktop apps. On Windows it
+installs any missing official Claude Code/Codex packages, prepares the
+tenant-isolated CLI profiles, and installs isolated desktop app profiles.
+Native client profiles stay untouched and the vendor executables stay signed
+and unmodified.
+
+Usage:
+  impel setup                       Interactive wizard
+  impel setup --pat <pat>           Non-interactive; add --tenant to skip the picker
+  impel setup --tenant <org>        Preselect the organization
+  impel setup --skip-apps           Skip the desktop-app installation step
+  impel setup --skip-clis           On Windows, don't install missing vendor CLIs
+`;
+
+/**
+ * Pick the tenant for the wizard. Pure so it's testable: returns the tenant
+ * for an explicit request (or throws if unavailable), auto-selects a sole
+ * tenant, and otherwise resolves an interactive answer (number, id, slug, or
+ * empty = default).
+ */
+export function resolveTenantChoice(listing, { requested = null, answer = null, currentTenantId = null } = {}) {
+  const byToken = (token) => {
+    const normalized = normalizeTenantId(token);
+    return listing.tenants.find((tenant) => tenant.id === normalized || tenant.slug === normalized) || null;
+  };
+
+  if (requested) {
+    const tenant = byToken(requested);
+    if (!tenant) throw new Error(`tenant "${requested}" is not available to this user`);
+    return tenant;
+  }
+  if (listing.tenants.length === 1) return listing.tenants[0];
+
+  const fallbackId = listing.tenants.some((tenant) => tenant.id === currentTenantId)
+    ? currentTenantId
+    : listing.defaultTenantId;
+  if (answer === null || answer === "") {
+    return listing.tenants.find((tenant) => tenant.id === fallbackId) || listing.tenants[0];
+  }
+  const index = /^\d+$/.test(answer) ? Number(answer) : NaN;
+  if (Number.isInteger(index) && index >= 1 && index <= listing.tenants.length) {
+    return listing.tenants[index - 1];
+  }
+  const tenant = byToken(answer);
+  if (!tenant) throw new Error(`tenant "${answer}" is not available to this user`);
+  return tenant;
+}
+
+/** Best-effort gateway probe; any HTTP response means the gateway is routing. */
+async function probeGateway(gatewayUrl, pat, tenantId, fetchImpl = fetch) {
+  const url = `${gatewayUrl}/anthropic/v1/messages`;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 5000);
+  try {
+    const res = await fetchImpl(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...(pat && tenantId ? { authorization: `Bearer ${tenantCredential(pat, tenantId)}` } : {}),
+      },
+      body: "{}",
+      signal: controller.signal,
+    });
+    return { reachable: true, status: res.status, rejected: res.status === 401 || res.status === 403 };
+  } catch (err) {
+    return {
+      reachable: false,
+      error: err?.name === "AbortError" ? "timed out after 5s" : redactSecretText(err?.message || err),
+    };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export async function cmdSetup(argv, overrides = {}) {
+  const io = {
+    promptSecret,
+    promptText,
+    fetchTenants,
+    installApps: cmdApps,
+    prepareWindowsClis,
+    probe: probeGateway,
+    isTTY: process.stdin.isTTY,
+    platform: process.platform,
+    ...overrides,
+  };
+  const { flags, positionals } = parseFlags(argv, {
+    pat: { type: "string" },
+    tenant: { type: "string" },
+    gateway: { type: "string" },
+    app: { type: "string" },
+    "skip-apps": { type: "boolean" },
+    "skip-clis": { type: "boolean" },
+    help: { type: "boolean" },
+  });
+  if (flags.help) {
+    console.log(HELP);
+    return;
+  }
+  if (positionals.length > 0) {
+    console.error(
+      `impel setup: no longer takes a target ("${positionals[0]}"). Run bare \`impel setup\` — it installs the vendored Impel apps. To flip a native tool, use \`impel use gateway [claude|codex]\`.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  const existing = loadConfig();
+  const gatewayUrl = normalizeGatewayUrl(flags.gateway || existing?.gatewayUrl || resolveDefaultGateway());
+  const appUrl = normalizeGatewayUrl(flags.app || existing?.appUrl || resolveDefaultAppUrl());
+
+  console.log("Impel gateway setup");
+  console.log(`  gateway: ${gatewayUrl}`);
+  console.log(`  app:     ${appUrl}`);
+  console.log("");
+
+  // ── Step 1: token ────────────────────────────────────────────────────────
+  let pat = flags.pat;
+  if (!pat && existing?.pat) {
+    if (io.isTTY) {
+      const entered = await io.promptSecret(
+        `1/4 Token — one is already stored (${maskSecret(existing.pat)}). Press Enter to keep it, or paste a new one: `
+      );
+      pat = entered || existing.pat;
+    } else {
+      pat = existing.pat;
+    }
+  } else if (!pat) {
+    if (!io.isTTY) {
+      console.error("impel setup: no token stored and stdin is not a TTY; pass --pat <impel_pat_...>.");
+      process.exitCode = 1;
+      return;
+    }
+    console.log(`1/4 Token — create one at ${appUrl}/settings/gateway (step 3 on that page mints it).`);
+    pat = await io.promptSecret("    Paste your Personal Access Token (impel_pat_...): ");
+  }
+  if (!pat) {
+    console.error("impel setup: no token provided, aborting.");
+    process.exitCode = 1;
+    return;
+  }
+  if (!pat.startsWith("impel_pat_")) {
+    console.warn(
+      `impel: warning: that token doesn't start with "impel_pat_" — double check you copied the right value.`
+    );
+  }
+
+  const config = { ...(existing || {}), pat, gatewayUrl, appUrl, updatedAt: new Date().toISOString() };
+  saveConfig(config);
+  console.log(`    ✓ stored in ~/.config/impel/config.json (mode 0600)`);
+  console.log("");
+
+  // ── Step 2: organization ─────────────────────────────────────────────────
+  // A successful tenant fetch also proves the token: the app verifies it
+  // against impel-identity before answering.
+  let listing;
+  try {
+    listing = await io.fetchTenants(config);
+  } catch (error) {
+    console.error(`impel setup: could not verify the token (${redactSecretText(error?.message || error)})`);
+    console.error("  Check the token and your network, then re-run `impel setup`.");
+    process.exitCode = 1;
+    return;
+  }
+
+  let tenant;
+  try {
+    if (flags.tenant || listing.tenants.length === 1 || !io.isTTY) {
+      tenant = resolveTenantChoice(listing, {
+        requested: flags.tenant || null,
+        currentTenantId: existing?.tenantId || null,
+      });
+    } else {
+      console.log("2/4 Organization");
+      listing.tenants.forEach((candidate, index) => {
+        const markers = [
+          candidate.id === existing?.tenantId ? "current" : null,
+          candidate.id === listing.defaultTenantId ? "default" : null,
+        ].filter(Boolean);
+        console.log(`    [${index + 1}] ${candidate.id}${markers.length ? ` (${markers.join(", ")})` : ""}\t${candidate.name}`);
+      });
+      const fallback = resolveTenantChoice(listing, { currentTenantId: existing?.tenantId || null });
+      const answer = await io.promptText(`    Select [1-${listing.tenants.length}] (Enter for ${fallback.id}): `);
+      tenant = resolveTenantChoice(listing, { answer, currentTenantId: existing?.tenantId || null });
+    }
+  } catch (error) {
+    console.error(`impel setup: ${redactSecretText(error?.message || error)}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  config.tenantId = tenant.id;
+  if (listing.productAccess) config.productAccess = listing.productAccess;
+  else delete config.productAccess;
+  if (listing.scopes) config.scopes = listing.scopes;
+  else delete config.scopes;
+  config.tenantsUpdatedAt = new Date().toISOString();
+  saveConfig(config);
+  console.log(`    ✓ tenant: ${tenant.id} (${tenant.name})`);
+  console.log("");
+
+  // ── Step 3: apps ─────────────────────────────────────────────────────────
+  // Order inside `impel app install`: close running Claude/ChatGPT apps (a
+  // running app makes the install fail), bring the vendor apps to the latest
+  // version, then build the vendored Impel bundles from that fresh copy.
+  // Native Claude Code and Codex profiles are never touched.
+  let platformSetupFailed = false;
+  if (io.platform === "win32") {
+    console.log(
+      flags["skip-clis"]
+        ? "3/4 Windows CLIs: preparing isolated profiles (vendor CLI installation skipped)…"
+        : "3/4 Windows CLIs: ensuring Claude Code and Codex are installed, then preparing isolated profiles…"
+    );
+    try {
+      const result = await io.prepareWindowsClis({
+        gatewayUrl,
+        tenantId: tenant.id,
+        skipInstall: Boolean(flags["skip-clis"]),
+      });
+      for (const [tool, label] of [["claude", "Claude Code"], ["codex", "Codex"]]) {
+        const binary = result.binaries[tool];
+        if (binary) console.log(`    ✓ ${label}: ${redactSecretText(binary)}`);
+        else console.log(`    ✗ ${label}: not found`);
+      }
+      if (result.missingAfter.length > 0 && !flags["skip-clis"]) {
+        platformSetupFailed = true;
+        if (result.installSucceeded === false) {
+          const failure = result.installFailure;
+          const detail = failure?.message
+            ? `: ${redactSecretText(failure.message)}`
+            : Number.isInteger(failure?.status)
+              ? ` (exit code ${failure.status})`
+              : failure?.signal
+                ? ` (signal ${failure.signal})`
+                : "";
+          console.error(`    npm could not install the missing vendor CLIs${detail}.`);
+          console.error("    Retry this command in the same PowerShell window:");
+          console.error(`      ${result.installCommand || windowsCliInstallCommand(result.missingAfter)}`);
+        } else {
+          console.error("    npm completed, but the installed commands are not discoverable.");
+          console.error("    Close and reopen PowerShell, then re-run `impel setup`.");
+          console.error("    If they are still missing, run `npm prefix --global` and add that directory to your user PATH.");
+        }
+      } else if (result.missingAfter.length > 0) {
+        console.log("    Vendor CLI installation was skipped; install it before using the matching launcher.");
+      } else {
+        console.log("    ✓ tenant-isolated Claude and Codex profiles are ready");
+      }
+    } catch (error) {
+      platformSetupFailed = true;
+      console.error(`    ✗ Windows CLI setup failed (${redactSecretText(error?.message || error)})`);
+      console.error("    Fix the issue, then re-run `impel setup`.");
+    }
+    if (flags["skip-apps"]) {
+      console.log("    Windows desktop apps: skipped (--skip-apps).");
+    } else {
+      console.log("    Windows desktop apps: installing signed vendor apps and isolated Impel profiles…");
+      try {
+        const installed = await io.installApps(["install", "all"]);
+        if (installed === false) {
+          platformSetupFailed = true;
+          console.error("    ✗ Windows desktop app setup failed; fix the issue above, then re-run `impel app install all`.");
+        } else {
+          console.log("    ✓ Impel Claude and Impel ChatGPT profiles are ready");
+        }
+      } catch (error) {
+        platformSetupFailed = true;
+        console.error(`    ✗ Windows desktop app setup failed (${redactSecretText(error?.message || error)})`);
+        console.error("    Fix the issue, then re-run `impel app install all`.");
+      }
+    }
+  } else if (flags["skip-apps"]) {
+    console.log("3/4 Apps: skipped (--skip-apps). Install later with `impel app install`.");
+  } else if (io.platform !== "darwin") {
+    console.log(
+      "3/4 Apps: skipped — isolated desktop apps are unavailable on this platform. Use `impel claude` / `impel codex` for isolated CLI sessions."
+    );
+  } else {
+    console.log(
+      "3/4 Installing the Impel desktop apps (running Claude/ChatGPT apps are closed, vendor apps updated first)…"
+    );
+    try {
+      await io.installApps(["install", "all"]);
+      console.log("    ✓ Impel Claude and Impel ChatGPT installed");
+    } catch (error) {
+      platformSetupFailed = true;
+      console.error(
+        `    ✗ app installation failed (${redactSecretText(error?.message || error)})`
+      );
+      console.error("    Fix the issue, then re-run `impel app install`.");
+    }
+  }
+  console.log("");
+
+  // ── Step 4: verify ───────────────────────────────────────────────────────
+  const probe = await io.probe(gatewayUrl, pat, tenant.id);
+  let verificationFailed = false;
+  if (probe.reachable && !probe.rejected) {
+    console.log(`4/4 Verify: ✓ gateway reachable (HTTP ${probe.status})`);
+  } else if (probe.rejected) {
+    verificationFailed = true;
+    console.log(`4/4 Verify: ✗ gateway reachable but it rejected the token (HTTP ${probe.status}).`);
+    console.log("    Mint a fresh token and re-run `impel setup`.");
+    process.exitCode = 1;
+  } else {
+    verificationFailed = true;
+    console.log(`4/4 Verify: ✗ gateway unreachable (${probe.error}).`);
+    console.log("    Check your network, then run `impel status` to retry.");
+    process.exitCode = 1;
+  }
+
+  if (platformSetupFailed) process.exitCode = 1;
+
+  console.log("");
+  if (platformSetupFailed || verificationFailed) {
+    console.log("Setup is incomplete; the token and tenant were saved, but the failed step above still needs attention.");
+    console.log("Fix it and re-run `impel setup`.");
+    return;
+  }
+  console.log("You're set. Try:");
+  if (io.platform === "darwin") console.log("  impel app open    open the Impel desktop apps");
+  if (io.platform === "win32") console.log("  impel app open all    open Claude and ChatGPT with isolated Impel profiles");
+  console.log("  impel claude      isolated Claude Code through the gateway");
+  console.log("  impel codex       isolated Codex through the gateway");
+  console.log("  impel status      full diagnostics any time");
+}

package/src/commands/skills.js

@@ -0,0 +1,108 @@
+// `impel skills sync [claude|codex|all]` — explicitly refresh the Bifrost
+// shared-skills marketplace into every managed installation of a client:
+//   - the native profile that `impel use gateway` manages (~/.claude, ~/.codex),
+//   - the isolated `impel claude` / `impel codex` CLI profile (cliProfiles.js),
+//   - the isolated desktop app profile (apps.js), when it is initialized.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+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 { resolveSkillsGateway, syncSkillsSafe } from "../skills.js";
+import { ensureTenantSelection } from "../tenants.js";
+import { windowsClaudeUserData } from "../windowsApps.js";
+
+const VALID_TARGETS = ["claude", "codex", "all"];
+
+function normalizeSkillsTarget(token) {
+  if (token === undefined || token === "all") return "all";
+  if (token === "claude") return "claude";
+  if (token === "codex" || token === "codex-cli" || token === "codex-app") return "codex";
+  return null;
+}
+
+/**
+ * Managed profiles to sync for a client. Env overrides steer the client binary
+ * at the SAME profile each managed installation writes to. Isolated CLI/app
+ * profiles are only included when they already exist, so we never conjure a
+ * half-initialized profile just to sync skills into it.
+ */
+export function managedSkillProfiles(
+  client,
+  {
+    homeDir = os.homedir(),
+    existsSync = fs.existsSync,
+    tenantId = null,
+    platform = process.platform,
+    environment = process.env,
+  } = {},
+) {
+  const profiles = [];
+  const cliPaths = tenantId ? tenantCliProfilePaths(tenantId) : null;
+  const claudeUserData = platform === "win32"
+    ? windowsClaudeUserData(environment, tenantId)
+    : null;
+  const paths = appPaths(homeDir, tenantId, { claudeUserData });
+
+  if (client === "claude") {
+    // Native ~/.claude — what `impel use gateway claude` manages. No env override
+    // so the binary resolves its config exactly as a bare `claude` would.
+    profiles.push({ label: "Claude Code (native profile)", env: {} });
+    if (cliPaths && existsSync(cliPaths.claudeConfigDir)) {
+      profiles.push({ label: "Impel isolated Claude (impel claude)", env: { CLAUDE_CONFIG_DIR: cliPaths.claudeConfigDir } });
+    }
+    const appInstalled = platform === "win32"
+      ? existsSync(path.join(paths.claude.userData, "configLibrary", `${CLAUDE_CONFIG_ID}.json`))
+      : existsSync(paths.claude.launcher);
+    if (appInstalled) {
+      profiles.push({ label: "Impel Claude app", env: { CLAUDE_CONFIG_DIR: paths.claude.userData } });
+    }
+  } else {
+    // Native Codex home — `impel use gateway codex` manages CODEX_HOME (env or ~/.codex).
+    profiles.push({ label: "Codex CLI (native profile)", env: { CODEX_HOME } });
+    if (cliPaths && existsSync(cliPaths.codexHome)) {
+      profiles.push({ label: "Impel isolated Codex (impel codex)", env: { CODEX_HOME: cliPaths.codexHome } });
+    }
+    const appInstalled = platform === "win32"
+      ? existsSync(path.join(paths.chatgpt.codexHome, "config.toml"))
+      : existsSync(paths.chatgpt.launcher);
+    if (appInstalled) {
+      profiles.push({ label: "Impel ChatGPT app", env: { CODEX_HOME: paths.chatgpt.codexHome } });
+    }
+  }
+
+  return profiles;
+}
+
+export async function cmdSkills(argv) {
+  const [action = "sync", targetToken] = argv;
+  if (action !== "sync") {
+    console.error(`impel skills: unknown action "${action}". Try \`impel skills sync [claude|codex|all]\`.`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const target = normalizeSkillsTarget(targetToken);
+  if (target === null) {
+    console.error(`impel skills: unknown target "${targetToken}". Use \`claude\`, \`codex\`, or \`all\`.`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const config = loadConfig();
+  const gatewayUrl = resolveSkillsGateway(config?.gatewayUrl);
+  const tenantId = config?.pat
+    ? (await ensureTenantSelection(config)).tenantId
+    : null;
+  const clients = target === "all" ? ["claude", "codex"] : [target];
+
+  for (const client of clients) {
+    for (const profile of managedSkillProfiles(client, { tenantId })) {
+      await syncSkillsSafe({ client, gatewayUrl, env: profile.env, label: profile.label });
+    }
+  }
+}

package/src/commands/status.js

@@ -0,0 +1,95 @@
+import { loadConfig, resolveDefaultGateway, resolveDefaultAppUrl, maskSecret } from "../config.js";
+import { detectClaudeMode } from "../claudeSetup.js";
+import { detectCodexMode } from "../codexSetup.js";
+import { ensureTenantSelection, productAccessLabel, tenantCredential } from "../tenants.js";
+import { maybePrintUpdateNotice } from "../updates.js";
+import { findNativeBinary } from "../nativeProcess.js";
+
+function modeLabel(mode) {
+  return mode === "gateway" ? "GATEWAY" : "ACCOUNT";
+}
+
+export async function cmdStatus() {
+  const config = loadConfig();
+  const gatewayUrl = config?.gatewayUrl || resolveDefaultGateway();
+  const appUrl = config?.appUrl || resolveDefaultAppUrl();
+
+  console.log(`Gateway URL: ${gatewayUrl}`);
+  console.log(`App URL:     ${appUrl}`);
+  console.log(`PAT stored:  ${config?.pat ? `yes (${maskSecret(config.pat)})` : "no — run `impel auth`"}`);
+  let tenantId = config?.tenantId || null;
+  let productAccess = null;
+  let scopes = null;
+  let selectionFresh = false;
+  if (config?.pat) {
+    try {
+      const selected = await ensureTenantSelection(config, { refresh: true });
+      tenantId = selected.tenantId;
+      productAccess = selected.productAccess;
+      scopes = selected.scopes;
+      selectionFresh = true;
+    } catch {
+      // The reachability probe below still reports the underlying network/auth state.
+    }
+  }
+  const staleLabel = config?.pat && !selectionFresh ? " (cached selection; live check failed)" : "";
+  const unavailableReason = config?.pat ? "live check failed" : "run `impel auth`";
+  console.log(`Tenant:      ${tenantId ? `${tenantId}${staleLabel}` : "not selected — run `impel tenant list`"}`);
+  console.log(`Access:      ${selectionFresh ? productAccessLabel(productAccess) : `Unknown — ${unavailableReason}`}`);
+  console.log(`PAT scopes:  ${selectionFresh && scopes?.length ? scopes.join(", ") : `unknown — ${unavailableReason}`}`);
+  const claudeBinary = findNativeBinary("claude");
+  const codexBinary = findNativeBinary("codex");
+  console.log("Isolated CLI launchers:");
+  console.log(
+    `  Claude: ${config?.pat && claudeBinary ? "READY (`impel claude`)" : !config?.pat ? "NOT READY — run `impel setup`" : "NOT READY — Claude Code is not installed"}`
+  );
+  console.log(
+    `  Codex:  ${config?.pat && codexBinary ? "READY (`impel codex`)" : !config?.pat ? "NOT READY — run `impel setup`" : "NOT READY — Codex is not installed"}`
+  );
+
+  // Per-tool mode. Codex CLI and the Codex app/IDE share the same
+  // ~/.codex/config.toml, so they always report the same mode.
+  const claude = detectClaudeMode(gatewayUrl);
+  const codex = detectCodexMode();
+
+  console.log("");
+  console.log("Native profile mode (isolated launchers do not change this):");
+  console.log(`  Claude Code:  ${modeLabel(claude.mode)}`);
+  console.log(`  Codex CLI:    ${modeLabel(codex.mode)}`);
+  console.log(`  Codex app:    ${modeLabel(codex.mode)}  (shares ~/.codex/config.toml with the CLI)`);
+  console.log("  Flip: `impel use gateway|account [claude|codex|all]`  (aliases: `impel on` / `impel off`)");
+
+  maybePrintUpdateNotice();
+
+  const url = `${gatewayUrl}/anthropic/v1/messages`;
+  console.log("");
+  process.stdout.write(`Reachability: probing ${url} ... `);
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 5000);
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...(config?.pat && tenantId
+          ? { authorization: `Bearer ${tenantCredential(config.pat, tenantId)}` }
+          : {}),
+      },
+      body: "{}",
+      signal: controller.signal,
+    });
+    // Any HTTP response — even a 4xx from a malformed/empty test body — means
+    // the gateway is up and routing. This is a best-effort reachability
+    // check, not a validity check of the request itself.
+    console.log(`HTTP ${res.status} ${res.statusText || ""}`.trim());
+    if (res.status === 401 || res.status === 403) {
+      console.log("  (gateway is reachable; that status usually means the PAT was rejected)");
+    }
+  } catch (err) {
+    console.log("unreachable");
+    console.log(`  ${err.name === "AbortError" ? "timed out after 5s" : err.message}`);
+  } finally {
+    clearTimeout(timeout);
+  }
+}