layerx1 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Layer X1
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,99 @@
+# layerx1
+
+Point your coding agent at **Layer X1** in one command. Configures
+[Claude Code](https://claude.com/claude-code), [OpenAI Codex CLI](https://developers.openai.com/codex),
+[Aider](https://aider.chat), [Continue](https://continue.dev), [Cline](https://cline.bot),
+[Cursor](https://cursor.com), and [Windsurf](https://windsurf.com) to send their requests
+to the Layer X1 API — one endpoint, one key, one model catalog.
+
+Zero dependencies. Needs Node ≥ 18.
+
+## Quick start
+
+```bash
+# interactive — asks for your key, model, and which tools to set up
+npx layerx1
+
+# or non-interactive
+npx layerx1 setup --key lx1_your_key --tool all
+npx layerx1 setup --key lx1_your_key --tool claude-code,codex --model lx1-glm-5.2
+
+# verify (reuses the key you just configured — no flag needed)
+npx layerx1 test
+```
+
+Get an `lx1_` key from your Layer X1 dashboard.
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `npx layerx1` / `npx layerx1 init` | Interactive setup. |
+| `npx layerx1 setup --key <k> [--tool <ids>]` | Configure one or more tools non-interactively. |
+| `npx layerx1 status` | Show which tools are pointed at Layer X1. |
+| `npx layerx1 models [--url <u>]` | List the model catalog with pricing. |
+| `npx layerx1 test [--key <k>]` | Send one request to verify everything works. Without `--key` it reuses `LAYERX1_API_KEY` or the key already written to Claude Code's settings. |
+| `npx layerx1 unset [--tool <ids>]` | Remove Layer X1 config (previous files are kept as timestamped backups). |
+| `npx layerx1 --version` | Print the CLI version. |
+
+### Flags
+
+| Flag | Default |
+|---|---|
+| `--key <k>` | — (required for `setup`) |
+| `--url <u>` | `https://layerx1-gateway.orbitweb00.workers.dev` |
+| `--model <m>` | `lx1-gpt-oss-120b` |
+| `--small-model <m>` | `lx1-glm-4.7-flash` |
+| `--tool <ids>` | comma-separated: `claude-code,codex,aider,continue,cline,cursor,windsurf` or `all` |
+| `--print` | Print the config instead of writing files. |
+| `--persist-key` / `--no-persist-key` | Save `LAYERX1_API_KEY` for new shells without asking / never touch env or shell profile. |
+| `--home <dir>` | Write configs under `<dir>` instead of your home directory (sandboxes, tests). Also settable via `LAYERX1_HOME`. |
+
+Model ids are always `lx1-*` — run `npx layerx1 models` for the full catalog.
+
+## What it writes
+
+| Tool | File / step | Notes |
+|---|---|---|
+| **Claude Code** | `~/.claude/settings.json` (`env` block) | `ANTHROPIC_BASE_URL` (origin, no `/v1`), `ANTHROPIC_AUTH_TOKEN`, model tiers. Run `/logout` first if you were logged in. |
+| **Codex CLI** | `~/.codex/config.toml` | Top-level keys (`model`, `model_provider`, context window) at the head of the file, the `[model_providers.layerx1]` table at the end — your own keys are never disturbed. `wire_api="responses"` → Layer X1's `/v1/responses`. Key via `LAYERX1_API_KEY` (see below). |
+| **Aider** | `~/.aider.conf.yml` | OpenAI-compatible route (`model: openai/<m>`, `openai-api-base`, key). |
+| **Continue** | `~/.continue/config.yaml` | Adds an `openai`-provider model with your `apiBase`. (Prints the entry to merge if a config already exists.) |
+| **Cline** | prints values | GUI-only — paste Base URL / API Key / Model into its settings panel. |
+| **Cursor** | prints steps | GUI-only — Settings → Models: paste your key as the OpenAI API key, enable *Override OpenAI Base URL* → `<gateway>/v1`, add `lx1-*` model ids. |
+| **Windsurf** | prints steps | GUI-only — add an OpenAI-compatible provider with the same Base URL / key / model. |
+
+Existing files are backed up to `<file>.layerx1.bak-<timestamp>` before any change. File
+configs use managed blocks (`# >>> layerx1 … <<<`) so re-running is idempotent and
+`unset` cleanly removes only our additions.
+
+## Your key for Codex (`LAYERX1_API_KEY`)
+
+Codex reads its API key from the environment. After `setup`, the CLI offers to persist it
+for you (skip with `--no-persist-key`, force with `--persist-key`):
+
+- **Windows (PowerShell)** — saved to your User environment, so every new terminal has it:
+
+  ```powershell
+  [Environment]::SetEnvironmentVariable('LAYERX1_API_KEY','lx1_your_key','User')
+  ```
+
+- **macOS / Linux** — appended to your shell profile (`~/.zshrc`, `~/.bashrc`, or
+  `~/.config/fish/config.fish`, detected from `$SHELL`) inside a managed block that
+  `npx layerx1 unset` removes again:
+
+  ```bash
+  export LAYERX1_API_KEY="lx1_your_key"
+  ```
+
+Open a new terminal (or `source` your profile) afterwards.
+
+## Notes
+
+- **Claude Code** uses the host root for `ANTHROPIC_BASE_URL` (the SDK appends `/v1/messages`); every other tool uses the `/v1` base. The installer derives both from `--url` automatically.
+- **Codex** requires the OpenAI **Responses** API — Layer X1 serves `/v1/responses`, so it works out of the box.
+- `npx layerx1 test` uses `max_tokens: 512` so models that think before they answer still return visible text.
+
+## License
+
+MIT

package/bin/layerx1.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+"use strict";
+require("../src/cli").main(process.argv.slice(2));

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "layerx1",
+  "version": "0.2.0",
+  "description": "Point your coding agent (Claude Code, Codex, Aider, Continue, Cline, Cursor, Windsurf) at Layer X1 in one command.",
+  "bin": {
+    "layerx1": "bin/layerx1.js"
+  },
+  "type": "commonjs",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node bin/layerx1.js",
+    "test": "node --test",
+    "prepublishOnly": "node --test"
+  },
+  "author": "Layer X1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ATOM00blue/layerx1-cli.git"
+  },
+  "homepage": "https://layerx1.vercel.app",
+  "bugs": {
+    "url": "https://github.com/ATOM00blue/layerx1-cli/issues"
+  },
+  "keywords": [
+    "layerx1",
+    "llm",
+    "gateway",
+    "ai",
+    "cli",
+    "installer",
+    "claude-code",
+    "codex",
+    "aider",
+    "continue",
+    "cline",
+    "cursor",
+    "windsurf",
+    "openai",
+    "anthropic"
+  ],
+  "license": "MIT"
+}

