subconscious-cli 0.2.0 → 0.3.0

package/bin/auth.js

@@ -8,7 +8,8 @@
  *  3. The web app authenticates the user, generates an API key, and
  *     delivers it back to the CLI via a cross-origin fetch to
  *     localhost:{port}/callback?token=...&state=...
- *  4. CLI verifies the `state` matches, saves the key to ~/.subcon/config.json.
+ *  4. CLI verifies the `state`, saves the key to ~/.subconscious/config.json,
+ *     and creates a coding-agent profile under ~/.subconscious/profiles/.
  *
  * Override SUBCONSCIOUS_URL env var for local development.
  */
@@ -20,9 +21,14 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { c } from './colors.js';
+import { clearProfileApiKey, DEFAULT_PROFILE, ensureProfile } from './profiles.js';
 
-const CONFIG_DIR = path.join(os.homedir(), '.subcon');
+const CONFIG_OVERRIDE = process.env.SUBC_CONFIG_DIR?.trim();
+const CONFIG_DIR = CONFIG_OVERRIDE || path.join(os.homedir(), '.subconscious');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const LEGACY_CONFIG_FILE = CONFIG_OVERRIDE
+  ? null
+  : path.join(os.homedir(), '.subcon', 'config.json');
 // Defaults to production. Developers set SUBCONSCIOUS_URL=http://localhost:3000 for local dev.
 const PLATFORM_URL = process.env.SUBCONSCIOUS_URL || 'https://www.subconscious.dev';
 
