@lunaroute/cli 0.1.0 → 0.2.0

package/dist/index.js

@@ -0,0 +1,1623 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command, InvalidArgumentError, Option } from "commander";
+
+// src/login.ts
+import { createServer } from "http";
+import { hostname } from "os";
+import open from "open";
+
+// src/pkce.ts
+import { randomBytes, createHash } from "crypto";
+function genState() {
+  return randomBytes(16).toString("hex");
+}
+function genVerifier() {
+  return randomBytes(32).toString("hex");
+}
+function challengeFor(verifier) {
+  return createHash("sha256").update(verifier).digest("hex");
+}
+
+// src/apiClient.ts
+async function exchangeCode(apiUrl, req) {
+  const res = await fetch(`${apiUrl}/v1/auth/cli/exchange`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(req)
+  });
+  if (!res.ok) {
+    let detail = `HTTP ${res.status}`;
+    try {
+      const body = await res.json();
+      const code = body?.error?.code;
+      const message = body?.error?.message;
+      if (code && message) detail = `${code}: ${message}`;
+      else if (code) detail = code;
+      else if (message) detail = message;
+    } catch {
+    }
+    throw new Error(`exchange failed: ${detail}`);
+  }
+  return await res.json();
+}
+async function cliGet(ctx, path) {
+  const res = await fetch(`${ctx.apiUrl}${path}`, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${ctx.apiKey}` }
+  });
+  if (!res.ok) {
+    let detail = `HTTP ${res.status}`;
+    try {
+      const body2 = await res.json();
+      const code = body2?.error?.code;
+      const message = body2?.error?.message;
+      if (code && message) detail = `${code}: ${message}`;
+      else if (code) detail = code;
+      else if (message) detail = message;
+    } catch {
+    }
+    throw new Error(`request failed: ${detail}`);
+  }
+  const body = await res.json();
+  return body.data;
+}
+async function getModels(ctx) {
+  const data = await cliGet(ctx, "/v1/cli/models");
+  return data.map((m) => m.id).sort();
+}
+async function getPricing(ctx, model) {
+  const q = model ? `?model=${encodeURIComponent(model)}` : "";
+  return cliGet(ctx, `/v1/cli/pricing${q}`);
+}
+async function getUsage(ctx, limit) {
+  const q = limit ? `?limit=${limit}` : "";
+  return cliGet(ctx, `/v1/cli/usage${q}`);
+}
+
+// src/config.ts
+import { homedir } from "os";
+import { join } from "path";
+import {
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  renameSync,
+  existsSync,
+  chmodSync
+} from "fs";
+function configDir() {
+  const base = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(base, "lunaroute");
+}
+function configPath() {
+  return join(configDir(), "config.json");
+}
+function hasValidShape(parsed) {
+  return typeof parsed === "object" && parsed !== null && typeof parsed.profiles === "object" && parsed.profiles !== null;
+}
+function backupCorruptConfig(path) {
+  const backup = `${path}.corrupt`;
+  try {
+    if (existsSync(backup)) {
+      console.warn(
+        `lunaroute: config file at ${path} is invalid; a prior backup exists at ${backup}`
+      );
+      return;
+    }
+    renameSync(path, backup);
+    console.warn(
+      `lunaroute: config file was invalid and has been moved to ${backup}`
+    );
+  } catch {
+    console.warn(`lunaroute: config file at ${path} is invalid`);
+  }
+}
+function readConfig() {
+  const path = configPath();
+  if (!existsSync(path)) return { profiles: {} };
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    backupCorruptConfig(path);
+    return { profiles: {} };
+  }
+  if (!hasValidShape(parsed)) {
+    backupCorruptConfig(path);
+    return { profiles: {} };
+  }
+  return parsed;
+}
+function writeConfig(cfg) {
+  mkdirSync(configDir(), { recursive: true, mode: 448 });
+  const path = configPath();
+  writeFileSync(path, JSON.stringify(cfg, null, 2), { mode: 384 });
+  chmodSync(path, 384);
+}
+function loadProfile(name) {
+  return readConfig().profiles[name] ?? null;
+}
+function saveProfile(name, creds) {
+  const cfg = readConfig();
+  cfg.profiles[name] = creds;
+  writeConfig(cfg);
+}
+function clearProfile(name) {
+  const cfg = readConfig();
+  delete cfg.profiles[name];
+  writeConfig(cfg);
+}
+function resolveSettings(name) {
+  const stored = loadProfile(name) ?? {
+    api_url: "https://api.lunaroute.com",
+    routing_url: "https://gw.lunaroute.com",
+    front_url: "https://app.lunaroute.com",
+    org_id: "",
+    routing_key: "",
+    user_email: ""
+  };
+  return {
+    api_url: process.env.LUNAROUTE_API_URL || stored.api_url,
+    routing_url: process.env.LUNAROUTE_ROUTING_URL || stored.routing_url,
+    front_url: process.env.LUNAROUTE_FRONT_URL || stored.front_url,
+    org_id: stored.org_id,
+    routing_key: process.env.LUNAROUTE_API_KEY || stored.routing_key,
+    user_email: stored.user_email
+  };
+}
+
+// src/login.ts
+var LOGIN_TIMEOUT_MS = 3 * 6e4;
+async function waitWithTimeout(server, ms) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(
+        new Error(
+          "timed out waiting for browser authorization. Re-run `lunaroute login`."
+        )
+      ),
+      ms
+    );
+  });
+  try {
+    return await Promise.race([server.waitForCallback(), timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+    server.close();
+  }
+}
+async function startLoopbackServer() {
+  let resolveCb;
+  const cbPromise = new Promise((r) => resolveCb = r);
+  const server = createServer((req, res) => {
+    const url = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (url.pathname !== "/callback") {
+      res.statusCode = 404;
+      res.end("not found");
+      return;
+    }
+    const code = url.searchParams.get("code") ?? "";
+    const state = url.searchParams.get("state") ?? "";
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "text/html");
+    res.end(
+      "<html><body><h2>LunaRoute CLI authorized.</h2><p>You can close this tab and return to your terminal.</p></body></html>"
+    );
+    resolveCb({ code, state });
+  });
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const addr = server.address();
+  const port = typeof addr === "object" && addr ? addr.port : 0;
+  return {
+    port,
+    waitForCallback: () => cbPromise,
+    close: () => server.close()
+  };
+}
+async function runLogin(profile) {
+  const settings = resolveSettings(profile);
+  const state = genState();
+  const verifier = genVerifier();
+  const challenge = challengeFor(verifier);
+  const server = await startLoopbackServer();
+  const authUrl = `${settings.front_url}/cli-auth?port=${server.port}&state=${state}&challenge=${challenge}`;
+  console.log(`Opening your browser to authorize:
+  ${authUrl}
+`);
+  await open(authUrl).catch(() => {
+    console.log(
+      "Could not open a browser automatically. Open the URL above manually."
+    );
+  });
+  const cb = await waitWithTimeout(server, LOGIN_TIMEOUT_MS);
+  if (cb.state !== state) {
+    throw new Error(
+      "state mismatch \u2014 aborting (possible cross-process interference)"
+    );
+  }
+  const result = await exchangeCode(settings.api_url, {
+    code: cb.code,
+    verifier,
+    label: hostname()
+  });
+  saveProfile(profile, {
+    api_url: settings.api_url,
+    routing_url: settings.routing_url,
+    front_url: settings.front_url,
+    org_id: result.org_id,
+    routing_key: result.full_key,
+    user_email: result.user_email
+  });
+  console.log(`
+\u2713 Logged in as ${result.user_email} (org ${result.org_id}).`);
+  console.log(`  Routing key saved to profile "${profile}".`);
+}
+
+// src/commands/login.ts
+async function login(profile) {
+  try {
+    await runLogin(profile);
+  } catch (err) {
+    console.error(`Login failed: ${err.message}`);
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/whoami.ts
+function whoami(profile) {
+  const creds = loadProfile(profile);
+  if (!creds || !creds.routing_key) {
+    console.log('Not logged in. Run "lunaroute login" to get started.');
+    return;
+  }
+  console.log(`Logged in as ${creds.user_email}`);
+  console.log(`  Organization: ${creds.org_id}`);
+  console.log(`  Profile:      ${profile}`);
+  console.log(`  API:          ${creds.api_url}`);
+}
+
+// src/commands/logout.ts
+function logout(profile) {
+  if (!loadProfile(profile)) {
+    console.log(`No credentials stored for profile "${profile}".`);
+    return;
+  }
+  clearProfile(profile);
+  console.log(`Logged out of profile "${profile}".`);
+}
+
+// src/catalog.ts
+async function fetchModels(routingUrl) {
+  const url = `${routingUrl}/v1/models`;
+  const res = await fetch(url, { method: "GET" });
+  if (!res.ok) {
+    throw new Error(`failed to fetch models: HTTP ${res.status} from ${url}`);
+  }
+  const body = await res.json();
+  const models = (body.data ?? []).map((m) => ({
+    id: m.id ?? "",
+    display_name: m.display_name,
+    context_window_tokens: m.context_window,
+    max_output_tokens: m.max_output_tokens,
+    capabilities: m.capabilities,
+    client_compat: m.client_compat
+  })).filter((m) => m.id.length > 0);
+  if (models.length === 0) {
+    throw new Error(`no models available from ${url}`);
+  }
+  return models.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+// src/setup/apply.ts
+import {
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2,
+  copyFileSync,
+  existsSync as existsSync2,
+  chmodSync as chmodSync2
+} from "fs";
+import { dirname } from "path";
+function readExistingJson(path) {
+  if (!existsSync2(path)) return null;
+  const raw = readFileSync2(path, "utf8").trim();
+  if (raw === "") return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(
+      `refusing to modify ${path}: it exists but is not valid JSON (malformed). Fix or remove it, or re-run with --print to copy the config manually.`
+    );
+  }
+}
+function resolveContent(fw) {
+  if (fw.kind === "text") {
+    const curStr2 = existsSync2(fw.path) ? readFileSync2(fw.path, "utf8") : null;
+    return { nextStr: fw.content, curStr: curStr2 };
+  }
+  const existing = readExistingJson(fw.path);
+  const curStr = existing === null ? null : `${JSON.stringify(existing, null, 2)}
+`;
+  const nextStr = `${JSON.stringify(fw.merge(existing), null, 2)}
+`;
+  return { nextStr, curStr };
+}
+async function applyPlan(plan, opts) {
+  const summary = { written: [], backedUp: [] };
+  for (const fw of plan.fileWrites) {
+    const { nextStr, curStr } = resolveContent(fw);
+    if (opts.print) {
+      console.log(`
+# would write ${fw.path}:
+${nextStr}`);
+      continue;
+    }
+    if (curStr !== null) {
+      if (curStr === nextStr) continue;
+      copyFileSync(fw.path, `${fw.path}.bak`);
+      summary.backedUp.push(`${fw.path}.bak`);
+    }
+    const dir = dirname(fw.path);
+    const dirExisted = existsSync2(dir);
+    mkdirSync2(dir, { recursive: true });
+    if (!dirExisted) chmodSync2(dir, fw.dirMode ?? 448);
+    writeFileSync2(fw.path, nextStr, { mode: fw.fileMode ?? 384 });
+    chmodSync2(fw.path, fw.fileMode ?? 384);
+    summary.written.push(fw.path);
+  }
+  if (plan.exports.length > 0) {
+    console.log("\n# Add these to your shell profile:");
+    for (const e of plan.exports) {
+      const value = e.value === "__KEY__" ? opts.key : e.value;
+      console.log(`export ${e.name}=${value}`);
+    }
+  }
+  for (const note of plan.notes) console.log(note);
+  return summary;
+}
+
+// src/setup/prompt.ts
+import { createInterface } from "readline/promises";
+var NonInteractiveTerminalError = class extends Error {
+};
+async function confirm(question, opts = {}) {
+  if (opts.yes) return true;
+  const input = opts.input ?? process.stdin;
+  if (!input.isTTY) {
+    throw new NonInteractiveTerminalError();
+  }
+  const rl = createInterface({ input, output: opts.output ?? process.stdout });
+  try {
+    const answer = (await rl.question(`${question} [y/N] `)).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+// src/commands/setup.ts
+import { spawn } from "child_process";
+
+// src/setup/paths.ts
+import { execSync } from "child_process";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function configHome() {
+  return process.env.XDG_CONFIG_HOME || join2(homedir2(), ".config");
+}
+function opencodeConfigPath() {
+  return join2(configHome(), "opencode", "opencode.json");
+}
+function openclawConfigPath() {
+  return join2(homedir2(), ".openclaw", "openclaw.json");
+}
+function piModelsPath() {
+  return join2(homedir2(), ".pi", "agent", "models.json");
+}
+var LUNAROUTE_SKILL_NAME = "lunaroute-memory";
+function claudeUserConfigPath() {
+  return join2(homedir2(), ".claude.json");
+}
+function claudeUserSkillPath(name = LUNAROUTE_SKILL_NAME) {
+  return join2(homedir2(), ".claude", "skills", name, "SKILL.md");
+}
+function claudeProjectMcpPath(root) {
+  return join2(root, ".mcp.json");
+}
+function claudeProjectSkillPath(root, name = LUNAROUTE_SKILL_NAME) {
+  return join2(root, ".claude", "skills", name, "SKILL.md");
+}
+function gitRepoRoot(cwd = process.cwd()) {
+  try {
+    const out = execSync("git rev-parse --show-toplevel", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return out || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/setup/adapters/opencode.ts
+var EXTENSION = "@lunaroute/opencode-extension";
+var PROD_GATEWAY_HOST = "gw.lunaroute.com";
+function buildPlan(ctx, opts = {}) {
+  if (opts.extension) return extensionPlan(ctx);
+  return providerPlan(ctx);
+}
+function extensionPlan(ctx) {
+  return {
+    fileWrites: [
+      {
+        kind: "json",
+        path: opencodeConfigPath(),
+        merge: (existing) => {
+          const obj = existing ?? {};
+          const raw = obj.plugin;
+          const plugins = Array.isArray(raw) ? raw : typeof raw === "string" ? [raw] : [];
+          if (!plugins.includes(EXTENSION)) plugins.push(EXTENSION);
+          const next = { ...obj, plugin: plugins };
+          if (!isProdGateway(ctx.routingUrl)) {
+            const providers = objectOrEmpty(obj.provider);
+            const lr = objectOrEmpty(providers.lunaroute);
+            next.provider = {
+              ...providers,
+              lunaroute: { ...lr, options: { ...objectOrEmpty(lr.options), baseURL: `${ctx.routingUrl}/v1` } }
+            };
+          }
+          return next;
+        }
+      }
+    ],
+    // No env key: login happens in-app via /connect.
+    exports: [],
+    notes: [
+      "\nopencode: the extension installs on the next opencode start (npm plugins auto-install at startup).",
+      "Inside opencode: run /connect to log in, then /models to pick a LunaRoute model."
+    ]
+  };
+}
+function isProdGateway(url) {
+  try {
+    return new URL(url).host === PROD_GATEWAY_HOST;
+  } catch {
+    return false;
+  }
+}
+function objectOrEmpty(v) {
+  return typeof v === "object" && v !== null ? v : {};
+}
+function providerPlan(ctx) {
+  const models = {};
+  for (const m of ctx.models) models[m.id] = { name: m.id };
+  const block = {
+    npm: "@ai-sdk/openai-compatible",
+    name: "LunaRoute",
+    options: {
+      baseURL: `${ctx.routingUrl}/v1`,
+      // Real key; the AI-SDK sends it as Authorization: Bearer lr_…, which
+      // LunaRoute authenticates and strips at the edge.
+      apiKey: `{env:${ctx.keyEnvVar}}`
+    },
+    models
+  };
+  return {
+    fileWrites: [
+      {
+        kind: "json",
+        path: opencodeConfigPath(),
+        merge: (existing) => {
+          const obj = existing ?? {};
+          const existingProviders = objectOrEmpty(obj.provider);
+          const provider = { ...existingProviders, lunaroute: block };
+          return { ...obj, provider };
+        }
+      }
+    ],
+    exports: [{ name: ctx.keyEnvVar, value: "__KEY__" }],
+    notes: [
+      "\nopencode: restart opencode, then run /models and pick a LunaRoute model."
+    ]
+  };
+}
+
+// src/setup/adapters/pi.ts
+function buildPiModelEntry(m) {
+  const reasoning = m.capabilities?.reasoning === true;
+  const entry = {
+    id: m.id,
+    name: m.display_name ?? m.id,
+    reasoning,
+    input: m.capabilities?.vision ? ["text", "image"] : ["text"],
+    contextWindow: m.context_window_tokens ?? 0,
+    maxTokens: m.max_output_tokens ?? 0
+  };
+  if (!reasoning) return entry;
+  const pi = m.client_compat?.pi;
+  if (!pi) return entry;
+  if (pi.thinkingLevelMap && typeof pi.thinkingLevelMap === "object") {
+    entry.thinkingLevelMap = pi.thinkingLevelMap;
+  }
+  const compat = {};
+  for (const [k, v] of Object.entries(pi)) {
+    if (k !== "thinkingLevelMap") compat[k] = v;
+  }
+  if (Object.keys(compat).length > 0) entry.compat = compat;
+  return entry;
+}
+function buildPlan2(ctx) {
+  const block = {
+    baseUrl: `${ctx.routingUrl}/v1`,
+    api: "openai-completions",
+    // Real key; rides the native Authorization: Bearer header.
+    apiKey: `$${ctx.keyEnvVar}`,
+    models: ctx.models.map(buildPiModelEntry)
+  };
+  return {
+    fileWrites: [
+      {
+        kind: "json",
+        path: piModelsPath(),
+        merge: (existing) => {
+          const obj = existing ?? {};
+          const existingProviders = typeof obj.providers === "object" && obj.providers !== null ? obj.providers : {};
+          const providers = { ...existingProviders, lunaroute: block };
+          return { ...obj, providers };
+        }
+      }
+    ],
+    exports: [{ name: ctx.keyEnvVar, value: "__KEY__" }],
+    notes: [
+      "\npi: open /model to pick a LunaRoute model (models.json hot-reloads).",
+      "Tip: the lunaroute-pi-extension auto-registers models from /v1/models so you can skip this file \u2014 `pi install npm:@lunaroute/pi-extension` then `/login lunaroute`."
+    ]
+  };
+}
+
+// src/setup/adapters/claudeCode.ts
+function buildPlan3(ctx) {
+  const firstModel = ctx.models[0]?.id ?? "<model>";
+  return {
+    fileWrites: [],
+    exports: [
+      { name: ctx.keyEnvVar, value: "__KEY__" },
+      // Point at the routing root; Claude Code appends /v1/messages itself.
+      { name: "ANTHROPIC_BASE_URL", value: ctx.routingUrl },
+      // Claude Code sends ANTHROPIC_API_KEY as the native x-api-key header. The
+      // routing edge recognizes the lr_ prefix, authenticates it, and strips the
+      // header before forwarding upstream — so the key never leaks and never
+      // sits in the URL path.
+      { name: "ANTHROPIC_API_KEY", value: `$${ctx.keyEnvVar}` },
+      { name: "ANTHROPIC_MODEL", value: firstModel }
+    ],
+    notes: [
+      "\nClaude Code: add the exports above to your shell profile, then restart Claude Code.",
+      `Change ANTHROPIC_MODEL to any of: ${ctx.models.map((m) => m.id).join(", ")}`,
+      "(Auth travels in the native x-api-key header via ANTHROPIC_API_KEY.)",
+      "If your Claude Code build requires a bearer token instead, set ANTHROPIC_AUTH_TOKEN=$LUNAROUTE_API_KEY \u2014 LunaRoute also authenticates lr_ keys sent as Authorization: Bearer.",
+      "To set these in ~/.claude/settings.json instead, note its env values are literal \u2014 the key would be baked into the file rather than read from $LUNAROUTE_API_KEY.",
+      "If Claude Code hangs or keeps retrying when connecting, your key is likely wrong \u2014 it retries auth errors silently. Debug with the curl below, which fails fast with the real error:",
+      `  curl ${ctx.routingUrl}/v1/messages -H "x-api-key: $${ctx.keyEnvVar}" -H "content-type: application/json" -d '{"model":"${firstModel}","max_tokens":16,"messages":[{"role":"user","content":"ping"}]}'`
+    ]
+  };
+}
+
+// src/setup/adapters/copilotCli.ts
+function buildPlan4(ctx) {
+  const firstModel = ctx.models[0]?.id ?? "<model>";
+  return {
+    fileWrites: [],
+    exports: [
+      { name: ctx.keyEnvVar, value: "__KEY__" },
+      // OpenAI-compatible provider; Copilot CLI appends /chat/completions itself.
+      { name: "COPILOT_PROVIDER_TYPE", value: "openai" },
+      { name: "COPILOT_PROVIDER_BASE_URL", value: `${ctx.routingUrl}/v1` },
+      // Copilot sends this as Authorization: Bearer. The lr_ prefix tells the
+      // routing service it is a LunaRoute key (authenticated at the edge, never
+      // forwarded upstream), so the key stays out of the URL path.
+      { name: "COPILOT_PROVIDER_API_KEY", value: `$${ctx.keyEnvVar}` },
+      { name: "COPILOT_MODEL", value: firstModel }
+    ],
+    notes: [
+      "\nGitHub Copilot CLI: add the exports above to your shell profile, then restart Copilot CLI.",
+      `Change COPILOT_MODEL to any of: ${ctx.models.map((m) => m.id).join(", ")}`,
+      "Auth rides the Authorization header as a bearer token; LunaRoute recognizes the lr_ key prefix and authenticates it at the edge (it is never sent to the upstream provider).",
+      `Anthropic-style alternative: set COPILOT_PROVIDER_TYPE=anthropic and COPILOT_PROVIDER_BASE_URL=${ctx.routingUrl} (no /v1); the key then rides the x-api-key header.`,
+      `Verify with: curl ${ctx.routingUrl}/v1/chat/completions -H "Authorization: Bearer $${ctx.keyEnvVar}" -H "content-type: application/json" -d '{"model":"${firstModel}","max_tokens":16,"messages":[{"role":"user","content":"ping"}]}'`
+    ]
+  };
+}
+
+// src/setup/adapters/generic.ts
+function buildPlan5(ctx) {
+  return {
+    fileWrites: [],
+    exports: [{ name: ctx.keyEnvVar, value: "__KEY__" }],
+    notes: [
+      "\nGeneric OpenAI-compatible setup:",
+      `  Base URL:  ${ctx.routingUrl}/v1`,
+      `  Auth:      header  Authorization: Bearer $${ctx.keyEnvVar}`,
+      `  Auth (alt): path    ${ctx.routingUrl}/a/$${ctx.keyEnvVar}/v1`,
+      `  Sample model id: ${ctx.models[0]?.id ?? "<model>"}`,
+      `  All models: ${ctx.models.map((m) => m.id).join(", ")}`
+    ]
+  };
+}
+
+// src/setup/routing-url.ts
+function validatedRoutingUrl(routingUrl) {
+  function fail(reason) {
+    throw new Error(
+      `routingUrl rejected (reason: ${reason}; <redacted URL>) \u2014 check --routing-url or the profile's routing URL`
+    );
+  }
+  if (!/^https?:\/\/[^/?#]/.test(routingUrl)) fail("invalid-url");
+  if (/[?#]/.test(routingUrl)) fail("query-or-fragment");
+  if (routingUrl !== routingUrl.trim()) fail("whitespace");
+  if (routingUrl.endsWith("/")) fail("trailing-slash");
+  let parsed;
+  try {
+    parsed = new URL(routingUrl);
+  } catch {
+    fail("invalid-url");
+  }
+  if (parsed.username !== "" || parsed.password !== "") fail("userinfo");
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") fail("invalid-url");
+  if (parsed.hostname === "") fail("invalid-url");
+  return routingUrl;
+}
+
+// src/setup/adapters/openclaw.ts
+function asRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
+}
+function buildPlan6(ctx) {
+  const base = validatedRoutingUrl(ctx.routingUrl);
+  const models = ctx.models.map((m) => ({ id: m.id, name: m.id }));
+  return {
+    fileWrites: [
+      {
+        kind: "json",
+        path: openclawConfigPath(),
+        merge: (existing) => {
+          const obj = asRecord(existing);
+          const modelsCfg = asRecord(obj.models);
+          const providers = asRecord(modelsCfg.providers);
+          const agents = asRecord(obj.agents);
+          const defaults = asRecord(agents.defaults);
+          const model = asRecord(defaults.model);
+          return {
+            ...obj,
+            models: {
+              ...modelsCfg,
+              mode: modelsCfg.mode ?? "merge",
+              providers: {
+                ...providers,
+                lunaroute: {
+                  baseUrl: `${base}/v1`,
+                  // OpenClaw interpolates the env var and sends it as
+                  // Authorization: Bearer lr_…; the edge authenticates the lr_
+                  // key and strips the header before forwarding upstream.
+                  apiKey: `\${${ctx.keyEnvVar}}`,
+                  api: "openai-completions",
+                  models
+                }
+              }
+            },
+            agents: {
+              ...agents,
+              defaults: {
+                ...defaults,
+                model: {
+                  ...model,
+                  // Preserve an existing primary model, like OpenClaw onboarding.
+                  primary: model.primary ?? `lunaroute/${ctx.models[0]?.id ?? "<model>"}`
+                }
+              }
+            }
+          };
+        }
+      }
+    ],
+    exports: [{ name: ctx.keyEnvVar, value: "__KEY__" }],
+    notes: [
+      `
+openclaw: restart the gateway, then \`openclaw models list\` and \`openclaw models set lunaroute/${ctx.models[0]?.id ?? "<model>"}\` (only if you have no default model already). If lunaroute/* models do not appear in \`openclaw models list\`, check that models.mode is merge \u2014 setup preserves whatever mode you have.`
+    ]
+  };
+}
+
+// src/commands/setup.ts
+var ADAPTERS = {
+  opencode: buildPlan,
+  pi: buildPlan2,
+  openclaw: buildPlan6,
+  "claude-code": buildPlan3,
+  "copilot-cli": buildPlan4,
+  generic: buildPlan5
+};
+var PI_INSTALL_PACKAGES = ["npm:@lunaroute/pi-extension", "npm:pi-mcp-adapter"];
+async function runSetup(harness, opts, deps = {
+  confirm,
+  spawn: (command, args) => spawn(command, args, { stdio: "inherit" })
+}) {
+  if (harness === "pi" && opts.extension && opts.models) {
+    console.error("Choose one of --extension or --models.");
+    return 1;
+  }
+  const adapter = ADAPTERS[harness];
+  if (!adapter) {
+    console.error(`Unknown harness "${harness}". Choose one of: ${Object.keys(ADAPTERS).join(", ")}.`);
+    return 1;
+  }
+  const creds = loadProfile(opts.profile);
+  if (!creds || !creds.routing_key) {
+    console.error('Not logged in. Run "lunaroute login" first.');
+    return 1;
+  }
+  const routingUrlRaw = opts.routingUrl || creds.routing_url;
+  if (!routingUrlRaw) {
+    console.error("No routing URL in profile; pass --routing-url.");
+    return 1;
+  }
+  let routingUrl;
+  try {
+    routingUrl = validatedRoutingUrl(routingUrlRaw.replace(/\/+$/, "").trim());
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    return 1;
+  }
+  if (harness === "pi" && !opts.print) {
+    return runPiSetup(opts, deps);
+  }
+  if (harness === "opencode") {
+    return runOpencodeSetup(creds, routingUrl, opts, deps);
+  }
+  let models;
+  try {
+    models = await fetchModels(routingUrl);
+  } catch (err) {
+    console.error(`Could not fetch the model catalog: ${err instanceof Error ? err.message : err}`);
+    return 1;
+  }
+  const ctx = {
+    routingUrl,
+    orgId: creds.org_id,
+    models,
+    keyEnvVar: "LUNAROUTE_API_KEY"
+  };
+  let plan;
+  try {
+    plan = adapter(ctx);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    return 1;
+  }
+  try {
+    const summary = await applyPlan(plan, { print: opts.print, key: creds.routing_key });
+    if (!opts.print && summary.written.length > 0) {
+      console.log(`
+Wrote: ${summary.written.join(", ")}`);
+      if (summary.backedUp.length > 0) console.log(`  Backups: ${summary.backedUp.join(", ")}`);
+    }
+    return 0;
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+}
+async function runPiSetup(opts, deps) {
+  try {
+    if (opts.extension) {
+      const ok = await deps.confirm(
+        "Install the LunaRoute Pi extension + MCP adapter via 'pi install'?",
+        { yes: opts.yes }
+      );
+      if (!ok) {
+        console.log("Skipped. Re-run with --yes, or install manually:");
+        console.log(`  pi install ${PI_INSTALL_PACKAGES.join(" && pi install ")}`);
+        return 0;
+      }
+      return installPiExtension(deps.spawn);
+    }
+    if (opts.models) {
+      return applyPiModels(opts, await deps.confirm("Merge LunaRoute provider into ~/.pi/agent/models.json (backup kept, other providers preserved)?", { yes: opts.yes }));
+    }
+    if (await deps.confirm(
+      "Install the LunaRoute Pi extension + MCP adapter via 'pi install' (recommended \u2014 auto-registers models)?",
+      { yes: opts.yes }
+    )) {
+      return installPiExtension(deps.spawn);
+    }
+    return applyPiModels(
+      opts,
+      await deps.confirm("Merge LunaRoute provider into ~/.pi/agent/models.json (backup kept, other providers preserved)?", {
+        yes: opts.yes
+      })
+    );
+  } catch (err) {
+    if (err instanceof NonInteractiveTerminalError) {
+      console.error(
+        "No interactive terminal available. Re-run with --yes to accept prompts, or --print to preview without writing."
+      );
+      return 1;
+    }
+    console.error(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+}
+async function runOpencodeSetup(creds, routingUrl, opts, deps) {
+  try {
+    if (opts.print) {
+      const plan = buildPlan(
+        { routingUrl, orgId: creds.org_id, models: [], keyEnvVar: "LUNAROUTE_API_KEY" },
+        { extension: true }
+      );
+      return applyAndReport(plan, creds.routing_key, false);
+    }
+    if (await deps.confirm(
+      "Install the LunaRoute OpenCode extension (recommended \u2014 /connect login, models auto-sync)?",
+      { yes: opts.yes }
+    )) {
+      const plan = buildPlan(
+        { routingUrl, orgId: creds.org_id, models: [], keyEnvVar: "LUNAROUTE_API_KEY" },
+        { extension: true }
+      );
+      const code = await applyAndReport(plan, creds.routing_key, !opts.print);
+      if (code !== 0) return code;
+      if (await deps.confirm("Start opencode now? (if it's already open, quit and reopen it to load the extension)", {
+        yes: opts.yes
+      })) {
+        return launchOpencode(deps.spawn);
+      }
+      console.log("\nStart opencode when ready \u2014 then run /connect to log in and /models to pick a LunaRoute model.");
+      return 0;
+    }
+    const write = await deps.confirm(
+      "Merge LunaRoute provider into opencode.json instead? (backup kept, other providers preserved)",
+      { yes: opts.yes }
+    );
+    return applyOpencodeProvider(creds, routingUrl, write);
+  } catch (err) {
+    if (err instanceof NonInteractiveTerminalError) {
+      console.error(
+        "No interactive terminal available. Re-run with --yes to accept prompts, or --print to preview without writing."
+      );
+      return 1;
+    }
+    console.error(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+}
+async function applyOpencodeProvider(creds, routingUrl, write) {
+  let models;
+  try {
+    models = await fetchModels(routingUrl);
+  } catch (err) {
+    console.error(`Could not fetch the model catalog: ${err instanceof Error ? err.message : err}`);
+    return 1;
+  }
+  const plan = buildPlan({
+    routingUrl,
+    orgId: creds.org_id,
+    models,
+    keyEnvVar: "LUNAROUTE_API_KEY"
+  });
+  return applyAndReport(plan, creds.routing_key, write);
+}
+async function applyAndReport(plan, key, write) {
+  try {
+    const summary = await applyPlan(plan, { print: !write, key });
+    if (write && summary.written.length > 0) {
+      console.log(`
+Wrote: ${summary.written.join(", ")}`);
+      if (summary.backedUp.length > 0) console.log(`  Backups: ${summary.backedUp.join(", ")}`);
+    }
+    return 0;
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+}
+async function launchOpencode(spawn3) {
+  return new Promise((resolve) => {
+    const child = spawn3("opencode", []);
+    child.on("error", (err) => {
+      const e = err;
+      if (e?.code === "ENOENT") {
+        console.error(`Error: "opencode" not found on PATH. Install OpenCode first: https://opencode.ai (exit 127)`);
+        resolve(127);
+        return;
+      }
+      console.error(err instanceof Error ? err.message : String(err));
+      resolve(1);
+    });
+    child.on("exit", (code) => {
+      resolve(typeof code === "number" ? code : 1);
+    });
+  });
+}
+async function installPiExtension(spawn3) {
+  for (const pkg of PI_INSTALL_PACKAGES) {
+    const code = await new Promise((resolve) => {
+      const child = spawn3("pi", ["install", pkg]);
+      child.on("error", (err) => {
+        const e = err;
+        if (e?.code === "ENOENT") {
+          console.error(`Error: "pi" not found on PATH. Install pi first: https://pi.dev (exit 127)`);
+          resolve(127);
+          return;
+        }
+        console.error(err instanceof Error ? err.message : String(err));
+        resolve(1);
+      });
+      child.on("exit", (code2) => {
+        resolve(typeof code2 === "number" ? code2 : 1);
+      });
+    });
+    if (code !== 0) {
+      const done = PI_INSTALL_PACKAGES.slice(0, PI_INSTALL_PACKAGES.indexOf(pkg));
+      console.error(
+        `'pi install ${pkg}' failed (exit ${code}). Installed so far: ${done.length ? done.join(", ") : "nothing"}. Re-run 'lunaroute setup pi --extension' to retry.`
+      );
+      return code || 1;
+    }
+  }
+  console.log("\nInstalled. Next steps inside pi:");
+  console.log("  1. /login lunaroute \u2014 browser login issues and stores an lr_ key.");
+  console.log("  2. /model \u2014 pick a lunaroute/* model (models auto-sync from /v1/models).");
+  return 0;
+}
+async function applyPiModels(opts, write) {
+  const creds = loadProfile(opts.profile);
+  let models;
+  try {
+    models = await fetchModels(opts.routingUrl || creds.routing_url || "");
+  } catch (err) {
+    console.error(`Could not fetch the model catalog: ${err instanceof Error ? err.message : err}`);
+    return 1;
+  }
+  const plan = buildPlan2({
+    routingUrl: opts.routingUrl || creds.routing_url,
+    orgId: creds.org_id,
+    models,
+    keyEnvVar: "LUNAROUTE_API_KEY"
+  });
+  try {
+    const summary = await applyPlan(plan, { print: !write, key: creds.routing_key });
+    if (write && summary.written.length > 0) {
+      console.log(`
+Wrote: ${summary.written.join(", ")}`);
+      if (summary.backedUp.length > 0) console.log(`  Backups: ${summary.backedUp.join(", ")}`);
+    }
+    return 0;
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+}
+
+// src/commands/models.ts
+async function runModels(profile, opts) {
+  const s = resolveSettings(profile);
+  if (!s.routing_key) {
+    console.error('Not logged in. Run "lunaroute login" first.');
+    return 1;
+  }
+  let ids;
+  try {
+    ids = await getModels({ apiUrl: s.api_url, apiKey: s.routing_key });
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(ids, null, 2));
+  } else {
+    for (const id of ids) console.log(id);
+  }
+  return 0;
+}
+
+// src/render.ts
+function renderTable(headers, rows) {
+  const all = [headers, ...rows];
+  const widths = headers.map(
+    (_, col) => Math.max(...all.map((r) => (r[col] ?? "").length))
+  );
+  const fmt = (r) => r.map((cell, col) => col === r.length - 1 ? cell : (cell ?? "").padEnd(widths[col])).join("  ").replace(/\s+$/, "");
+  return [headers, ...rows].map(fmt).join("\n");
+}
+
+// src/commands/pricing.ts
+async function runPricing(profile, opts) {
+  const s = resolveSettings(profile);
+  if (!s.routing_key) {
+    console.error('Not logged in. Run "lunaroute login" first.');
+    return 1;
+  }
+  let rows;
+  try {
+    rows = await getPricing({ apiUrl: s.api_url, apiKey: s.routing_key }, opts.model);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(rows, null, 2));
+    return 0;
+  }
+  const cell = (n) => n === void 0 ? "\u2014" : String(n);
+  const table = renderTable(
+    ["MODEL", "INPUT (cr/M)", "OUTPUT (cr/M)", "CACHED (cr/M)"],
+    rows.map(
+      (r) => r.priced ? [r.model, cell(r.input_credits_per_million), cell(r.output_credits_per_million), cell(r.cached_input_credits_per_million)] : [r.model, "\u2014", "\u2014", "\u2014"]
+    )
+  );
+  console.log(table);
+  return 0;
+}
+
+// src/commands/usage.ts
+var tok = (n) => n === null || n === void 0 ? "0" : String(n);
+async function runUsage(profile, opts) {
+  const s = resolveSettings(profile);
+  if (!s.routing_key) {
+    console.error('Not logged in. Run "lunaroute login" first.');
+    return 1;
+  }
+  let usage;
+  try {
+    usage = await getUsage({ apiUrl: s.api_url, apiKey: s.routing_key }, opts.limit);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(usage, null, 2));
+    return 0;
+  }
+  const w = usage.wallet;
+  console.log(
+    `Wallet: available ${w.available_credits}  (balance ${w.balance_credits}, reserved ${w.reserved_credits})`
+  );
+  console.log("");
+  const table = renderTable(
+    ["TIME", "MODEL", "IN", "OUT", "CACHED", "\u0394CREDITS", "BALANCE"],
+    usage.entries.map((e) => [
+      e.created_at,
+      e.model || "\u2014",
+      tok(e.input_tokens),
+      tok(e.output_tokens),
+      tok(e.cached_input_tokens),
+      String(e.credit_delta),
+      String(e.balance_after_credits)
+    ])
+  );
+  console.log(table);
+  return 0;
+}
+
+// src/projectId.ts
+import { execSync as execSync2 } from "child_process";
+function normalizeRemote(url) {
+  let s = url.trim();
+  if (s.includes("://")) {
+    s = s.replace(/^[a-z][a-z0-9+.-]*:\/\//i, "");
+    s = s.replace(/^[^/@]+@/, "");
+    s = s.replace(/^([^/:]+):\d+/, "$1");
+  } else if (/^[^/]+:/.test(s)) {
+    s = s.replace(/^[^@/]+@/, "");
+    s = s.replace(":", "/");
+  }
+  s = s.replace(/\.git$/, "");
+  s = s.toLowerCase();
+  if (s.length > 128) s = s.slice(0, 128);
+  return s;
+}
+function resolveProjectId() {
+  const env = process.env.LUNAROUTE_PROJECT_ID?.trim();
+  if (env) return env;
+  try {
+    const url = execSync2("git config --get remote.origin.url", {
+      cwd: process.cwd(),
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (!url) return null;
+    return normalizeRemote(url);
+  } catch {
+    return null;
+  }
+}
+
+// src/memoryClient.ts
+async function memoryPost(ctx, path, body) {
+  const res = await fetch(`${ctx.routingUrl}${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${ctx.routingKey}` },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    let detail = `HTTP ${res.status}`;
+    try {
+      const b = await res.json();
+      const code = b?.error?.code;
+      const message = b?.error?.message;
+      if (code && message) detail = `${code}: ${message}`;
+      else if (message) detail = message;
+      else if (code) detail = code;
+    } catch {
+    }
+    if (res.status === 404 && path.endsWith("/read")) detail = "exchange not found";
+    throw new Error(`memory request failed: ${detail}`);
+  }
+  return await res.json();
+}
+async function searchMemory(ctx, p) {
+  const body = { project_id: p.projectId };
+  if (p.query !== void 0) body.query = p.query;
+  if (p.concepts !== void 0) body.concepts = p.concepts;
+  if (p.mode !== void 0) body.mode = p.mode;
+  if (p.limit !== void 0) body.limit = p.limit;
+  if (p.after !== void 0) body.after = p.after;
+  if (p.before !== void 0) body.before = p.before;
+  return memoryPost(ctx, "/v1/memory/search", body);
+}
+async function readMemory(ctx, p) {
+  const body = { project_id: p.projectId, id: p.id };
+  if (p.startLine !== void 0) body.start_line = p.startLine;
+  if (p.endLine !== void 0) body.end_line = p.endLine;
+  return memoryPost(ctx, "/v1/memory/read", body);
+}
+
+// src/commands/memory.ts
+var NOT_LOGGED_IN = 'Not logged in. Run "lunaroute login" first.';
+var NO_PROJECT = "No project context: run inside a git repo with an origin remote, or set LUNAROUTE_PROJECT_ID.";
+function contextFor(profile) {
+  const s = resolveSettings(profile);
+  if (!s.routing_key) {
+    console.error(NOT_LOGGED_IN);
+    return 1;
+  }
+  const projectId = resolveProjectId();
+  if (!projectId) {
+    console.error(NO_PROJECT);
+    return 1;
+  }
+  return { ctx: { routingUrl: s.routing_url, routingKey: s.routing_key }, projectId };
+}
+async function runMemorySearch(profile, opts) {
+  const c = contextFor(profile);
+  if (typeof c === "number") return c;
+  const concepts = opts.concepts ? opts.concepts.split(",").map((x) => x.trim()).filter(Boolean) : void 0;
+  const hasQuery = !!opts.query && opts.query.trim() !== "";
+  const hasConcepts = !!concepts && concepts.length > 0;
+  if (hasQuery === hasConcepts) {
+    console.error("Provide exactly one of a query argument or --concepts.");
+    return 1;
+  }
+  let result;
+  try {
+    result = await searchMemory(c.ctx, {
+      projectId: c.projectId,
+      query: hasQuery ? opts.query : void 0,
+      concepts: hasConcepts ? concepts : void 0,
+      mode: opts.mode,
+      limit: opts.limit,
+      after: opts.after,
+      before: opts.before
+    });
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
+  if (result.results.length === 0) {
+    console.log("No results.");
+    return 0;
+  }
+  for (const h of result.results) {
+    const snippet = h.user_turn.replace(/\s+/g, " ").slice(0, 100);
+    console.log(`${h.exchange_id}  score=${h.score.toFixed(3)}  ${h.timestamp}  ${h.model}`);
+    console.log(`  ${snippet}`);
+  }
+  return 0;
+}
+async function runMemoryRead(profile, id, opts) {
+  const c = contextFor(profile);
+  if (typeof c === "number") return c;
+  let result;
+  try {
+    result = await readMemory(c.ctx, { projectId: c.projectId, id, startLine: opts.start, endLine: opts.end });
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
+  console.log(result.text);
+  return 0;
+}
+
+// src/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+var NO_PROJECT2 = "No project context: run the MCP server inside a git repo with an origin remote, or set LUNAROUTE_PROJECT_ID.";
+function toolError(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+function toolOk(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+async function handleSearch(deps, args) {
+  const projectId = deps.resolveProjectId();
+  if (!projectId) return toolError(NO_PROJECT2);
+  const concepts = args.concepts?.map((c) => c.trim()).filter(Boolean);
+  const hasQuery = !!args.query && args.query.trim() !== "";
+  const hasConcepts = !!concepts && concepts.length > 0;
+  if (hasQuery === hasConcepts) return toolError("Provide exactly one of query or concepts.");
+  try {
+    const data = await deps.search({
+      projectId,
+      query: hasQuery ? args.query : void 0,
+      concepts: hasConcepts ? concepts : void 0,
+      mode: args.mode,
+      limit: args.limit,
+      after: args.after,
+      before: args.before
+    });
+    return toolOk(data);
+  } catch (err) {
+    return toolError(err instanceof Error ? err.message : String(err));
+  }
+}
+async function handleRead(deps, args) {
+  const projectId = deps.resolveProjectId();
+  if (!projectId) return toolError(NO_PROJECT2);
+  try {
+    const data = await deps.read({ projectId, id: args.id, startLine: args.startLine, endLine: args.endLine });
+    return toolOk(data);
+  } catch (err) {
+    return toolError(err instanceof Error ? err.message : String(err));
+  }
+}
+async function runMcp(profile) {
+  const s = resolveSettings(profile);
+  if (!s.routing_key) {
+    console.error('Not logged in. Run "lunaroute login" first.');
+    process.exit(1);
+  }
+  const ctx = { routingUrl: s.routing_url, routingKey: s.routing_key };
+  const deps = {
+    search: (p) => searchMemory(ctx, p),
+    read: (p) => readMemory(ctx, p),
+    resolveProjectId
+  };
+  const server = new McpServer({ name: "lunaroute-memory", version: "0.1.0" });
+  server.registerTool(
+    "search",
+    {
+      title: "Search LunaRoute memory",
+      description: "Search past conversations for this project before starting a task to recover prior decisions and solutions. Provide either a natural-language query or a list of concepts (AND-matched).",
+      inputSchema: {
+        query: z.string().optional(),
+        concepts: z.array(z.string()).optional(),
+        mode: z.enum(["vector", "text", "both"]).optional(),
+        limit: z.number().int().positive().optional(),
+        after: z.string().optional(),
+        before: z.string().optional()
+      }
+    },
+    async (args) => handleSearch(deps, args)
+  );
+  server.registerTool(
+    "read",
+    {
+      title: "Read a LunaRoute memory exchange",
+      description: "Read a full past conversation by id, with optional line pagination.",
+      inputSchema: {
+        id: z.string(),
+        startLine: z.number().int().optional(),
+        endLine: z.number().int().optional()
+      }
+    },
+    async (args) => handleRead(deps, args)
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/skill/content.ts
+var SKILL_MD = `---
+name: lunaroute-memory
+description: >-
+  Search and read this project's cross-session LunaRoute memory. Use BEFORE
+  starting a task to recover prior decisions, solutions, and gotchas from past
+  conversations, and whenever you need context that isn't in the current files.
+---
+
+# LunaRoute Memory
+
+This project has cross-session memory captured by LunaRoute from past coding
+sessions. Two tools are available from the \`lunaroute-memory\` MCP server:
+
+- **search** \u2014 find relevant past exchanges for this project. Pass a natural
+  \`query\`, or \`concepts\` (AND-matched) for precise lookups. Returns ranked
+  hits, each with an \`exchange_id\`, a snippet, the model, and a timestamp.
+- **read** \u2014 fetch the full text of one exchange by \`id\` (optionally a line
+  range) once a search hit looks relevant.
+
+## When to use
+
+- **Before starting any non-trivial task**, search for prior work on the same
+  area to avoid re-deriving decisions or repeating past mistakes.
+- When you hit an unfamiliar pattern, error, or design choice, search for it.
+- After a promising search hit, **read** the full exchange for the detail and
+  rationale the snippet omits.
+
+Memory is scoped to the current project automatically. An empty search result
+is not an error \u2014 just proceed normally.
+`;
+
+// src/skill/plan.ts
+function buildSkillPlan(opts) {
+  const args = ["-y", "@lunaroute/cli", "mcp"];
+  if (opts.profile !== "default") args.push("--profile", opts.profile);
+  const entry = { type: "stdio", command: "npx", args };
+  const mergeMcp = (existing) => {
+    const obj = existing ?? {};
+    const servers = typeof obj.mcpServers === "object" && obj.mcpServers !== null ? obj.mcpServers : {};
+    return { ...obj, mcpServers: { ...servers, [LUNAROUTE_SKILL_NAME]: entry } };
+  };
+  const skillPath = opts.project ? claudeProjectSkillPath(opts.root) : claudeUserSkillPath();
+  const mcpPath = opts.project ? claudeProjectMcpPath(opts.root) : claudeUserConfigPath();
+  return {
+    fileWrites: [
+      { kind: "text", path: skillPath, content: SKILL_MD, fileMode: 420, dirMode: 493 },
+      { kind: "json", path: mcpPath, merge: mergeMcp, fileMode: 384 }
+    ],
+    exports: [],
+    notes: [
+      "\nLunaRoute memory installed for Claude Code. Restart Claude Code to pick it up.",
+      'If you have not yet, run "lunaroute login" \u2014 the memory server authenticates with your stored key at runtime.',
+      'Verify by asking Claude to "search project memory", or run /lunaroute-memory.'
+    ]
+  };
+}
+
+// src/commands/skillInstall.ts
+async function runSkillInstall(profile, opts) {
+  const s = resolveSettings(profile);
+  if (!s.routing_key) {
+    console.error(
+      'Warning: not logged in \u2014 the memory server will not authenticate until you run "lunaroute login".'
+    );
+  }
+  let root;
+  if (opts.project) {
+    const r = gitRepoRoot();
+    if (!r) {
+      console.error(
+        "--project requires a git repository (no work tree found). Omit --project to install at the user level."
+      );
+      return 1;
+    }
+    root = r;
+  }
+  const plan = buildSkillPlan({ project: opts.project, profile, root });
+  try {
+    const summary = await applyPlan(plan, { print: opts.print, key: "" });
+    if (!opts.print) {
+      for (const f of summary.written) console.log(`wrote ${f}`);
+      for (const b of summary.backedUp) console.log(`backed up ${b}`);
+    }
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+  return 0;
+}
+
+// src/commands/run.ts
+import { spawn as spawn2 } from "child_process";
+
+// src/run/adapters/claudeCode.ts
+function buildRunSpec(ctx) {
+  return {
+    command: "claude",
+    args: [],
+    env: {
+      ANTHROPIC_BASE_URL: ctx.routingUrl,
+      ANTHROPIC_API_KEY: ctx.apiKey,
+      ANTHROPIC_MODEL: ctx.model,
+      // Pins the Haiku/background model so Claude Code's background tasks
+      // (titles, summaries, compaction) route through LunaRoute instead of
+      // 404'ing against Anthropic's hardcoded Haiku id. Mirrors the Connect tab
+      // (kata f59a). Same default as ANTHROPIC_MODEL — catalog has no
+      // size/tier field, so users tune it; the point is a valid LunaRoute model.
+      ANTHROPIC_DEFAULT_HAIKU_MODEL: ctx.model,
+      // Populates the /model picker from GET /v1/models at startup. LunaRoute
+      // already serves the Anthropic-native shape (spike-verified, kata nkey).
+      CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1"
+    }
+  };
+}
+
+// src/run/adapters/codex.ts
+function buildRunSpec2(ctx) {
+  return {
+    command: "codex",
+    args: ["--model", ctx.model],
+    env: {
+      OPENAI_BASE_URL: `${ctx.routingUrl}/v1`,
+      OPENAI_API_KEY: ctx.apiKey
+    }
+  };
+}
+
+// src/commands/run.ts
+var ADAPTERS2 = {
+  claude: buildRunSpec,
+  "claude-code": buildRunSpec,
+  codex: buildRunSpec2
+};
+var INSTALL_HINT = {
+  claude: "Install Claude Code: https://docs.anthropic.com/claude-code/install",
+  "claude-code": "Install Claude Code: https://docs.anthropic.com/claude-code/install",
+  codex: "Install Codex: https://github.com/openai/codex#install"
+};
+var realDeps = {
+  spawn: (command, args, env) => spawn2(command, args, { env, stdio: "inherit" }),
+  fetchModels
+};
+async function runRun(harness, opts, deps = realDeps) {
+  const adapter = ADAPTERS2[harness];
+  if (!adapter) {
+    console.error(`Unknown harness "${harness}". Choose one of: ${Object.keys(ADAPTERS2).join(", ")}.`);
+    return 1;
+  }
+  const creds = loadProfile(opts.profile);
+  if (!creds || !creds.routing_key) {
+    console.error('Not logged in. Run "lunaroute login" first.');
+    return 1;
+  }
+  let model = opts.model;
+  if (!model) {
+    let models;
+    try {
+      models = await deps.fetchModels(creds.routing_url);
+    } catch (err) {
+      console.error(`Could not fetch the model catalog: ${err instanceof Error ? err.message : err}`);
+      return 1;
+    }
+    model = models[0]?.id;
+    if (!model) {
+      console.error("No models available from the catalog. Pass --model to pick one.");
+      return 1;
+    }
+    console.error(`# using model ${model} (pass --model to change)`);
+  }
+  const spec = adapter({
+    routingUrl: creds.routing_url,
+    apiKey: creds.routing_key,
+    model
+  });
+  const args = spec.args.concat(opts.passthrough ?? []);
+  const env = { ...process.env, ...spec.env };
+  const child = deps.spawn(spec.command, args, env);
+  return new Promise((resolve) => {
+    child.on("error", (err) => {
+      const e = err;
+      if (e?.code === "ENOENT") {
+        console.error(
+          `Error: "${spec.command}" not found on PATH. ${INSTALL_HINT[harness]} (exit 127)`
+        );
+        resolve(127);
+        return;
+      }
+      console.error(err instanceof Error ? err.message : String(err));
+      resolve(1);
+    });
+    child.on("exit", (code) => {
+      resolve(typeof code === "number" ? code : 1);
+    });
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("lunaroute").description("LunaRoute CLI \u2014 configure coding harnesses and manage your account.").version("0.1.0").option("-p, --profile <name>", "credential profile to use", "default");
+program.command("login").description("Authorize this device via the browser and store a routing key.").action(async () => {
+  await login(program.opts().profile);
+});
+program.command("whoami").description("Show the signed-in user and organization.").action(() => {
+  whoami(program.opts().profile);
+});
+program.command("logout").description("Remove stored credentials for the active profile.").action(() => {
+  logout(program.opts().profile);
+});
+program.command("setup <harness>").description("Configure a coding harness (opencode | pi | claude-code | copilot-cli | generic).").option("--print", "print the config instead of writing files", false).option("--routing-url <url>", "override the routing base URL").option("--yes", "accept all confirmation prompts without a TTY (for scripts)", false).option("--extension", "pi only: jump straight to installing the Pi extension + MCP adapter").option("--models", "pi only: jump straight to writing the models.json provider block").action(async (harness, opts) => {
+  const code = await runSetup(harness, {
+    profile: program.opts().profile,
+    print: opts.print,
+    routingUrl: opts.routingUrl,
+    yes: opts.yes,
+    extension: opts.extension,
+    models: opts.models
+  });
+  if (code !== 0) process.exit(code);
+});
+program.command("run <harness>").description("Launch a coding harness (claude | claude-code | codex) configured to use LunaRoute for this session.").option("--model <id>", "model id to launch on (default: first model in the catalog)").allowUnknownOption(true).action(async (harness, opts) => {
+  const raw = process.argv;
+  const ddIdx = raw.indexOf("--");
+  const runIdx = raw.indexOf("run");
+  const passthrough = ddIdx > runIdx && ddIdx !== -1 ? raw.slice(ddIdx + 1) : [];
+  const code = await runRun(
+    harness,
+    { profile: program.opts().profile, model: opts.model, passthrough }
+  );
+  if (code !== 0) process.exit(code);
+});
+program.command("models").description("List available LunaRoute models.").option("--json", "output machine-readable JSON", false).action(async (opts) => {
+  const code = await runModels(program.opts().profile, { json: opts.json });
+  if (code !== 0) process.exit(code);
+});
+program.command("pricing").description("Show per-model pricing (credits per million tokens).").option("--model <id>", "show pricing for a single model").option("--json", "output machine-readable JSON", false).action(async (opts) => {
+  const code = await runPricing(program.opts().profile, { json: opts.json, model: opts.model });
+  if (code !== 0) process.exit(code);
+});
+program.command("usage").description("Show wallet balance and recent usage.").option("--limit <n>", "number of ledger entries (default 20)", (v) => {
+  const n = parseInt(v, 10);
+  if (Number.isNaN(n) || n < 1) {
+    throw new InvalidArgumentError("--limit must be a positive integer");
+  }
+  return n;
+}).option("--json", "output machine-readable JSON", false).action(async (opts) => {
+  const code = await runUsage(program.opts().profile, { json: opts.json, limit: opts.limit });
+  if (code !== 0) process.exit(code);
+});
+program.command("mcp").description("Run a stdio MCP server exposing LunaRoute memory search/read tools.").action(async () => {
+  await runMcp(program.opts().profile);
+});
+var memory = program.command("memory").description("Query LunaRoute memory for the current project.");
+memory.command("search [query]").description("Search past conversations for the current project.").option("--concepts <list>", "comma-separated concepts (AND-matched); alternative to a query").addOption(new Option("--mode <mode>", "search mode").choices(["vector", "text", "both"])).option("--limit <n>", "max results", (v) => {
+  const n = parseInt(v, 10);
+  if (Number.isNaN(n) || n < 1) throw new InvalidArgumentError("--limit must be a positive integer");
+  return n;
+}).option("--after <ts>", "only results after this ISO timestamp").option("--before <ts>", "only results before this ISO timestamp").option("--json", "output machine-readable JSON", false).action(async (query, opts) => {
+  const code = await runMemorySearch(program.opts().profile, { query, ...opts });
+  if (code !== 0) process.exit(code);
+});
+memory.command("read <id>").description("Read a full past conversation by id.").option("--start <n>", "start line (1-based)", (v) => {
+  const n = parseInt(v, 10);
+  if (Number.isNaN(n) || n < 1) throw new InvalidArgumentError("--start must be a positive integer");
+  return n;
+}).option("--end <n>", "end line (1-based)", (v) => {
+  const n = parseInt(v, 10);
+  if (Number.isNaN(n) || n < 1) throw new InvalidArgumentError("--end must be a positive integer");
+  return n;
+}).option("--json", "output machine-readable JSON", false).action(async (id, opts) => {
+  const code = await runMemoryRead(program.opts().profile, id, opts);
+  if (code !== 0) process.exit(code);
+});
+var skill = program.command("skill").description("Install LunaRoute memory into a coding harness.");
+skill.command("install").description("Install the LunaRoute memory skill + MCP server into Claude Code.").option("--project", "write committable repo-local config instead of user-level", false).option("--print", "print what would be written instead of writing", false).action(async (opts) => {
+  const code = await runSkillInstall(program.opts().profile, opts);
+  if (code !== 0) process.exit(code);
+});
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+});