package/src/cli.js

@@ -0,0 +1,332 @@
+// `layerx1` — point your coding agent at the Layer X1 gateway in one command.
+//   npx layerx1                      interactive setup
+//   npx layerx1 setup --tool claude-code --key lx1_... [--url ...] [--model ...]
+//   npx layerx1 status | models | test | unset --tool <id>
+"use strict";
+const U = require("./util");
+const { TARGETS, byId } = require("./targets");
+const pkg = require("../package.json");
+
+const DEFAULT_URL = "https://layerx1-gateway.orbitweb00.workers.dev";
+// Catalog defaults — MUST be canonical lx1-* ids from GET /v1/models (the gateway serves
+// its own default for an unknown id, silently — a typo here would misconfigure every user).
+const DEFAULT_MODEL = "lx1-gpt-oss-120b"; // the gateway default — fast, tool-capable
+const DEFAULT_SMALL = "lx1-glm-4.7-flash"; // quick background/small-task model
+
+function parseArgs(argv) {
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq !== -1) flags[a.slice(2, eq)] = a.slice(eq + 1);
+      else if (i + 1 < argv.length && !argv[i + 1].startsWith("--")) flags[a.slice(2)] = argv[++i];
+      else flags[a.slice(2)] = true;
+    } else positional.push(a);
+  }
+  return { cmd: positional[0], rest: positional.slice(1), flags };
+}
+
+function ctxFrom(flags, { url, key, model, smallModel } = {}) {
+  const origin = U.normalizeOrigin(url || flags.url || DEFAULT_URL);
+  return {
+    origin,
+    v1: U.withV1(origin),
+    key: key || flags.key || flags.token || "",
+    model: model || flags.model || DEFAULT_MODEL,
+    smallModel: smallModel || flags["small-model"] || DEFAULT_SMALL,
+    print: !!flags.print,
+    // Where tool configs live. Overridable (--home / LAYERX1_HOME) so tests and sandboxes
+    // can exercise every writer against a scratch dir instead of the real home directory.
+    home: (typeof flags.home === "string" && flags.home) || process.env.LAYERX1_HOME || U.HOME,
+  };
+}
+
+function banner() {
+  U.log(U.c.bold(`\n  Layer X1 ${U.c.dim("· configure your coding agent")}`));
+}
+
+function printResult(t, res) {
+  if (res.error) return U.err(`${t.label}: ${res.error}`);
+  if (res.noop) {
+    U.info(`${t.label}: nothing to remove`);
+  } else if (res.wrote) {
+    U.ok(`${t.label} → wrote ${U.c.cyan(res.wrote)}`);
+    if (res.backup) U.info(`backed up previous file to ${U.c.dim(res.backup)}`);
+  } else if (res.printed) {
+    U.warn(`${t.label}: manual step —`);
+    U.log("\n" + res.printed.split("\n").map((l) => "    " + l).join("\n") + "\n");
+  }
+  for (const n of res.notes || []) U.info(n);
+}
+
+function resolveTools(sel) {
+  if (!sel || sel === "all") return TARGETS;
+  const ids = String(sel).split(",").map((s) => s.trim()).filter(Boolean);
+  const out = [];
+  for (const id of ids) {
+    if (byId[id]) out.push(byId[id]);
+    else U.warn(`unknown tool "${id}" (known: ${TARGETS.map((t) => t.id).join(", ")})`);
+  }
+  return out;
+}
+
+// --- key persistence ---------------------------------------------------------
+// Codex (and anything else reading LAYERX1_API_KEY) needs the key in the ENVIRONMENT, not
+// a file we write — so after setup we OFFER to persist it, per-OS, and never force it:
+//   win32  → the User environment via PowerShell (survives new terminals, no profile edit)
+//   POSIX  → a managed block appended to the detected shell profile (unset removes it)
+// Explicit --persist-key / --no-persist-key decide non-interactively; otherwise we only
+// prompt on a real TTY (CI/pipes get the printed guidance from the codex notes instead).
+function escapePwshSingle(s) {
+  return String(s).replace(/'/g, "''");
+}
+function escapeShDouble(s) {
+  return String(s).replace(/(["\\$`])/g, "\\$1");
+}
+async function offerPersistKey(ctx, tools, flags) {
+  if (ctx.print || !ctx.key) return;
+  if (!tools.some((t) => t.id === "codex")) return; // only codex consumes LAYERX1_API_KEY
+  const declined = flags["no-persist-key"] === true || flags["persist-key"] === "false";
+  if (declined) return;
+  const forced = flags["persist-key"] === true || flags["persist-key"] === "true";
+  if (!forced) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) return; // guidance already printed
+    const where =
+      process.platform === "win32" ? "your User environment" : U.shellProfile(ctx.home);
+    const a = await U.prompt(`Persist LAYERX1_API_KEY to ${where} now? (Y/n)`, "Y");
+    if (!/^y/i.test(a)) return;
+  }
+  if (process.platform === "win32") {
+    // Array-args spawn (no shell string interpolation) + single-quote escaping: the key
+    // never passes through a shell parser.
+    const { spawnSync } = require("child_process");
+    const r = spawnSync(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `[Environment]::SetEnvironmentVariable('LAYERX1_API_KEY','${escapePwshSingle(ctx.key)}','User')`,
+      ],
+      { stdio: "ignore" },
+    );
+    if (r.status === 0) U.ok("LAYERX1_API_KEY saved to your User environment — open a NEW terminal to pick it up.");
+    else U.err("could not set the User environment variable — run the PowerShell command above manually.");
+    return;
+  }
+  const profile = U.shellProfile(ctx.home);
+  const line = /config\.fish$/.test(profile)
+    ? `set -gx LAYERX1_API_KEY "${escapeShDouble(ctx.key)}"`
+    : `export LAYERX1_API_KEY="${escapeShDouble(ctx.key)}"`;
+  const next = U.upsertManagedBlock(U.readFileSafe(profile) || "", line, { label: "env", position: "end" });
+  U.writeFileSafe(profile, next);
+  U.ok(`LAYERX1_API_KEY added to ${U.c.cyan(profile)} — restart your shell (or source it) to pick it up.`);
+}
+
+/** Undo of offerPersistKey, run by `unset`: our profile block is marker-identified so it is
+ *  safe to remove automatically; the win32 User-env var may predate us, so only print how. */
+function unsetPersistedKey(ctx) {
+  if (process.platform === "win32") {
+    U.info(
+      `If you persisted LAYERX1_API_KEY, clear it with:  [Environment]::SetEnvironmentVariable('LAYERX1_API_KEY',$null,'User')`,
+    );
+    return;
+  }
+  const profile = U.shellProfile(ctx.home);
+  const content = U.readFileSafe(profile);
+  if (content && U.hasManagedBlock(content, "env")) {
+    U.writeFileSafe(profile, U.removeManagedBlock(content));
+    U.ok(`removed LAYERX1_API_KEY from ${U.c.cyan(profile)}`);
+  }
+}
+
+/** The key `test` should use, in trust order: explicit --key → LAYERX1_API_KEY env → the key
+ *  setup already wrote into Claude Code's settings. The settings token is reused ONLY when
+ *  its base URL matches the gateway being tested — never send a token for one host to another. */
+function resolveKey(ctx) {
+  if (ctx.key) return { key: ctx.key, source: "--key" };
+  if (process.env.LAYERX1_API_KEY) return { key: process.env.LAYERX1_API_KEY, source: "LAYERX1_API_KEY" };
+  const cfg = U.readJsonSafe(U.path.join(ctx.home, ".claude", "settings.json"));
+  const env = cfg && cfg.env;
+  if (env && env.ANTHROPIC_AUTH_TOKEN && U.normalizeOrigin(env.ANTHROPIC_BASE_URL) === ctx.origin) {
+    return { key: env.ANTHROPIC_AUTH_TOKEN, source: "~/.claude/settings.json" };
+  }
+  return null;
+}
+
+async function cmdSetup(flags, toolsSel) {
+  const ctx = ctxFrom(flags);
+  if (!ctx.key) return U.err("missing --key (your lx1_ gateway key). Get one from the dashboard.");
+  const tools = resolveTools(toolsSel || flags.tool);
+  if (!tools.length) return U.err("no tools selected (use --tool claude-code,codex,aider,continue,cline,cursor,windsurf or all)");
+  U.head(`Configuring ${tools.length} tool(s) → ${U.c.cyan(ctx.origin)}  model=${U.c.cyan(ctx.model)}`);
+  for (const t of tools) printResult(t, t.apply(ctx));
+  await offerPersistKey(ctx, tools, flags);
+  U.log("");
+}
+
+async function cmdInit(flags) {
+  banner();
+  U.log(U.c.dim("  Press enter to accept the [default].\n"));
+  const url = await U.prompt("Gateway URL:", U.normalizeOrigin(flags.url || DEFAULT_URL));
+  let key = flags.key || "";
+  while (!key) key = await U.prompt("API key (lx1_…):", "");
+  const model = await U.prompt("Default model:", flags.model || DEFAULT_MODEL);
+  U.head("Which tools? (comma-separated numbers, or 'all')");
+  TARGETS.forEach((t, i) => U.log(`    ${i + 1}. ${t.label} ${U.c.dim("· " + t.protocol)}`));
+  const pick = await U.prompt("Selection:", "all");
+  let tools;
+  if (pick.trim() === "all" || !pick.trim()) tools = TARGETS;
+  else
+    tools = pick
+      .split(",")
+      .map((s) => TARGETS[parseInt(s.trim(), 10) - 1])
+      .filter(Boolean);
+  if (!tools.length) return U.err("nothing selected.");
+  const ctx = ctxFrom(flags, { url, key, model });
+  U.head(`Configuring → ${U.c.cyan(ctx.origin)}  model=${U.c.cyan(ctx.model)}`);
+  for (const t of tools) printResult(t, t.apply(ctx));
+  await offerPersistKey(ctx, tools, flags);
+  U.log("\n  " + U.c.green("Done.") + " Run `npx layerx1 test` to verify the gateway.\n");
+}
+
+async function cmdStatus(flags) {
+  const ctx = ctxFrom(flags);
+  U.head(`Layer X1 config status  ${U.c.dim("(gateway " + ctx.origin + ")")}`);
+  for (const t of TARGETS) {
+    const s = t.status(ctx);
+    const mark = s.configured === true ? U.c.green("✓") : s.configured === null ? U.c.yellow("?") : U.c.dim("·");
+    U.log(`  ${mark} ${t.label.padEnd(30)} ${U.c.dim(s.detail)}`);
+  }
+  U.log("");
+}
+
+async function cmdModels(flags) {
+  const ctx = ctxFrom(flags);
+  const url = ctx.v1 + "/models";
+  U.head(`Models @ ${U.c.cyan(url)}`);
+  try {
+    const r = await fetch(url);
+    if (!r.ok) return U.err(`GET /v1/models → ${r.status}`);
+    const data = (await r.json()).data || [];
+    U.ok(`${data.length} models`);
+    for (const m of data) {
+      // Pad the RAW strings, then colorize: ANSI escapes count toward .length, so padding
+      // a colored string under-pads it and the columns drift.
+      const name = String(m.id || "").padEnd(28);
+      const extras = m.aliases && m.aliases.length ? `(${m.aliases.join(", ")}) ` : "";
+      const tier = String(m.tier || "").padEnd(16);
+      const price = m.pricing_usd_per_mtok || {};
+      const priceStr =
+        price.input != null ? `$${price.input}/$${price.output} per Mtok` : "";
+      U.log(`    ${U.c.cyan(name)} ${U.c.dim(tier)} ${U.c.dim(extras + priceStr)}`);
+    }
+    U.log("");
+  } catch (e) {
+    U.err(`could not reach ${url}: ${e.message}`);
+  }
+}
+
+async function cmdTest(flags) {
+  const ctx = ctxFrom(flags);
+  const found = resolveKey(ctx);
+  if (!found) return U.err("no key found — pass --key, set LAYERX1_API_KEY, or run `npx layerx1 setup` first.");
+  if (found.source !== "--key") U.info(`using the key from ${found.source}`);
+  const url = ctx.v1 + "/messages";
+  U.head(`Test → ${U.c.cyan(url)}  model=${U.c.cyan(ctx.model)}`);
+  try {
+    const t0 = Date.now();
+    const r = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json", "x-api-key": found.key },
+      body: JSON.stringify({
+        // 512, not less: reasoning models spend output budget on hidden thinking before any
+        // visible text — a smaller cap can come back 200-with-empty-content and look broken.
+        model: ctx.model,
+        max_tokens: 512,
+        messages: [{ role: "user", content: "Reply with exactly: pong" }],
+      }),
+    });
+    const served = r.headers.get("x1-model");
+    const body = await r.json();
+    if (!r.ok) return U.err(`${r.status} ${JSON.stringify(body).slice(0, 200)}`);
+    const text = (body.content || []).map((b) => b.text || "").join("").trim();
+    U.ok(`200 OK  model=${U.c.cyan(served || body.model || "?")}  ${Date.now() - t0}ms`);
+    U.info(`reply: ${JSON.stringify(text).slice(0, 80)}`);
+    U.log("");
+  } catch (e) {
+    U.err(`request failed: ${e.message}`);
+  }
+}
+
+async function cmdUnset(flags, toolsSel) {
+  const ctx = ctxFrom(flags);
+  const tools = resolveTools(toolsSel || flags.tool || "all");
+  U.head(`Removing Layer X1 config from ${tools.length} tool(s)`);
+  for (const t of tools) printResult(t, t.unset(ctx));
+  if (tools.some((t) => t.id === "codex")) unsetPersistedKey(ctx);
+  U.log("");
+}
+
+function help() {
+  banner();
+  U.log(`
+  ${U.c.bold("Usage")}
+    npx layerx1                     interactive setup
+    npx layerx1 setup --key <lx1_…> [--tool <ids>] [--url <u>] [--model <m>]
+    npx layerx1 status              show which tools are configured
+    npx layerx1 models [--url <u>]  list the model catalog
+    npx layerx1 test [--key <k>]    send one request to verify (reuses your configured key)
+    npx layerx1 unset [--tool <ids>]
+    npx layerx1 --version
+
+  ${U.c.bold("Tools")}  (--tool, comma-separated, or "all")
+${TARGETS.map((t) => `    ${t.id.padEnd(12)} ${U.c.dim(t.label + " — " + t.protocol)}`).join("\n")}
+
+  ${U.c.bold("Flags")}
+    --key <k>            your lx1_ gateway API key (required for setup)
+    --url <u>            gateway URL            ${U.c.dim("(default " + DEFAULT_URL + ")")}
+    --model <m>          default model          ${U.c.dim("(default " + DEFAULT_MODEL + ")")}
+    --small-model <m>    background model       ${U.c.dim("(default " + DEFAULT_SMALL + ")")}
+    --print              show config instead of writing files
+    --persist-key        save LAYERX1_API_KEY for new shells without asking
+    --no-persist-key     never touch env/shell profile
+    --home <dir>         write configs under <dir> instead of your home ${U.c.dim("(sandboxes/tests)")}
+`);
+}
+
+async function main(argv) {
+  const { cmd, rest, flags } = parseArgs(argv);
+  if (flags.version || flags.V || cmd === "version") return U.log(pkg.version);
+  if (flags.help || flags.h || cmd === "help") return help();
+  try {
+    switch (cmd) {
+      case undefined:
+      case "init":
+        return await cmdInit(flags);
+      case "setup":
+      case "configure":
+        return await cmdSetup(flags, rest[0]);
+      case "status":
+        return await cmdStatus(flags);
+      case "models":
+        return await cmdModels(flags);
+      case "test":
+        return await cmdTest(flags);
+      case "unset":
+      case "remove":
+        return await cmdUnset(flags, rest[0]);
+      default:
+        U.err(`unknown command "${cmd}"`);
+        return help();
+    }
+  } catch (e) {
+    U.err(e && e.stack ? e.stack : String(e));
+    process.exitCode = 1;
+  }
+}
+
+// parseArgs/defaults exported for the test suite — bin/layerx1.js only calls main().
+module.exports = { main, parseArgs, ctxFrom, DEFAULT_URL, DEFAULT_MODEL, DEFAULT_SMALL };

