@xevy/cli 0.1.3 → 0.1.6

package/README.md

@@ -10,9 +10,13 @@ npx @xevy/cli         # open pi with the Xevy extension loaded
 ## `xevy setup`
 
 1. Installs the **pi agent** if it isn't already on your PATH.
-2. Downloads the Xevy pi extension (`xevy.ts`) into **`~/.xevy/extensions/`**.
-3. Asks for your **API key** and prints a **direct link to the API-keys tab** so
-   you can generate one in a couple of clicks, then stores it in
+2. Installs the Xevy extensions:
+   - **`xevy-core.ts`** (shared UI + setup/context), **`xevy-model.ts`** (the
+     `xevy/*` models), and **`xevy-mcp.ts`** (the MCP→pi tool bridge) into pi's
+     **global** dir `~/.pi/agent/extensions/`, so they load in *every* pi session.
+   - **`xevy.ts`** (tools + workflow commands) into **`~/.xevy/extensions/`**.
+3. Asks for your **API key** (reuses an already-saved one if present) and prints a
+   **direct link to the API-keys tab** to generate one, then stores it in
    `~/.config/xevy/credentials` (mode `600`, never printed).
 
 The API-keys link opens **Settings → Profile → API keys** directly:
@@ -20,21 +24,14 @@ The API-keys link opens **Settings → Profile → API keys** directly:
 
 ## `xevy`
 
-Opens pi, loading every `*.ts` extension in `~/.xevy/extensions` (`pi -e …`).
-Any extra arguments are forwarded to pi:
+Opens pi, loading `~/.xevy/extensions` via `pi -e …` (pi also auto-loads the
+global dir, so core + model + MCP come along). Extra arguments are forwarded to pi:
 
 ```bash
 xevy                       # interactive pi session with Xevy
 xevy "summarise this repo" # forwards the prompt to pi
 ```
 
-## `xevy pi` (alternative)
-
-Installs the split **model + MCP** extensions (`xevy-model.ts`, `xevy-mcp.ts`)
-into pi's own extensions dir and authenticates over **OAuth** (`/login xevy`) —
-no API key. Use this instead of `setup` if you prefer OAuth and the hosted
-`xevy/*` models + MCP tool bridge.
-
 ## Options
 
 ```

package/bin/xevy.mjs

@@ -2,15 +2,14 @@
 /**
  * @xevy/cli — the `xevy` command.
  *
- *   xevy setup   Install the pi agent (if missing), download the Xevy pi
- *                extension into ~/.xevy/extensions, and store your API key.
- *   xevy         Open pi with the Xevy extensions from ~/.xevy/extensions.
- *   xevy pi      (alt) Install the split model + MCP extensions into pi's own
- *                extensions dir, authenticated via OAuth.
+ *   xevy setup   Install the pi agent (if missing); install the Xevy extensions
+ *                (core + model + MCP globally, xevy.ts into ~/.xevy/extensions);
+ *                and store your API key.
+ *   xevy         Open pi with the Xevy extensions.
  *
- * `xevy setup` is the default flow: it fetches `xevy.ts` from the server and
- * asks for an API key (with a direct link to the exact page to generate one),
- * stored in ~/.config/xevy/credentials. Then `xevy` launches pi with it.
+ * `xevy setup` fetches the extensions from the server and asks for an API key
+ * (with a direct link to the exact page to generate one), stored in
+ * ~/.config/xevy/credentials. Then `xevy` launches pi with them.
  */
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
@@ -40,12 +39,9 @@ const CREDENTIALS_DIR = path.join(
 );
 const CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "credentials");
 
-// `xevy pi` (alt flow) installs these into pi's own extensions dir over OAuth.
+// pi's global extensions dir — core + model + MCP are installed here so they
+// load in every pi session.
 const PI_EXTENSION_DIR = path.join(os.homedir(), ".pi", "agent", "extensions");
-const PI_EXTENSIONS = [
-  { file: "xevy-model.ts", marker: "xevyModelExtension" },
-  { file: "xevy-mcp.ts", marker: "xevyMcpExtension" },
-];
 
 function apiKeysUrl(base) {
   // Direct link to the API keys tab (Profile → API keys), reachable without a
@@ -71,8 +67,7 @@ function usage() {
   console.log(`Xevy CLI
 
   xevy                   Open pi with the Xevy extensions in ~/.xevy/extensions
