subconscious-cli 4.0.17 → 4.1.0-windows.0

package/bin/update-check.js

@@ -1,16 +1,69 @@
 import fs from 'node:fs/promises';
 import { spawn } from 'node:child_process';
+import { spawnWindows } from './windows/process.js';
 import readline from 'node:readline';
 import { fileURLToPath } from 'node:url';
 import { LOGO_ART_SMALL_LINES } from './branding.js';
 import { c, colorEnabled } from './colors.js';
-import { detectInstallCommand } from './upgrade.js';
 
 export const PACKAGE_NAME = 'subconscious-cli';
 export const UPDATE_CHECK_TIMEOUT_MS = 1500;
 const UPDATE_ACTIONS = ['Update now', 'Skip for now'];
 const UPDATE_LOGO = LOGO_ART_SMALL_LINES;
 
+function shellQuote(value) {
+  const text = String(value);
+  return /^[-/@A-Za-z0-9._:]+$/.test(text)
+    ? text
+    : `'${text.replaceAll("'", `'"'"'`)}'`;
+}
+
+export function detectInstallTarget(
+  here = fileURLToPath(import.meta.url),
+  platform = process.platform,
+) {
+  const normalized = here.replace(/\\/g, '/');
+  if (normalized.includes('/.pnpm/') || normalized.includes('/pnpm/global/')) {
+    return {
+      command: 'pnpm',
+      args: ['add', '-g', `${PACKAGE_NAME}@latest`],
+      display: `pnpm add -g ${PACKAGE_NAME}@latest`,
+    };
+  }
+  if (normalized.includes('/.yarn/') || normalized.includes('/yarn/global/')) {
+    return {
+      command: 'yarn',
+      args: ['global', 'add', `${PACKAGE_NAME}@latest`],
+      display: `yarn global add ${PACKAGE_NAME}@latest`,
+    };
+  }
+  if (normalized.includes('/.bun/install/global/')) {
+    return {
+      command: 'bun',
+      args: ['add', '-g', `${PACKAGE_NAME}@latest`],
+      display: `bun add -g ${PACKAGE_NAME}@latest`,
+    };
+  }
+
+  const marker = `/lib/node_modules/${PACKAGE_NAME}/`;
+  let prefix = normalized.includes(marker) ? normalized.slice(0, normalized.indexOf(marker)) : '';
+  if (!prefix && platform === 'win32') {
+    const windowsMarker = `/node_modules/${PACKAGE_NAME}/`;
+    if (normalized.includes(windowsMarker)) {
+      prefix = normalized.slice(0, normalized.indexOf(windowsMarker));
+    }
+  }
+  const args = ['install', '-g'];
+  if (prefix) args.push('--prefix', prefix);
+  args.push(`${PACKAGE_NAME}@latest`);
+  return {
+    command: 'npm',
+    args,
+    display: ['npm', ...args].map(platform === 'win32' ? value => /^[-/@A-Za-z0-9._:]+$/.test(value) ? value : `"${value}"` : shellQuote).join(' '),
+    prefix,
+  };
+}
+
 function parseVersion(version) {
   const match = String(version)
     .trim()
@@ -123,13 +176,8 @@ export function renderUpdateNotice(installedVersion, latestVersion) {
   ].join('\n');
 }
 
