@jentrix/cli 0.5.4 → 0.5.6

package/dist/main.js

@@ -10327,14 +10327,17 @@ var require_dist = __commonJS({
 import { spawn as spawn3 } from "node:child_process";
 import { createInterface } from "node:readline";
 import {
+  appendFileSync,
   closeSync as closeSync3,
+  copyFileSync,
   existsSync as existsSync6,
+  mkdirSync as mkdirSync4,
   openSync as openSync3,
   readFileSync as readFileSync7,
   statSync as statSync3
 } from "node:fs";
 import { homedir } from "node:os";
-import { basename as basename2, join as join6 } from "node:path";
+import { basename as basename2, dirname as dirname4, join as join6 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // node_modules/.pnpm/commander@14.0.3/node_modules/commander/esm.mjs
@@ -20959,7 +20962,7 @@ function refreshAccessToken(input) {
 
 // src/client.ts
 var CLI_NAME = "stacks-cli";
-var CLI_VERSION = "0.5.4";
+var CLI_VERSION = "0.5.6";
 var DEAD_TOKEN_MESSAGE = "authentication failed (HTTP 401): the token is dead or expired \u2014 mint a new PAT at /account/tokens on your Jentrix server and update STACKS_TOKEN (or --token / the config file).";
 var RELOGIN_MESSAGE = "OAuth session expired and could not be refreshed \u2014 run `jentrix login` to sign in again.";
 function originOf2(url2) {
@@ -21095,6 +21098,26 @@ function readOAuthRecord(configPath, reader) {
   }
 }
 
+// src/exec-target.ts
+var INTERPRETED = /\.(cmd|bat)$/i;
+function quoteForCmd(token) {
+  return `"${token.replace(/"/g, '""')}"`;
+}
+function execTarget(file, args, platform2 = process.platform, comSpec = process.env.ComSpec) {
+  if (platform2 !== "win32" || !INTERPRETED.test(file)) {
+    return { file, args: [...args], options: {} };
+  }
+  const line = [file, ...args].map(quoteForCmd).join(" ");
+  return {
+    file: comSpec || "cmd.exe",
+    // `/d` skips any AutoRun command the machine has registered; `/s` makes cmd
+    // strip exactly the outer quote pair and take the rest verbatim, which is
+    // the only form that survives a quoted program path.
+    args: ["/d", "/s", "/c", `"${line}"`],
+    options: { windowsVerbatimArguments: true }
+  };
+}
+
 // src/loopback.ts
 import { createServer } from "node:http";
 import { spawn } from "node:child_process";
@@ -23541,10 +23564,20 @@ var MAX_WORK_ITEMS = 15;
 async function projectBoards(caller, projectId) {
   const project = await callStructured(caller, "get_project", { projectId });
   const links = project.links ?? [];
+  const workspaceId = String(project.workspaceId);
+  const linkedBoardIds = links.filter((link) => link.targetType === "BOARD").map((link) => link.targetId);
+  let liveBoardIds = new Set(linkedBoardIds);
+  if (linkedBoardIds.length > 0) {
+    const boards = (await callStructured(caller, "list_boards", { workspaceId })).boards ?? [];
+    liveBoardIds = new Set(
+      boards.filter((b) => !b.archivedAt).map((b) => String(b.id))
+    );
+  }
   return {
-    workspaceId: String(project.workspaceId),
+    workspaceId,
     name: String(project.name),
-    boardIds: links.filter((link) => link.targetType === "BOARD").map((link) => link.targetId),
+    boardIds: linkedBoardIds.filter((id) => liveBoardIds.has(id)),
+    staleBoardIds: linkedBoardIds.filter((id) => !liveBoardIds.has(id)),
     repoOwners: links.filter((link) => link.targetType === "REPO").map((link) => link.targetId.trim().toLowerCase())
   };
 }
@@ -24025,7 +24058,7 @@ ${JSON.stringify(session.alignment, null, 2)}`
         targetId: boardId
       });
       deps2.writeOut(
-        `Project "${project.name}" linked no board \u2014 created board "${project.name}" and linked it.`
+        project.staleBoardIds.length > 0 ? `Project "${project.name}" linked ${project.staleBoardIds.length === 1 ? "a board that no longer exists" : "only boards that no longer exist"} (${project.staleBoardIds.join(", ")}) \u2014 created board "${project.name}" and linked it.` : `Project "${project.name}" linked no board \u2014 created board "${project.name}" and linked it.`
       );
     }
     const columns = await callStructured(caller, "list_columns", { boardId });
@@ -27181,6 +27214,11 @@ function relayFailure(deps2, step, result) {
   );
   return EXIT_CODES.INTERNAL;
 }
+function persistentPluginRoot(globalNodeModules, ownRoot, exists) {
+  if (!globalNodeModules) return ownRoot;
+  const global = join4(globalNodeModules, "@jentrix", "cli");
+  return exists(global) ? global : ownRoot;
+}
 function isPluginMarketplaceDir(dir) {
   return existsSync4(join4(dir, ".claude-plugin", "marketplace.json"));
 }
@@ -27458,22 +27496,33 @@ function invokeRunnerProcess(file, args, stdin, timeoutMs = RUNNER_TIMEOUT_MS) {
   if (!isAbsolute(file)) {
     return Promise.reject(new Error("runner executable path must be absolute"));
   }
+  const target = execTarget(file, args);
   return new Promise((resolveInvocation, reject) => {
     const child = execFile2(
-      file,
-      args,
+      target.file,
+      target.args,
       {
         timeout: timeoutMs,
         maxBuffer: RUNNER_OUTPUT_CAP,
-        windowsHide: true
+        windowsHide: true,
+        ...target.options
       },
       (error2, stdout, stderr) => {
         if (error2 && error2.killed) {
           reject(new Error("runner subprocess timed out"));
           return;
         }
+        const raw = error2?.code;
+        if (error2 && typeof raw === "string") {
+          resolveInvocation({
+            code: 1,
+            stdout: String(stdout),
+            stderr: `${String(stderr)}${raw}: ${error2.message}`
+          });
+          return;
+        }
         resolveInvocation({
-          code: typeof error2?.code === "number" ? Number(error2.code) : 0,
+          code: typeof raw === "number" ? Number(raw) : 0,
           stdout: String(stdout),
           stderr: String(stderr)
         });
@@ -27794,8 +27843,12 @@ function runRunnerForeground(file, args) {
   if (!isAbsolute(file)) {
     return Promise.reject(new Error("runner executable path must be absolute"));
   }
+  const target = execTarget(file, args);
   return new Promise((resolveRun, reject) => {
-    const child = spawn2(file, args, { stdio: "inherit" });
+    const child = spawn2(target.file, target.args, {
+      stdio: "inherit",
+      ...target.options
+    });
     child.once("error", reject);
     child.once("exit", (code, signal) => resolveRun(code ?? (signal ? 1 : 0)));
   });
@@ -27842,6 +27895,312 @@ function registerRunnerCommand(program3, deps2, onExit2) {
   );
 }
 
+// src/commands/setup.ts
+var NPM_INSTALL_TIMEOUT_MS2 = 3e5;
+var SUPERSEDED = ["@jentrix/stacks-cli", "@jentrix/stacks-runner"];
+var CLI_SPEC = `@jentrix/cli@${CLI_VERSION}`;
+var RUNNER_SPEC2 = `@jentrix/runner@${CLI_VERSION}`;
+function say(deps2, text = "") {
+  deps2.writeOut(text);
+}
+async function installToolchain(deps2) {
+  const npm = await deps2.resolveNpm();
+  const existing = await deps2.resolveJentrix();
+  if (existing) {
+    say(deps2, `jentrix ${CLI_VERSION} is already installed (${existing}).`);
+    say(deps2, "  Upgrade it any time with: npm update -g @jentrix/cli");
+  } else {
+    if (!npm) {
+      deps2.writeErr(
+        "NPM_NOT_FOUND: the toolchain installs from npm and `npm` is not on PATH \u2014 install Node.js >= 20 (https://nodejs.org), then retry."
+      );
+      return EXIT_CODES.INVALID_INPUT;
+    }
+    await deps2.invoke(npm, ["rm", "-g", ...SUPERSEDED], void 0, 6e4);
+    say(deps2, `Installing ${CLI_SPEC} + ${RUNNER_SPEC2} (npm -g)\u2026`);
+    const installed = await deps2.invoke(
+      npm,
+      ["install", "-g", CLI_SPEC, RUNNER_SPEC2],
+      void 0,
+      NPM_INSTALL_TIMEOUT_MS2
+    );
+    if (installed.code !== 0) {
+      const detail = (installed.stderr || installed.stdout).trim();
+      deps2.writeErr(
+        `TOOLCHAIN_INSTALL_FAILED: \`npm install -g\` exited ${installed.code}${detail ? `: ${detail}` : ""}`
+      );
+      deps2.writeErr(
+        "  On EACCES, fix npm's global prefix (https://docs.npmjs.com/resolving-eacces-permissions-errors); on EEXIST, delete the bin npm names and retry."
+      );
+      return EXIT_CODES.INTERNAL;
+    }
+    if (!await deps2.resolveJentrix()) {
+      deps2.writeErr(
+        "TOOLCHAIN_NOT_ON_PATH: the packages installed but `jentrix` is not resolvable \u2014 add npm's global bin directory (`npm prefix -g`) to PATH, then retry."
+      );
+      return EXIT_CODES.INTERNAL;
+    }
+    say(deps2, "Installed the CLI and the session runner.");
+  }
+  if (!await deps2.resolveRunner()) {
+    if (!npm) {
+      deps2.writeErr(
+        `RUNNER_NOT_INSTALLED: connected sessions need the runner and npm was not found to install it \u2014 npm install -g ${RUNNER_SPEC2}, then retry.`
+      );
+      return EXIT_CODES.INVALID_INPUT;
+    }
+    say(deps2, `Installing ${RUNNER_SPEC2} (connected sessions need it)\u2026`);
+    const runner = await deps2.invoke(
+      npm,
+      ["install", "-g", RUNNER_SPEC2],
+      void 0,
+      NPM_INSTALL_TIMEOUT_MS2
+    );
+    if (runner.code !== 0 || !await deps2.resolveRunner()) {
+      deps2.writeErr(
+        `RUNNER_NOT_INSTALLED: \`npm install -g ${RUNNER_SPEC2}\` did not leave a resolvable runner \u2014 install it by hand, then retry.`
+      );
+      return EXIT_CODES.INTERNAL;
+    }
+  }
+  return EXIT_CODES.OK;
+}
+async function installRuntimes(deps2) {
+  if (await deps2.resolveClaude()) {
+    await deps2.installPlugin("claude");
+  } else {
+    say(deps2, "note: the `claude` CLI is not installed \u2014 skipped its plugin.");
+    say(
+      deps2,
+      "      Install Claude Code (https://claude.com/claude-code), then run: jentrix plugin install"
+    );
+  }
+  if (await deps2.resolveCodex()) {
+    if (await deps2.installPlugin("codex") !== EXIT_CODES.OK) {
+      say(
+        deps2,
+        "note: `jentrix plugin install codex` did not complete \u2014 retry it after `jentrix login`."
+      );
+    }
+  } else {
+    say(
+      deps2,
+      "note: the `codex` CLI is not installed \u2014 skipped its plugin and MCP server."
+    );
+    say(
+      deps2,
+      "      Install Codex (https://developers.openai.com/codex/cli), then re-run this command."
+    );
+  }
+}
+async function registerCodexMcp(deps2, codex, pending) {
+  const configPath = deps2.codexConfigPath();
+  const config2 = deps2.readTextFile(configPath);
+  const existingKey = config2 ? /^\[mcp_servers\.jentrix\]/m.test(config2) ? "jentrix" : /^\[mcp_servers\.stacks\]/m.test(config2) ? "stacks" : null : null;
+  if (existingKey) {
+    say(
+      deps2,
+      `note: Codex already has an [mcp_servers.${existingKey}] entry \u2014 left untouched.`
+    );
+    say(
+      deps2,
+      `      It may point at a different deployment; check ${configPath}.`
+    );
+    say(
+      deps2,
+      `      To move it off an exported STACKS_CODEX_TOKEN and onto sign-in:`
+    );
+    say(
+      deps2,
+      `      \`codex mcp remove ${existingKey}\`, then re-run this command.`
+    );
+    return;
+  }
+  const url2 = deps2.signedInUrl();
+  if (!url2) {
+    say(
+      deps2,
+      "note: skipped the Codex MCP entry \u2014 this machine is not signed in yet, so"
+    );
+    say(
+      deps2,
+      "      there is no endpoint to register. Run `jentrix login`, then re-run this command."
+    );
+    return;
+  }
+  const oauth = (await deps2.invoke(codex, ["mcp", "login", "--help"])).code === 0;
+  if (config2 !== null) {
+    const stamp = deps2.now().toISOString().replace(/[-:T]/g, "").slice(0, 14);
+    deps2.copyFile(configPath, `${configPath}.bak-jentrix-${stamp}`);
+  }
+  const lines = ["", "# Added by the Jentrix installer."];
+  lines.push(
+    oauth ? "# Authenticated by `codex mcp login jentrix` \u2014 no token to export." : "# Needs STACKS_CODEX_TOKEN in the environment (a personal access token, scopes read + write)."
+  );
+  lines.push("[mcp_servers.jentrix]", `url = "${url2}"`);
+  if (!oauth) lines.push('bearer_token_env_var = "STACKS_CODEX_TOKEN"');
+  deps2.appendTextFile(configPath, `${lines.join("\n")}
+`);
+  say(deps2, `Codex: registered [mcp_servers.jentrix] \u2192 ${url2}`);
+  if (!oauth) {
+    say(
+      deps2,
+      "       (this Codex build has no `codex mcp login`, so the entry reads a token"
+    );
+    say(deps2, "        from the environment)");
+    pending.codexTokenUrl = `${url2.replace(/\/api\/mcp$/, "")}/account/tokens`;
+    return;
+  }
+  if (!deps2.isInteractive) {
+    pending.codexLoginUrl = url2;
+    return;
+  }
+  say(
+    deps2,
+    "Signing Codex in \u2014 approve the Jentrix consent screen in your browser\u2026"
+  );
+  if ((await deps2.invoke(codex, ["mcp", "login", "jentrix"])).code !== 0) {
+    pending.codexLoginUrl = url2;
+  }
+}
+async function bootstrapRepository(deps2) {
+  const here = deps2.cwd();
+  if (!await deps2.resolveGit()) {
+    say(deps2, "note: `git` is not installed \u2014 skipped the repository step.");
+    say(
+      deps2,
+      "      Jentrix aligns sessions by repository identity, so install git (https://git-scm.com/downloads) and re-run."
+    );
+    return;
+  }
+  const inRepo = async () => (await deps2.git(["rev-parse", "--is-inside-work-tree"], here)).code === 0;
+  if (!await inRepo()) {
+    const reply = await deps2.readLine(
+      `Initialize a git repository in ${here} so agent sessions can align here? [y/N] `
+    );
+    if (!/^y/i.test(reply.trim())) return;
+    if ((await deps2.git(["init"], here)).code !== 0) {
+      say(deps2, "note: `git init` failed \u2014 skipped the repository step.");
+      return;
+    }
+  }
+  if ((await deps2.git(["remote", "get-url", "origin"], here)).code === 0)
+    return;
+  const fallback = here.split(/[/\\]/).filter(Boolean).pop().toLowerCase().replace(/ /g, "-");
+  say(
+    deps2,
+    "Jentrix aligns sessions by repository identity (owner/name); the remote doesn't have to exist yet."
+  );
+  say(
+    deps2,
+    `Optional \u2014 leave it blank and this checkout aligns as local/${fallback}.`
+  );
+  const answer = (await deps2.readLine(
+    "GitHub repo for origin (owner/name or full URL, blank to skip): "
+  )).trim();
+  if (!answer) return;
+  const url2 = /:\/\/|^[^/]+@[^:]+:/.test(answer) ? answer : /^[^/]+\/[^/]+$/.test(answer) ? `https://github.com/${answer}.git` : null;
+  if (!url2) {
+    say(deps2, `skipped \u2014 "${answer}" is neither owner/name nor a URL`);
+    return;
+  }
+  if ((await deps2.git(["remote", "add", "origin", url2], here)).code === 0) {
+    say(deps2, `origin \u2192 ${url2}`);
+  }
+}
+async function runSetupCommand(flags, deps2) {
+  const nodeMajor = Number(process.versions.node.split(".")[0]);
+  if (Number.isFinite(nodeMajor) && nodeMajor < 20) {
+    deps2.writeErr(
+      `NODE_TOO_OLD: Jentrix requires Node.js >= 20 (running v${process.versions.node}) \u2014 upgrade from https://nodejs.org, then retry.`
+    );
+    return EXIT_CODES.INVALID_INPUT;
+  }
+  const toolchain = await installToolchain(deps2);
+  if (toolchain !== EXIT_CODES.OK) return toolchain;
+  await installRuntimes(deps2);
+  if (!deps2.hasCredential()) {
+    if (deps2.isInteractive) {
+      say(deps2, "");
+      say(deps2, "Connecting this machine to a Jentrix server\u2026");
+      if (await deps2.login({ url: flags.url, local: flags.local }) !== 0) {
+        say(
+          deps2,
+          "note: sign-in did not complete \u2014 run `jentrix login` when you're ready."
+        );
+      }
+    } else {
+      say(
+        deps2,
+        "note: no credential is configured \u2014 run `jentrix login` (interactive) to connect."
+      );
+    }
+  }
+  const pending = {};
+  const codex = await deps2.resolveCodex();
+  if (codex) await registerCodexMcp(deps2, codex, pending);
+  if (flags.git !== false && deps2.isInteractive && deps2.cwd() !== deps2.homeDir()) {
+    await bootstrapRepository(deps2);
+  }
+  say(deps2, "");
+  say(deps2, "Done. Verify with: jentrix whoami");
+  if (pending.codexLoginUrl) {
+    say(deps2, "");
+    say(
+      deps2,
+      `One step left for Codex \u2014 approve its access to ${pending.codexLoginUrl}:`
+    );
+    say(
+      deps2,
+      "  codex mcp login jentrix    (opens the browser; no token to copy)"
+    );
+  }
+  if (pending.codexTokenUrl) {
+    say(deps2, "");
+    say(
+      deps2,
+      "One step left for Codex \u2014 its MCP client carries its own token:"
+    );
+    say(
+      deps2,
+      `  1. mint a personal access token (scopes read + write) at ${pending.codexTokenUrl}`
+    );
+    say(
+      deps2,
+      "  2. export STACKS_CODEX_TOKEN in the shell you start Codex from"
+    );
+    say(deps2, "  3. restart Codex");
+    say(
+      deps2,
+      "  (deliberately not STACKS_TOKEN \u2014 that would also override the CLI's own"
+    );
+    say(deps2, "   rotating login, which refreshes itself and needs no export)");
+  }
+  say(deps2, "");
+  say(deps2, "Next: open your agent in the project folder and align \u2014");
+  say(deps2, "  Claude Code:  /jentrix-align");
+  say(deps2, "  Codex:        $jentrix-align");
+  say(deps2, "  any terminal: jentrix align");
+  say(
+    deps2,
+    "(Bind a folder to a different server any time with: jentrix login --local)"
+  );
+  return EXIT_CODES.OK;
+}
+function registerSetupCommand(program3, deps2, onExit2) {
+  return program3.command("setup").description(
+    "Install and connect the whole local toolchain \u2014 CLI, session runner, the plugins for whichever agent runtimes are present, browser sign-in, the Codex MCP server, and this folder's repository. The same command on Windows, macOS and Linux. Safe to re-run."
+  ).option(
+    "--url <url>",
+    "MCP endpoint to sign in against (default: the interactive server picker)"
+  ).option(
+    "--local",
+    "bind THIS folder to that server (./.stacks/config.json) instead of the machine-wide config"
+  ).option("--no-git", "never touch the current folder's git repository").action(async (options) => {
+    onExit2(await runSetupCommand(options, deps2));
+  });
+}
+
 // src/commands/snapshot.ts
 import {
   closeSync as closeSync2,
@@ -28393,10 +28752,16 @@ var sessionDeps = {
   runSessionHost: (runnerBin, planPath) => runRunnerForeground(runnerBin, ["session-run", "--plan-file", planPath]),
   spawnSessionHostDetached: (runnerBin, planPath, logPath) => {
     const fd = openSync3(logPath, "a", 384);
+    const target = execTarget(runnerBin, [
+      "session-run",
+      "--plan-file",
+      planPath
+    ]);
     try {
-      const child = spawn3(runnerBin, ["session-run", "--plan-file", planPath], {
+      const child = spawn3(target.file, target.args, {
         detached: true,
-        stdio: ["ignore", fd, fd]
+        stdio: ["ignore", fd, fd],
+        ...target.options
       });
       child.unref();
       return child.pid ?? -1;
@@ -28410,36 +28775,92 @@ var sessionCommand = registerSessionCommand(program2, sessionDeps, onExit);
 registerSnapshotCommand(sessionCommand, sessionDeps, onExit);
 registerAlignCommand(program2, sessionDeps, onExit);
 registerPushCommand(program2, sessionDeps, onExit);
+var PACKAGE_ROOT = fileURLToPath(new URL("..", import.meta.url));
 var PLUGIN_DIR = fileURLToPath(new URL("../claude-plugin", import.meta.url));
 var CODEX_PLUGIN_DIR = fileURLToPath(
   new URL("../codex-plugin", import.meta.url)
 );
-registerPluginCommand(
-  program2,
-  {
-    resolvePluginDir: () => existsSync6(PLUGIN_DIR) && isPluginMarketplaceDir(PLUGIN_DIR) ? PLUGIN_DIR : null,
-    resolveCodexPluginDir: () => existsSync6(CODEX_PLUGIN_DIR) && isCodexPluginMarketplaceDir(CODEX_PLUGIN_DIR) ? CODEX_PLUGIN_DIR : null,
-    resolveClaude: () => resolveExecutableOnPath(platformExecutableNames("claude"), process.env),
-    resolveCodex: () => resolveExecutableOnPath(platformExecutableNames("codex"), process.env),
-    resolveRunner: () => resolveRunnerExecutable(process.env),
-    resolveNpm: () => resolveExecutableOnPath(platformExecutableNames("npm"), process.env),
-    invoke: invokeRunnerProcess,
-    writeOut: (text) => process.stdout.write(`${text}
+var pluginDeps = {
+  resolvePluginDir: () => existsSync6(PLUGIN_DIR) && isPluginMarketplaceDir(PLUGIN_DIR) ? PLUGIN_DIR : null,
+  resolveCodexPluginDir: () => existsSync6(CODEX_PLUGIN_DIR) && isCodexPluginMarketplaceDir(CODEX_PLUGIN_DIR) ? CODEX_PLUGIN_DIR : null,
+  resolveClaude: () => resolveExecutableOnPath(platformExecutableNames("claude"), process.env),
+  resolveCodex: () => resolveExecutableOnPath(platformExecutableNames("codex"), process.env),
+  resolveRunner: () => resolveRunnerExecutable(process.env),
+  resolveNpm: () => resolveExecutableOnPath(platformExecutableNames("npm"), process.env),
+  invoke: invokeRunnerProcess,
+  writeOut: (text) => process.stdout.write(`${text}
 `),
-    writeErr: (text) => process.stderr.write(`${text}
+  writeErr: (text) => process.stderr.write(`${text}
 `),
-    // AGE-952: the one-liner install ends connected — same in-process login
-    // reuse as runner setup (never a `jentrix` subprocess).
-    hasCredential: () => {
+  // AGE-952: the one-liner install ends connected — same in-process login
+  // reuse as runner setup (never a `jentrix` subprocess).
+  hasCredential: () => {
+    try {
+      resolveConfig({ env: process.env, file: configFile() });
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  login: () => runLoginCommand({}, loginDeps),
+  isInteractive: Boolean(process.stdin.isTTY && process.stdout.isTTY)
+};
+registerPluginCommand(program2, pluginDeps, onExit);
+registerSetupCommand(
+  program2,
+  {
+    ...pluginDeps,
+    resolveJentrix: () => resolveExecutableOnPath(platformExecutableNames("jentrix"), process.env),
+    resolveGit: () => resolveExecutableOnPath(platformExecutableNames("git"), process.env),
+    // Register the plugin from whichever copy of the package PERSISTS. Under
+    // `npx @jentrix/cli setup` the running module lives in npm's _npx cache,
+    // and a marketplace registered from there dangles the moment npm prunes
+    // it. `npm root -g` names the copy that stays.
+    installPlugin: async (provider) => {
+      const npm = await resolveExecutableOnPath(
+        platformExecutableNames("npm"),
+        process.env
+      );
+      const root = npm ? (await invokeRunnerProcess(npm, ["root", "-g"])).stdout.trim() || null : null;
+      const packageRoot = persistentPluginRoot(
+        root,
+        PACKAGE_ROOT,
+        (dir) => isPluginMarketplaceDir(join6(dir, "claude-plugin"))
+      );
+      return runPluginInstall(
+        packageRoot === PACKAGE_ROOT ? pluginDeps : {
+          ...pluginDeps,
+          resolvePluginDir: () => join6(packageRoot, "claude-plugin"),
+          resolveCodexPluginDir: () => {
+            const dir = join6(packageRoot, "codex-plugin");
+            return isCodexPluginMarketplaceDir(dir) ? dir : null;
+          }
+        },
+        provider
+      );
+    },
+    // The endpoint a token actually resolves against — the in-process answer
+    // to what install.sh had to ask for with `jentrix whoami --json`.
+    signedInUrl: () => {
       try {
-        resolveConfig({ env: process.env, file: configFile() });
-        return true;
+        return resolveConfig({ env: process.env, file: configFile() }).url;
       } catch {
-        return false;
+        return null;
       }
     },
-    login: () => runLoginCommand({}, loginDeps),
-    isInteractive: Boolean(process.stdin.isTTY && process.stdout.isTTY)
+    login: (flags) => runLoginCommand(flags, loginDeps),
+    codexConfigPath: () => join6(process.env.CODEX_HOME ?? join6(homedir(), ".codex"), "config.toml"),
+    readTextFile: (path) => existsSync6(path) ? readFileSync7(path, "utf8") : null,
+    appendTextFile: (path, text) => {
+      mkdirSync4(dirname4(path), { recursive: true });
+      appendFileSync(path, text);
+    },
+    copyFile: (from, to) => copyFileSync(from, to),
+    now: () => /* @__PURE__ */ new Date(),
+    cwd: () => process.cwd(),
+    homeDir: () => homedir(),
+    git: defaultGitRunner,
+    readLine
   },
   onExit
 );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jentrix/cli",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "Command-line client for the Jentrix MCP surface (jentrix tool <name>, generated noun-verb commands).",
   "keywords": [
     "jentrix",