subconscious-cli 4.0.6 → 4.0.7

package/README.md

@@ -31,9 +31,13 @@ subc pi
 subc <agent> uninstall
 ```
 
-Top-level help (`subc`, `subc help`, or `subc --help`) displays the
-Subconscious logo as portable ASCII art. Set `NO_COLOR=1` for a
-monochrome version; redirected output automatically uses a plain wordmark.
+Running `subc` with no arguments in a terminal opens the native Go TUI. Use
+the arrow keys and Enter to launch agents or manage the active profile, `p` to
+switch profiles, and `q` to quit. The menu includes dedicated **Create profile**,
+**Set default model**, and **Update base URL** actions. Model and URL changes
+are validated and saved to the active profile without leaving the TUI.
+`subc help` and `subc --help` continue to print script-friendly command help.
+Non-interactive `subc` also prints regular help.
 
 Every command accepts `help` as a subcommand. These only read the selected
 profile; they do not authenticate, install, configure, or launch anything:
@@ -135,6 +139,7 @@ DeepSeek Harness context and output settings used by the packaged runbook script
 
 ```bash
 subc config                         # list every profile and its file path
+subc -p staging config create      # create a profile with default settings
 subc -p staging config              # print that path and env file
 subc -p staging config --model subconscious/glm-5.2
 subc config --gateway-url https://gateway.example

package/bin/agents.js