-  xevy setup [--base u]  Install pi (if missing) + the Xevy pi extension, store your API key
-  xevy pi [--base u]     (alt) Install the split model + MCP extensions over OAuth
+  xevy setup [--base u]  Install pi (if missing) + the Xevy extensions, store your API key
 
 Options:
       --base <url>       Xevy host (default: XEVY_BASE or ${DEFAULT_BASE})
@@ -95,9 +90,9 @@ function parseArgv(argv) {
   if (first === "-h" || first === "--help" || first === "help") return { command: "help", base };
   if (first === "-v" || first === "--version") return { command: "version", base };
 
-  if (first === "setup" || first === "pi") {
+  if (first === "setup") {
     args.shift();
-    const opts = { command: first, base, piArgs: [] };
+    const opts = { command: "setup", base, piArgs: [] };
     while (args.length > 0) {
       const a = args.shift();
       if (a === "--base") {
@@ -106,7 +101,7 @@ function parseArgv(argv) {
         opts.base = v.replace(/\/$/, "");
         continue;
       }
-      die(`Unknown option for \`xevy ${first}\`: ${a}. Try \`xevy --help\`.`);
+      die(`Unknown option for \`xevy setup\`: ${a}. Try \`xevy --help\`.`);
     }
     return opts;
   }
@@ -167,15 +162,22 @@ async function downloadExtension(base, file, destDir, markers) {
   return dest;
 }
 
+// One shared readline interface for the whole prompt sequence. Creating a fresh
+// interface per question drops buffered stdin (the next answer is lost), so we
+// reuse one and close it explicitly when prompting is done.
+let _rl;
 function promptLine(question) {
+  if (!_rl) _rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve) => {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(String(answer || "").trim());
-    });
+    _rl.question(question, (answer) => resolve(String(answer || "").trim()));
   });
 }
+function closePrompts() {
+  if (_rl) {
+    _rl.close();
+    _rl = undefined;
+  }
+}
 
 function writeCredentials(base, token) {
   fs.mkdirSync(CREDENTIALS_DIR, { recursive: true });
@@ -191,6 +193,41 @@ function writeCredentials(base, token) {
   }
 }
 
