subconscious-cli 4.1.3 → 4.2.0

package/bin/tui.js

@@ -6,8 +6,9 @@ import { fileURLToPath } from 'node:url';
 
 import { agentList } from './agents.js';
 import { DEFAULT_PLATFORM_URL, getApiKey, getPlatformUrl } from './auth.js';
-import { resolveModelCatalog } from './models.js';
+import { isAbortError, normalizeModelIds, resolveModelCatalog } from './models.js';
 import { discoverSessions, SESSION_HARNESSES } from './sessions.js';
+import { compareVersions, fetchLatestVersion } from './update-check.js';
 import {
   DEFAULT_PROFILE,
   listProfiles,
@@ -47,27 +48,43 @@ async function pathExists(file) {
   }
 }
 
+export async function tuiSourceIsNewerThan(binary, sourceFile = path.join(TUI_SOURCE_DIR, 'cmd/subc-tui/main.go')) {
+  try {
+    const [binaryStat, sourceStat] = await Promise.all([fs.stat(binary), fs.stat(sourceFile)]);
+    return sourceStat.mtimeMs > binaryStat.mtimeMs;
+  } catch {
+    return false;
+  }
+}
+
+function sourceTuiCommand() {
+  return {
+    command: 'go',
+    args: ['run', './cmd/subc-tui'],
+    cwd: TUI_SOURCE_DIR,
+  };
+}
+
 export async function resolveTuiExecutable(options = {}) {
   const override = options.binary || process.env.SUBC_TUI_BIN?.trim();
-  if (override) return { command: override, args: [], cwd: undefined };
+  if (override) {
+    return { command: override, args: options.binaryArgs || [], cwd: undefined };
+  }
 
+  const hasSource = await pathExists(path.join(TUI_SOURCE_DIR, 'go.mod'));
   const target = nativeTargetName(options.platform, options.arch);
   if (target) {
     const packaged = path.join(BIN_DIR, 'native', target);
-    if (await pathExists(packaged)) {
+    // Source checkouts keep a cached host binary for speed. If TUI source is
+    // newer, that cache is stale (for example it will reject --updates).
+    if (await pathExists(packaged) && !(hasSource && (await tuiSourceIsNewerThan(packaged)))) {
       return { command: packaged, args: [], cwd: undefined };
     }
   }
 
   // Source checkouts can run the TUI without committing native build output.
   // Published packages always contain a prebuilt platform binary.
-  if (await pathExists(path.join(TUI_SOURCE_DIR, 'go.mod'))) {
-    return {
-      command: 'go',
-      args: ['run', './cmd/subc-tui'],
-      cwd: TUI_SOURCE_DIR,
-    };
-  }
+  if (hasSource) return sourceTuiCommand();
   return null;
 }
 
@@ -98,7 +115,71 @@ async function packageVersion() {
   return pkg.version;
 }
 
-export async function createTuiState(profileName = DEFAULT_PROFILE, options = {}) {
+function serializeSessions(sessions = []) {
+  return sessions.map((session) => ({
+    key: session.key,
+    harness: session.harness,
+    harnessName: session.harnessName,
+    title: session.title,
+    cwd: session.cwd,
+    updatedAt: session.updatedAt,
+    model: session.model,
+    portable: session.portable,
+  }));
+}
+
+function sessionHarnessList() {
+  return Object.entries(SESSION_HARNESSES).map(([id, harness]) => ({
+    id,
+    name: harness.name,
+    portable: harness.portable,
+  }));
+}
+
+function agentMenuItems() {
+  return agentList().map((agent) => ({
+    command: agent.alias,
+    name: agent.name,
+    action: agent.action,
+    description: agent.description,
+    launch: agent.launch,
+  }));
+}
+
+const ATOMIC_REPLACE_CODES = new Set(['EEXIST', 'EPERM', 'EACCES', 'EBUSY']);
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function replaceFile(tmp, file) {
+  try {
+    await fs.rename(tmp, file);
+  } catch (error) {
+    if (!ATOMIC_REPLACE_CODES.has(error.code)) throw error;
+    // Windows rejects a rename over a file another process still has open.
+    await fs.rm(file, { force: true });
+    await fs.rename(tmp, file);
+  }
+}
+
+export async function writeAtomicJson(file, value) {
+  const payload = `${JSON.stringify(value)}\n`;
+  for (let attempt = 0; attempt < 8; attempt++) {
+    const tmp = `${file}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
+    try {
+      await fs.writeFile(tmp, payload, { mode: 0o600 });
+      await replaceFile(tmp, file);
+      return;
+    } catch (error) {
+      await fs.rm(tmp, { force: true }).catch(() => {});
+      if (!ATOMIC_REPLACE_CODES.has(error.code) || attempt === 7) throw error;
+      await delay(20 * (attempt + 1));
+    }
+  }
+}
+
+export async function createLocalTuiState(profileName = DEFAULT_PROFILE, options = {}) {
   const activeProfile = options.profile || (await loadProfile(profileName));
   const names = [...new Set([profileName, ...(await listProfiles())])].sort((a, b) => {
     if (a === profileName) return -1;
@@ -118,26 +199,17 @@ export async function createTuiState(profileName = DEFAULT_PROFILE, options = {}
     }),
   );
 
-  const auth = await getApiKey(activeProfile);
   const requestedModel = selectedModelFor(activeProfile);
   const gatewayUrl = gatewayFor(activeProfile);
   const platformUrl = platformFor(activeProfile);
-  const catalog = await resolveModelCatalog({
-    baseUrl: gatewayUrl,
-    apiKey: auth?.key,
-    selectedModel: requestedModel,
-    fallbackModels: PACKAGED_MODELS,
-  });
-  const selectedModel = requestedModel;
-  const sessions = await discoverSessions({ max: options.maxSessions || 500 });
 
   return {
     version: await packageVersion(),
     activeProfile: profileName,
     profilePath: activeProfile.path,
     profiles,
-    models: catalog.models,
-    selectedModel,
+    models: normalizeModelIds([requestedModel, ...PACKAGED_MODELS], requestedModel),
+    selectedModel: requestedModel,
     subagentModel: subagentModelFor(activeProfile),
     gatewayUrl,
     savedGatewayUrl:
@@ -148,39 +220,138 @@ export async function createTuiState(profileName = DEFAULT_PROFILE, options = {}
     savedPlatformUrl:
       activeProfile.values.PLATFORM_URL?.trim().replace(/\/+$/, '') || DEFAULT_PLATFORM_URL,
     platformOverridden: Boolean(process.env.SUBCONSCIOUS_URL?.trim()),
-    modelError: catalog.error?.message || '',
-    modelSource: catalog.source,
-    sessions: sessions.map((session) => ({
-      key: session.key,
-      harness: session.harness,
-      harnessName: session.harnessName,
-      title: session.title,
-      cwd: session.cwd,
-      updatedAt: session.updatedAt,
-      model: session.model,
-      portable: session.portable,
-    })),
-    sessionHarnesses: Object.entries(SESSION_HARNESSES).map(([id, harness]) => ({
-      id,
-      name: harness.name,
-      portable: harness.portable,
-    })),
-    agents: agentList().map((agent) => ({
-      command: agent.alias,
-      name: agent.name,
-      action: agent.action,
-      description: agent.description,
-      launch: agent.launch,
-    })),
+    modelError: '',
+    modelSource: 'packaged',
+    modelsLoading: true,
+    sessionsLoading: true,
+    sessions: [],
+    sessionHarnesses: sessionHarnessList(),
+    agents: agentMenuItems(),
+    updateAvailable: false,
+    latestVersion: '',
   };
 }
 
+function whenAborted(signal) {
+  return new Promise((_, reject) => {
+    const fail = () => {
+      const error = new Error('cancelled');
+      error.name = 'AbortError';
+      reject(error);
+    };
+    if (signal.aborted) {
+      fail();
+      return;
+    }
+    signal.addEventListener('abort', fail, { once: true });
+  });
+}
+
+async function raceAbort(signal, promise) {
+  if (!signal) return promise;
+  return Promise.race([promise, whenAborted(signal)]);
+}
+
+export async function loadRemoteTuiUpdates(state, options = {}) {
+  const signal = options.signal;
+  const writePatch = options.writePatch || (async () => {});
+  const resolveCatalog = options.resolveCatalog || resolveModelCatalog;
+  const discover = options.discoverSessions || discoverSessions;
+  const fetchLatest = options.fetchLatestVersion || fetchLatestVersion;
+  const readApiKey = options.getApiKey || getApiKey;
+  const updateDisabled =
+    options.disableUpdateCheck ?? process.env.SUBC_DISABLE_UPDATE_CHECK?.trim() === '1';
+
+  const tasks = [
+    (async () => {
+      const profile = options.profile || (await loadProfile(state.activeProfile));
+      if (signal?.aborted) return;
+      const auth = await readApiKey(profile);
+      if (signal?.aborted) return;
+      const catalog = await resolveCatalog({
+        baseUrl: state.gatewayUrl,
+        apiKey: auth?.key,
+        selectedModel: state.selectedModel,
+        fallbackModels: PACKAGED_MODELS,
+        fetchImpl: options.fetchImpl,
+        timeoutMs: options.timeoutMs,
+        signal,
+      });
+      if (signal?.aborted) return;
+      await writePatch({
+        models: catalog.models,
+        modelError: catalog.error?.message || '',
+        modelSource: catalog.source,
+        modelsLoading: false,
+      });
+    })(),
+    (async () => {
+      const sessions = await raceAbort(
+        signal,
+        discover({
+          max: options.maxSessions || 500,
+          home: options.home,
+          roots: options.roots,
+          indexes: options.indexes,
+          execute: options.execute,
+          signal,
+        }),
+      );
+      if (signal?.aborted) return;
+      await writePatch({
+        sessions: serializeSessions(sessions),
+        sessionsLoading: false,
+      });
+    })(),
+  ];
+
+  if (!updateDisabled) {
+    tasks.push(
+      (async () => {
+        try {
+          const latest = await fetchLatest({
+            fetchImpl: options.updateFetchImpl || options.fetchImpl,
+            timeoutMs: options.updateTimeoutMs,
+            signal,
+          });
+          if (signal?.aborted || !latest) return;
+          if (compareVersions(latest, state.version) > 0) {
+            await writePatch({ updateAvailable: true, latestVersion: latest });
+          }
+        } catch (error) {
+          if (isAbortError(error) || signal?.aborted) return;
+        }
+      })(),
+    );
+  }
+
+  const results = await Promise.allSettled(tasks);
+  for (const result of results) {
+    if (result.status !== 'rejected') continue;
+    if (isAbortError(result.reason) || signal?.aborted) continue;
+    throw result.reason;
+  }
+}
+
+export async function createTuiState(profileName = DEFAULT_PROFILE, options = {}) {
+  const state = await createLocalTuiState(profileName, options);
+  let next = { ...state };
+  await loadRemoteTuiUpdates(state, {
+    ...options,
+    writePatch: async (partial) => {
+      next = { ...next, ...partial };
+    },
+  });
+  return next;
+}
+
 function spawnAndWait(command, args, options = {}) {
+  const spawnImpl = options.spawn || spawn;
   return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
+    const child = spawnImpl(command, args, {
       cwd: options.cwd,
       env: process.env,
-      stdio: 'inherit',
+      stdio: options.stdio ?? 'inherit',
     });
     child.once('error', reject);
     child.once('exit', (code, signal) => {
@@ -197,10 +368,28 @@ export async function runTui(options = {}) {
   const executable = await resolveTuiExecutable(options);
   if (!executable) return null;
 
-  const state = options.state || (await createTuiState(options.profileName, options));
+  const providedState = options.state;
+  const state = providedState || (await createLocalTuiState(options.profileName, options));
   const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'subc-tui-'));
   const statePath = path.join(tempDir, 'state.json');
   const resultPath = path.join(tempDir, 'result.json');
+  const updatesPath = path.join(tempDir, 'updates.json');
+  const controller = new AbortController();
+
+  let patch = {};
+  const writePatch = async (partial) => {
+    if (controller.signal.aborted) return;
+    patch = { ...patch, ...partial };
+    try {
+      await writeAtomicJson(updatesPath, patch);
+    } catch {
+      // The TUI may have already exited and removed the working directory.
+    }
+  };
+
+  const remote = providedState
+    ? Promise.resolve()
+    : loadRemoteTuiUpdates(state, { ...options, signal: controller.signal, writePatch });
 
   try {
     // This state intentionally contains only display data. API keys are used
@@ -208,9 +397,11 @@ export async function runTui(options = {}) {
     await fs.writeFile(statePath, `${JSON.stringify(state)}\n`, { mode: 0o600 });
     const code = await spawnAndWait(
       executable.command,
-      [...executable.args, '--state', statePath, '--result', resultPath],
-      { cwd: executable.cwd },
+      [...executable.args, '--state', statePath, '--result', resultPath, '--updates', updatesPath],
+      { cwd: executable.cwd, spawn: options.spawn, stdio: options.stdio },
     );
+    controller.abort();
+    await remote.catch(() => {});
     if (code !== 0) throw new Error(`Subconscious TUI exited with status ${code}`);
 
     try {
@@ -220,7 +411,12 @@ export async function runTui(options = {}) {
       if (error.code === 'ENOENT') return null;
       throw error;
     }
+  } catch (error) {
+    controller.abort();
+    await remote.catch(() => {});
+    throw error;
   } finally {
+    controller.abort();
     await fs.rm(tempDir, { recursive: true, force: true });
   }
 }

package/bin/update-check.js

@@ -116,27 +116,48 @@ export async function currentVersion() {
 export async function fetchLatestVersion(options = {}) {
   const fetchImpl = options.fetchImpl || globalThis.fetch;
   const timeoutMs = options.timeoutMs ?? UPDATE_CHECK_TIMEOUT_MS;
+  const signal = options.signal;
   if (typeof fetchImpl !== 'function') throw new Error('fetch is unavailable');
 
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), timeoutMs);
   timeout.unref?.();
+  const onAbort = () => controller.abort();
+  if (signal?.aborted) {
+    const error = new Error('Update check was cancelled');
+    error.name = 'AbortError';
+    clearTimeout(timeout);
+    throw error;
+  }
+  signal?.addEventListener('abort', onAbort, { once: true });
 
   try {
-    const response = await fetchImpl(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
-      headers: {
-        Accept: 'application/json',
-        'Cache-Control': 'no-cache, no-store',
-        Pragma: 'no-cache',
-      },
-      cache: 'no-store',
-      signal: controller.signal,
+    const aborted = new Promise((_, reject) => {
+      const fail = () => {
+        const error = new Error(signal?.aborted ? 'Update check was cancelled' : 'Update check timed out');
+        error.name = 'AbortError';
+        reject(error);
+      };
+      controller.signal.addEventListener('abort', fail, { once: true });
     });
+    const response = await Promise.race([
+      fetchImpl(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+        headers: {
+          Accept: 'application/json',
+          'Cache-Control': 'no-cache, no-store',
+          Pragma: 'no-cache',
+        },
+        cache: 'no-store',
+        signal: controller.signal,
+      }),
+      aborted,
+    ]);
     if (!response.ok) throw new Error(`npm returned HTTP ${response.status}`);
     const payload = await response.json();
     if (!parseVersion(payload?.version)) throw new Error('npm returned an invalid version');
     return payload.version;
   } finally {
+    signal?.removeEventListener('abort', onAbort);
     clearTimeout(timeout);
   }
 }

package/bin/usage.js

@@ -56,6 +56,33 @@ export function renderProgressBar(percentage, width = 20) {
   return `${color}${'█'.repeat(filled)}${c.dim}${'░'.repeat(empty)}${c.reset}`;
 }
 
+/**
+ * Whole percent. Never rounds up to 100 while allowance remains — a meter
+ * that reads 100% claims the day is spent.
+ */
+export function formatAllowancePercent(percent) {
+  const n = Number(percent);
+  if (!Number.isFinite(n) || n <= 0) return '0%';
+  const whole = Math.round(n);
+  if (n >= 100) return '100%';
+  if (whole >= 100) return '99%';
+  return `${whole}%`;
+}
+
+/** New percent payloads, or the pre-basis token shape (consumed / amount). */
+export function describeDailyAllowance(allowance) {
+  if (!allowance || typeof allowance !== 'object') return null;
+  if (allowance.basis === 'unavailable') return { kind: 'unavailable' };
+  if (allowance.basis === 'credit' || allowance.basis === 'tokens') {
+    return { kind: allowance.basis, percent: Number(allowance.percent) || 0 };
+  }
+
+  const consumed = Number(allowance.consumed) || 0;
+  const amount = Number(allowance.amount) || 0;
+  if (amount <= 0) return null;
+  return { kind: 'tokens', percent: (consumed / amount) * 100 };
+}
+
 export function formatUsageDisplay(data) {
   const lines = [];
   lines.push(`\n  ${c.bold}Subconscious Usage${c.reset}\n`);
@@ -81,24 +108,29 @@ export function formatUsageDisplay(data) {
     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}`);
+  } else {
+    const described = describeDailyAllowance(allowance);
+    if (described) {
+      lines.push('');
+      lines.push(`  ${c.dim}Daily allowance${c.reset}`);
+      if (described.kind === 'unavailable') {
+        lines.push(`  ${c.dim}Daily credit unavailable${c.reset}`);
+        lines.push(
+          `  ${c.dim}Today's credit usage could not be read just now. Your plan and access are unaffected, and the figure returns on its own.${c.reset}`,
+        );
+      } else {
+        const label =
+          described.kind === 'credit' ? 'of daily credit used' : 'of daily tokens used';
+        lines.push(
+          `  ${renderProgressBar(described.percent)}  ${formatAllowancePercent(described.percent)} ${label}`,
+        );
+        lines.push(`  ${c.dim}Resets midnight UTC${c.reset}`);
+        if (described.kind === 'credit' && described.percent >= 100) {
+          lines.push(
+            `  ${c.yellow}Past today's allowance - further usage bills from your balance.${c.reset}`,
+          );
+        }
+      }
     }
   }
 
@@ -221,7 +253,7 @@ Usage:
   subc usage --json
   subc usage help
 
-Show billing mode, daily token allowance, credit balance, and per-model usage
+Show billing mode, daily allowance, credit balance, and per-model usage
 for the authenticated organization.
 
   --json   Print the raw platform JSON response

package/bin/windows/launch.js

@@ -3,6 +3,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { claudeNativeLaunch } from './claude.js';
+import { buildOpenCodeConfig } from '../opencode-provider.js';
 import { modelSupportsVision } from '../model-capabilities.js';
 import { defaults, value, origin, modelIds, positiveInteger, parseOptions, writeJson } from './common.js';
 
@@ -26,16 +27,9 @@ export async function windowsLaunch(id, argv, env, { tempRoot = os.tmpdir() } =
   if (id === 'opencode') {
     const context = positiveInteger(value(env, 'OPENCODE_CONTEXT_LIMIT', '5000000'), 'OPENCODE_CONTEXT_LIMIT');
     const output = positiveInteger(value(env, 'OPENCODE_OUTPUT_LIMIT', '65536'), 'OPENCODE_OUTPUT_LIMIT');
-    const models = Object.fromEntries(modelIds(env).map(id => [id, {
-      name: id, tools: true, limit: { context, output },
-      ...(modelSupportsVision(id) ? { attachment: true, modalities: { input: ['text', 'image'], output: ['text'] } } : {}),
-    }]));
-    childEnv.OPENCODE_CONFIG_CONTENT = JSON.stringify({
-      $schema: 'https://opencode.ai/config.json', disabled_providers: ['subconscious'],
-      provider: { 'subconscious-cli': { npm: '@ai-sdk/openai-compatible', name: 'Subconscious Gateway', options: {
-        baseURL: `${base}/v1`, apiKey: '{env:SUBCONSCIOUS_API_KEY}', headers: { 'x-subconscious-client': 'opencode' },
-      }, models } }, model: `subconscious-cli/${model}`,
-    });
+    childEnv.OPENCODE_CONFIG_CONTENT = JSON.stringify(
+      buildOpenCodeConfig({ baseUrl: base, model, modelIds: modelIds(env), context, output }),
+    );
     return { command: 'opencode', args: parseOptions(argv, {}).rest, env: childEnv };
   }
   if (id === 'codex') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "subconscious-cli",
-  "version": "4.1.3",
+  "version": "4.2.0",
   "description": "CLI for Subconscious — run Subconscious Code, Claude Code, Codex, OpenCode, DeepSeek Harness, Cursor, Copilot, and Pi",
   "bin": {
     "subc": "bin/cli.js"