cortexterm 0.1.0 → 0.1.1

package/README.md

@@ -12,3 +12,16 @@ runs on its own: you can close the terminal (its start output goes to `~/.cortex
 running the command again while it runs only says so.
 
 Arguments go to the app: `npx cortexterm --headless`, `npx cortexterm --safe`.
+
+## A Mac nobody sits at: the runner
+
+```sh
+npx cortexterm runner
+npx cortexterm runner join <invitation>
+```
+
+`runner` keeps CortexTerm running on this Mac without a window, now and at every login (a LaunchAgent,
+`~/Library/LaunchAgents/com.cortexterm.runner.plist`; its output goes to `~/.cortexterm/logs/runner.log`).
+`runner join` joins it to your network with an invitation made in Settings > Mesh on another computer.
+The other computers then list it under COMPUTERS and open shells on it. `npx cortexterm runner off`
+stops it. On Linux, start it with `npx cortexterm --headless` for now.

package/bin/cortexterm.mjs

@@ -4,7 +4,9 @@
 // later runs start the installed app at once, without looking at the catalog: the app updates its
 // frame and plugins itself, so a newer app release is only for machines that have none. The app runs
 // on its own: closing the terminal does not quit it (its start output goes to ~/.cortexterm/logs/start.log).
-// Arguments go to the app (`--headless`, `--safe`).
+// Arguments go to the app (`--headless`, `--safe`). `npx cortexterm runner` keeps it running without a
+// window at every login (a LaunchAgent), for a Mac nobody sits at; `runner join <invitation>` joins
+// that Mac to the network, `runner off` stops it.
 
 import { spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
@@ -14,6 +16,7 @@ import https from 'node:https';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { pipeline } from 'node:stream/promises';
+import { fileURLToPath } from 'node:url';
 
 const REPO = process.env.CORTEXTERM_REPO || 'agentbusiness/CortexTerm';
 // CORTEXTERM_CATALOG: another catalog (a mirror, or a release under test).
@@ -152,17 +155,8 @@ function prune(keep) {
     .forEach((name) => rmSync(join(APPS, name), { recursive: true, force: true }));
 }
 
-async function main() {
-  const args = process.argv.slice(2);
-  if (args.includes('--help') || args.includes('-h')) {
-    process.stdout.write('npx cortexterm [--headless] [--safe]\n\nStarts CortexTerm; the first run downloads it into ~/.cortexterm/app.\n');
-    return 0;
-  }
-  const pid = running();
-  if (pid) {
-    say(`CortexTerm is already running (pid ${pid})`);
-    return 0;
-  }
+/** The installed app to start (downloaded first on a machine that has none), or null. */
+async function ensureApp() {
   const key = platform();
   // The installed app updates itself (frame and plugins): only a machine without one downloads.
   if (installed().length === 0) {
@@ -178,9 +172,154 @@ async function main() {
   const chosen = installed()[0];
   if (!chosen) {
     say('CortexTerm is not installed and could not be downloaded');
-    return 1;
+    return null;
   }
   prune(chosen);
+  return chosen;
+}
+
+// --- the runner: CortexTerm with no window, kept running on a Mac nobody sits at -------------------
+
+const LABEL = 'com.cortexterm.runner';
+const AGENT = join(homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
+const RUNNER = join(HOME, 'runner', 'cortexterm.mjs');
+
+const xml = (text) => String(text).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+
+/** A LaunchAgent that starts this launcher (a copy kept in the home: npx's own is temporary) in
+ * the foreground with `--headless` at every login, and again when the app ends with an error. */
+function agentPlist() {
+  const env = process.env.CORTEX_HOME ? `<key>EnvironmentVariables</key><dict><key>CORTEX_HOME</key><string>${xml(HOME)}</string></dict>` : '';
+  const log = xml(join(HOME, 'logs', 'runner.log'));
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+<key>Label</key><string>${LABEL}</string>
+<key>ProgramArguments</key><array><string>${xml(process.execPath)}</string><string>${xml(RUNNER)}</string><string>--headless</string><string>--foreground</string></array>
+<key>RunAtLoad</key><true/>
+<key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict>
+<key>StandardOutPath</key><string>${log}</string>
+<key>StandardErrorPath</key><string>${log}</string>
+${env}
+</dict></plist>
+`;
+}
+
+function launchctl(args) {
+  return new Promise((resolve) => {
+    const child = spawn('/bin/launchctl', args, { stdio: 'ignore' });
+    child.on('error', () => resolve(false));
+    child.on('exit', (code) => resolve(code === 0));
+  });
+}
+
+/** The frame's API token: in the Keychain on macOS, in `run/frame.json` elsewhere. */
+function frameToken(info) {
+  if (info.token) return Promise.resolve(info.token);
+  return new Promise((resolve, reject) => {
+    let out = '';
+    const child = spawn('/usr/bin/security', ['find-generic-password', '-s', 'CortexTerm frame token', '-a', HOME, '-w'], { stdio: ['ignore', 'pipe', 'ignore'] });
+    child.stdout.on('data', (chunk) => { out += chunk; });
+    child.on('error', reject);
+    child.on('exit', (code) => (code === 0 ? resolve(out.trim()) : reject(new Error('the frame token is not in the Keychain'))));
+  });
+}
+
+/** One call on the running frame (`POST /api/rpc`), as scripts make it. */
+async function frameCall(method, params) {
+  let info;
+  try {
+    info = JSON.parse(readFileSync(join(HOME, 'run', 'frame.json'), 'utf8'));
+    process.kill(info.pid, 0);
+  } catch {
+    throw new Error('CortexTerm is not running here: start it first (npx cortexterm runner)');
+  }
+  const token = await frameToken(info);
+  const response = await fetch(`http://127.0.0.1:${info.port}/api/rpc?token=${encodeURIComponent(token)}`, {
+    method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ method, params }),
+  });
+  const answer = await response.json();
+  if (!answer.ok) throw new Error(answer.error?.message ?? JSON.stringify(answer.error));
+  return answer.result;
+}
+
+async function runner(args) {
+  const [what, ...rest] = args;
+  if (what === 'join') {
+    const code = rest.join(' ').trim();
+    if (!code) {
+      say('npx cortexterm runner join <invitation>: the invitation from Settings > Mesh on a computer of your network');
+      return 1;
+    }
+    const member = await frameCall('mesh.pair.join', { code });
+    say(`joined the network as ${member.name}`);
+    return 0;
+  }
+  if (process.platform !== 'darwin') {
+    say('the runner is for Macs for now; elsewhere start CortexTerm with `npx cortexterm --headless`');
+    return 1;
+  }
+  const domain = `gui/${process.getuid()}`;
+  if (what === 'off') {
+    await launchctl(['bootout', `${domain}/${LABEL}`]);
+    rmSync(AGENT, { force: true });
+    say('the runner is off: CortexTerm no longer starts at login, and the runner\'s CortexTerm has stopped');
+    return 0;
+  }
+  if (what) {
+    say(`unknown runner command \`${what}\` (runner, runner join <invitation>, runner off)`);
+    return 1;
+  }
+  if (!(await ensureApp())) return 1;
+  mkdirSync(join(HOME, 'runner'), { recursive: true });
+  mkdirSync(join(HOME, 'logs'), { recursive: true });
+  mkdirSync(join(homedir(), 'Library', 'LaunchAgents'), { recursive: true });
+  writeFileSync(RUNNER, readFileSync(fileURLToPath(import.meta.url)));
+  writeFileSync(AGENT, agentPlist());
+  await launchctl(['bootout', `${domain}/${LABEL}`]);
+  if (!(await launchctl(['bootstrap', domain, AGENT]))) {
+    say(`cannot start the runner (launchctl bootstrap ${domain} ${AGENT} failed)`);
+    return 1;
+  }
+  const pid = running();
+  say(pid
+    ? `CortexTerm is already running here (pid ${pid}); the runner keeps it running without a window from the next login`
+    : 'the runner is on: CortexTerm runs here without a window, now and at every login');
+  say('to join your network: npx cortexterm runner join <invitation>');
+  return 0;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.includes('--help') || args.includes('-h')) {
+    process.stdout.write([
+      'npx cortexterm [--headless] [--safe]   start CortexTerm; the first run downloads it into ~/.cortexterm/app',
+      'npx cortexterm runner                  keep CortexTerm running here without a window, at every login (macOS)',
+      'npx cortexterm runner join <invitation>  join this computer to your network (the invitation from Settings > Mesh)',
+      'npx cortexterm runner off              stop the runner',
+      '',
+    ].join('\n'));
+    return 0;
+  }
+  if (args[0] === 'runner') return runner(args.slice(1));
+  const pid = running();
+  if (pid) {
+    say(`CortexTerm is already running (pid ${pid})`);
+    return 0;
+  }
+  const chosen = await ensureApp();
+  if (!chosen) return 1;
+  // The runner's LaunchAgent: the app in the foreground, so launchd sees it end.
+  if (args.includes('--foreground')) {
+    const child = spawn(executable(join(APPS, chosen)), args.filter((arg) => arg !== '--foreground'), { stdio: 'inherit' });
+    return await new Promise((resolve) => {
+      child.on('error', (error) => {
+        say(`cannot start CortexTerm: ${error.message}`);
+        resolve(1);
+      });
+      child.on('exit', (code) => resolve(code ?? 1));
+    });
+  }
   // Its own session, detached from this terminal: closing the terminal does not quit it.
   mkdirSync(join(HOME, 'logs'), { recursive: true });
   const log = openSync(START_LOG, 'a');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cortexterm",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "CortexTerm, an AI terminal with a local model: npx cortexterm downloads the app for this machine from the official releases and starts it.",
   "type": "module",
   "bin": {