subconscious-cli 5.0.3 → 6.0.1

package/bin/usage.js

@@ -2,8 +2,8 @@
  * Usage display for `subc usage` — fetches billing/quota from the platform API.
  */
 
-import { c } from './colors.js';
 import { getApiKey, getPlatformUrl } from './auth.js';
+import { c } from './colors.js';
 import { DEFAULT_PROFILE } from './profiles.js';
 import { printLoginUpgradeWarning } from './upgrade.js';
 
@@ -33,13 +33,18 @@ export function formatCurrency(value) {
 
 export function shortModelSlug(slug) {
   const text = String(slug ?? '').trim();
-  return text.startsWith('subconscious/') ? text.slice('subconscious/'.length) : text;
+  return text.startsWith('subconscious/')
+    ? text.slice('subconscious/'.length)
+    : text;
 }
 
 export function isLegacyUsagePayload(data) {
   if (!data || typeof data !== 'object') return true;
-  if ('credits' in data && data.plan && typeof data.plan === 'object') return false;
-  return 'dailyTokenCeiling' in data || 'consumedToday' in data || !('plan' in data);
+  if ('credits' in data && data.plan && typeof data.plan === 'object')
+    return false;
+  return (
+    'dailyTokenCeiling' in data || 'consumedToday' in data || !('plan' in data)
+  );
 }
 
 export function meterColor(percentage) {
@@ -120,7 +125,9 @@ export function formatUsageDisplay(data) {
         );
       } else {
         const label =
-          described.kind === 'credit' ? 'of daily credit used' : 'of daily tokens used';
+          described.kind === 'credit'
+            ? 'of daily credit used'
+            : 'of daily tokens used';
         lines.push(
           `  ${renderProgressBar(described.percent)}  ${formatAllowancePercent(described.percent)} ${label}`,
         );
@@ -155,9 +162,7 @@ export function formatUsageDisplay(data) {
     );
     for (const model of models) {
       const label = shortModelSlug(model.slug).padEnd(slugWidth);
-      lines.push(
-        `    ${label}  ${formatTokens(model.consumedToday ?? 0)}`,
-      );
+      lines.push(`    ${label}  ${formatTokens(model.consumedToday ?? 0)}`);
     }
   }
 
@@ -166,10 +171,13 @@ export function formatUsageDisplay(data) {
 }
 
 export async function fetchUsage(apiKey, platformUrl, fetchImpl = fetch) {
-  const res = await fetchImpl(`${platformUrl.replace(/\/$/, '')}${USAGE_API_PATH}`, {
-    headers: { Authorization: `Bearer ${apiKey}` },
-    signal: AbortSignal.timeout(5000),
-  });
+  const res = await fetchImpl(
+    `${platformUrl.replace(/\/$/, '')}${USAGE_API_PATH}`,
+    {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(5000),
+    },
+  );
   return res;
 }
 
@@ -183,7 +191,9 @@ export async function usageCommand(argv = [], options = {}) {
   const auth = await getApiKey(options.profile);
   if (!auth) {
     console.log(`\n  ${c.dim}Not logged in.${c.reset}`);
-    console.log(`  Run ${c.cyan}subc ${profileFlag}login${c.reset} to get started.\n`);
+    console.log(
+      `  Run ${c.cyan}subc ${profileFlag}login${c.reset} to get started.\n`,
+    );
     return;
   }
 
@@ -236,7 +246,9 @@ export async function usageCommand(argv = [], options = {}) {
     console.log(formatUsageDisplay(data));
   } catch (error) {
     if (error.name === 'TimeoutError' || error.name === 'AbortError') {
-      console.log(`\n  ${c.yellow}Could not reach the platform (timed out).${c.reset}`);
+      console.log(
+        `\n  ${c.yellow}Could not reach the platform (timed out).${c.reset}`,
+      );
       console.log(`  ${c.dim}Host: ${platformUrl}${c.reset}\n`);
       return;
     }

package/bin/windows/agents.js

@@ -1,79 +1,182 @@
-import path from 'node:path';
 import os from 'node:os';
+import path from 'node:path';
 import readline from 'node:readline';
-import { windowsEnv, windowsBinDirs, windowsPath, resolveWindowsExecutable, readWindowsVersion, runWindows } from './process.js';
-import { windowsInstallSpec, installWindowsAgent } from './install.js';
-import { windowsSetup } from './setup.js';
-import { windowsLaunch, executeWindowsLaunch } from './launch.js';
 import { parseOptions } from './common.js';
+import { installWindowsAgent, windowsInstallSpec } from './install.js';
+import { executeWindowsLaunch, windowsLaunch } from './launch.js';
+import {
+  readWindowsVersion,
+  resolveWindowsExecutable,
+  runWindows,
+  windowsBinDirs,
+  windowsEnv,
+  windowsPath,
+} from './process.js';
+import { windowsSetup } from './setup.js';
 
-const askInstall = name => new Promise(resolve => {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  rl.question(`  ${name} isn't installed. Install it now? [Y/n] `, answer => { rl.close(); resolve(['', 'y', 'yes'].includes(answer.trim().toLowerCase())); });
-});
+const askInstall = (name) =>
+  new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(
+      `  ${name} isn't installed. Install it now? [Y/n] `,
+      (answer) => {
+        rl.close();
+        resolve(['', 'y', 'yes'].includes(answer.trim().toLowerCase()));
+      },
+    );
+  });
 
 export async function runWindowsAgent(agent, argv, dependencies) {
-  const { profile, parseAgentAction, extractModel, requireApiKey, resolvedModelsForLaunch, selectLaunchModel, runbookEnv } = dependencies;
+  const {
+    profile,
+    parseAgentAction,
+    extractModel,
+    requireApiKey,
+    resolvedModelsForLaunch,
+    selectLaunchModel,
+    runbookEnv,
+  } = dependencies;
   const parsed = parseAgentAction(agent, argv);
-  let args = parsed.action !== 'launch' && parsed.action === argv[0] ? argv.slice(1) : argv;
+  let args =
+    parsed.action !== 'launch' && parsed.action === argv[0]
+      ? argv.slice(1)
+      : argv;
   const environment = windowsEnv(profile?.values, process.env);
   const preferredDirs = agent.runbook?.installDir
-    ? [path.resolve(environment[agent.runbook.installDirEnv] || path.join(os.homedir(), agent.runbook.installDir))] : [];
-  environment.PATH = windowsPath([...preferredDirs, ...(environment.PATH || '').split(';'), ...windowsBinDirs(environment)]);
+    ? [
+        path.resolve(
+          environment[agent.runbook.installDirEnv] ||
+            path.join(os.homedir(), agent.runbook.installDir),
+        ),
+      ]
+    : [];
+  environment.PATH = windowsPath([
+    ...preferredDirs,
+    ...(environment.PATH || '').split(';'),
+    ...windowsBinDirs(environment),
+  ]);
   if (agent.id === 'subconscious-code' && parsed.action === 'install') {
     if (args.length) throw new Error('Usage: subc marathon install');
     return finish(await installWindowsAgent(agent.id, environment));
   }
   if (['status', 'uninstall'].includes(parsed.action)) {
-    return finish(await windowsSetup(agent.id, parsed.action, args, environment));
+    return finish(
+      await windowsSetup(agent.id, parsed.action, args, environment),
+    );
   }
 
   // Honor -- after which all arguments belong to the underlying agent.
   const boundary = args.indexOf('--');
   const tail = boundary < 0 ? [] : args.slice(boundary);
-  const extracted = extractModel(boundary < 0 ? args : args.slice(0, boundary), profile);
+  const extracted = extractModel(
+    boundary < 0 ? args : args.slice(0, boundary),
+    profile,
+  );
   args = [...extracted.rest, ...tail];
   let explicit = {};
   if (parsed.action === 'install' || agent.id === 'claude-code') {
-    const handled = parseOptions(boundary < 0 ? args : args.slice(0, args.indexOf('--')), { '--api-key': 1, '--gateway-url': 1 });
+    const handled = parseOptions(
+      boundary < 0 ? args : args.slice(0, args.indexOf('--')),
+      { '--api-key': 1, '--gateway-url': 1 },
+    );
     explicit = handled.options;
   }
-  const key = explicit['--api-key'] || await requireApiKey(profile, agent);
+  const key = explicit['--api-key'] || (await requireApiKey(profile, agent));
   if (!key) return finish(1);
-  const catalogProfile = explicit['--gateway-url'] ? { ...profile, values: { ...profile?.values, GATEWAY_URL: explicit['--gateway-url'] } } : profile;
-  const catalog = await resolvedModelsForLaunch(catalogProfile, key, extracted.model);
-  const model = selectLaunchModel(extracted.model, extracted.modelSource, catalog);
-  if (extracted.model && model !== extracted.model) console.error(`Configured model ${extracted.model} is not in the live catalog; using ${model}.`);
+  const catalogProfile = explicit['--gateway-url']
+    ? {
+        ...profile,
+        values: { ...profile?.values, GATEWAY_URL: explicit['--gateway-url'] },
+      }
+    : profile;
+  const catalog = await resolvedModelsForLaunch(
+    catalogProfile,
+    key,
+    extracted.model,
+  );
+  const model = selectLaunchModel(
+    extracted.model,
+    extracted.modelSource,
+    catalog,
+  );
+  if (extracted.model && model !== extracted.model)
+    console.error(
+      `Configured model ${extracted.model} is not in the live catalog; using ${model}.`,
+    );
   let executable;
   if (parsed.action === 'launch') {
-    executable = resolveWindowsExecutable(agent.bin, { env: environment, preferredDirs });
+    executable = resolveWindowsExecutable(agent.bin, {
+      env: environment,
+      preferredDirs,
+    });
     if (!executable) {
       const installer = windowsInstallSpec(agent.id, environment);
-      if (!installer || !process.stdin.isTTY || !process.stdout.isTTY || !await askInstall(agent.name)) {
-        console.error(`${agent.name} isn't installed. ${installer ? `Install it with: ${installer.display}` : 'Install it separately, then rerun subc.'}`);
+      if (
+        !installer ||
+        !process.stdin.isTTY ||
+        !process.stdout.isTTY ||
+        !(await askInstall(agent.name))
+      ) {
+        console.error(
+          `${agent.name} isn't installed. ${installer ? `Install it with: ${installer.display}` : 'Install it separately, then rerun subc.'}`,
+        );
         return finish(127);
       }
       const installed = await installWindowsAgent(agent.id, environment);
       if (installed) return finish(installed);
-      executable = resolveWindowsExecutable(agent.bin, { env: environment, preferredDirs });
+      executable = resolveWindowsExecutable(agent.bin, {
+        env: environment,
+        preferredDirs,
+      });
       if (!executable) {
-        console.error(`Installed ${agent.name}, but ${agent.bin} was not found. Add its installation directory to PATH or restart your terminal.`);
+        console.error(
+          `Installed ${agent.name}, but ${agent.bin} was not found. Add its installation directory to PATH or restart your terminal.`,
+        );
         return finish(127);
       }
     }
     if (agent.id === 'claude-code') {
-      const version = dependencies.parseClaudeVersion(readWindowsVersion(executable, environment));
-      if (dependencies.claudeVersionNeedsUpgrade(version)) console.error(`Minimum supported Claude Code version is ${dependencies.minimumClaudeVersion}; installed version is ${version}. Please upgrade Claude Code.`);
+      const version = dependencies.parseClaudeVersion(
+        readWindowsVersion(executable, environment),
+      );
+      if (dependencies.claudeVersionNeedsUpgrade(version))
+        console.error(
+          `Minimum supported Claude Code version is ${dependencies.minimumClaudeVersion}; installed version is ${version}. Please upgrade Claude Code.`,
+        );
     }
   }
   // Reuse profile/catalog semantics, but use Windows path and environment rules.
-  const env = windowsEnv(runbookEnv(key, model, executable && path.dirname(executable), catalogProfile, agent, catalog.models), { PATH: windowsPath(executable ? [path.dirname(executable)] : [], environment.PATH) });
+  const env = windowsEnv(
+    runbookEnv(
+      key,
+      model,
+      executable && path.dirname(executable),
+      catalogProfile,
+      agent,
+      catalog.models,
+    ),
+    {
+      PATH: windowsPath(
+        executable ? [path.dirname(executable)] : [],
+        environment.PATH,
+      ),
+    },
+  );
   if (explicit['--gateway-url']) env.GATEWAY_URL = explicit['--gateway-url'];
-  if (parsed.action === 'install') return finish(await windowsSetup(agent.id, 'install', args, env));
+  if (parsed.action === 'install')
+    return finish(await windowsSetup(agent.id, 'install', args, env));
   if (agent.id === 'pi') await windowsSetup('pi', 'install', [], env);
   if (agent.id === 'codex') {
-    try { await windowsSetup('codex', 'install', [], env, { log: () => {} }); }
-    catch (error) { console.error(`Could not refresh Codex hooks (launch will continue): ${error.message}`); }
+    try {
+      await windowsSetup('codex', 'install', [], env, { log: () => {} });
+    } catch (error) {
+      console.error(
+        `Could not refresh Codex hooks (launch will continue): ${error.message}`,
+      );
+    }
   }
   const spec = await windowsLaunch(agent.id, args, env);
   if (spec.command === agent.bin) spec.command = executable;

package/bin/windows/claude.js

@@ -1,37 +1,65 @@
 // Windows-only equivalent of the existing Claude shell launch.
 import { readFileSync } from 'node:fs';
 import { resolvedModelSetting } from '../profiles.js';
-import { positiveInteger, parseOptions } from './common.js';
-const DEFAULTS = JSON.parse(readFileSync(new URL('../registry.generated.json', import.meta.url), 'utf8')).defaults;
+import { parseOptions, positiveInteger } from './common.js';
+
+const DEFAULTS = JSON.parse(
+  readFileSync(new URL('../registry.generated.json', import.meta.url), 'utf8'),
+).defaults;
 function claudePickerSettings(models) {
-  return { availableModels: models, modelPicker: { replaceBuiltInOptions: true, options: models.map(model => ({model, label: model, description: 'Subconscious model ' + model})) } };
+  return {
+    availableModels: models,
+    modelPicker: {
+      replaceBuiltInOptions: true,
+      options: models.map((model) => ({
+        model,
+        label: model,
+        description: `Subconscious model ${model}`,
+      })),
+    },
+  };
 }
 
 export function claudeNativeLaunch(argv, environment) {
   const { options, rest: passthrough } = parseOptions(argv, {
-    '--gateway-url': 1, '--api-key': 1, '--model': 1,
-    '--compact-window': 1, '--max-context-tokens': 1,
+    '--gateway-url': 1,
+    '--api-key': 1,
+    '--model': 1,
+    '--compact-window': 1,
+    '--max-context-tokens': 1,
   });
-  const gatewayUrl = options['--gateway-url'] || environment.GATEWAY_URL?.trim() || '';
-  const apiKey = options['--api-key'] || environment.CLAUDE_CODE_API_KEY?.trim() || environment.API_KEY?.trim() || '';
-  const model = options['--model'] || environment.MODEL?.trim() || DEFAULTS.model;
-  const compactWindow = options['--compact-window'] ||
+  const gatewayUrl =
+    options['--gateway-url'] || environment.GATEWAY_URL?.trim() || '';
+  const apiKey =
+    options['--api-key'] ||
+    environment.CLAUDE_CODE_API_KEY?.trim() ||
+    environment.API_KEY?.trim() ||
+    '';
+  const model =
+    options['--model'] || environment.MODEL?.trim() || DEFAULTS.model;
+  const compactWindow =
+    options['--compact-window'] ||
     environment.CLAUDE_CODE_AUTO_COMPACT_WINDOW?.trim() ||
     environment.COMPACT_WINDOW?.trim() ||
     '1000000';
-  const maxContextTokens = options['--max-context-tokens'] ||
+  const maxContextTokens =
+    options['--max-context-tokens'] ||
     environment.CLAUDE_CODE_MAX_CONTEXT_TOKENS?.trim() ||
     environment.MAX_CONTEXT_TOKENS?.trim() ||
     '3000000';
 
   if (!gatewayUrl || !apiKey) {
-    throw new Error('GATEWAY_URL and API_KEY are required to launch Claude Code');
+    throw new Error(
+      'GATEWAY_URL and API_KEY are required to launch Claude Code',
+    );
   }
   positiveInteger(compactWindow, 'compact-window');
   positiveInteger(maxContextTokens, 'max-context-tokens');
 
-  const effectiveGatewayUrl = environment.CLAUDE_GATEWAY_URL?.trim() || gatewayUrl;
-  const subagentModel = resolvedModelSetting(environment.CLAUDE_CODE_SUBAGENT_MODEL) || model;
+  const effectiveGatewayUrl =
+    environment.CLAUDE_GATEWAY_URL?.trim() || gatewayUrl;
+  const subagentModel =
+    resolvedModelSetting(environment.CLAUDE_CODE_SUBAGENT_MODEL) || model;
   const settings =
     environment.SUBC_CLAUDE_SETTINGS?.trim() ||
     JSON.stringify(claudePickerSettings([model], model));
@@ -41,7 +69,8 @@ export function claudeNativeLaunch(argv, environment) {
     ANTHROPIC_BASE_URL: effectiveGatewayUrl,
     ANTHROPIC_AUTH_TOKEN: apiKey,
     ANTHROPIC_MODEL: environment.ANTHROPIC_MODEL?.trim() || model,
-    ANTHROPIC_SMALL_FAST_MODEL: environment.ANTHROPIC_SMALL_FAST_MODEL?.trim() || model,
+    ANTHROPIC_SMALL_FAST_MODEL:
+      environment.ANTHROPIC_SMALL_FAST_MODEL?.trim() || model,
     CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY:
       environment.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY?.trim() || '0',
     CLAUDE_CODE_SUBAGENT_MODEL: subagentModel,

package/bin/windows/common.js

@@ -1,58 +1,95 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { readFileSync } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
 
-export const defaults = JSON.parse(readFileSync(new URL('../registry.generated.json', import.meta.url), 'utf8')).defaults;
+export const defaults = JSON.parse(
+  readFileSync(new URL('../registry.generated.json', import.meta.url), 'utf8'),
+).defaults;
 export const value = (env, key, fallback = '') => env[key]?.trim() || fallback;
-export const origin = url => url.replace(/\/+$/, '').replace(/\/v1(?:\/(?:messages|responses|chat\/completions))?$/, '');
+export const origin = (url) =>
+  url
+    .replace(/\/+$/, '')
+    .replace(/\/v1(?:\/(?:messages|responses|chat\/completions))?$/, '');
 export function positiveInteger(input, name) {
-  if (!/^[1-9][0-9]*$/.test(String(input)) || !Number.isSafeInteger(Number(input))) throw new Error(`${name} must be a positive integer`);
+  if (
+    !/^[1-9][0-9]*$/.test(String(input)) ||
+    !Number.isSafeInteger(Number(input))
+  )
+    throw new Error(`${name} must be a positive integer`);
   return Number(input);
 }
 export function modelIds(env) {
-  const models = [...new Set([value(env, 'MODEL', defaults.model), ...value(env, 'SUBCONSCIOUS_MODELS', defaults.models.join('\n')).split(/\r?\n/)].filter(Boolean))];
-  for (const model of models) if (!/^[-A-Za-z0-9._:/+]+$/.test(model)) throw new Error(`Invalid model id: ${model}`);
+  const models = [
+    ...new Set(
+      [
+        value(env, 'MODEL', defaults.model),
+        ...value(env, 'SUBCONSCIOUS_MODELS', defaults.models.join('\n')).split(
+          /\r?\n/,
+        ),
+      ].filter(Boolean),
+    ),
+  ];
+  for (const model of models)
+    if (!/^[-A-Za-z0-9._:/+]+$/.test(model))
+      throw new Error(`Invalid model id: ${model}`);
   return models;
 }
 export function parseOptions(argv, schema, { strict = false } = {}) {
-  const options = {}, rest = [];
+  const options = {},
+    rest = [];
   for (let i = 0; i < argv.length; i++) {
     if (argv[i] === '--') {
-      if (strict && i + 1 < argv.length) throw new Error(`Unexpected setup argument: ${argv[i + 1]}`);
-      rest.push(...argv.slice(i + 1)); break;
+      if (strict && i + 1 < argv.length)
+        throw new Error(`Unexpected setup argument: ${argv[i + 1]}`);
+      rest.push(...argv.slice(i + 1));
+      break;
     }
     const [flag, ...equals] = argv[i].split('=');
     if (!Object.hasOwn(schema, flag)) {
       if (strict) throw new Error(`Unknown setup option: ${argv[i]}`);
-      rest.push(argv[i]); continue;
+      rest.push(argv[i]);
+      continue;
     }
     if (schema[flag] === true) {
       if (equals.length) throw new Error(`${flag} does not take a value`);
-      options[flag] = true; continue;
+      options[flag] = true;
+      continue;
     }
     const next = equals.length ? equals.join('=') : argv[++i];
-    if (!next || next.startsWith('--')) throw new Error(`${flag} requires a value`);
+    if (!next || next.startsWith('--'))
+      throw new Error(`${flag} requires a value`);
     options[flag] = next;
   }
   return { options, rest };
 }
 export async function readJson(file, fallback) {
-  try { return JSON.parse((await fs.readFile(file, 'utf8')).replace(/^\uFEFF/, '')); }
-  catch (error) {
+  try {
+    return JSON.parse((await fs.readFile(file, 'utf8')).replace(/^\uFEFF/, ''));
+  } catch (error) {
     if (error.code === 'ENOENT') return fallback;
-    throw new Error(`Cannot read ${file}; leaving it unchanged: ${error.message}`);
+    throw new Error(
+      `Cannot read ${file}; leaving it unchanged: ${error.message}`,
+    );
   }
 }
 export function object(value, description) {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(`${description} must be a JSON object; leaving it unchanged`);
+  if (!value || typeof value !== 'object' || Array.isArray(value))
+    throw new Error(
+      `${description} must be a JSON object; leaving it unchanged`,
+    );
   return value;
 }
 export async function writeJson(file, data) {
   await fs.mkdir(path.dirname(file), { recursive: true });
   const temp = `${file}.${randomUUID()}.tmp`;
   try {
-    await fs.writeFile(temp, JSON.stringify(data, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+    await fs.writeFile(temp, `${JSON.stringify(data, null, 2)}\n`, {
+      mode: 0o600,
+      flag: 'wx',
+    });
     await fs.rename(temp, file);
-  } finally { await fs.rm(temp, { force: true }); }
+  } finally {
+    await fs.rm(temp, { force: true });
+  }
 }