@@ -32,6 +38,17 @@ async function loadConfig() {
   try {
     const content = await fs.readFile(CONFIG_FILE, 'utf-8');
     return JSON.parse(content);
+  } catch (error) {
+    if (error.code !== 'ENOENT' || !LEGACY_CONFIG_FILE) return {};
+  }
+
+  // One-way compatibility migration. Keep the old file untouched so this is
+  // recoverable, but all future writes go to ~/.subconscious.
+  try {
+    const content = await fs.readFile(LEGACY_CONFIG_FILE, 'utf-8');
+    const config = JSON.parse(content);
+    await saveConfig(config);
+    return config;
   } catch {
     return {};
   }
@@ -48,13 +65,20 @@ async function saveConfig(config) {
  * Resolve the active API key. The env var takes precedence over the saved
  * config so CI and per-shell overrides win. Returns null when unauthenticated.
  */
-export async function getApiKey() {
+export async function getApiKey(profile) {
   const envKey = process.env.SUBCONSCIOUS_API_KEY?.trim();
   if (envKey) return { key: envKey, source: 'SUBCONSCIOUS_API_KEY env var' };
 
+  const profileKey = profile?.values?.API_KEY?.trim();
+  if (profileKey) return { key: profileKey, source: profile.path };
+
+  // Named profiles are isolated: an empty/missing key must not silently fall
+  // back to the default credential and send traffic to the wrong account.
+  if (profile?.name && profile.name !== DEFAULT_PROFILE) return null;
+
   const config = await loadConfig();
   if (config.subconscious_api_key) {
-    return { key: config.subconscious_api_key, source: '~/.subcon/config.json' };
+    return { key: config.subconscious_api_key, source: '~/.subconscious/config.json' };
   }
   return null;
 }
@@ -231,15 +255,20 @@ h1{font-size:15px;font-weight:600;margin-bottom:4px;letter-spacing:-.01em}
 
 // ── Commands ────────────────────────────────────────────────────────────
 
-export async function loginCommand() {
-  const existing = await getApiKey();
+export async function loginCommand(_argv = [], options = {}) {
+  const profileName = options.profileName || DEFAULT_PROFILE;
+  const existing = await getApiKey(options.profile);
 
   if (existing) {
+    const profile = await ensureProfile(profileName, existing.key);
+    const logout =
+      profileName === DEFAULT_PROFILE ? 'subc logout' : `subc --profile ${profileName} logout`;
     const masked = existing.key.slice(0, 8) + '...' + existing.key.slice(-4);
     console.log(`\n${c.yellow}Already logged in.${c.reset}`);
     console.log(`  Key: ${c.dim}${masked}${c.reset}`);
+    console.log(`  Profile: ${c.dim}${profile.path}${c.reset}`);
     console.log(
-      `\n  Run ${c.cyan}subconscious logout${c.reset} first to switch accounts.\n`,
+      `\n  Run ${c.cyan}${logout}${c.reset} first to switch accounts.\n`,
     );
     return;
   }
@@ -283,14 +312,23 @@ export async function loginCommand() {
     clearInterval(spinner);
     process.stdout.write('\r' + ' '.repeat(50) + '\r');
 
-    const config = await loadConfig();
-    config.subconscious_api_key = result.token;
-    await saveConfig(config);
+    if (profileName === DEFAULT_PROFILE) {
+      const config = await loadConfig();
+      config.subconscious_api_key = result.token;
+      await saveConfig(config);
+    }
+    const profile = await ensureProfile(profileName, result.token);
 
     const masked = result.token.slice(0, 8) + '...' + result.token.slice(-4);
     console.log(`  ${c.green}${c.bold}✓ Logged in successfully!${c.reset}`);
     console.log(`  ${c.dim}Key: ${masked}${c.reset}`);
-    console.log(`  ${c.dim}Saved to ~/.subcon/config.json${c.reset}`);
+    if (profileName === DEFAULT_PROFILE) {
+      console.log(`  ${c.dim}Saved to ~/.subconscious/config.json${c.reset}`);
+    }
+    console.log(`  ${c.dim}Runbook profile: ${profile.path}${c.reset}`);
+    const setup =
+      profileName === DEFAULT_PROFILE ? 'subc setup' : `subc --profile ${profileName} setup`;
+    console.log(`  ${c.dim}Run ${setup} once to configure all coding agents.${c.reset}`);
     console.log();
   } catch (error) {
     clearInterval(spinner);
@@ -300,29 +338,65 @@ export async function loginCommand() {
   }
 }
 
-export async function logoutCommand() {
+export async function updateApiKeyCommand(argv = [], options = {}) {
+  if (argv.length !== 1 || !argv[0]?.trim()) {
+    throw new Error('Usage: subc update-key <api-key>');
+  }
+
+  const key = argv[0].trim();
+  const profileName = options.profileName || DEFAULT_PROFILE;
+  const profile = await ensureProfile(profileName, key);
+
+  if (profileName === DEFAULT_PROFILE) {
+    const config = await loadConfig();
+    config.subconscious_api_key = key;
+    await saveConfig(config);
+  }
+
+  const masked = key.length <= 12 ? '********' : `${key.slice(0, 8)}...${key.slice(-4)}`;
+  console.log(`\n  ${c.green}${c.bold}✓ API key updated.${c.reset}`);
+  console.log(`  ${c.dim}Profile: ${profile.path}${c.reset}`);
+  console.log(`  ${c.dim}Key:     ${masked}${c.reset}`);
+  if (process.env.SUBCONSCIOUS_API_KEY?.trim()) {
+    console.log(
+      `\n  ${c.yellow}SUBCONSCIOUS_API_KEY is set and will override this saved key.${c.reset}`,
+    );
+  }
+  console.log();
+}
+
+export async function logoutCommand(_argv = [], options = {}) {
+  const profileName = options.profileName || DEFAULT_PROFILE;
   const config = await loadConfig();
+  const clearedProfile = await clearProfileApiKey(profileName);
+  const clearSavedConfig = profileName === DEFAULT_PROFILE && config.subconscious_api_key;
 
-  if (!config.subconscious_api_key) {
+  if (!clearSavedConfig && !clearedProfile) {
     console.log(`\n  ${c.dim}Not logged in.${c.reset}\n`);
     return;
   }
 
-  delete config.subconscious_api_key;
-  await saveConfig(config);
+  if (clearSavedConfig) {
+    delete config.subconscious_api_key;
+    await saveConfig(config);
+  }
 
   console.log(
-    `\n  ${c.green}✓${c.reset} Logged out. API key removed from ${c.dim}~/.subcon/config.json${c.reset}\n`,
+    `\n  ${c.green}✓${c.reset} Logged out of profile '${profileName}'.${c.reset}\n`,
   );
 }
 
-export async function whoamiCommand() {
-  const auth = await getApiKey();
+export async function whoamiCommand(_argv = [], options = {}) {
+  const auth = await getApiKey(options.profile);
+  const profileFlag =
+    options.profileName && options.profileName !== DEFAULT_PROFILE
+      ? `--profile ${options.profileName} `
+      : '';
 
   if (!auth) {
     console.log(`\n  ${c.dim}Not logged in.${c.reset}`);
     console.log(
-      `  Run ${c.cyan}subconscious login${c.reset} to get started.\n`,
+      `  Run ${c.cyan}subc ${profileFlag}login${c.reset} to get started.\n`,
     );
     return;
   }
@@ -353,7 +427,7 @@ export async function whoamiCommand() {
       console.log(`  ${c.dim}Source: ${source}${c.reset}`);
       console.log();
       console.log(
-        `  Run ${c.cyan}subconscious logout${c.reset} then ${c.cyan}subconscious login${c.reset} to re-authenticate.`,
+        `  Run ${c.cyan}subc ${profileFlag}logout${c.reset} then ${c.cyan}subc ${profileFlag}login${c.reset} to re-authenticate.`,
       );
     }
   } catch {

package/bin/branding.js

@@ -0,0 +1,39 @@
+import { colorEnabled } from './colors.js';
+
+// Pre-rendered from assets/imgs/logo.png as portable, 7-bit ASCII art.
+const LOGO = [
+  '       #####        #####',
+  '      #######      #######',
+  '     ########      ########',
+  '      ########    ########',
+  '             ######',
+  '               ##',
+  ' ######       ####       ######',
+  '##########  ########  ##########',
+  '##########  ########  ##########',
+  ' ######       ####       ######',
+  '               ##',
+  '             ######',
+  '       #######    #######',
+  '      #######      #######',
+  '      #######      #######',
+  '      ######        #####',
+].join('\n');
+
+const ORANGE = '\x1b[38;2;255;92;40m';
+const BOLD = '\x1b[1m';
+const RESET = '\x1b[0m';
+
+export function renderBanner(options = {}) {
+  const isTTY = options.isTTY ?? process.stdout.isTTY === true;
+  const term = options.term ?? process.env.TERM;
+  const color = options.color ?? colorEnabled;
+  const title = color ? `${BOLD}Subconscious CLI${RESET}` : 'Subconscious CLI';
+
+  // Avoid multi-line art in logs and pipes. Interactive NO_COLOR sessions
+  // still get the same logo without ANSI styling.
+  if (!isTTY || term === 'dumb') return `  ${title}`;
+
+  const logo = color ? `${ORANGE}${LOGO}${RESET}` : LOGO;
+  return `${logo}\n\n  ${title}`;
+}

package/bin/cli.js

@@ -3,54 +3,133 @@
 /**
  * Subconscious CLI — log in, then launch coding agents on your hosted models.
  *
- *   subconscious login | logout | whoami     — manage your API key
- *   subconscious <agent> [...args]            — launch a coding agent
+ *   subc login | update-key | logout | whoami — manage your API key
+ *   subc <agent> [...args]            — launch or configure a coding agent
  *
  * Auth lives in ./auth.js, the agent launcher + registry in ./agents.js.
  */
 
 import fs from 'node:fs/promises';
 import { c } from './colors.js';
-import { loginCommand, logoutCommand, whoamiCommand } from './auth.js';
-import { resolveAgent, runAgent, agentList } from './agents.js';
+import { renderBanner } from './branding.js';
+import {
+  loginCommand,
+  logoutCommand,
+  updateApiKeyCommand,
+  whoamiCommand,
+} from './auth.js';
+import {
+  resolveAgent,
+  runAgent,
+  agentList,
+  parseSetupRequest,
+  isAgentHelpRequest,
+} from './agents.js';
+import {
+  configCommand,
+  DEFAULT_PROFILE,
+  loadProfile,
+  modelsCommand,
+  updateUrlCommand,
+  validateProfileName,
+} from './profiles.js';
 
 function printHelp() {
   const agents = agentList()
-    .map(({ name, alias }) => `    ${c.cyan}${alias.padEnd(13)}${c.reset}${c.dim}Launch ${name}${c.reset}`)
+    .map(({ name, alias, action }) => `    ${c.cyan}${alias.padEnd(13)}${c.reset}${c.dim}${action} ${name}${c.reset}`)
     .join('\n');
 
-  console.log(`
-  ${c.magenta}${c.bold}Subconscious CLI${c.reset}
+  console.log(`${renderBanner()}
 
   ${c.bold}Usage${c.reset}
-    ${c.cyan}subconscious${c.reset} <command> [...args]
+    ${c.cyan}subc${c.reset} <command> [...args]
 
   ${c.bold}Auth${c.reset}
     ${c.cyan}login${c.reset}        Authenticate and save your API key
+    ${c.cyan}update-key${c.reset}   Replace the selected profile's API key
+    ${c.cyan}update-url${c.reset}   Update the active profile's gateway URL automatically
     ${c.cyan}logout${c.reset}       Remove saved credentials
     ${c.cyan}whoami${c.reset}       Show current authentication status
 
+  ${c.bold}Setup and profiles${c.reset}
+    ${c.cyan}help <agent>${c.reset}  Show coding-agent integration help and settings
+    ${c.cyan}setup${c.reset}        Configure all or one coding-agent integration
+    ${c.cyan}config${c.reset}       Show or update the selected runbook profile
+    ${c.cyan}settings${c.reset}     Edit profile and per-agent settings interactively
+    ${c.cyan}models${c.reset}       List available Subconscious models
+
   ${c.bold}Coding agents${c.reset}
 ${agents}
 
   ${c.bold}Options${c.reset}
-    ${c.dim}--model <id>${c.reset}   Model to use (default subconscious/tim-qwen3.6-27b)
+    ${c.dim}--model <id>${c.reset}   Model to use (default subconscious/glm-5.2)
+    ${c.dim}-p, --profile${c.reset}  Select a profile (default: default)
     ${c.dim}-h, --help${c.reset}     Show this help
     ${c.dim}-v, --version${c.reset}  Show version
 
   ${c.bold}Examples${c.reset}
-    ${c.dim}$${c.reset} subconscious login
-    ${c.dim}$${c.reset} subconscious claude-code
-    ${c.dim}$${c.reset} subconscious open-code --model subconscious/tim-qwen3.6-27b
+    ${c.dim}$${c.reset} subc login
+    ${c.dim}$${c.reset} subc update-key sk-...
+    ${c.dim}$${c.reset} subc update-url https://api.subconscious.dev
+    ${c.dim}$${c.reset} subc setup
+    ${c.dim}$${c.reset} subc settings
+    ${c.dim}$${c.reset} subc models
+    ${c.dim}$${c.reset} subc help codex
+    ${c.dim}$${c.reset} subc claude
+    ${c.dim}$${c.reset} subc --profile staging codex
+    ${c.dim}$${c.reset} subc codex --model subconscious/glm-5.2
 
-  ${c.dim}Anything after the agent name is forwarded to the underlying CLI.${c.reset}
+  ${c.dim}Arguments are forwarded to terminal agents or their runbook setup.${c.reset}
 `);
 }
 
-const authCommands = { login: loginCommand, logout: logoutCommand, whoami: whoamiCommand };
+const authCommands = {
+  login: loginCommand,
+  'update-key': updateApiKeyCommand,
+  logout: logoutCommand,
+  whoami: whoamiCommand,
+};
+
+function extractProfile(argv) {
+  let profileName =
+    process.env.SUBC_PROFILE?.trim() ||
+    process.env.MBTA_PROFILE?.trim() ||
+    DEFAULT_PROFILE;
+  const args = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--') {
+      args.push(...argv.slice(i));
+      break;
+    }
+    if (arg === '--profile' || arg === '-p') {
+      const value = argv[++i];
+      if (!value) throw new Error(`${arg} requires a profile name`);
+      profileName = value;
+      continue;
+    }
+    if (arg.startsWith('--profile=')) {
+      profileName = arg.slice('--profile='.length);
+      continue;
+    }
+    args.push(arg);
+  }
+  validateProfileName(profileName);
+  return { args, profileName };
+}
+
+function requireNamedProfile(profile) {
+  if (profile.name !== DEFAULT_PROFILE && !profile.exists) {
+    throw new Error(
+      `Profile '${profile.name}' does not exist. Create it with ` +
+        `subc --profile ${profile.name} config --api-key KEY`,
+    );
+  }
+}
 
 async function main() {
-  const args = process.argv.slice(2);
+  const parsed = extractProfile(process.argv.slice(2));
+  const { args, profileName } = parsed;
   const command = args[0];
 
   if (!command || command === '--help' || command === '-h') {
@@ -58,6 +137,18 @@ async function main() {
     return;
   }
 
+  if (command === 'help') {
+    if (!args[1]) {
+      printHelp();
+      return;
+    }
+    const agent = resolveAgent(args[1]);
+    if (!agent) throw new Error(`Unknown coding agent: ${args[1]}`);
+    const profile = await loadProfile(profileName);
+    await runAgent(agent, ['help'], { profile });
+    return;
+  }
+
   if (command === '--version' || command === '-v') {
     const pkgPath = new URL('../package.json', import.meta.url);
     const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));
@@ -67,13 +158,92 @@ async function main() {
 
   const authHandler = authCommands[command];
   if (authHandler) {
-    await authHandler(args.slice(1));
+    const profile = await loadProfile(profileName);
+    await authHandler(args.slice(1), { profile, profileName });
+    return;
+  }
+
+  if (command === 'config') {
+    await configCommand(args.slice(1), profileName);
+    return;
+  }
+
+  if (command === 'settings') {
+    if (['help', '-h', '--help'].includes(args[1])) {
+      console.log(`
+Usage:
+  subc settings
+  subc --profile NAME settings
+  subc --profile NAME config interactive
+
+Interactively choose or create a profile, then edit shared or per-agent settings.
+`);
+      return;
+    }
+    if (args.length > 1) throw new Error('Usage: subc [--profile NAME] settings');
+    await configCommand(['interactive'], profileName);
+    return;
+  }
+
+  if (command === 'models') {
+    modelsCommand();
+    return;
+  }
+
+  if (command === 'update-url') {
+    await updateUrlCommand(args.slice(1), { profileName });
+    return;
+  }
+
+  if (command === 'setup') {
+    const setupArgs = args.slice(1);
+    if (setupArgs[0] === '-h' || setupArgs[0] === '--help') {
+      console.log(`
+Usage:
+  subc setup [install|status|uninstall]
+  subc setup AGENT [install|status|uninstall] [agent options]
+
+Examples:
+  subc setup                    Configure every coding-agent integration
+  subc setup status             Show every integration's setup status
+  subc setup codex              Configure only Codex
+  subc setup codex status       Show only Codex's setup status
+  subc setup codex --subagents  Configure Codex's legacy subagent mode
+  subc setup codex env          Print persistent Codex exports for sourcing
+`);
+      return;
+    }
+    const request = parseSetupRequest(setupArgs);
+    const profile = await loadProfile(profileName);
+    const targetHelp = request.targeted && isAgentHelpRequest(request.args);
+    const persistentHelper = ['use', 'env', 'unset'].includes(request.action);
+    const oneOffApiKey = request.targeted && request.args.includes('--api-key');
+    if (!targetHelp && !persistentHelper && !oneOffApiKey) requireNamedProfile(profile);
+    const failures = [];
+    for (const agent of request.agents) {
+      const code = await runAgent(agent, request.args, { profile, setup: true });
+      if (code) failures.push(agent.name);
+    }
+    if (failures.length) {
+      throw new Error(`Setup failed for: ${failures.join(', ')}`);
+    }
+    if (targetHelp || persistentHelper) return;
+    const subject = request.targeted ? request.agents[0].name : 'Coding-agent';
+    const message =
+      request.action === 'status'
+        ? `${subject} status check complete.`
+        : request.action === 'uninstall'
+          ? `${subject} integration${request.targeted ? '' : 's'} removed.`
+          : `${subject} setup complete.`;
+    console.log(`\n  ${c.green}${c.bold}✓ ${message}${c.reset}\n`);
     return;
   }
 
   const agent = resolveAgent(command);
   if (agent) {
-    await runAgent(agent, args.slice(1));
+    const profile = await loadProfile(profileName);
+    if (!isAgentHelpRequest(args.slice(1))) requireNamedProfile(profile);
+    await runAgent(agent, args.slice(1), { profile });
     return;
   }
 

package/bin/colors.js

@@ -1,12 +1,24 @@
-// ANSI color helpers shared across the CLI.
+// ANSI color helpers shared across the CLI. Keep redirected output machine
+// readable and honor the standard NO_COLOR opt-out.
+const noColor = Object.prototype.hasOwnProperty.call(process.env, 'NO_COLOR');
+const forceColor =
+  process.env.FORCE_COLOR !== undefined && process.env.FORCE_COLOR !== '0';
+
+export const colorEnabled =
+  !noColor &&
+  process.env.TERM !== 'dumb' &&
+  (forceColor || process.stdout.isTTY === true);
+
+const ansi = (code) => (colorEnabled ? `\x1b[${code}m` : '');
+
 export const c = {
-  reset: '\x1b[0m',
-  bold: '\x1b[1m',
-  dim: '\x1b[2m',
-  cyan: '\x1b[36m',
-  green: '\x1b[32m',
-  red: '\x1b[31m',
-  yellow: '\x1b[33m',
-  magenta: '\x1b[35m',
-  underline: '\x1b[4m',
+  reset: ansi(0),
+  bold: ansi(1),
+  dim: ansi(2),
+  cyan: ansi(36),
+  green: ansi(32),
+  red: ansi(31),
+  yellow: ansi(33),
+  magenta: ansi(35),
+  underline: ansi(4),
 };