subconscious-cli 0.2.0 → 0.2.1

package/README.md

@@ -24,15 +24,36 @@ subconscious open-code
 point the agent at Subconscious, and exec's the real CLI. Nothing is written to
 the agent's own config — the provider is passed in-memory for that run only.
 
-| Command                    | Launches    | Requires (install)                                     |
-| -------------------------- | ----------- | ------------------------------------------------------ |
-| `subconscious claude-code` | Claude Code | `npm i -g @anthropic-ai/claude-code`                   |
-| `subconscious open-code`   | OpenCode    | `npm i -g opencode-ai`                                 |
-| `subconscious aider`       | Aider       | `python -m pip install aider-install && aider-install` |
-| `subconscious codex`       | Codex CLI   | `npm i -g @openai/codex`                               |
-
-If the underlying agent isn't installed, the CLI tells you the exact install
-command. Anything after the agent name is forwarded straight to it:
+Install commands are **OS-specific** — the CLI picks the right one for your
+platform automatically. The table below shows the macOS/Linux command; on
+Windows the equivalent native installer is used instead.
+
+| Command                    | Launches    | Requires (install, macOS/Linux)                         |
+| -------------------------- | ----------- | ------------------------------------------------------- |
+| `subconscious claude-code` | Claude Code | `curl -fsSL https://claude.ai/install.sh \| bash`       |
+| `subconscious open-code`   | OpenCode    | `npm i -g opencode-ai`                                  |
+| `subconscious aider`       | Aider       | `python3 -m pip install aider-install && aider-install` |
+| `subconscious codex`       | Codex CLI   | `npm i -g @openai/codex`                                |
+
+Claude Code uses its **native installer** (the `curl`/`irm` script above), with
+`npm i -g @anthropic-ai/claude-code` kept as an automatic fallback if the native
+installer fails.
+
+If the underlying agent isn't installed and you're in an interactive terminal,
+the CLI offers to install it for you (just press Enter), runs the right
+installer for your OS (trying the fallback if the primary fails), and launches
+it once the install succeeds. In a non-interactive context (CI) it instead
+prints the exact install command (and any fallback) and exits without running
+anything.
+
+Freshly-installed binaries (e.g. Aider and Claude Code land in `~/.local/bin`,
+npm globals in the npm prefix) often aren't on your current shell's `PATH` yet.
+The CLI looks in those common locations and launches the agent anyway. If it
+still can't find the binary right after install, it tells you to **open a new
+terminal** (or add the printed dir to `PATH`) and re-run the command — the
+install itself succeeded.
+
+Anything after the agent name is forwarded straight to it:
 
 ```bash
 subconscious claude-code --resume
@@ -49,6 +70,16 @@ subconscious open-code --model subconscious/tim-qwen3.6-27b
 export SUBCONSCIOUS_MODEL=subconscious/tim-qwen3.6-27b
 ```
 
+### Pointing at a different endpoint
+
+By default the CLI targets `https://api.subconscious.dev`. Override the base URL
+per run (or for a whole session) with `SUBCONSCIOUS_BASE_URL` — it flows to both
+the Anthropic-style base and the OpenAI-compatible `/v1` base:
+
+```bash
+SUBCONSCIOUS_BASE_URL=http://localhost:9999 subconscious claude-code
+```
+
 ## Auth commands
 
 ### `login`

package/bin/agents.js

@@ -3,103 +3,84 @@
  *
  * `subconscious <agent>` resolves your saved API key, injects the env vars that
  * point the agent at your hosted Subconscious model, and exec's the real CLI —
- * nothing is written to the agent's own config. Each entry here mirrors the
- * matching example under `examples/<agent>` (its `subconscious.agent` block),
- * which stays the source of truth.
+ * nothing is written to the agent's own config.
+ *
+ * There is NO hardcoded agent data here: everything is read from
+ * `registry.generated.json` (shipped under `bin/`), which is generated from the
+ * single source of truth `agents/registry.json`. Run `pnpm generate` to update.
  */
 
