impel-cli 0.16.5 → 0.17.1

package/src/commands/status.js

@@ -1,95 +1,145 @@
-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";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 
-function modeLabel(mode) {
-  return mode === "gateway" ? "GATEWAY" : "ACCOUNT";
-}
+import { appPaths, CLAUDE_CONFIG_ID, readTenantManifest } from "../apps.js";
+import { loadConfig, maskSecret } from "../config.js";
+import { environmentValue, findNativeBinary } from "../nativeProcess.js";
+import { tenantCliClientReadiness } from "../provisioning.js";
+import { windowsTenantShortcutName } from "../shellEntries.js";
+import {
+  ensureTenantSelection,
+  PAT_SCOPE_CLAUDE,
+  PAT_SCOPE_CODEX,
+  productAccessLabel,
+} from "../tenants.js";
+import { installedVersion, maybePrintUpdateNotice } from "../updates.js";
+import { windowsClaudeUserData } from "../windowsApps.js";
 
-export async function cmdStatus() {
-  const config = loadConfig();
-  const gatewayUrl = config?.gatewayUrl || resolveDefaultGateway();
-  const appUrl = config?.appUrl || resolveDefaultAppUrl();
+function readShellManifest(paths) {
+  try {
+    const value = JSON.parse(fs.readFileSync(path.join(paths.tenantRoot, "shell-entries.json"), "utf8"));
+    return Array.isArray(value?.entries) ? value.entries : [];
+  } catch {
+    return [];
+  }
+}
 
-  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.
+function desktopReadiness(tenant, {
+  platform = process.platform,
+  homeDir = os.homedir(),
+  environment = process.env,
+  existsSync = fs.existsSync,
+} = {}) {
+  if (!["darwin", "win32"].includes(platform)) {
+    return {
+      claude: { app: "unavailable", shell: "unavailable" },
+      codex: { app: "unavailable", shell: "unavailable" },
+    };
+  }
+  const claudeUserData = platform === "win32" ? windowsClaudeUserData(environment, tenant.id) : null;
+  const paths = appPaths(homeDir, tenant.id, { tenantName: tenant.name, claudeUserData });
+  const manifest = readTenantManifest(homeDir, tenant.id);
+  const available = new Set(manifest?.availableTargets || manifest?.targets || []);
+  const registered = new Set(readShellManifest(paths).map((entry) => entry.product));
+  const appData = environmentValue(environment, "APPDATA");
+  const states = {};
+  for (const [client, product] of [["claude", "claude"], ["codex", "chatgpt"]]) {
+    if (manifest && !available.has(product)) {
+      states[client] = { app: "unsupported", shell: "unsupported" };
+      continue;
+    }
+    const appReady = platform === "darwin"
+      ? existsSync(paths[product].launcher)
+      : existsSync(product === "claude"
+        ? path.join(paths.claude.userData, "configLibrary", `${CLAUDE_CONFIG_ID}.json`)
+        : path.join(paths.chatgpt.codexHome, "config.toml"));
+    let shellReady = appReady && registered.has(product);
+    if (platform === "win32" && appData) {
+      const shortcutPath = path.win32.join(
+        appData,
+        "Microsoft", "Windows", "Start Menu", "Programs", "Impel",
+        windowsTenantShortcutName(product, tenant.id, tenant.name),
+      );
+      shellReady = appReady && existsSync(shortcutPath);
     }
+    states[client] = {
+      app: appReady ? "ready" : "missing",
+      shell: shellReady ? "ready" : "missing",
+    };
   }
-  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`)");
+  return states;
+}
 
-  maybePrintUpdateNotice();
+function cliState({ supported, profileReady, binaryReady }) {
+  if (!supported) return "unsupported";
+  return profileReady && binaryReady ? "ready" : "missing";
+}
 
-  const url = `${gatewayUrl}/anthropic/v1/messages`;
-  console.log("");
-  process.stdout.write(`Reachability: probing ${url} ... `);
+export async function cmdStatus(overrides = {}) {
+  const io = {
+    loadConfig,
+    ensureTenantSelection,
+    cliReadiness: tenantCliClientReadiness,
+    desktopReadiness,
+    installedVersion,
+    findNativeBinary,
+    maybePrintUpdateNotice,
+    platform: process.platform,
+    environment: process.env,
+    ...overrides,
+  };
+  const config = io.loadConfig();
+  console.log(`impel-cli: v${io.installedVersion() || "?"}`);
+  console.log(`Authentication: ${config?.pat ? `configured (${maskSecret(config.pat)})` : "not configured - run `impel setup`"}`);
+  if (!config?.pat) {
+    io.maybePrintUpdateNotice();
+    return;
+  }
 
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), 5000);
+  let selected;
   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,
+    selected = await io.ensureTenantSelection(config, { refresh: true });
+    console.log(`Authentication check: accepted (${productAccessLabel(selected.productAccess)})`);
+  } catch (error) {
+    console.log(`Authentication check: unavailable (${error?.message || error})`);
+    console.log(`Current CLI tenant: ${config.tenantId || "not selected"}`);
+    console.log("Run `impel setup` to refresh authentication, then `impel update` to repair local tenants.");
+    io.maybePrintUpdateNotice();
+    return;
+  }
+
+  console.log(`Current CLI tenant: ${selected.tenantId}`);
+  console.log("Change it with: impel tenant use <tenant>");
+  const scopes = new Set(selected.scopes || []);
+  const scopeKnown = selected.scopes != null;
+  const binaries = {
+    claude: Boolean(io.findNativeBinary("claude", io.environment, io.platform)),
+    codex: Boolean(io.findNativeBinary("codex", io.environment, io.platform)),
+  };
+  console.log("Tenant readiness:");
+  let incomplete = false;
+  for (const tenant of [...selected.tenants].sort((left, right) => left.id.localeCompare(right.id))) {
+    const profiles = io.cliReadiness(tenant.id);
+    const desktop = io.desktopReadiness(tenant, overrides);
+    const claudeCli = cliState({
+      supported: !scopeKnown || scopes.has(PAT_SCOPE_CLAUDE),
+      profileReady: profiles.claude,
+      binaryReady: binaries.claude,
     });
-    // 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);
+    const codexCli = cliState({
+      supported: !scopeKnown || scopes.has(PAT_SCOPE_CODEX),
+      profileReady: profiles.codex,
+      binaryReady: binaries.codex,
+    });
+    const states = [claudeCli, codexCli, desktop.claude.app, desktop.codex.app, desktop.claude.shell, desktop.codex.shell];
+    if (states.includes("missing")) incomplete = true;
+    console.log(
+      `  ${tenant.id}${tenant.id === selected.tenantId ? " (current)" : ""}: `
+      + `Claude CLI ${claudeCli}, Codex CLI ${codexCli}, `
+      + `Claude app ${desktop.claude.app}, ChatGPT app ${desktop.codex.app}`,
+    );
   }
+  if (incomplete) console.log("Repair or finish missing tenant surfaces with: impel update");
+  io.maybePrintUpdateNotice();
 }

package/src/commands/tasks.js

@@ -92,7 +92,7 @@ async function requestJson({ flags, path, query, method = "GET", body }) {
     fail("impel tasks: the control plane did not return live PAT scopes; retry after it is upgraded.");
   }
   if (!selected.scopes.includes(PAT_SCOPE_TASKS)) {
-    fail("impel tasks: this PAT is missing the \"tasks\" scope; create a fresh PAT in Impel Gateway setup, then run `impel auth --pat <pat>`.");
+    fail("impel tasks: this PAT is missing the \"tasks\" scope; create a fresh PAT in Impel Gateway setup, then run `impel setup` and provide it.");
   }
   const selectedOrgId = flags.org || selected.tenantId;
   const resolvedQuery = { ...(query || {}) };

package/src/commands/tenant.js

@@ -1,7 +1,6 @@
 import { parseFlags } from "../args.js";
 import { loadConfig } from "../config.js";
 import { ensureTenantSelection, productAccessLabel, selectTenant } from "../tenants.js";
-import { cmdApps } from "./apps.js";
 import { cmdLaunch } from "./launch.js";
 
 const HELP = `impel tenant - select the organization used by Impel sessions
@@ -9,7 +8,7 @@ const HELP = `impel tenant - select the organization used by Impel sessions
 Usage:
   impel tenant list
   impel tenant current
-  impel tenant use <org-slug> [--launch claude|codex|apps]
+  impel tenant use <org-slug> [--launch claude|codex]
 
 Aliases: impel tenants ..., impel org ...
 `;
@@ -69,10 +68,9 @@ export async function cmdTenant(argv) {
 
   const launch = flags.launch;
   if (!launch) {
-    console.log("Next: `impel claude`, `impel codex`, or `impel app open`.");
+    console.log("Next: `impel claude` or `impel codex`. Desktop apps are available from Finder or Windows Search.");
     return;
   }
   if (launch === "claude" || launch === "codex") return cmdLaunch(launch, []);
-  if (launch === "apps") return cmdApps(["open", "all"]);
-  throw new Error(`unknown launch target "${launch}"; use claude, codex, or apps`);
+  throw new Error(`unknown launch target "${launch}"; use claude or codex`);
 }

package/src/commands/update.js

@@ -1,21 +1,13 @@
-// `impel update` — bring everything current in one command: the CLI itself
-// (npm reinstall from the public package), then the managed desktop apps/profiles, then
-// skills and native tenant agents. The app step re-executes the freshly installed CLI so the new code
-// performs it.
+// `impel update` — update the CLI, then let the freshly installed build
+// reconcile every tenant and managed surface from the live control-plane list.
 
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 
 import { parseFlags } from "../args.js";
-import { CLAUDE_CONFIG_ID, appPaths } from "../apps.js";
 import { loadConfig, redactSecretText } from "../config.js";
 import { nativeCommandInvocation } from "../nativeProcess.js";
-import { windowsClaudeUserData } from "../windowsApps.js";
 import { withProgress } from "../progress.js";
-import { installedAppTenantIds } from "./apps.js";
 import { runInstallRecovery } from "../installRecovery/engine.js";
 import {
   fetchRemoteVersion,
@@ -30,16 +22,14 @@ const CLI_BIN = fileURLToPath(new URL("../../bin/impel.js", import.meta.url));
 
 const HELP = `impel update - update everything Impel in one command
 
-Reinstalls impel-cli from npm, then cascades with the NEW build:
-\`impel app update all\` (update every locally installed tenant's vendor apps
-and managed app profiles), then \`impel skills sync all\` and
-\`impel agents sync all\` across native and isolated CLI profiles.
+Reinstalls impel-cli from npm, then uses the new build to discover every
+accessible tenant. Missing tenants are installed; existing tenant profiles and
+apps are repaired and upgraded in place while preserving local state.
 
 Usage:
-  impel update              Update the CLI, then cascade to apps, skills, and agents
+  impel update              Update the CLI and reconcile every accessible tenant
   impel update --check      Report whether an update is available; change nothing
-  impel update --skip-apps  Skip the desktop-app step of the cascade
-  impel update --repair     Explicitly opt into sanitized assisted recovery on failure
+  impel update --skip-apps  Reconcile only isolated CLI profiles
   impel update --no-recovery  Disable local and hosted recovery for this run
 `;
 
@@ -93,17 +83,25 @@ function defaultSelfUpdate(spec) {
 
 // The cascading steps re-execute the (freshly installed) CLI binary so the
 // NEW code performs them, not the process that started the update.
-export function defaultRunAppsUpdate({
+export function defaultRunConvergence({
+  skipApps = false,
+  noRecovery = false,
   spawn = spawnSync,
   execPath = process.execPath,
   cliBin = CLI_BIN,
 } = {}) {
-  const result = spawn(execPath, [cliBin, "app", "update", "all"], {
+  const args = [cliBin, "_converge"];
+  if (skipApps) args.push("--skip-apps");
+  if (noRecovery) args.push("--no-recovery");
+  const result = spawn(execPath, args, {
     stdio: "inherit",
   });
   return result.status === 0;
 }
 
+// Compatibility export for callers from the previous cascade implementation.
+export const defaultRunAppsUpdate = defaultRunConvergence;
+
 export function defaultRunSkillsSync({
   spawn = spawnSync,
   execPath = process.execPath,
@@ -126,36 +124,6 @@ export function defaultRunAgentsSync({
   return result.status === 0;
 }
 
-function anyAppInstalled(homeDir = os.homedir()) {
-  if (installedAppTenantIds(["claude", "chatgpt"], {
-    homeDir,
-    platform: process.platform,
-    environment: process.env,
-  }).length > 0) return true;
-  const config = loadConfig();
-  const claudeUserData = process.platform === "win32"
-    ? windowsClaudeUserData(process.env, config?.tenantId || null)
-    : null;
-  const paths = appPaths(homeDir, config?.tenantId || null, { claudeUserData });
-  if (process.platform === "win32") {
-    return (
-      fs.existsSync(path.join(
-        paths.claude.userData,
-        "configLibrary",
-        `${CLAUDE_CONFIG_ID}.json`,
-      ))
-      || fs.existsSync(path.join(paths.chatgpt.codexHome, "config.toml"))
-    );
-  }
-  const legacyPaths = appPaths(homeDir);
-  return (
-    fs.existsSync(paths.claude.launcher)
-    || fs.existsSync(paths.chatgpt.launcher)
-    || fs.existsSync(legacyPaths.claude.launcher)
-    || fs.existsSync(legacyPaths.chatgpt.launcher)
-  );
-}
-
 export async function cmdUpdate(argv, overrides = {}) {
   const io = {
     fetchRemoteVersion,
@@ -163,16 +131,29 @@ export async function cmdUpdate(argv, overrides = {}) {
     refreshUpdateCache,
     writeCache: writeUpdateCache,
     selfUpdate: defaultSelfUpdate,
+    runConvergence: defaultRunConvergence,
     runAppsUpdate: defaultRunAppsUpdate,
     runSkillsSync: defaultRunSkillsSync,
     runAgentsSync: defaultRunAgentsSync,
-    appsInstalled: anyAppInstalled,
     platform: process.platform,
     progress: withProgress,
     recoverInstall: runInstallRecovery,
     loadConfig,
     ...overrides,
   };
+  // Older embedders injected the three public cascade callbacks. Treat an
+  // injected app step as the convergence boundary so their tests/automation
+  // never fall through to a real fresh-build child process.
+  if (!overrides.runConvergence && (
+    overrides.runAppsUpdate || overrides.runSkillsSync || overrides.runAgentsSync
+  )) {
+    io.runConvergence = (options) => {
+      if (!options?.skipApps && overrides.runAppsUpdate && !overrides.runAppsUpdate()) return false;
+      if (overrides.runSkillsSync && !overrides.runSkillsSync()) return false;
+      if (overrides.runAgentsSync && !overrides.runAgentsSync()) return false;
+      return true;
+    };
+  }
   const { flags } = parseFlags(argv, {
     check: { type: "boolean" },
     "skip-apps": { type: "boolean" },
@@ -228,6 +209,7 @@ export async function cmdUpdate(argv, overrides = {}) {
           const recovery = await io.recoverInstall(
             {
               failure: {
+                scope: "shared",
                 platform: io.platform,
                 architecture: process.arch,
                 step: "install.impel_cli",
@@ -278,41 +260,13 @@ export async function cmdUpdate(argv, overrides = {}) {
     console.log(`CLI: updated${remote ? ` to v${remote}` : ""}.`);
   }
 
-  // ── Cascade: every tenant app, then non-app managed profiles ───────────
-  let cascadeFailed = false;
-  if (flags["skip-apps"]) {
-    console.log("Apps: skipped (--skip-apps).");
-  } else if (io.platform !== "darwin" && io.platform !== "win32") {
-    console.log("Apps: skipped — isolated desktop apps are unavailable on this platform.");
-  } else if (!io.appsInstalled()) {
-    console.log("Apps: none installed; skipping (run `impel app install` or `impel setup`).");
-  } else {
-    console.log(io.platform === "win32"
-      ? "Apps: updating every installed tenant's signed Claude and ChatGPT profiles…"
-      : "Apps: refreshing every installed tenant and rebuilding only stale app bundles…");
-    // These child commands inherit the terminal and render their own progress
-    // and log lines. Wrapping them in another spinner makes both processes
-    // write the same terminal row, producing glued output such as
-    // "Updating managed desktop apps (...)Updating all managed...".
-    if (!await io.runAppsUpdate()) {
-      console.error("impel update: the app update failed; re-run `impel app update` after fixing the issue.");
-      cascadeFailed = true;
-    }
-  }
-
-  console.log("Skills: syncing native and isolated CLI profiles…");
-  if (!await io.runSkillsSync()) {
-    console.error("impel update: skill sync failed; re-run `impel skills sync` after fixing the issue.");
-    cascadeFailed = true;
-  }
-
-  console.log("Agents: syncing the selected tenant into native and isolated CLI profiles…");
-  if (!await io.runAgentsSync()) {
-    console.error("impel update: agent sync failed; re-run `impel agents sync` after fixing the issue.");
-    cascadeFailed = true;
-  }
-
-  if (cascadeFailed) {
+  console.log("Tenants: discovering, installing, repairing, and upgrading every accessible tenant…");
+  const convergenceArgs = {
+    skipApps: Boolean(flags["skip-apps"]),
+    noRecovery: Boolean(flags["no-recovery"]),
+  };
+  if (!await io.runConvergence(convergenceArgs)) {
+    console.error("impel update: tenant convergence failed; rerun `impel update` after addressing the reported issue.");
     process.exitCode = 1;
     return;
   }