+/** Return the stored xevy_pk_ token from the credentials file, or null. */
+function readStoredToken() {
+  try {
+    if (!fs.existsSync(CREDENTIALS_FILE)) return null;
+    for (const line of fs.readFileSync(CREDENTIALS_FILE, "utf-8").split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("token=")) {
+        const value = trimmed.slice("token=".length).trim();
+        return value.startsWith(API_KEY_PREFIX) ? value : null;
+      }
+    }
+  } catch {
+    // ignore unreadable credentials
+  }
+  return null;
+}
+
+function isYes(answer, defaultYes = true) {
+  const a = String(answer || "").trim().toLowerCase();
+  if (!a) return defaultYes;
+  return a === "y" || a === "yes";
+}
+
+async function promptNewApiKey(base) {
+  console.log("\nGet your API key (this link opens the API keys tab directly):");
+  console.log(`  ${apiKeysUrl(base)}`);
+  console.log("  Sign in if prompted, then click “Create API key” and copy it.\n");
+  const token = await promptLine(`Paste your Xevy API key (${API_KEY_PREFIX}…): `);
+  if (!token) die("API key is required. Re-run `xevy setup` when you have one.");
+  if (!token.startsWith(API_KEY_PREFIX)) {
+    die(`That doesn't look like a Xevy API key (expected '${API_KEY_PREFIX}…'). Not saved.`);
+  }
+  return token;
+}
+
 async function setup(opts) {
   console.log("Setting up Xevy for pi\n");
 
@@ -198,33 +235,48 @@ async function setup(opts) {
   ensurePi();
 
   // 2. Extensions:
-  //    • xevy.ts       → ~/.xevy/extensions   (tools/workflow; loaded by `xevy`)
-  //    • xevy-model.ts → pi's GLOBAL extensions dir, so the xevy/* models are
-  //      available in EVERY pi session (plain `pi` too), not just via `xevy`.
-  await downloadExtension(opts.base, XEVY_EXTENSION_FILE, XEVY_EXTENSIONS_DIR, [
-    "EXTENSION_VERSION",
+  //    • xevy-core.ts  → pi's GLOBAL extensions dir (shared base: ask_question
+  //      tool + setup/context). Global so it loads in EVERY pi session and is
+  //      always present for xevy.ts (which requires it). Global-only avoids a
+  //      double-load: if it were also in ~/.xevy it'd register ask_question twice.
+  //    • xevy-model.ts → GLOBAL too, so the xevy/* models are available in every
+  //      pi session (plain `pi` included), not just via `xevy`.
+  //    • xevy-mcp.ts   → GLOBAL too — the MCP→pi tool bridge (auth reused from
+  //      the model login), available in every pi session.
+  //    • xevy.ts       → ~/.xevy/extensions (tools/workflow; loaded by `xevy`,
+  //      which also auto-loads the global dir → core + model + MCP come along).
+  await downloadExtension(opts.base, "xevy-core.ts", PI_EXTENSION_DIR, [
+    "xevyCoreExtension",
     "registerCommand",
   ]);
   await downloadExtension(opts.base, "xevy-model.ts", PI_EXTENSION_DIR, [
     "xevyModelExtension",
     "registerCommand",
   ]);
+  await downloadExtension(opts.base, "xevy-mcp.ts", PI_EXTENSION_DIR, [
+    "xevyMcpExtension",
+    "registerCommand",
+  ]);
+  await downloadExtension(opts.base, XEVY_EXTENSION_FILE, XEVY_EXTENSIONS_DIR, [
+    "EXTENSION_VERSION",
+    "registerCommand",
+  ]);
 
-  // 2. API key — with a direct link to the exact page to generate one.
-  console.log("\nGet your API key (this link opens the API keys tab directly):");
-  console.log(`  ${apiKeysUrl(opts.base)}`);
-  console.log("  Sign in if prompted, then click “Create API key” and copy it.\n");
-
-  const token = await promptLine(`Paste your Xevy API key (${API_KEY_PREFIX}…): `);
-  if (!token) die("API key is required. Re-run `xevy setup` when you have one.");
-  if (!token.startsWith(API_KEY_PREFIX)) {
-    die(`That doesn't look like a Xevy API key (expected '${API_KEY_PREFIX}…'). Not saved.`);
+  // 3. API key — reuse the saved one if present, otherwise ask for a new one.
+  const existing = readStoredToken();
+  let token;
+  if (existing) {
+    const reuse = await promptLine(`An API key is already saved (…${existing.slice(-4)}). Reuse it? [Y/n]: `);
+    token = isYes(reuse) ? existing : await promptNewApiKey(opts.base);
+  } else {
+    token = await promptNewApiKey(opts.base);
   }
+  closePrompts();
   writeCredentials(opts.base, token);
   console.log(`✓ API key stored at ${CREDENTIALS_FILE} (key not shown).`);
 
   console.log("\n✓ Setup complete.");
-  console.log("  • Xevy models (xevy/auto, xevy/fast, …) are available in any pi session — no /login needed.");
+  console.log("  • Xevy models (xevy/auto, xevy/fast, …) + MCP tools are available in any pi session — no /login needed.");
   console.log("  • Run `xevy` to open pi with the Xevy tools + models loaded.");
   if (opts.base !== DEFAULT_BASE) console.log(`  • Host: ${opts.base}`);
 }
@@ -253,29 +305,12 @@ function open(opts) {
   process.exit(r.status ?? 0);
 }
 
-async function piSetup(opts) {
-  console.log("Setting up the pi agent + Xevy extensions (model + MCP)\n");
-
-  ensurePi();
-  for (const ext of PI_EXTENSIONS) {
-    await downloadExtension(opts.base, ext.file, PI_EXTENSION_DIR, [ext.marker, "registerCommand"]);
-  }
-
-  console.log("\n✓ pi + Xevy extensions ready.");
-  console.log("  • Sign in once: /login xevy — authenticates both the models and the MCP tools.");
-  console.log("  • Xevy models: xevy/auto, xevy/fast, xevy/advance, xevy/min, xevy/max, xevy/vision.");
-  console.log("  • MCP tools bridge automatically on session start (or run /xevy-mcp).");
-  console.log("  • If pi is already running, use /reload to load the extensions.");
-  if (opts.base !== DEFAULT_BASE) console.log(`  • Source host: ${opts.base}`);
-}
-
 async function main() {
   const opts = parseArgv(process.argv.slice(2));
 
   if (opts.command === "help") return usage();
   if (opts.command === "version") return console.log(readCliVersion());
   if (opts.command === "setup") return setup(opts);
-  if (opts.command === "pi") return piSetup(opts);
   if (opts.command === "open") return open(opts);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xevy/cli",
-  "version": "0.1.3",
+  "version": "0.1.6",
   "description": "Xevy CLI — `xevy setup` installs the pi agent + the Xevy pi extension and stores your API key; `xevy` opens pi with it.",
   "type": "module",
   "keywords": [