package/src/targets.js

@@ -0,0 +1,310 @@
+// One configurator per coding tool. Each returns a result describing what it did:
+//   { wrote, backup, notes }  — a config file was written (backup path if it replaced one)
+//   { printed, notes }        — manual step (GUI tool, or an existing config we won't clobber)
+//   { error }                 — couldn't proceed safely
+//
+// ctx = { origin, v1, key, model, smallModel, print, home }
+//   origin = gateway root WITHOUT /v1  (Claude Code's ANTHROPIC_BASE_URL — SDK adds /v1/messages)
+//   v1     = origin + "/v1"            (OpenAI-style tools)
+//   home   = directory the tool configs live under — os.homedir() in real use; tests point it
+//            at a scratch dir so the suite never touches this machine's actual configs.
+"use strict";
+const U = require("./util");
+const path = U.path;
+
+// Codex reads its key from the environment, so setup must also get LAYERX1_API_KEY to
+// persist across shells. The exact incantation is per-OS; setup OFFERS to run it (cli.js),
+// these strings are the always-printed fallback guidance.
+function keyPersistNotes(key) {
+  if (process.platform === "win32") {
+    return [
+      `Persist your key for new shells (PowerShell):  ${U.c.bold(
+        `[Environment]::SetEnvironmentVariable('LAYERX1_API_KEY','${key}','User')`,
+      )}`,
+      `Current shell only:  ${U.c.dim(`$env:LAYERX1_API_KEY = '${key}'`)}`,
+    ];
+  }
+  return [
+    `Persist your key: add  ${U.c.bold(`export LAYERX1_API_KEY="${key}"`)}  to your shell profile (setup offers to do this for you).`,
+  ];
+}
+
+const MANAGED_KC = [
+  "ANTHROPIC_BASE_URL",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_MODEL",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+  "ANTHROPIC_SMALL_FAST_MODEL",
+];
+
+const claudeCode = {
+  id: "claude-code",
+  label: "Claude Code",
+  protocol: "Anthropic /v1/messages",
+  apply(ctx) {
+    const p = path.join(ctx.home, ".claude", "settings.json");
+    let cfg = U.readJsonSafe(p);
+    if (cfg === undefined) return { error: `${p} exists but is not valid JSON — fix/remove it first` };
+    cfg = cfg || {};
+    // Deep-merge into the existing settings: only OUR env keys are touched — the user's
+    // permissions/hooks/other env entries pass through untouched.
+    const env = (cfg.env = cfg.env || {});
+    env.ANTHROPIC_BASE_URL = ctx.origin; // root, no /v1
+    env.ANTHROPIC_AUTH_TOKEN = ctx.key; // Bearer (avoids the "custom API key?" prompt)
+    env.ANTHROPIC_MODEL = ctx.model;
+    env.ANTHROPIC_DEFAULT_OPUS_MODEL = ctx.model;
+    env.ANTHROPIC_DEFAULT_SONNET_MODEL = ctx.model;
+    env.ANTHROPIC_DEFAULT_HAIKU_MODEL = ctx.smallModel;
+    env.ANTHROPIC_SMALL_FAST_MODEL = ctx.smallModel;
+    const notes = [];
+    if (env.CLAUDE_CODE_USE_BEDROCK === "1" || env.CLAUDE_CODE_USE_VERTEX === "1") {
+      notes.push("Unset CLAUDE_CODE_USE_BEDROCK / CLAUDE_CODE_USE_VERTEX — they override the base URL.");
+    }
+    notes.push("If you previously logged in to Claude, run `/logout` once so the gateway key is used.");
+    notes.push("Then just run `claude`.");
+    if (ctx.print) return { printed: `# ${p}\n${JSON.stringify(cfg, null, 2)}`, notes };
+    return { wrote: p, backup: U.writeFileSafe(p, JSON.stringify(cfg, null, 2) + "\n"), notes };
+  },
+  status(ctx) {
+    const cfg = U.readJsonSafe(path.join(ctx.home, ".claude", "settings.json"));
+    const base = cfg && cfg.env && cfg.env.ANTHROPIC_BASE_URL;
+    return { configured: !!base, detail: base ? `ANTHROPIC_BASE_URL=${base}` : "not configured" };
+  },
+  unset(ctx) {
+    const p = path.join(ctx.home, ".claude", "settings.json");
+    const cfg = U.readJsonSafe(p);
+    if (!cfg || !cfg.env) return { noop: true };
+    for (const k of MANAGED_KC) delete cfg.env[k];
+    return { wrote: p, backup: U.writeFileSafe(p, JSON.stringify(cfg, null, 2) + "\n") };
+  },
+};
+
+/** The slice of a TOML document BEFORE its first [table] header — the only region where a
+ *  bare `key = value` is top-level. Conflict checks run on this slice, not the whole file:
+ *  a `model =` inside someone's [profiles.x] table is a DIFFERENT key and must not stop us
+ *  from writing the real top-level one. */
+function tomlTopLevel(content) {
+  return String(content).split(/^\s*\[/m)[0];
+}
+
+const codex = {
+  id: "codex",
+  label: "OpenAI Codex CLI",
+  protocol: "OpenAI Responses /v1/responses",
+  apply(ctx) {
+    const p = path.join(ctx.home, ".codex", "config.toml");
+    const existing = U.readFileSafe(p) || "";
+    // Rebuild from the user's own content (all our blocks stripped, whatever version wrote
+    // them) so re-runs are deterministic: head block → user content → provider table at EOF.
+    const user = U.removeManagedBlock(existing);
+    const top = tomlTopLevel(user);
+    const hasModel = /^\s*model\s*=/m.test(top);
+    const hasProvider = /^\s*model_provider\s*=/m.test(top);
+    const hasCtxWindow = /^\s*model_context_window\s*=/m.test(top);
+    const hasCompact = /^\s*model_auto_compact_token_limit\s*=/m.test(top);
+    // Top-level keys — MUST precede any [table] header or TOML scopes them into that table.
+    // Only keys the user hasn't set themselves (a TOML duplicate key is a hard parse error).
+    const head = [];
+    if (!hasModel) head.push(`model = "${ctx.model}"`);
+    if (!hasProvider) head.push(`model_provider = "layerx1"`);
+    // Window/compact parity so Codex compacts before the context limit instead of erroring.
+    if (!hasCtxWindow) head.push(`model_context_window = 200000`);
+    if (!hasCompact) head.push(`model_auto_compact_token_limit = 160000`);
+    const table = [
+      `[model_providers.layerx1]`,
+      `name = "Layer X1"`,
+      `base_url = "${ctx.v1}"`, // Codex base_url INCLUDES /v1
+      `env_key = "LAYERX1_API_KEY"`,
+      `wire_api = "responses"`, // the only value Codex accepts as of 2026
+    ].join("\n");
+    let next = user;
+    if (head.length) next = U.upsertManagedBlock(next, head.join("\n"), { label: "head", position: "head" });
+    // The table goes at EOF: comments don't reset TOML table scope, so anywhere else it
+    // would capture whatever top-level keys follow it into [model_providers.layerx1].
+    next = U.upsertManagedBlock(next, table, { label: "provider", position: "end" });
+    const notes = [...keyPersistNotes(ctx.key)];
+    if (hasProvider) {
+      notes.push(`Your config already sets model_provider — switch it to "layerx1" (or run \`codex -c model_provider=layerx1\`).`);
+    }
+    notes.push("Codex requires the Responses API — Layer X1 serves /v1/responses.");
+    notes.push("Then run `codex`.");
+    if (ctx.print) return { printed: `# ${p}\n${next}`, notes };
+    return { wrote: p, backup: U.writeFileSafe(p, next), notes };
+  },
+  status(ctx) {
+    const content = U.readFileSafe(path.join(ctx.home, ".codex", "config.toml")) || "";
+    const has = content.includes("[model_providers.layerx1]");
+    return { configured: has, detail: has ? "model_providers.layerx1 present" : "not configured" };
+  },
+  unset(ctx) {
+    const p = path.join(ctx.home, ".codex", "config.toml");
+    const content = U.readFileSafe(p);
+    if (!content) return { noop: true };
+    return {
+      wrote: p,
+      backup: U.writeFileSafe(p, U.removeManagedBlock(content)),
+      notes: ['If you set model_provider="layerx1" manually, revert it.'],
+    };
+  },
+};
+
+const aider = {
+  id: "aider",
+  label: "Aider",
+  protocol: "OpenAI /v1/chat/completions (via LiteLLM)",
+  apply(ctx) {
+    const p = path.join(ctx.home, ".aider.conf.yml");
+    const existing = U.readFileSafe(p) || "";
+    const userContent = U.removeManagedBlock(existing);
+    const conflict = /^\s*(model|openai-api-base|openai-api-key)\s*:/m.test(userContent);
+    const body = [
+      `model: openai/${ctx.model}`, // openai/ prefix → LiteLLM OpenAI-compatible route
+      `openai-api-base: ${ctx.v1}`,
+      `openai-api-key: ${ctx.key}`,
+    ].join("\n");
+    const notes = ["Run `aider` in your repo (add --no-show-model-warnings to silence unknown-model notices)."];
+    if (conflict && !U.hasManagedBlock(existing)) {
+      return {
+        printed: `# merge into ${p}:\n${body}`,
+        notes: ["Your ~/.aider.conf.yml already sets model/openai-api-base — merge the above manually to avoid duplicate keys.", ...notes],
+      };
+    }
+    const next = U.upsertManagedBlock(existing, body);
+    if (ctx.print) return { printed: `# ${p}\n${next}`, notes };
+    return { wrote: p, backup: U.writeFileSafe(p, next), notes };
+  },
+  status(ctx) {
+    const content = U.readFileSafe(path.join(ctx.home, ".aider.conf.yml")) || "";
+    const has = U.hasManagedBlock(content);
+    return { configured: has, detail: has ? "managed block present" : "not configured" };
+  },
+  unset(ctx) {
+    const p = path.join(ctx.home, ".aider.conf.yml");
+    const content = U.readFileSafe(p);
+    if (!content) return { noop: true };
+    return { wrote: p, backup: U.writeFileSafe(p, U.removeManagedBlock(content)) };
+  },
+};
+
+const continueDev = {
+  id: "continue",
+  label: "Continue (VS Code / JetBrains)",
+  protocol: "OpenAI /v1/chat/completions",
+  apply(ctx) {
+    const p = path.join(ctx.home, ".continue", "config.yaml");
+    const existing = U.readFileSafe(p);
+    const entry = [
+      `  - name: Layer X1 (${ctx.model})`,
+      `    provider: openai`,
+      `    model: ${ctx.model}`,
+      `    apiBase: ${ctx.v1}`,
+      `    apiKey: ${ctx.key}`,
+      `    roles: [chat, edit, apply]`,
+    ].join("\n");
+    const fresh = `name: Layer X1\nversion: 0.0.1\nschema: v1\nmodels:\n${entry}\n`;
+    const notes = ["Reload VS Code (or the Continue extension) to pick up the model."];
+    if (existing == null) {
+      if (ctx.print) return { printed: `# ${p}\n${fresh}`, notes };
+      return { wrote: p, backup: U.writeFileSafe(p, fresh), notes };
+    }
+    // A config already exists — merging into a YAML list without a parser risks corruption,
+    // so print the entry for the user to add under their existing `models:` list.
+    return {
+      printed: `# add under the existing 'models:' list in ${p}:\n${entry}`,
+      notes: ["You already have a Continue config — add the entry above under its `models:` list.", ...notes],
+    };
+  },
+  status(ctx) {
+    const content = U.readFileSafe(path.join(ctx.home, ".continue", "config.yaml")) || "";
+    const has = content.includes("Layer X1");
+    return { configured: has, detail: has ? "Layer X1 model present" : "not configured" };
+  },
+  unset() {
+    return { noop: true, notes: ["Remove the 'Layer X1' entry from ~/.continue/config.yaml manually."] };
+  },
+};
+
+const cline = {
+  id: "cline",
+  label: "Cline (VS Code)",
+  protocol: "OpenAI /v1/chat/completions",
+  apply(ctx) {
+    const printed = [
+      `Cline is configured in its UI. Open the Cline panel → gear (Settings) →`,
+      `API Provider: "OpenAI Compatible", then set:`,
+      ``,
+      `    Base URL:  ${ctx.v1}`,
+      `    API Key:   ${ctx.key}`,
+      `    Model ID:  ${ctx.model}`,
+    ].join("\n");
+    return { printed, notes: ["Cline is GUI-configured — paste the values above into its settings panel."] };
+  },
+  status() {
+    return { configured: null, detail: "GUI-configured (cannot be auto-detected)" };
+  },
+  unset() {
+    return { noop: true, notes: ['Remove the "OpenAI Compatible" provider in Cline’s settings panel.'] };
+  },
+};
+
+// Cursor stores model settings inside the app (encrypted database, no config file we could
+// safely write) — so this target is print-only: exact clicks + the values to paste.
+const cursor = {
+  id: "cursor",
+  label: "Cursor",
+  protocol: "OpenAI /v1/chat/completions",
+  apply(ctx) {
+    const printed = [
+      `Cursor is configured in its UI (its settings store is encrypted — no file to write):`,
+      ``,
+      `  1. Cursor Settings (Ctrl/Cmd+Shift+J) → Models`,
+      `  2. In the OpenAI API Key section, paste your key:  ${ctx.key}`,
+      `  3. Enable "Override OpenAI Base URL" and set it to:  ${ctx.v1}`,
+      `  4. Click "+ Add model" and add:  ${ctx.model}`,
+      `     (add any other lx1-* ids you want — see \`npx layerx1 models\`)`,
+      `  5. Click "Verify", then pick ${ctx.model} in the model list.`,
+    ].join("\n");
+    return { printed, notes: ["Cursor is GUI-configured — follow the steps above inside Cursor."] };
+  },
+  status() {
+    return { configured: null, detail: "GUI-configured (cannot be auto-detected)" };
+  },
+  unset() {
+    return { noop: true, notes: ['In Cursor Settings → Models, disable "Override OpenAI Base URL" and remove the key.'] };
+  },
+};
+
+// Windsurf likewise keeps provider settings in the app — print-only.
+const windsurf = {
+  id: "windsurf",
+  label: "Windsurf",
+  protocol: "OpenAI /v1/chat/completions",
+  apply(ctx) {
+    const printed = [
+      `Windsurf is configured in its UI:`,
+      ``,
+      `  1. Windsurf Settings → Advanced Settings (or the settings panel in Cascade)`,
+      `  2. Add an "OpenAI-compatible" provider / enable the OpenAI base-URL override:`,
+      ``,
+      `       Base URL:  ${ctx.v1}`,
+      `       API Key:   ${ctx.key}`,
+      `       Model ID:  ${ctx.model}`,
+      ``,
+      `  (Menu names vary by Windsurf version — look for "custom provider" or "base URL".)`,
+    ].join("\n");
+    return { printed, notes: ["Windsurf is GUI-configured — paste the values above into its settings."] };
+  },
+  status() {
+    return { configured: null, detail: "GUI-configured (cannot be auto-detected)" };
+  },
+  unset() {
+    return { noop: true, notes: ["Remove the custom provider entry in Windsurf's settings."] };
+  },
+};
+
+const TARGETS = [claudeCode, codex, aider, continueDev, cline, cursor, windsurf];
+const byId = Object.fromEntries(TARGETS.map((t) => [t.id, t]));
+
+module.exports = { TARGETS, byId };

package/src/util.js

@@ -0,0 +1,177 @@
+// Shared helpers for the Layer X1 installer. Zero runtime dependencies — pure Node, so
+// `npx layerx1` works with nothing installed.
+"use strict";
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const readline = require("readline");
+
+const HOME = os.homedir();
+
+// --- colors (disabled when not a TTY or NO_COLOR is set) --------------------
+const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+const wrap = (code) => (s) => (useColor ? `\x1b[${code}m${s}\x1b[0m` : String(s));
+const c = {
+  bold: wrap("1"),
+  dim: wrap("2"),
+  red: wrap("31"),
+  green: wrap("32"),
+  yellow: wrap("33"),
+  blue: wrap("34"),
+  cyan: wrap("36"),
+  gray: wrap("90"),
+};
+
+const log = (s = "") => process.stdout.write(s + "\n");
+const ok = (s) => log(`  ${c.green("✓")} ${s}`);
+const info = (s) => log(`  ${c.cyan("•")} ${s}`);
+const warn = (s) => log(`  ${c.yellow("!")} ${s}`);
+const err = (s) => log(`  ${c.red("✗")} ${s}`);
+const head = (s) => log(`\n${c.bold(s)}`);
+
+// --- URL handling -----------------------------------------------------------
+// Accept a gateway URL in any form and produce both the ORIGIN (no /v1, for the
+// Anthropic SDK which appends /v1/messages) and the /v1 base (for OpenAI-style tools).
+function normalizeOrigin(url) {
+  let u = String(url || "").trim();
+  if (!u) return "";
+  if (!/^https?:\/\//i.test(u)) u = "https://" + u;
+  u = u.replace(/\/+$/, ""); // trailing slashes
+  u = u.replace(/\/v1$/i, ""); // a trailing /v1
+  return u;
+}
+const withV1 = (origin) => origin + "/v1";
+
+// --- files ------------------------------------------------------------------
+function readFileSafe(p) {
+  try {
+    return fs.readFileSync(p, "utf8");
+  } catch {
+    return null;
+  }
+}
+function readJsonSafe(p) {
+  const raw = readFileSafe(p);
+  if (raw == null) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return undefined; // exists but unparseable — caller must decide
+  }
+}
+function ensureDir(p) {
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+}
+/** Back up an existing file to <path>.layerx1.bak-<ts>; returns the backup path or null. */
+function backup(p) {
+  if (!fs.existsSync(p)) return null;
+  const bak = `${p}.layerx1.bak-${Date.now()}`;
+  fs.copyFileSync(p, bak);
+  return bak;
+}
+/** Write content, backing up any existing file first. Best-effort 0600 perms. */
+function writeFileSafe(p, content) {
+  ensureDir(p);
+  const bak = backup(p);
+  fs.writeFileSync(p, content);
+  try {
+    fs.chmodSync(p, 0o600);
+  } catch {
+    /* windows / no-op */
+  }
+  return bak;
+}
+
+// --- managed-block (for TOML/YAML text configs) -----------------------------
+// Blocks are LABELED (e.g. "head", "provider") because one file may need two of them at
+// different positions. Concretely: TOML comments do NOT reset table scope, so a
+// `[model_providers.layerx1]` table prepended above a user's config would capture their
+// pre-existing TOP-LEVEL keys into our table (silent config corruption). The fix is
+// structural: top-level keys go in a "head" block at the FILE HEAD (a block of bare
+// `key = value` lines captures nothing), and table blocks go at EOF (nothing follows
+// them, so nothing can be captured).
+const MARK_PREFIX = "# >>> layerx1";
+const MARK_END = "# <<< layerx1 <<<";
+const markStart = (label) =>
+  `${MARK_PREFIX}${label ? ":" + label : ""} (managed block — do not edit between markers) >>>`;
+const MARK_START = markStart(""); // unlabeled form — kept for pre-0.2.0 files in the wild
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Matches EVERY layerx1 block regardless of label — including pre-0.2.0 unlabeled ones. */
+const ANY_BLOCK_RE = () =>
+  new RegExp(`${escapeRe(MARK_PREFIX)}[^\\n]*>>>\\n[\\s\\S]*?${escapeRe(MARK_END)}\\n?`, "g");
+const blockRe = (label) =>
+  new RegExp(`${escapeRe(markStart(label))}\\n[\\s\\S]*?${escapeRe(MARK_END)}\\n?`, "g");
+function hasManagedBlock(content, label = "") {
+  return content != null && content.includes(markStart(label));
+}
+/** Insert/replace the block with this label. If it already exists it is swapped in place
+ *  (idempotent re-runs); otherwise it is placed per `position` — "end" (default, safe for
+ *  TOML tables) or "head" (top-level keys that must precede any table header). */
+function upsertManagedBlock(existing, body, { label = "", position = "end" } = {}) {
+  const block = `${markStart(label)}\n${body.trimEnd()}\n${MARK_END}\n`;
+  if (hasManagedBlock(existing, label)) return existing.replace(blockRe(label), block);
+  if (!existing || !existing.trim()) return block;
+  return position === "head"
+    ? `${block}\n${existing}`
+    : `${existing.replace(/\n*$/, "")}\n\n${block}`;
+}
+/** Strip ALL our blocks (any label, any vintage), leaving only the user's own content. */
+function removeManagedBlock(existing) {
+  if (!existing) return existing;
+  return existing
+    .replace(ANY_BLOCK_RE(), "")
+    .replace(/\n{3,}/g, "\n\n")
+    .replace(/^\n+/, "");
+}
+
+// --- shell profile detection (POSIX key persistence) --------------------------
+/** The interactive-shell profile we offer to append LAYERX1_API_KEY to. Detection is by
+ *  $SHELL basename only — good enough for an OFFERED (never forced) edit, and the managed
+ *  block makes a wrong guess harmless + removable. */
+function shellProfile(home, shellEnv = process.env.SHELL) {
+  const sh = String(shellEnv || "").split("/").pop();
+  if (sh === "zsh") return path.join(home, ".zshrc");
+  if (sh === "fish") return path.join(home, ".config", "fish", "config.fish");
+  return path.join(home, ".bashrc"); // bash and anything unrecognized
+}
+
+// --- interactive prompt -----------------------------------------------------
+async function prompt(question, def) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const suffix = def ? c.dim(` [${def}]`) : "";
+  const answer = await new Promise((res) => rl.question(`  ${question}${suffix} `, res));
+  rl.close();
+  const v = answer.trim();
+  return v || def || "";
+}
+
+module.exports = {
+  fs,
+  path,
+  HOME,
+  c,
+  log,
+  ok,
+  info,
+  warn,
+  err,
+  head,
+  normalizeOrigin,
+  withV1,
+  readFileSafe,
+  readJsonSafe,
+  ensureDir,
+  backup,
+  writeFileSafe,
+  MARK_START,
+  MARK_END,
+  markStart,
+  hasManagedBlock,
+  upsertManagedBlock,
+  removeManagedBlock,
+  shellProfile,
+  prompt,
+  homePath: (...parts) => path.join(HOME, ...parts),
+};