-export function resolveInstallCommand(here = fileURLToPath(import.meta.url)) {
-  return detectInstallCommand(here);
-}
-
 export function renderUpdateOptions(selectedIndex = 0, versions = {}) {
-  const installCommand =
-    versions.installCommand || `npm install -g ${PACKAGE_NAME}@latest`;
+  const installCommand = versions.installCommand || detectInstallTarget().display;
   const descriptions = [
     `Runs \`${installCommand}\``,
     versions.installedVersion
@@ -209,12 +257,30 @@ export async function selectUpdateAction(options = {}) {
 }
 
 export async function installLatest(options = {}) {
-  const spawnImpl = options.spawnImpl || spawn;
-  const command = options.command || resolveInstallCommand();
+  const spawnImpl = options.spawnImpl || (process.platform === 'win32' ? spawnWindows : spawn);
+  const target = options.target || detectInstallTarget();
   return new Promise((resolve) => {
-    const child = spawnImpl(command, { shell: true, stdio: 'inherit' });
+    const child = spawnImpl(target.command, target.args, {
+      stdio: 'inherit',
+    });
     child.on('error', () => resolve(false));
-    child.on('exit', (code) => resolve(code === 0));
+    child.on('exit', async (code) => {
+      if (code !== 0) {
+        resolve(false);
+        return;
+      }
+      if (!options.expectedVersion) {
+        resolve(true);
+        return;
+      }
+      try {
+        const readVersion = options.readVersion || currentVersion;
+        const actualVersion = await readVersion();
+        resolve(compareVersions(actualVersion, options.expectedVersion) >= 0);
+      } catch {
+        resolve(false);
+      }
+    });
   });
 }
 
@@ -241,9 +307,13 @@ export async function showUpdateNotice(options = {}) {
       options.interactive ?? (process.stdin.isTTY === true && process.stderr.isTTY === true);
     if (!interactive) return { installedVersion, latestVersion, action: 'skip' };
 
-    const installCommand = options.installCommand || resolveInstallCommand();
     const select = options.select || selectUpdateAction;
-    const action = await select({ installedVersion, latestVersion, installCommand });
+    const installTarget = options.installTarget || detectInstallTarget();
+    const action = await select({
+      installedVersion,
+      latestVersion,
+      installCommand: installTarget.display,
+    });
     if (action === 'cancel') return { installedVersion, latestVersion, action };
     if (action === 'skip') {
       write(`\n  ${c.dim}Skipping update.${c.reset}\n\n`);
@@ -251,8 +321,10 @@ export async function showUpdateNotice(options = {}) {
     }
 
     write(`\n  ${c.cyan}Updating ${PACKAGE_NAME} to ${latestVersion}...${c.reset}\n\n`);
-    const install = options.install || installLatest;
-    const installed = await install();
+    const install =
+      options.install ||
+      ((expectedVersion) => installLatest({ expectedVersion, target: installTarget }));
+    const installed = await install(latestVersion);
     if (installed) {
       write(
         `\n  ${c.green}${c.bold}Update complete.${c.reset} Re-run your subc command.\n\n`,
@@ -260,8 +332,9 @@ export async function showUpdateNotice(options = {}) {
       return { installedVersion, latestVersion, action: 'updated' };
     }
 
-    write(`\n  ${c.red}Update failed.${c.reset} Try it manually:\n\n`);
-    write(`    ${c.cyan}${installCommand}${c.reset}\n\n`);
+    write(`\n  ${c.red}Update failed or the running installation stayed unchanged.${c.reset}\n`);
+    write(`  Try the exact detected install target manually:\n\n`);
+    write(`    ${c.cyan}${installTarget.display}${c.reset}\n\n`);
     return { installedVersion, latestVersion, action: 'failed' };
   } catch {
     // Update discovery must never prevent the requested command from running.

package/bin/upgrade.js

@@ -6,10 +6,12 @@
  */
 
 import { spawn } from 'node:child_process';
+import { runWindows } from './windows/process.js';
 import fs from 'node:fs/promises';
 import readline from 'node:readline';
 import { fileURLToPath } from 'node:url';
 import { c } from './colors.js';
+import { detectInstallTarget } from './update-check.js';
 
 export const PACKAGE_NAME = 'subconscious-cli';
 export const MIN_LOGIN_VERSION = '4.0';
@@ -24,17 +26,7 @@ export function parseUpgradeArgs(argv = []) {
 }
 
 export function detectInstallCommand(here = fileURLToPath(import.meta.url)) {
-  const normalized = here.replace(/\\/g, '/');
-  if (normalized.includes('/.pnpm/') || normalized.includes('/pnpm/global/')) {
-    return `pnpm add -g ${PACKAGE_NAME}@latest`;
-  }
-  if (normalized.includes('/.yarn/') || normalized.includes('/yarn/global/')) {
-    return `yarn global add ${PACKAGE_NAME}@latest`;
-  }
-  if (normalized.includes('/.bun/install/global/')) {
-    return `bun add -g ${PACKAGE_NAME}@latest`;
-  }
-  return `npm install -g ${PACKAGE_NAME}@latest`;
+  return detectInstallTarget(here).display;
 }
 
 export async function currentCliVersion() {
@@ -90,6 +82,10 @@ function askYesNo(question) {
 }
 
 function runInstall(command) {
+  if (process.platform === 'win32') {
+    const target = detectInstallTarget();
+    return runWindows(target.command, target.args).then(code => code === 0, () => false);
+  }
   return new Promise((resolve) => {
     const child = spawn(command, { shell: true, stdio: 'inherit' });
     child.on('error', () => resolve(false));
@@ -132,6 +128,26 @@ export async function installLatest(options = {}) {
     return false;
   }
 
+  if (latest) {
+    try {
+      const readVersion = options.readVersion || currentCliVersion;
+      const installedVersion = await readVersion();
+      if (compareVersions(installedVersion, latest) < 0) {
+        console.error(
+          `\n  ${c.red}Upgrade command completed, but this installation is still ${installedVersion}.${c.reset}`,
+        );
+        console.error(`  Run the exact detected command manually:\n`);
+        console.error(`    ${c.cyan}${command}${c.reset}\n`);
+        return false;
+      }
+    } catch {
+      console.error(`\n  ${c.red}Could not verify the updated CLI installation.${c.reset}`);
+      console.error(`  Run the exact detected command manually:\n`);
+      console.error(`    ${c.cyan}${command}${c.reset}\n`);
+      return false;
+    }
+  }
+
   console.log(`\n  ${c.green}${c.bold}✓ Upgraded.${c.reset} Re-run ${c.cyan}subc login${c.reset} if you were signing in.\n`);
   return true;
 }

package/bin/usage.js

@@ -0,0 +1,229 @@
+/**
+ * Usage display for `subc usage` — fetches billing/quota from the platform API.
+ */
+
+import { c } from './colors.js';
+import { getApiKey, getPlatformUrl } from './auth.js';
+import { DEFAULT_PROFILE } from './profiles.js';
+import { printLoginUpgradeWarning } from './upgrade.js';
+
+export const USAGE_API_PATH = '/api/v1/usage';
+
+export function formatTokens(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n < 0) return '0';
+  if (n >= 1_000_000_000) {
+    const scaled = n / 1_000_000_000;
+    return `${scaled.toFixed(n % 1_000_000_000 ? 1 : 0)}B`;
+  }
+  if (n >= 1_000_000) {
+    const scaled = n / 1_000_000;
+    return `${scaled.toFixed(n % 1_000_000 ? 1 : 0)}M`;
+  }
+  if (n >= 1_000) return `${Math.round(n / 1_000)}K`;
+  return n.toLocaleString('en-US');
+}
+
+export function formatCurrency(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return '$0.00';
+  const sign = n < 0 ? '-' : '';
+  return `${sign}$${Math.abs(n).toFixed(2)}`;
+}
+
+export function shortModelSlug(slug) {
+  const text = String(slug ?? '').trim();
+  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);
+}
+
+export function meterColor(percentage) {
+  if (percentage >= 100) return c.red;
+  if (percentage >= 80) return c.yellow;
+  return c.green;
+}
+
+export function renderProgressBar(percentage, width = 20) {
+  const pct = Math.max(0, Math.min(100, percentage));
+  const filled = Math.round((pct / 100) * width);
+  const empty = Math.max(0, width - filled);
+  const color = meterColor(pct);
+  return `${color}${'█'.repeat(filled)}${c.dim}${'░'.repeat(empty)}${c.reset}`;
+}
+
+export function formatUsageDisplay(data) {
+  const lines = [];
+  lines.push(`\n  ${c.bold}Subconscious Usage${c.reset}\n`);
+
+  const billingMode = data.billingMode ?? null;
+  const plan = data.plan ?? {};
+  const credits = data.credits ?? {};
+  const models = Array.isArray(data.models) ? data.models : [];
+
+  const planLabel = plan.label || 'No plan';
+  const planStatus = plan.status ? plan.status.replace(/_/g, ' ') : null;
+  const planLine = planStatus ? `${planLabel} · ${planStatus}` : planLabel;
+
+  lines.push(`  ${c.dim}Plan${c.reset}            ${planLine}`);
+  if (billingMode) {
+    lines.push(`  ${c.dim}Billing${c.reset}         ${billingMode}`);
+  }
+
+  const allowance = plan.dailyAllowance;
+  const unlimitedComp = Boolean(plan.isUnlimitedComp);
+
+  if (unlimitedComp) {
+    lines.push('');
+    lines.push(`  ${c.dim}Daily allowance${c.reset}`);
+    lines.push(`  ${c.green}Unlimited${c.reset} ${c.dim}(comp)${c.reset}`);
+  } else if (allowance && allowance.amount > 0) {
+    const consumed = Number(allowance.consumed) || 0;
+    const amount = Number(allowance.amount) || 0;
+    const remaining = Number(allowance.remaining) || 0;
+    const pct = amount > 0 ? Math.min((consumed / amount) * 100, 100) : 0;
+    const overage = Math.max(0, consumed - amount);
+
+    lines.push('');
+    lines.push(`  ${c.dim}Daily allowance${c.reset}`);
+    lines.push(
+      `  ${renderProgressBar(pct)}  ${formatTokens(consumed)} / ${formatTokens(amount)} tokens`,
+    );
+    const resetNote = allowance.resetAt
+      ? `${formatTokens(remaining)} remaining · resets midnight UTC`
+      : `${formatTokens(remaining)} remaining`;
+    lines.push(`  ${c.dim}${resetNote}${c.reset}`);
+    if (overage > 0) {
+      lines.push(`  ${c.yellow}+${formatTokens(overage)} over daily allowance${c.reset}`);
+    }
+  }
+
+  lines.push('');
+  lines.push(
+    `  ${c.dim}Credits${c.reset}         ${formatCurrency(credits.balanceDollars ?? 0)}`,
+  );
+  if (billingMode === 'subscription' || billingMode === 'comp' || allowance) {
+    const overage = Number(credits.overageThisPeriodDollars) || 0;
+    const overageColor = overage > 0 ? c.yellow : c.reset;
+    lines.push(
+      `  ${c.dim}Overage${c.reset}         ${overageColor}${formatCurrency(overage)} this period${c.reset}`,
+    );
+  }
+
+  if (models.length > 0) {
+    lines.push('');
+    lines.push(`  ${c.dim}Models today${c.reset}`);
+    const slugWidth = Math.max(
+      12,
+      ...models.map((model) => shortModelSlug(model.slug).length),
+    );
+    for (const model of models) {
+      const label = shortModelSlug(model.slug).padEnd(slugWidth);
+      lines.push(
+        `    ${label}  ${formatTokens(model.consumedToday ?? 0)}`,
+      );
+    }
+  }
+
+  lines.push('');
+  return lines.join('\n');
+}
+
+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),
+  });
+  return res;
+}
+
+export async function usageCommand(argv = [], options = {}) {
+  const jsonOutput = argv.includes('--json');
+  const profileFlag =
+    options.profileName && options.profileName !== DEFAULT_PROFILE
+      ? `--profile ${options.profileName} `
+      : '';
+
+  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`);
+    return;
+  }
+
+  const platformUrl = getPlatformUrl(options.profile);
+
+  try {
+    const res = await fetchUsage(auth.key, platformUrl);
+
+    if (res.status === 404) {
+      printLoginUpgradeWarning();
+      return;
+    }
+
+    let data;
+    try {
+      data = await res.json();
+    } catch {
+      throw new Error('Platform returned an invalid response');
+    }
+
+    if (!res.ok) {
+      const message = data?.error || `Request failed (${res.status})`;
+      if (res.status === 401) {
+        console.log(`\n  ${c.red}✗ ${message}${c.reset}`);
+        console.log(
+          `  Run ${c.cyan}subc ${profileFlag}logout${c.reset} then ${c.cyan}subc ${profileFlag}login${c.reset} to re-authenticate.\n`,
+        );
+        return;
+      }
+      if (res.status === 403) {
+        console.log(`\n  ${c.red}✗ ${message}${c.reset}\n`);
+        return;
+      }
+      throw new Error(message);
+    }
+
+    if (isLegacyUsagePayload(data)) {
+      console.log(`\n  ${c.yellow}Platform upgrade required.${c.reset}`);
+      console.log(
+        `  ${c.dim}This platform host returns a legacy usage shape. Deploy the latest platform or point PLATFORM_URL at a current host.${c.reset}\n`,
+      );
+      return;
+    }
+
+    if (jsonOutput) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+
+    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(`  ${c.dim}Host: ${platformUrl}${c.reset}\n`);
+      return;
+    }
+    console.error(`\n  ${c.red}${error.message}${c.reset}\n`);
+    process.exitCode = 1;
+  }
+}
+
+export function printUsageHelp() {
+  console.log(`
+Usage:
+  subc usage
+  subc -p NAME usage
+  subc usage --json
+  subc usage help
+
+Show billing mode, daily token allowance, credit balance, and per-model usage
+for the authenticated organization.
+
+  --json   Print the raw platform JSON response
+`);
+}

package/bin/windows/agents.js

@@ -0,0 +1,87 @@
+import path from 'node:path';
+import os from 'node:os';
+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';
+
+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 parsed = parseAgentAction(agent, 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)]);
+  if (agent.id === 'subconscious-code' && parsed.action === 'install') {
+    if (args.length) throw new Error('Usage: subc sc install');
+    return finish(await installWindowsAgent(agent.id, environment));
+  }
+  if (['status', 'uninstall'].includes(parsed.action)) {
+    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);
+  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 });
+    explicit = handled.options;
+  }
+  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}.`);
+  let executable;
+  if (parsed.action === 'launch') {
+    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.'}`);
+        return finish(127);
+      }
+      const installed = await installWindowsAgent(agent.id, environment);
+      if (installed) return finish(installed);
+      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.`);
+        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.`);
+    }
+  }
+  // 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) });
+  if (explicit['--gateway-url']) env.GATEWAY_URL = explicit['--gateway-url'];
+  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}`); }
+  }
+  const spec = await windowsLaunch(agent.id, args, env);
+  if (spec.command === agent.bin) spec.command = executable;
+  console.log(`  Launching ${agent.name} on Subconscious (${model})\n`);
+  return finish(await executeWindowsLaunch(spec, runWindows));
+}
+
+function finish(code) {
+  if (code) process.exitCode = code;
+  return code;
+}

package/bin/windows/claude.js

@@ -0,0 +1,71 @@
+// 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;
+function claudePickerSettings(models) {
+  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,
+  });
+  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'] ||
+    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');
+  }
+  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 settings =
+    environment.SUBC_CLAUDE_SETTINGS?.trim() ||
+    JSON.stringify(claudePickerSettings([model], model));
+  const withoutTrailingSlash = effectiveGatewayUrl.replace(/\/+$/, '');
+  const env = {
+    ...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,
+    CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY:
+      environment.CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY?.trim() || '0',
+    CLAUDE_CODE_SUBAGENT_MODEL: subagentModel,
+    CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS:
+      environment.MAX_CONCURRENT_SUBAGENTS?.trim() || '4',
+    CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH:
+      environment.MAX_SUBAGENT_SPAWN_DEPTH?.trim() || '1',
+    CLAUDE_CODE_AUTO_COMPACT_WINDOW: compactWindow,
+    CLAUDE_CODE_MAX_CONTEXT_TOKENS: maxContextTokens,
+    CLAUDE_CODE_ENABLE_TELEMETRY:
+      environment.CLAUDE_CODE_ENABLE_TELEMETRY?.trim() || '1',
+    CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC:
+      environment.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC?.trim() || '1',
+    ENABLE_CLAUDEAI_MCP_SERVERS: 'false',
+    OTEL_LOGS_EXPORTER: environment.OTEL_LOGS_EXPORTER?.trim() || 'otlp',
+    OTEL_EXPORTER_OTLP_PROTOCOL:
+      environment.OTEL_EXPORTER_OTLP_PROTOCOL?.trim() || 'http/json',
+    OTEL_EXPORTER_OTLP_LOGS_ENDPOINT: `${withoutTrailingSlash}/v1/logs`,
+    OTEL_EXPORTER_OTLP_HEADERS: `x-api-key=${apiKey}`,
+    OTEL_EXPORTER_OTLP_TIMEOUT:
+      environment.OTEL_EXPORTER_OTLP_TIMEOUT?.trim() || '2000',
+    OTEL_LOGS_EXPORT_INTERVAL:
+      environment.OTEL_LOGS_EXPORT_INTERVAL?.trim() || '2000',
+  };
+
+  return { args: ['--settings', settings, ...passthrough], env };
+}

package/bin/windows/common.js

@@ -0,0 +1,58 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+
+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 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`);
+  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}`);
+  return models;
+}
+export function parseOptions(argv, schema, { strict = false } = {}) {
+  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;
+    }
+    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;
+    }
+    if (schema[flag] === true) {
+      if (equals.length) throw new Error(`${flag} does not take a value`);
+      options[flag] = true; continue;
+    }
+    const next = equals.length ? equals.join('=') : argv[++i];
+    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) {
+    if (error.code === 'ENOENT') return fallback;
+    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`);
+  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.rename(temp, file);
+  } finally { await fs.rm(temp, { force: true }); }
+}