@volter/supercode 0.5.150 → 0.5.151

package/README.md

@@ -13,13 +13,15 @@ supercode login --provider   # paste your OpenRouter key
 supercode run "fix the failing test in src/lib.rs"
 ```
 
-This package is a thin launcher; the actual binary ships as a platform-specific
-optional dependency (`@volter/supercode-cli-<os>-<cpu>`), so `npm` downloads only the
-build matching your machine — no compile step, no postinstall network fetch.
+This package is supercode's front door. Commands that have moved to TypeScript are served
+here, in Node (`supercode front-door` lists them); every other command goes to the native binary,
+which ships as a platform-specific optional dependency (`@volter/supercode-cli-<os>-<cpu>`), so
+`npm` downloads only the build matching your machine — no compile step, no postinstall network fetch.
 
 Supported platforms: `darwin-arm64`, `darwin-x64`, `linux-x64`, `linux-arm64`,
 `win32-x64`.
-On other platforms install from source (`cargo install supercode-cli`) or via
+On other platforms install from source
+(`cargo install --git https://github.com/volter-ai/supercode supercode-cli`) or via
 the [install script](https://github.com/volter-ai/supercode#install).
 
 Full docs, the SDK, and source: <https://github.com/volter-ai/supercode>.

package/bin/supercode.js

@@ -1,38 +1,59 @@
 #!/usr/bin/env node
-// Thin launcher for the `supercode` CLI. The actual binary ships in a
-// platform-specific optional dependency
-// (`@volter/supercode-cli-<os>-<cpu>`); npm
-// installs only the one matching the host. We resolve it and exec it,
-// forwarding argv, stdio (so the interactive REPL/TTY works), and the exit code.
+// The `supercode` front door. A command that has moved to TypeScript (lib/commands.mjs) is served here, in Node; every
+// other command goes to the native binary, which ships in a platform-specific optional dependency
+// (`@volter/supercode-cli-<os>-<cpu>`, npm installs only the one matching the host), with argv, stdio (so the
+// interactive REPL/TTY works) and the exit code forwarded as before (arc t_08d00e09, route step 2).
 "use strict";
 
 const { spawnSync } = require("child_process");
+const { pathToFileURL } = require("url");
+const path = require("path");
 
 const platform = process.platform; // darwin | linux | win32 | ...
 const arch = process.arch; // arm64 | x64 | ...
 const pkg = `@volter/supercode-cli-${platform}-${arch}`;
 const binName = platform === "win32" ? "supercode.exe" : "supercode";
 
-let binPath;
-try {
-  binPath = require.resolve(`${pkg}/bin/${binName}`);
-} catch {
-  console.error(
-    `supercode: no prebuilt binary for ${platform}-${arch}.\n` +
-      `Supported via npm: darwin-arm64, darwin-x64, linux-x64, linux-arm64, win32-x64.\n` +
-      `Otherwise install from source (cargo install supercode-cli) or via the\n` +
-      `install script: https://github.com/volter-ai/supercode#install`
-  );
-  process.exit(1);
+/** The native binary's path, or null when no platform package is installed. */
+function nativeBinary() {
+  try {
+    return require.resolve(`${pkg}/bin/${binName}`);
+  } catch {
+    return null;
+  }
 }
 
-const result = spawnSync(binPath, process.argv.slice(2), { stdio: "inherit" });
-if (result.error) {
-  console.error(result.error.message);
-  process.exit(1);
+function runNative(args) {
+  const binPath = nativeBinary();
+  if (!binPath) {
+    console.error(
+      `supercode: no prebuilt binary for ${platform}-${arch}.\n` +
+        `Supported via npm: darwin-arm64, darwin-x64, linux-x64, linux-arm64, win32-x64.\n` +
+        `Otherwise install from source (cargo install --git https://github.com/volter-ai/supercode supercode-cli)\n` +
+        `or via the install script: https://github.com/volter-ai/supercode#install`
+    );
+    process.exit(1);
+  }
+  const result = spawnSync(binPath, args, { stdio: "inherit" });
+  if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+  }
+  if (result.signal) process.exit(1);
+  process.exit(result.status === null ? 1 : result.status);
 }
-// Mirror signal-termination as the conventional 128+signo exit code.
-if (result.signal) {
-  process.exit(1);
+
+async function main() {
+  const args = process.argv.slice(2);
+  const { route } = await import(pathToFileURL(path.join(__dirname, "..", "lib", "commands.mjs")).href);
+  const served = route(args);
+  if (!served) return runNative(args);
+  const command = await import(pathToFileURL(path.join(__dirname, "..", "lib", served.module)).href);
+  const code = await command.run(served.rest, { native: { path: nativeBinary(), package: pkg, run: runNative } });
+  process.exit(typeof code === "number" ? code : 0);
 }
-process.exit(result.status === null ? 1 : result.status);
+
+main().catch((error) => {
+  console.error(`supercode: ${error && error.message ? error.message : error}`);
+  process.exit(1);
+});

package/lib/commands.mjs

@@ -0,0 +1,21 @@
+// The commands the front door serves in TypeScript (arc t_08d00e09). Each row is a command path, the leading words of
+// argv, and the module under lib/ that serves it; a module exports `run(rest, context) -> exit code`. Any argv whose
+// leading words match no row goes to the native binary untouched, so a command not listed here answers as before.
+// The longest matching path wins, so one verb of a command can move before its siblings (`message send` before
+// `message watch`). Global options before the command (`supercode --quiet message send`) are not parsed here: such a
+// line goes to the native binary, which still understands every command.
+export const COMMANDS = Object.freeze([
+  { path: ['front-door'], module: 'front-door.mjs', summary: 'What this front door serves in TypeScript, and which native binary serves the rest' },
+  { path: ['workflow'], module: 'workflow.mjs', summary: 'A board verb called on a board by its address (--at): the whole answer on the call; any other workflow line goes to the native binary' },
+]);
+
+/** The row serving `args` and the arguments after its path, or null for the native binary. */
+export function route(args) {
+  let best = null;
+  for (const row of COMMANDS) {
+    if (row.path.length > args.length) continue;
+    if (!row.path.every((word, index) => args[index] === word)) continue;
+    if (!best || row.path.length > best.path.length) best = row;
+  }
+  return best ? { ...best, rest: args.slice(best.path.length) } : null;
+}

package/lib/front-door.mjs

@@ -0,0 +1,27 @@
+// `supercode front-door [--json]`: the commands this launcher serves in TypeScript, and the native binary that serves
+// every other command (its package, path and version).
+import { readFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { COMMANDS } from './commands.mjs';
+
+export async function run(rest, { native }) {
+  const own = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'), 'utf8'));
+  const version = native.path ? spawnSync(native.path, ['--version'], { encoding: 'utf8', timeout: 5_000 }).stdout?.trim() || null : null;
+  const report = {
+    launcher: { package: own.name, version: own.version },
+    native: { package: native.package, path: native.path, version },
+    typescript: COMMANDS.map(({ path, summary }) => ({ command: path.join(' '), summary })),
+  };
+  if (rest.includes('--json')) {
+    process.stdout.write(JSON.stringify(report, null, 2) + '\n');
+    return 0;
+  }
+  process.stdout.write(`${report.launcher.package} ${report.launcher.version}\n`);
+  process.stdout.write(`native: ${native.path ? `${version ?? 'version unreadable'} (${native.path})` : `none installed (${native.package})`}\n`);
+  process.stdout.write('served in TypeScript:\n');
+  for (const row of report.typescript) process.stdout.write(`  supercode ${row.command}  ${row.summary}\n`);
+  process.stdout.write('every other command goes to the native binary.\n');
+  return 0;
+}

package/lib/workflow.mjs

@@ -0,0 +1,54 @@
+// `supercode workflow <verb> … --at sc:<machine>:board:<name>`: the verb called on that board, wherever the board is,
+// and its whole answer (exit code, stdout, stderr) on this same call (D152 row 2). It goes to this machine's daemon
+// through its board door, which names the calling session from this process itself (the kernel's peer, not anything
+// this command says) and reaches the board's machine through Teams; there the verb runs as that session, with the
+// board's own checks, the dispatcher running or not. Any other `workflow` line goes to the native binary.
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/** The Teams CLI: SUPERCODE_TEAMS_ENTRY, the Teams package installed beside this one, or this checkout's sdk/teams. */
+function teamsEntry() {
+  if (process.env.SUPERCODE_TEAMS_ENTRY && existsSync(process.env.SUPERCODE_TEAMS_ENTRY)) return process.env.SUPERCODE_TEAMS_ENTRY;
+  try { return createRequire(import.meta.url).resolve('@volter/supercode-teams/bin'); } catch { /* not installed beside */ }
+  const checkout = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'sdk', 'teams', 'bin', 'teams.mjs');
+  return existsSync(checkout) ? checkout : null;
+}
+
+export async function run(rest, { native }) {
+  const at = rest.findIndex((arg) => arg === '--at' || arg.startsWith('--at='));
+  if (at < 0) {
+    // The orchestrator the native binary runs hands the line to the one the home's record names (its board/cli.mjs
+    // handOff): the one place that is decided.
+    return native.run(['workflow', ...rest]);
+  }
+  const board = rest[at].startsWith('--at=') ? rest[at].slice('--at='.length) : rest[at + 1];
+  const argv = rest.filter((_, index) => index !== at && (rest[at].startsWith('--at=') || index !== at + 1));
+  if (!board || !/^sc:[^:\s]+:board:[^:\s]+$/.test(board)) {
+    process.stderr.write('Error: --at names the board\'s address (sc:<machine>:board:<name>)\n');
+    return 2;
+  }
+  const entry = teamsEntry();
+  if (!entry) {
+    process.stderr.write('Error: the Teams package is not installed, so no board can be called by its address\n');
+    return 1;
+  }
+  const child = spawn(process.execPath, [entry, 'board'], { stdio: ['pipe', 'pipe', 'inherit'] });
+  let out = '';
+  child.stdout.on('data', (chunk) => { out += chunk; });
+  child.stdin.end(JSON.stringify({ board, argv }));
+  const code = await new Promise((resolve) => { child.on('error', () => resolve(1)); child.on('close', resolve); });
+  let answer;
+  try { answer = JSON.parse(out.trim().split('\n').pop()); } catch { answer = null; }
+  if (!answer || typeof answer.code !== 'number') {
+    process.stderr.write(`Error: ${board} did not answer${out.trim() ? `: ${out.trim().slice(0, 500)}` : ` (exit ${code})`}\n`);
+    return 1;
+  }
+  // Returned only once written: the front door exits on return, and a pipe takes 64 KiB at a time.
+  const written = (out, text) => new Promise((resolve) => (text ? out.write(text, resolve) : resolve()));
+  await written(process.stdout, answer.stdout);
+  await written(process.stderr, answer.stderr);
+  return answer.code;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode",
-  "version": "0.5.150",
+  "version": "0.5.151",
   "description": "Volter Harness: a lightweight, customizable AI coding agent CLI — any model via OpenRouter; natively continues Claude Code and Codex sessions.",
   "repository": { "type": "git", "url": "git+https://github.com/volter-ai/supercode.git" },
   "homepage": "https://github.com/volter-ai/supercode#readme",
@@ -8,13 +8,13 @@
   "license": "MIT OR Apache-2.0",
   "keywords": ["ai", "agent", "llm", "coding", "cli", "openrouter", "claude", "codex"],
   "bin": { "supercode": "bin/supercode.js" },
-  "files": ["bin/"],
+  "files": ["bin/", "lib/"],
   "engines": { "node": ">=16" },
   "optionalDependencies": {
-    "@volter/supercode-cli-darwin-arm64": "0.5.150",
-    "@volter/supercode-cli-darwin-x64": "0.5.150",
-    "@volter/supercode-cli-linux-x64": "0.5.150",
-    "@volter/supercode-cli-linux-arm64": "0.5.150",
-    "@volter/supercode-cli-win32-x64": "0.5.150"
+    "@volter/supercode-cli-darwin-arm64": "0.5.151",
+    "@volter/supercode-cli-darwin-x64": "0.5.151",
+    "@volter/supercode-cli-linux-x64": "0.5.151",
+    "@volter/supercode-cli-linux-arm64": "0.5.151",
+    "@volter/supercode-cli-win32-x64": "0.5.151"
   }
 }