-import { spawn } from 'node:child_process';
+import { spawn, execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
 import fs from 'node:fs/promises';
 import { constants as fsConstants } from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
+import readline from 'node:readline';
 import { c } from './colors.js';
 import { getApiKey } from './auth.js';
 
-// Subconscious endpoints. The Anthropic-style base has no `/v1`; the
-// OpenAI-compatible base does.
-const API_BASE = 'https://api.subconscious.dev';
-const API_BASE_V1 = 'https://api.subconscious.dev/v1';
-const DEFAULT_MODEL = 'subconscious/tim-qwen3.6-27b';
+// --- Registry (single source of truth, generated copy shipped in the package).
+const registry = JSON.parse(
+  readFileSync(new URL('./registry.generated.json', import.meta.url), 'utf-8'),
+);
+const DEFAULTS = registry.defaults;
+
+// --- Token substitution — same rules as scripts/lib/registry.js.
+// Replaces {apiKey}, {model}, {baseUrl}, {baseUrlV1}. NEVER touches {env:...}.
+const TOKENS = ['apiKey', 'model', 'baseUrl', 'baseUrlV1'];
+
+function substituteString(str, ctx) {
+  let out = str;
+  for (const token of TOKENS) {
+    if (ctx[token] === undefined) continue;
+    out = out.split(`{${token}}`).join(ctx[token]);
+  }
+  return out;
+}
+
+function substitute(value, ctx) {
+  if (typeof value === 'string') return substituteString(value, ctx);
+  if (Array.isArray(value)) return value.map((v) => substitute(v, ctx));
+  if (value && typeof value === 'object') {
+    const keys = Object.keys(value);
+    if (keys.length === 1 && keys[0] === '$json') {
+      return JSON.stringify(substitute(value.$json, ctx));
+    }
+    const out = {};
+    for (const key of keys) out[substituteString(key, ctx)] = substitute(value[key], ctx);
+    return out;
+  }
+  return value;
+}
 
 /**
- * Agent registry. Each entry:
- *   name    — display name
- *   aliases — accepted subcommands (first is canonical)
- *   install — how to install the underlying CLI (shown when it's missing)
- *   bin     — executable we exec and probe on PATH
- *   env     — (key, model) => extra env vars merged over process.env
- *   args    — (model) => array of args passed to `bin`
+ * Resolve the install command for the current OS from a per-OS install object.
+ * Falls back to the linux command, then any string value present, if the exact
+ * `process.platform` key is missing. Tolerates a legacy plain-string `install`.
+ * Returns `{ command, fallback }` where `fallback` may be undefined.
  */
-const AGENTS = [
-  {
-    name: 'Claude Code',
-    aliases: ['claude-code', 'claude', 'claudecode'],
-    install: 'npm i -g @anthropic-ai/claude-code',
-    bin: 'claude',
-    env: (key, model) => ({
-      ANTHROPIC_BASE_URL: API_BASE,
-      ANTHROPIC_AUTH_TOKEN: key,
-      ANTHROPIC_MODEL: model,
-      ANTHROPIC_SMALL_FAST_MODEL: model,
-      // Let Subconscious manage context instead of client-side compaction.
-      DISABLE_AUTO_COMPACT: 'true',
-    }),
-    args: () => [],
-  },
-  {
-    name: 'OpenCode',
-    aliases: ['open-code', 'opencode'],
-    install: 'npm i -g opencode-ai',
-    bin: 'opencode',
-    env: (key, model) => ({
-      SUBCONSCIOUS_API_KEY: key,
-      // OpenCode deep-merges this at startup; nothing touches ~/.config/opencode.
-      OPENCODE_CONFIG_CONTENT: JSON.stringify({
-        $schema: 'https://opencode.ai/config.json',
-        provider: {
-          subconscious: {
-            npm: '@ai-sdk/openai-compatible',
-            name: 'Subconscious',
-            options: { baseURL: API_BASE_V1, apiKey: '{env:SUBCONSCIOUS_API_KEY}' },
-            models: { [model]: { name: 'Subconscious', tools: true } },
-          },
-        },
-        model: `subconscious/${model}`,
-      }),
-    }),
-    args: () => [],
-  },
-  {
-    name: 'Aider',
-    aliases: ['aider'],
-    install: 'python -m pip install aider-install && aider-install',
-    bin: 'aider',
-    env: (key) => ({
-      OPENAI_API_BASE: API_BASE_V1,
-      OPENAI_API_KEY: key,
-    }),
-    args: (model) => ['--model', `openai/${model}`],
-  },
-  {
-    name: 'Codex CLI',
-    aliases: ['codex'],
-    install: 'npm i -g @openai/codex',
-    bin: 'codex',
-    env: (key) => ({ SUBCONSCIOUS_API_KEY: key }),
-    // `-c model=…` (not `--model`, which is codex's Ollama shortcut).
-    args: (model) => [
-      '-c', 'model_providers.subconscious.name=Subconscious',
-      '-c', `model_providers.subconscious.base_url=${API_BASE_V1}`,
-      '-c', 'model_providers.subconscious.env_key=SUBCONSCIOUS_API_KEY',
-      '-c', 'model_provider=subconscious',
-      '-c', `model=${model}`,
-    ],
-  },
-];
+function resolveInstall(install) {
+  if (typeof install === 'string') return { command: install, fallback: undefined };
+  if (!install || typeof install !== 'object') return { command: undefined, fallback: undefined };
+  const command =
+    install[process.platform] ||
+    install.linux ||
+    Object.values(install).find((v) => typeof v === 'string');
+  return { command, fallback: install.fallback };
+}
 
+// --- Build the in-memory registry + alias index.
+// Each agent gets a resolved per-OS `install` (string) plus optional
+// `installFallback`, while keeping the original per-OS object available.
+const AGENTS = registry.agents.map((agent) => {
+  const { command, fallback } = resolveInstall(agent.install);
+  return { ...agent, install: command, installFallback: fallback };
+});
 const BY_ALIAS = new Map();
 for (const agent of AGENTS) {
-  for (const alias of agent.aliases) BY_ALIAS.set(alias, agent);
+  BY_ALIAS.set(agent.id, agent);
+  for (const alias of agent.aliases || []) BY_ALIAS.set(alias, agent);
 }
 
 export function resolveAgent(name) {
@@ -107,16 +88,27 @@ export function resolveAgent(name) {
 }
 
 export function agentList() {
-  return AGENTS.map((a) => ({ name: a.name, alias: a.aliases[0] }));
+  return AGENTS.map((a) => ({ name: a.name, alias: a.id }));
+}
+
+/**
+ * Resolve the substitution context for a launch:
+ *   model     — --model flag → SUBCONSCIOUS_MODEL → registry default
+ *   baseUrl   — SUBCONSCIOUS_BASE_URL → registry default
+ *   baseUrlV1 — `${baseUrl}/v1` (so an override flows to both)
+ */
+function buildContext(apiKey, model) {
+  const baseUrl = process.env.SUBCONSCIOUS_BASE_URL?.trim() || DEFAULTS.baseUrl;
+  return { apiKey, model, baseUrl, baseUrlV1: `${baseUrl}/v1` };
 }
 
 /**
  * Pull a `--model <value>` / `--model=<value>` flag out of the passthrough
  * args (so it sets the Subconscious model rather than reaching the agent).
- * Falls back to SUBCONSCIOUS_MODEL, then the default.
+ * Falls back to SUBCONSCIOUS_MODEL, then the registry default.
  */
 function extractModel(argv) {
-  let model = process.env.SUBCONSCIOUS_MODEL?.trim() || DEFAULT_MODEL;
+  let model = process.env.SUBCONSCIOUS_MODEL?.trim() || DEFAULTS.model;
   const rest = [];
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -137,25 +129,176 @@ function extractModel(argv) {
   return { model, rest };
 }
 
-/** Is `bin` an executable resolvable on PATH? */
-async function isOnPath(bin) {
-  const dirs = (process.env.PATH || '').split(path.delimiter).filter(Boolean);
-  const exts =
-    process.platform === 'win32'
-      ? (process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM').split(';')
-      : [''];
+/**
+ * Common locations a freshly-installed coding-agent binary lands in but which
+ * are often NOT on the current process's PATH (e.g. aider/claude install into
+ * `~/.local/bin`; npm globals into the npm prefix bin). Best-effort, deduped.
+ */
+function candidateBinDirs() {
+  const home = os.homedir();
+  const dirs = [];
+
+  if (process.platform === 'win32') {
+    if (process.env.APPDATA) dirs.push(path.join(process.env.APPDATA, 'npm'));
+    if (process.env.USERPROFILE) {
+      dirs.push(path.join(process.env.USERPROFILE, '.local', 'bin'));
+    }
+    if (home) dirs.push(path.join(home, '.local', 'bin'));
+  } else {
+    dirs.push(path.join(home, '.local', 'bin'));
+    dirs.push('/opt/homebrew/bin');
+    dirs.push('/usr/local/bin');
+  }
+
+  // npm global bin (best-effort — npm may be absent).
+  try {
+    const prefix = execFileSync('npm', ['prefix', '-g'], {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    if (prefix) {
+      dirs.push(process.platform === 'win32' ? prefix : path.join(prefix, 'bin'));
+    }
+  } catch {
+    // npm not available — skip.
+  }
+
+  // Dedupe, drop empties.
+  return [...new Set(dirs.filter(Boolean))];
+}
+
+/** Executable extensions to probe (Windows uses PATHEXT). */
+function binExts() {
+  return process.platform === 'win32'
+    ? (process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM').split(';')
+    : [''];
+}
+
+/**
+ * Resolve `bin` against PATH plus the candidate bin dirs. Returns the directory
+ * containing the executable if found, otherwise null. Searching the candidate
+ * dirs lets us find binaries installed this session that aren't on PATH yet.
+ */
+async function resolveBinPath(bin) {
+  const pathDirs = (process.env.PATH || '').split(path.delimiter).filter(Boolean);
+  const dirs = [...pathDirs, ...candidateBinDirs()];
+  const exts = binExts();
   for (const dir of dirs) {
     for (const ext of exts) {
       const candidate = path.join(dir, bin + ext);
       try {
         await fs.access(candidate, fsConstants.F_OK);
-        return true;
+        return dir;
       } catch {
         // keep scanning
       }
     }
   }
-  return false;
+  return null;
+}
+
+/**
+ * Build a PATH string with `extraDirs` prepended (deduped against PATH).
+ * Returns the augmented PATH value for use in a child env.
+ */
+function augmentPath(extraDirs) {
+  const current = (process.env.PATH || '').split(path.delimiter).filter(Boolean);
+  const seen = new Set(current);
+  const prepend = extraDirs.filter((d) => d && !seen.has(d));
+  return [...prepend, ...current].join(path.delimiter);
+}
+
+/** Ask a yes/no question on the TTY. Empty answer counts as yes. */
+function askYesNo(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      const a = answer.trim().toLowerCase();
+      resolve(a === '' || a === 'y' || a === 'yes');
+    });
+  });
+}
+
+/** Run the agent's install command (may contain `&&`, so shell:true). */
+function runInstaller(install) {
+  return new Promise((resolve) => {
+    const child = spawn(install, { shell: true, stdio: 'inherit' });
+    child.on('error', () => resolve(false));
+    child.on('exit', (code) => resolve(code === 0));
+  });
+}
+
+/** Print the resolved install command (plus any fallback) for an agent. */
+function printInstallCommands(agent) {
+  console.error(`    ${c.cyan}${agent.install}${c.reset}`);
+  if (agent.installFallback) {
+    console.error(`  ${c.dim}or, as a fallback:${c.reset}`);
+    console.error(`    ${c.cyan}${agent.installFallback}${c.reset}`);
+  }
+  console.error('');
+}
+
+/**
+ * Ensure the agent's binary is resolvable. If missing:
+ *   - interactive TTY: offer to run the per-OS installer (with fallback), then
+ *     re-resolve against PATH + candidate dirs.
+ *   - non-interactive: print the resolved install command (+ fallback) and
+ *     exit 127 without running anything.
+ *
+ * Returns the directory containing the bin (to prepend to the child's PATH) on
+ * success. May exit the process on failure or when manual action is needed.
+ */
+async function ensureInstalled(agent) {
+  const existing = await resolveBinPath(agent.bin);
+  if (existing) return existing;
+
+  const interactive = process.stdin.isTTY && process.stdout.isTTY;
+
+  if (!interactive) {
+    console.error(
+      `\n  ${c.red}${agent.name} isn't installed${c.reset} ${c.dim}(\`${agent.bin}\` not found on PATH).${c.reset}`,
+    );
+    console.error(`  Install it with:\n`);
+    printInstallCommands(agent);
+    process.exit(127);
+  }
+
+  console.error(`\n  ${c.bold}${agent.name}${c.reset} isn't installed.`);
+  const ok = await askYesNo(`  Install it now? ${c.dim}[Y/n]${c.reset} `);
+  if (!ok) {
+    console.error(`\n  No problem. Install it yourself with:\n`);
+    printInstallCommands(agent);
+    process.exit(127);
+  }
+
+  console.error(`\n  ${c.dim}Running ${c.reset}${c.cyan}${agent.install}${c.reset}\n`);
+  let installed = await runInstaller(agent.install);
+
+  // Primary failed and a fallback exists — try it once.
+  if (!installed && agent.installFallback) {
+    console.error(
+      `\n  ${c.dim}That didn't work. Trying the fallback: ${c.reset}${c.cyan}${agent.installFallback}${c.reset}\n`,
+    );
+    installed = await runInstaller(agent.installFallback);
+  }
+
+  if (!installed) {
+    console.error(`\n  ${c.red}Install failed.${c.reset} Try it manually:\n`);
+    printInstallCommands(agent);
+    process.exit(127);
+  }
+
+  // PATH hardening: the freshly-installed binary is often not on the current
+  // process's PATH. Re-resolve against PATH + candidate dirs.
+  const found = await resolveBinPath(agent.bin);
+  if (found) return found;
+
+  console.error(
+    `\n  ${c.dim}Installed ${agent.name}, but it isn't on this shell's PATH yet. ` +
+      `Open a new terminal (or add a bin dir to PATH) and re-run \`subconscious ${agent.id}\`.${c.reset}\n`,
+  );
+  process.exit(0);
 }
 
 /**
@@ -174,30 +317,32 @@ export async function runAgent(agent, argv) {
     process.exit(1);
   }
 
-  if (!(await isOnPath(agent.bin))) {
-    console.error(
-      `\n  ${c.red}${agent.name} isn't installed${c.reset} ${c.dim}(\`${agent.bin}\` not found on PATH).${c.reset}`,
-    );
-    console.error(`  Install it with:\n`);
-    console.error(`    ${c.cyan}${agent.install}${c.reset}\n`);
-    process.exit(127);
-  }
+  const binDir = await ensureInstalled(agent);
+
+  const ctx = buildContext(auth.key, model);
+  const launch = substituteString(agent.launch, ctx);
+  const [bin, ...launchArgs] = launch.split(' ').filter(Boolean);
+  const envMap = substitute(agent.env, ctx);
 
-  const env = { ...process.env, ...agent.env(auth.key, model) };
-  const args = [...agent.args(model), ...rest];
+  // Prepend the resolved bin dir + candidate dirs to the child's PATH so the
+  // agent (and any subprocess it spawns) resolves correctly this session, even
+  // if it was installed into a dir not yet on the parent shell's PATH.
+  const extraDirs = [binDir, ...candidateBinDirs()].filter(Boolean);
+  const env = { ...process.env, ...envMap, PATH: augmentPath(extraDirs) };
+  const args = [...launchArgs, ...rest];
 
   console.log(
     `  ${c.dim}Launching ${c.reset}${c.bold}${agent.name}${c.reset} ${c.dim}on Subconscious ${c.reset}${c.dim}(${model})${c.reset}\n`,
   );
 
-  const child = spawn(agent.bin, args, { stdio: 'inherit', env });
+  const child = spawn(bin, args, { stdio: 'inherit', env });
 
   child.on('error', (err) => {
     if (err.code === 'ENOENT') {
       console.error(
-        `\n  ${c.red}Could not launch \`${agent.bin}\`.${c.reset} Install it with:\n`,
+        `\n  ${c.red}Could not launch \`${bin}\`.${c.reset} Install it with:\n`,
       );
-      console.error(`    ${c.cyan}${agent.install}${c.reset}\n`);
+      printInstallCommands(agent);
       process.exit(127);
     }
     console.error(`\n  ${c.red}${err.message}${c.reset}\n`);

package/bin/registry.generated.json

@@ -0,0 +1,158 @@
+{
+  "_generated": "Source of truth: agents/registry.json. Do not edit by hand.",
+  "defaults": {
+    "model": "subconscious/tim-qwen3.6-27b",
+    "baseUrl": "https://api.subconscious.dev",
+    "baseUrlV1": "https://api.subconscious.dev/v1",
+    "keyPlaceholder": "your_key",
+    "platformUrl": "https://subconscious.dev/platform"
+  },
+  "agents": [
+    {
+      "id": "claude-code",
+      "exampleDir": "claude_code",
+      "name": "Claude Code",
+      "aliases": [
+        "claude",
+        "claudecode"
+      ],
+      "displayName": "Claude Code + Subconscious",
+      "description": "Run Claude Code on your hosted Subconscious model — no code changes, just env vars.",
+      "framework": "Claude Code",
+      "language": "shell",
+      "category": "coding-agent",
+      "tags": [
+        "local",
+        "cli",
+        "agents"
+      ],
+      "protocol": "anthropic",
+      "homepage": "https://docs.anthropic.com/en/docs/claude-code",
+      "bin": "claude",
+      "install": {
+        "darwin": "curl -fsSL https://claude.ai/install.sh | bash",
+        "linux": "curl -fsSL https://claude.ai/install.sh | bash",
+        "win32": "powershell -ExecutionPolicy Bypass -Command \"irm https://claude.ai/install.ps1 | iex\"",
+        "fallback": "npm i -g @anthropic-ai/claude-code"
+      },
+      "launch": "claude",
+      "env": {
+        "ANTHROPIC_BASE_URL": "{baseUrl}",
+        "ANTHROPIC_AUTH_TOKEN": "{apiKey}",
+        "ANTHROPIC_MODEL": "{model}",
+        "ANTHROPIC_SMALL_FAST_MODEL": "{model}",
+        "DISABLE_AUTO_COMPACT": "true"
+      }
+    },
+    {
+      "id": "opencode",
+      "exampleDir": "opencode",
+      "name": "OpenCode",
+      "aliases": [
+        "open-code"
+      ],
+      "displayName": "OpenCode + Subconscious",
+      "description": "Run OpenCode on your hosted Subconscious model — registered as a custom provider, injected non-invasively (nothing written to your OpenCode config).",
+      "framework": "OpenCode",
+      "language": "shell",
+      "category": "coding-agent",
+      "tags": [
+        "local",
+        "cli",
+        "agents"
+      ],
+      "protocol": "openai",
+      "homepage": "https://opencode.ai",
+      "bin": "opencode",
+      "install": {
+        "darwin": "npm i -g opencode-ai",
+        "linux": "npm i -g opencode-ai",
+        "win32": "npm i -g opencode-ai"
+      },
+      "launch": "opencode",
+      "configEnv": "OPENCODE_CONFIG_CONTENT",
+      "env": {
+        "SUBCONSCIOUS_API_KEY": "{apiKey}",
+        "OPENCODE_CONFIG_CONTENT": {
+          "$json": {
+            "$schema": "https://opencode.ai/config.json",
+            "provider": {
+              "subconscious": {
+                "npm": "@ai-sdk/openai-compatible",
+                "name": "Subconscious",
+                "options": {
+                  "baseURL": "{baseUrlV1}",
+                  "apiKey": "{env:SUBCONSCIOUS_API_KEY}"
+                },
+                "models": {
+                  "{model}": {
+                    "name": "Subconscious",
+                    "tools": true
+                  }
+                }
+              }
+            },
+            "model": "subconscious/{model}"
+          }
+        }
+      }
+    },
+    {
+      "id": "aider",
+      "exampleDir": "aider",
+      "name": "Aider",
+      "aliases": [],
+      "displayName": "Aider + Subconscious",
+      "description": "Run Aider on your hosted Subconscious model — no code changes, just env vars.",
+      "framework": "Aider",
+      "language": "shell",
+      "category": "coding-agent",
+      "tags": [
+        "local",
+        "cli",
+        "agents"
+      ],
+      "protocol": "openai",
+      "homepage": "https://aider.chat",
+      "bin": "aider",
+      "install": {
+        "darwin": "python3 -m pip install aider-install && aider-install",
+        "linux": "python3 -m pip install aider-install && aider-install",
+        "win32": "python -m pip install aider-install && aider-install"
+      },
+      "launch": "aider --model openai/{model}",
+      "env": {
+        "OPENAI_API_BASE": "{baseUrlV1}",
+        "OPENAI_API_KEY": "{apiKey}"
+      }
+    },
+    {
+      "id": "codex",
+      "exampleDir": "codex",
+      "name": "Codex CLI",
+      "aliases": [],
+      "displayName": "Codex + Subconscious",
+      "description": "Run the Codex CLI on your hosted Subconscious model via a custom OpenAI-compatible provider.",
+      "framework": "Codex",
+      "language": "shell",
+      "category": "coding-agent",
+      "tags": [
+        "local",
+        "cli",
+        "agents"
+      ],
+      "protocol": "openai",
+      "homepage": "https://developers.openai.com/codex",
+      "bin": "codex",
+      "install": {
+        "darwin": "npm i -g @openai/codex",
+        "linux": "npm i -g @openai/codex",
+        "win32": "npm i -g @openai/codex"
+      },
+      "launch": "codex -c model_providers.subconscious.name=Subconscious -c model_providers.subconscious.base_url={baseUrlV1} -c model_providers.subconscious.env_key=SUBCONSCIOUS_API_KEY -c model_provider=subconscious -c model={model}",
+      "env": {
+        "SUBCONSCIOUS_API_KEY": "{apiKey}"
+      }
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "subconscious-cli",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "CLI for Subconscious — log in and launch coding agents (Claude Code, OpenCode, Aider, Codex) on your hosted models",
   "bin": {
     "subconscious": "./bin/cli.js",