subconscious-cli 0.3.1 → 4.0.0

package/bin/auth.js

@@ -4,14 +4,15 @@
  * Login flow (localhost callback pattern, similar to Vercel/Supabase CLIs):
  *  1. CLI generates a random `state` token (CSRF protection) and starts
  *     an ephemeral HTTP server on a random port bound to 127.0.0.1.
- *  2. Opens the browser to {PLATFORM_URL}/cli/auth?port=...&state=...
+ *  2. Opens the browser to {platformUrl}/cli/auth?port=...&state=...
  *  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`, saves the key to ~/.subconscious/config.json,
  *     and creates a coding-agent profile under ~/.subconscious/profiles/.
  *
- * Override SUBCONSCIOUS_URL env var for local development.
+ * Override SUBCONSCIOUS_URL env var for local development
+ * (e.g. http://localhost:3000). Production defaults to platform.subconscious.dev.
  */
 
 import http from 'node:http';
@@ -22,6 +23,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { c } from './colors.js';
 import { clearProfileApiKey, DEFAULT_PROFILE, ensureProfile } from './profiles.js';
+import { printLoginUpgradeWarning } from './upgrade.js';
 
 const CONFIG_OVERRIDE = process.env.SUBC_CONFIG_DIR?.trim();
 const CONFIG_DIR = CONFIG_OVERRIDE || path.join(os.homedir(), '.subconscious');
@@ -29,12 +31,17 @@ 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';
+// Defaults to the platform host. Developers set SUBCONSCIOUS_URL for local dev.
+export const DEFAULT_PLATFORM_URL = 'https://platform.subconscious.dev';
 
-// Login callback CORS. After the marketing/platform split, www 307s /cli/auth
-// to the platform host, so the browser Origin is platform even when the CLI
-// still opened www. Keep www so a non-redirected tab still works.
+export function getPlatformUrl() {
+  const raw = process.env.SUBCONSCIOUS_URL?.trim() || DEFAULT_PLATFORM_URL;
+  return raw.replace(/\/$/, '');
+}
+
+// Login callback CORS. After the marketing/platform split, /cli/auth lives on
+// platform. www may still 307 there for older CLIs; keep www so a redirected
+// or leftover tab can complete the callback.
 const CALLBACK_ORIGINS = new Set([
   'https://www.subconscious.dev',
   'https://platform.subconscious.dev',
@@ -42,7 +49,7 @@ const CALLBACK_ORIGINS = new Set([
   'https://platform-dev.subconscious.dev',
 ]);
 
-export function isAllowedCallbackOrigin(origin, platformUrl = PLATFORM_URL) {
+export function isAllowedCallbackOrigin(origin, platformUrl = getPlatformUrl()) {
   if (!origin) return false;
   if (origin === platformUrl || CALLBACK_ORIGINS.has(origin)) return true;
   try {
@@ -104,6 +111,24 @@ export async function getApiKey(profile) {
   return null;
 }
 
+export async function probeLoginPage(platformUrl = getPlatformUrl(), fetchImpl = fetch) {
+  const url = `${platformUrl.replace(/\/$/, '')}/cli/auth`;
+  try {
+    const res = await fetchImpl(url, {
+      method: 'GET',
+      redirect: 'manual',
+      signal: AbortSignal.timeout(8000),
+    });
+    return res.status;
+  } catch {
+    return null;
+  }
+}
+
+export function isLoginMissing(status) {
+  return status === 404;
+}
+
 // ── Browser opener ──────────────────────────────────────────────────────
 
 function openBrowser(url) {
@@ -141,7 +166,7 @@ function startCallbackServer(expectedState) {
       const allowed = isAllowedCallbackOrigin(origin);
       res.setHeader(
         'Access-Control-Allow-Origin',
-        allowed ? origin : PLATFORM_URL,
+        allowed ? origin : getPlatformUrl(),
       );
       res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
       res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
@@ -298,10 +323,18 @@ export async function loginCommand(_argv = [], options = {}) {
   );
   console.log();
 
+  const platformUrl = getPlatformUrl();
+  const loginStatus = await probeLoginPage(platformUrl);
+  if (isLoginMissing(loginStatus)) {
+    printLoginUpgradeWarning();
+    process.exitCode = 1;
+    return;
+  }
+
   const state = crypto.randomBytes(16).toString('hex');
   const { port, promise } = await startCallbackServer(state);
 
-  const authUrl = `${PLATFORM_URL}/cli/auth?port=${port}&state=${state}`;
+  const authUrl = `${platformUrl}/cli/auth?port=${port}&state=${state}`;
 
   console.log(`  ${c.dim}Opening browser to sign in...${c.reset}`);
   console.log();
@@ -426,11 +459,16 @@ export async function whoamiCommand(_argv = [], options = {}) {
 
   // Validate the key against the server; falls back to offline display if unreachable
   try {
-    const res = await fetch(`${PLATFORM_URL}/api/cli/whoami`, {
+    const res = await fetch(`${getPlatformUrl()}/api/cli/whoami`, {
       headers: { Authorization: `Bearer ${key}` },
       signal: AbortSignal.timeout(5000),
     });
 
+    if (res.status === 404) {
+      printLoginUpgradeWarning();
+      return;
+    }
+
     if (res.ok) {
       const data = await res.json();
       console.log(`  ${c.green}✓ Authenticated${c.reset}`);

package/bin/cli.js

@@ -3,7 +3,7 @@
 /**
  * Subconscious CLI — log in, then launch coding agents on your hosted models.
  *
- *   subc login | update-key | logout | whoami — manage your API key
+ *   subc login | update-key | logout | whoami | upgrade — 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.
@@ -18,6 +18,7 @@ import {
   updateApiKeyCommand,
   whoamiCommand,
 } from './auth.js';
+import { upgradeCommand } from './upgrade.js';
 import {
   resolveAgent,
   runAgent,
@@ -57,6 +58,7 @@ function printHelp() {
     ${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.cyan}upgrade${c.reset}      Upgrade this CLI to the latest version
 
   ${c.bold}Profiles${c.reset}
     ${c.cyan}config${c.reset}       List profiles, or show/edit one with ${c.dim}-p${c.reset}
@@ -73,6 +75,8 @@ ${agents}
 
   ${c.bold}Examples${c.reset}
     ${c.dim}$${c.reset} subc login
+    ${c.dim}$${c.reset} subc upgrade
+    ${c.dim}$${c.reset} subc upgrade --latest
     ${c.dim}$${c.reset} subc config
     ${c.dim}$${c.reset} subc config help
     ${c.dim}$${c.reset} subc -p staging config
@@ -112,6 +116,17 @@ Usage:
   subc whoami help
 
 Show the current authentication status for the selected profile.
+`,
+  upgrade: `
+Usage:
+  subc upgrade
+  subc upgrade --latest
+  subc upgrade help
+
+Upgrade subconscious-cli to the latest published version.
+
+  subc upgrade           Prompt "Do you want to upgrade?" then install @latest
+  subc upgrade --latest  Skip the prompt and install @latest
 `,
   'update-key': `
 Usage:
@@ -274,6 +289,15 @@ async function main() {
     return;
   }
 
+  if (command === 'upgrade') {
+    if (isHelpArg(args[1])) {
+      console.log(COMMAND_HELP.upgrade);
+      return;
+    }
+    await upgradeCommand(args.slice(1));
+    return;
+  }
+
   if (command === 'update-url') {
     if (isHelpArg(args[1])) {
       console.log(COMMAND_HELP['update-url']);

package/bin/upgrade.js

@@ -0,0 +1,164 @@
+/**
+ * Self-update for the Subconscious CLI (`subc upgrade`).
+ *
+ *   subc upgrade           Interactive confirm, then install @latest
+ *   subc upgrade --latest  Skip the prompt and install @latest
+ */
+
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import readline from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import { c } from './colors.js';
+
+export const PACKAGE_NAME = 'subconscious-cli';
+export const MIN_LOGIN_VERSION = '4.0';
+
+export function parseUpgradeArgs(argv = []) {
+  const latest = argv.includes('--latest');
+  const unknown = argv.filter((arg) => arg !== '--latest');
+  if (unknown.length) {
+    throw new Error(`Unknown argument: ${unknown[0]}\nUsage: subc upgrade [--latest]`);
+  }
+  return { latest };
+}
+
+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`;
+}
+
+export async function currentCliVersion() {
+  const pkg = JSON.parse(await fs.readFile(new URL('../package.json', import.meta.url), 'utf-8'));
+  return pkg.version;
+}
+
+export function compareVersions(a, b) {
+  const pa = String(a).split('.').map((part) => Number.parseInt(part, 10) || 0);
+  const pb = String(b).split('.').map((part) => Number.parseInt(part, 10) || 0);
+  const n = Math.max(pa.length, pb.length);
+  for (let i = 0; i < n; i++) {
+    const da = pa[i] || 0;
+    const db = pb[i] || 0;
+    if (da > db) return 1;
+    if (da < db) return -1;
+  }
+  return 0;
+}
+
+export async function fetchLatestVersion(fetchImpl = fetch) {
+  const res = await fetchImpl(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+    signal: AbortSignal.timeout(10000),
+  });
+  if (!res.ok) {
+    throw new Error(`Could not look up ${PACKAGE_NAME} on npm (${res.status}).`);
+  }
+  const data = await res.json();
+  if (!data?.version) throw new Error(`npm did not return a version for ${PACKAGE_NAME}.`);
+  return data.version;
+}
+
+export function printLoginUpgradeWarning() {
+  console.error();
+  console.error(
+    `  ${c.yellow}Upgrade to version ${MIN_LOGIN_VERSION} to login.${c.reset}`,
+  );
+  console.error(`  This login URL is no longer available (404).`);
+  console.error();
+  console.error(`  Run ${c.cyan}subc upgrade --latest${c.reset}`);
+  console.error();
+}
+
+function askYesNo(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      const a = answer.trim().toLowerCase();
+      resolve(a === '' || a === 'y' || a === 'yes');
+    });
+  });
+}
+
+function runInstall(command) {
+  return new Promise((resolve) => {
+    const child = spawn(command, { shell: true, stdio: 'inherit' });
+    child.on('error', () => resolve(false));
+    child.on('exit', (code) => resolve(code === 0));
+  });
+}
+
+export async function installLatest(options = {}) {
+  const install = options.install || runInstall;
+  const fetchLatest = options.fetchLatest || fetchLatestVersion;
+  const current = options.currentVersion || (await currentCliVersion());
+  const command = options.command || detectInstallCommand();
+
+  let latest;
+  try {
+    latest = await fetchLatest();
+  } catch (error) {
+    console.error(`  ${c.yellow}${error.message}${c.reset}`);
+    console.error(`  ${c.dim}Installing @latest anyway.${c.reset}\n`);
+  }
+
+  if (latest && compareVersions(current, latest) >= 0) {
+    console.log(`\n  ${c.green}Already up to date${c.reset} ${c.dim}(${current}).${c.reset}\n`);
+    return true;
+  }
+
+  if (latest) {
+    console.log(
+      `\n  Upgrading ${c.cyan}${PACKAGE_NAME}${c.reset} ${c.dim}${current}${c.reset} → ${c.cyan}${latest}${c.reset}`,
+    );
+  } else {
+    console.log(`\n  Upgrading ${c.cyan}${PACKAGE_NAME}${c.reset} ${c.dim}${current}${c.reset} → latest`);
+  }
+  console.log(`  ${c.dim}Running${c.reset} ${c.cyan}${command}${c.reset}\n`);
+
+  const ok = await install(command);
+  if (!ok) {
+    console.error(`\n  ${c.red}Upgrade failed.${c.reset} Try it 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;
+}
+
+export async function upgradeCommand(argv = [], options = {}) {
+  const { latest } = parseUpgradeArgs(argv);
+  const interactive = options.interactive ?? (process.stdin.isTTY && process.stdout.isTTY);
+  const ask = options.ask || askYesNo;
+  const installLatestFn = options.installLatest || installLatest;
+
+  if (!latest) {
+    if (!interactive) {
+      console.error(
+        `\n  ${c.yellow}Do you want to upgrade?${c.reset} requires a TTY.`,
+      );
+      console.error(`  Run ${c.cyan}subc upgrade --latest${c.reset} instead.\n`);
+      process.exitCode = 1;
+      return;
+    }
+
+    const ok = await ask(`  Do you want to upgrade? ${c.dim}[Y/n]${c.reset} `);
+    if (!ok) {
+      console.log(`\n  ${c.dim}Upgrade cancelled.${c.reset}\n`);
+      return;
+    }
+  }
+
+  const succeeded = await installLatestFn();
+  if (!succeeded) process.exitCode = 1;
+}

package/package.json

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