@@ -100,9 +100,12 @@ export function resolveAgent(name) {
 
 export function agentList() {
   return AGENTS.map((a) => ({
+    id: a.id,
     name: a.name,
     alias: a.command || a.id,
     action: a.runbook?.mode === 'setup' ? 'Configure' : 'Launch',
+    description: a.description || '',
+    launch: a.runbook?.mode !== 'setup',
   }));
 }
 

package/bin/cli.js

@@ -41,6 +41,7 @@ import {
 } from './profiles.js';
 import { resolveModelCatalog } from './models.js';
 import { showUpdateNotice } from './update-check.js';
+import { runTui } from './tui.js';
 
 function isHelpArg(arg) {
   return arg === 'help' || arg === '-h' || arg === '--help';
@@ -228,9 +229,20 @@ async function main() {
   const update = await showUpdateNotice();
   if (update?.action === 'updated' || update?.action === 'cancel') return;
 
-  const parsed = extractProfile(process.argv.slice(2));
-  const { args, profileName, profileExplicit } = parsed;
-  const command = args[0];
+  let parsed = extractProfile(process.argv.slice(2));
+  let { args, profileName, profileExplicit } = parsed;
+  let command = args[0];
+
+  if (!command && process.stdin.isTTY === true && process.stdout.isTTY === true && process.env.TERM !== 'dumb') {
+    const selection = await runTui({ profileName });
+    if (!selection?.args?.length) return;
+    if (selection.baseUrl?.trim()) {
+      process.env.SUBCONSCIOUS_BASE_URL = selection.baseUrl.trim();
+    }
+    parsed = extractProfile(selection.args);
+    ({ args, profileName, profileExplicit } = parsed);
+    command = args[0];
+  }
 
   if (!command || command === '--help' || command === '-h' || (command === 'help' && !args[1])) {
     printHelp();

package/bin/profiles.js

@@ -678,7 +678,7 @@ Usage:
   subc -p NAME config
   subc config edit [vim|nano]
   subc -p NAME config edit [vim|nano]
-  subc config [show|path|list|delete]
+  subc config [show|path|list|create|delete]
               [--gateway-url URL] [--api-key KEY] [--model MODEL]
 
   subc config                      List every profile and its file path
@@ -687,6 +687,7 @@ Usage:
   subc config edit vim             Open the selected profile in vim
   subc config edit nano            Open the selected profile in nano
   subc config path                 Print the selected profile path
+  subc -p NAME config create       Create a new profile with default settings
   subc -p NAME config delete       Delete a non-default profile
 `);
 }
@@ -715,7 +716,7 @@ export async function configCommand(argv, profileName = DEFAULT_PROFILE, options
     if (arg === 'help' || arg === '-h' || arg === '--help') {
       printConfigHelp();
       return;
-    } else if (['show', 'path', 'list', 'delete', 'edit', 'interactive'].includes(arg)) {
+    } else if (['show', 'path', 'list', 'create', 'delete', 'edit', 'interactive'].includes(arg)) {
       action = arg === 'interactive' ? 'edit' : arg;
     } else if (arg === '--gateway-url' || arg === '--api-key' || arg === '--model') {
       const value = argv[++i];
@@ -754,6 +755,18 @@ export async function configCommand(argv, profileName = DEFAULT_PROFILE, options
     return;
   }
 
+  if (action === 'create') {
+    if (Object.keys(updates).length) {
+      throw new Error('config create cannot be combined with profile updates');
+    }
+    const existing = await loadProfile(profileName);
+    if (existing.exists) throw new Error(`Profile '${profileName}' already exists`);
+    const profile = await ensureProfile(profileName);
+    console.log(`Created profile '${profileName}'.`);
+    await printProfile(profile);
+    return;
+  }
+
   if (action === 'delete') {
     if (profileName === DEFAULT_PROFILE) {
       throw new Error('Refusing to delete the default profile; use subc logout to clear its key');

package/bin/tui.js

@@ -0,0 +1,195 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { agentList } from './agents.js';
+import { getApiKey } from './auth.js';
+import { resolveModelCatalog } from './models.js';
+import {
+  DEFAULT_PROFILE,
+  listProfiles,
+  loadProfile,
+  RUNBOOK_DEFAULTS,
+  SUPPORTED_MODELS as PACKAGED_MODELS,
+} from './profiles.js';
+
+const BIN_DIR = path.dirname(fileURLToPath(import.meta.url));
+const TUI_SOURCE_DIR = path.resolve(BIN_DIR, '../tui');
+
+export function nativeTargetName(platform = process.platform, arch = process.arch) {
+  const goArch = { x64: 'amd64', arm64: 'arm64' }[arch];
+  if (!goArch || !['darwin', 'linux', 'win32'].includes(platform)) return null;
+  const goOS = platform === 'win32' ? 'windows' : platform;
+  const extension = platform === 'win32' ? '.exe' : '';
+  return `subc-tui-${goOS}-${goArch}${extension}`;
+}
+
+export function isTuiResult(result) {
+  return (
+    result !== null &&
+    typeof result === 'object' &&
+    Array.isArray(result.args) &&
+    result.args.every((arg) => typeof arg === 'string') &&
+    (result.baseUrl === undefined || typeof result.baseUrl === 'string')
+  );
+}
+
+async function pathExists(file) {
+  try {
+    await fs.access(file);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function resolveTuiExecutable(options = {}) {
+  const override = options.binary || process.env.SUBC_TUI_BIN?.trim();
+  if (override) return { command: override, args: [], cwd: undefined };
+
+  const target = nativeTargetName(options.platform, options.arch);
+  if (target) {
+    const packaged = path.join(BIN_DIR, 'native', target);
+    if (await pathExists(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,
+    };
+  }
+  return null;
+}
+
+function selectedModelFor(profile) {
+  return (
+    process.env.SUBCONSCIOUS_MODEL?.trim() ||
+    profile.values.MODEL?.trim() ||
+    RUNBOOK_DEFAULTS.MODEL
+  );
+}
+
+function gatewayFor(profile) {
+  return (
+    process.env.SUBCONSCIOUS_BASE_URL?.trim() ||
+    profile.values.GATEWAY_URL?.trim() ||
+    RUNBOOK_DEFAULTS.GATEWAY_URL
+  ).replace(/\/+$/, '');
+}
+
+async function packageVersion() {
+  const pkg = JSON.parse(
+    await fs.readFile(new URL('../package.json', import.meta.url), 'utf-8'),
+  );
+  return pkg.version;
+}
+
+export async function createTuiState(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;
+    if (b === profileName) return 1;
+    return a.localeCompare(b);
+  });
+  const profiles = await Promise.all(
+    names.map(async (name) => {
+      const profile = name === profileName ? activeProfile : await loadProfile(name);
+      const auth = await getApiKey(profile);
+      return {
+        name,
+        model: selectedModelFor(profile),
+        authenticated: Boolean(auth?.key),
+      };
+    }),
+  );
+
+  const auth = await getApiKey(activeProfile);
+  const selectedModel = selectedModelFor(activeProfile);
+  const gatewayUrl = gatewayFor(activeProfile);
+  const catalog = await resolveModelCatalog({
+    baseUrl: gatewayUrl,
+    apiKey: auth?.key,
+    selectedModel,
+    fallbackModels: PACKAGED_MODELS,
+  });
+
+  return {
+    version: await packageVersion(),
+    activeProfile: profileName,
+    profilePath: activeProfile.path,
+    profiles,
+    models: catalog.models,
+    selectedModel,
+    gatewayUrl,
+    savedGatewayUrl:
+      activeProfile.values.GATEWAY_URL?.trim().replace(/\/+$/, '') ||
+      RUNBOOK_DEFAULTS.GATEWAY_URL,
+    gatewayOverridden: Boolean(process.env.SUBCONSCIOUS_BASE_URL?.trim()),
+    modelError: catalog.error?.message || '',
+    agents: agentList().map((agent) => ({
+      command: agent.alias,
+      name: agent.name,
+      action: agent.action,
+      description: agent.description,
+      launch: agent.launch,
+    })),
+  };
+}
+
+function spawnAndWait(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: process.env,
+      stdio: 'inherit',
+    });
+    child.once('error', reject);
+    child.once('exit', (code, signal) => {
+      if (signal) {
+        reject(new Error(`Subconscious TUI exited with signal ${signal}`));
+        return;
+      }
+      resolve(code ?? 1);
+    });
+  });
+}
+
+export async function runTui(options = {}) {
+  const executable = await resolveTuiExecutable(options);
+  if (!executable) return null;
+
+  const state = options.state || (await createTuiState(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');
+
+  try {
+    // This state intentionally contains only display data. API keys are used
+    // by the Node command engine and are never passed into the TUI process.
+    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 },
+    );
+    if (code !== 0) throw new Error(`Subconscious TUI exited with status ${code}`);
+
+    try {
+      const result = JSON.parse(await fs.readFile(resultPath, 'utf-8'));
+      return isTuiResult(result) ? result : null;
+    } catch (error) {
+      if (error.code === 'ENOENT') return null;
+      throw error;
+    }
+  } finally {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  }
+}

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "subconscious-cli",
-  "version": "4.0.6",
+  "version": "4.0.7",
   "description": "CLI for Subconscious — run Claude Code, Codex, OpenCode, DeepSeek Harness, Cursor, Copilot, and Pi",
   "bin": {
     "subc": "bin/cli.js"
   },
   "scripts": {
-    "test": "node --test"
+    "build:tui": "node scripts/build-tui.js",
+    "build:tui:host": "node scripts/build-tui.js --host",
+    "test": "node --test",
+    "test:tui": "go -C tui test ./...",
+    "prepack": "npm run build:tui"
   },
   "files": [
     "bin"