@cordfuse/llmux 0.11.0 → 0.12.0

package/src/daemon/handlers.ts

@@ -0,0 +1,414 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+import qrcodeTerminal from 'qrcode-terminal';
+import { DEFAULT_AGENTS, isAgentInstalled, type AgentDefinition } from './agents.ts';
+import * as state from './state.ts';
+import * as tmux from './tmux.ts';
+import * as authStore from './auth-store.ts';
+import { startServer, printBanner } from './web/server.ts';
+import { getAddresses } from './net.ts';
+import type { ParsedArgs } from '../cli.ts';
+
+// ---------- helpers ----------
+
+function expandAgentList(spec: string): AgentDefinition[] {
+  if (spec === 'all') return Object.values(DEFAULT_AGENTS).filter(isAgentInstalled);
+  const keys = spec.split(',').map((k) => k.trim()).filter(Boolean);
+  const out: AgentDefinition[] = [];
+  for (const k of keys) {
+    const def = DEFAULT_AGENTS[k];
+    if (!def) throw new Error(`unknown agent "${k}". Known: ${Object.keys(DEFAULT_AGENTS).join(', ')}`);
+    if (!isAgentInstalled(def)) throw new Error(`agent "${k}" is not installed (looked for: ${def.cmd})`);
+    out.push(def);
+  }
+  return out;
+}
+
+function buildCommand(agent: AgentDefinition): string {
+  return agent.flags ? `${agent.cmd} ${agent.flags}` : agent.cmd;
+}
+
+function resolveCwd(input: string | undefined): string {
+  if (!input) return process.cwd();
+  const out = resolve(input);
+  if (!existsSync(out)) throw new Error(`cwd does not exist: ${out}`);
+  return out;
+}
+
+interface ResolvedTarget {
+  session: state.SessionState;
+}
+
+/** Resolve `<target>` to a single session; supports session-name OR agent-type-with-N=1. */
+export function resolveTarget(target: string): ResolvedTarget {
+  const direct = state.get(target);
+  if (direct) return { session: direct };
+
+  const byAgent = state.list().filter((s) => s.agent === target);
+  if (byAgent.length === 0) {
+    throw new Error(`no session matches "${target}" (not a session name; no agent of that type running)`);
+  }
+  if (byAgent.length > 1) {
+    const names = byAgent.map((s) => s.name).join(', ');
+    throw new Error(`"${target}" is ambiguous — ${byAgent.length} ${target} sessions: ${names}`);
+  }
+  return { session: byAgent[0]! };
+}
+
+// ---------- handlers ----------
+
+export function handleSpawn(args: ParsedArgs): void {
+  tmux.requireTmux();
+  const spec = args.positional[0];
+  if (!spec) throw new Error('spawn requires an agent (or `all`)');
+  const name = args.flags.name as string | undefined;
+  const prefix = args.flags.prefix as string | undefined;
+  const cwd = resolveCwd(args.flags.cwd as string | undefined);
+  if (name && prefix) throw new Error('--name and --prefix are mutually exclusive');
+
+  const agents = expandAgentList(spec);
+
+  if (name && agents.length > 1) {
+    throw new Error('--name is only valid with a single agent');
+  }
+
+  const parent = process.env.LLMUX_SESSION ?? null;
+  const created: string[] = [];
+
+  for (const agent of agents) {
+    const sessionName = name ?? (prefix ? `${prefix}${agent.key}` : agent.key);
+    if (state.get(sessionName) || tmux.hasSession(sessionName)) {
+      throw new Error(`session "${sessionName}" already exists`);
+    }
+    tmux.newSession({
+      name: sessionName,
+      command: buildCommand(agent),
+      cwd,
+      env: { LLMUX_SESSION: sessionName, LLMUX_AGENT: agent.key },
+    });
+    state.record({
+      name: sessionName,
+      agent: agent.key,
+      cwd,
+      createdAt: new Date().toISOString(),
+      parent,
+      restart: 'on-failure',
+    });
+    created.push(sessionName);
+    console.log(`spawned ${sessionName} (agent: ${agent.key}, cwd: ${cwd})`);
+  }
+
+  if (created.length === 0) {
+    console.log('no sessions spawned');
+  }
+}
+
+export function handleStatus(args: ParsedArgs): void {
+  // Reconcile state against tmux: anything tracked but missing in tmux is marked exited.
+  const tracked = state.list();
+  const live = new Set(tmux.listSessions().map((s) => s.name));
+
+  if (args.flags.json) {
+    const out = tracked.map((s) => ({
+      ...s,
+      state: live.has(s.name) ? 'running' : 'exited',
+    }));
+    console.log(JSON.stringify(out, null, 2));
+    return;
+  }
+
+  if (tracked.length === 0) {
+    console.log('no llmuxd sessions');
+    return;
+  }
+
+  const rows = tracked.map((s) => [
+    s.name,
+    s.agent,
+    live.has(s.name) ? 'running' : 'exited',
+    s.parent ?? '-',
+    s.cwd,
+  ]);
+  const headers = ['NAME', 'AGENT', 'STATE', 'PARENT', 'CWD'];
+  const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i]!.length)));
+  const fmt = (cols: string[]): string => cols.map((c, i) => c.padEnd(widths[i]!)).join('  ');
+  console.log(fmt(headers));
+  for (const r of rows) console.log(fmt(r));
+}
+
+export function handleSend(args: ParsedArgs): void {
+  tmux.requireTmux();
+  const [target, ...promptParts] = args.positional;
+  if (!target || promptParts.length === 0) {
+    throw new Error('send requires <session> and "<prompt>"');
+  }
+  const prompt = promptParts.join(' ');
+  const { session } = resolveTarget(target);
+  if (!tmux.hasSession(session.name)) {
+    throw new Error(`session "${session.name}" is in state but not live in tmux (exited?). Try \`llmuxd respawn ${session.name}\`.`);
+  }
+  tmux.sendKeys(session.name, prompt, { enter: true });
+  console.log(`sent ${prompt.length} bytes → ${session.name}`);
+}
+
+export function handleBroadcast(args: ParsedArgs): void {
+  tmux.requireTmux();
+  const [agentKey, ...promptParts] = args.positional;
+  if (!agentKey || promptParts.length === 0) {
+    throw new Error('broadcast requires <agent> and "<prompt>"');
+  }
+  if (!DEFAULT_AGENTS[agentKey]) {
+    throw new Error(`unknown agent "${agentKey}". Known: ${Object.keys(DEFAULT_AGENTS).join(', ')}`);
+  }
+  const prompt = promptParts.join(' ');
+  const sessions = state.list().filter((s) => s.agent === agentKey);
+  if (sessions.length === 0) {
+    console.log(`no ${agentKey} sessions running`);
+    return;
+  }
+  let n = 0;
+  for (const s of sessions) {
+    if (!tmux.hasSession(s.name)) continue;
+    tmux.sendKeys(s.name, prompt, { enter: true });
+    console.log(`sent → ${s.name}`);
+    n++;
+  }
+  console.log(`broadcast to ${n}/${sessions.length} ${agentKey} sessions`);
+}
+
+export function handleChat(args: ParsedArgs): void {
+  tmux.requireTmux();
+  const target = args.positional[0];
+  if (!target) throw new Error('chat requires <session>');
+  if (args.flags.browser) {
+    throw new Error('--browser requires `llmuxd serve` (Phase 4). Use `llmuxd chat` without --browser for now.');
+  }
+  const { session } = resolveTarget(target);
+  if (!tmux.hasSession(session.name)) {
+    throw new Error(`session "${session.name}" is not live in tmux`);
+  }
+  tmux.attachOrSwitch(session.name);
+}
+
+export async function handleServe(args: ParsedArgs): Promise<void> {
+  tmux.requireTmux();
+  const portRaw = (args.flags.port as string | undefined) ?? process.env.LLMUXD_PORT ?? '3000';
+  const port = Number(portRaw);
+  if (!Number.isFinite(port) || port <= 0 || port > 65535) {
+    throw new Error(`invalid port: ${portRaw}`);
+  }
+  const host = process.env.LLMUXD_HOST ?? '0.0.0.0';
+  const handle = startServer({ port, host });
+  printBanner(handle.port);
+
+  const shutdown = async (sig: string) => {
+    console.log(`\n${sig} received — shutting down`);
+    await handle.stop();
+    process.exit(0);
+  };
+  process.on('SIGINT', () => void shutdown('SIGINT'));
+  process.on('SIGTERM', () => void shutdown('SIGTERM'));
+
+  // Idle forever — the http server and ws server keep the event loop alive.
+  await new Promise<void>(() => {});
+}
+
+function endpointPort(): number {
+  // Default daemon port — matches the `serve` command default in commands.ts.
+  // QR builders run from a separate `token create` invocation that doesn't
+  // know which port the daemon is bound to, so we resolve from the running
+  // daemon if reachable, else fall back to 3030 (the documented default).
+  return Number(process.env.LLMUX_PORT) || 3030;
+}
+
+function selectorOf(label: string): string {
+  return label.toLowerCase().replace(/\s+/g, '-');
+}
+
+function resolveQrEndpoint(selector: string, port: number): { label: string; url: string } {
+  const addrs = getAddresses(port);
+  const wanted = selector.toLowerCase().trim();
+  const matches = addrs.filter((a) => selectorOf(a.label) === wanted);
+  if (matches.length === 0) {
+    const available = Array.from(new Set(addrs.map((a) => selectorOf(a.label)))).join(', ');
+    throw new Error(`unknown --qr-endpoint "${selector}". Available: ${available}`);
+  }
+  if (matches.length > 1) {
+    throw new Error(
+      `--qr-endpoint "${selector}" is ambiguous (${matches.length} matches). Use \`llmuxd token create --qr\` without an endpoint to pick interactively.`,
+    );
+  }
+  return matches[0]!;
+}
+
+async function pickEndpointInteractively(port: number): Promise<{ label: string; url: string }> {
+  const addrs = getAddresses(port);
+  if (addrs.length === 0) throw new Error('no reachable endpoints found');
+  console.log('');
+  console.log('Pick an endpoint for the QR code:');
+  for (let i = 0; i < addrs.length; i++) {
+    console.log(`  ${i + 1}) ${addrs[i]!.label.padEnd(18)} ${addrs[i]!.url}`);
+  }
+  if (!process.stdin.isTTY) {
+    throw new Error('--qr without --qr-endpoint requires an interactive terminal');
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise<string>((resolve) => rl.question('  > ', (a) => resolve(a)));
+  rl.close();
+  const idx = Number(answer.trim()) - 1;
+  if (!Number.isInteger(idx) || idx < 0 || idx >= addrs.length) {
+    throw new Error(`invalid selection "${answer}"`);
+  }
+  return addrs[idx]!;
+}
+
+function printQr(url: string, token: string, label: string): void {
+  const deepLink = `${url.replace(/\/$/, '')}/?token=${encodeURIComponent(token)}`;
+  console.log('');
+  console.log(`QR for ${label}:`);
+  console.log('');
+  qrcodeTerminal.generate(deepLink, { small: true });
+  console.log(`  ${deepLink}`);
+}
+
+export async function handleTokenCreate(args: ParsedArgs): Promise<void> {
+  const name = args.flags.name as string | undefined;
+  const expiry = args.flags.expiry as string | undefined;
+  const qrFlag = Boolean(args.flags.qr);
+  const qrEndpoint = args.flags['qr-endpoint'] as string | undefined;
+  if (expiry && isNaN(new Date(expiry).getTime())) {
+    throw new Error(`--expiry must be an ISO-8601 timestamp (got "${expiry}")`);
+  }
+  const wantsQr = qrFlag || qrEndpoint !== undefined;
+
+  // Resolve the QR endpoint BEFORE creating the token so a bad selector
+  // doesn't leave an orphan token in auth.json.
+  let endpoint: { label: string; url: string } | undefined;
+  if (wantsQr) {
+    const port = endpointPort();
+    endpoint = qrEndpoint
+      ? resolveQrEndpoint(qrEndpoint, port)
+      : await pickEndpointInteractively(port);
+  }
+
+  const wasEnabled = authStore.authEnabled();
+  const rec = authStore.createAuthToken({
+    ...(name !== undefined ? { name } : {}),
+    ...(expiry !== undefined ? { expiresAt: expiry } : {}),
+  });
+  console.log(`token created (id: ${rec.id})${rec.name ? ` "${rec.name}"` : ''}`);
+  console.log('');
+  console.log(`  ${rec.token}`);
+  console.log('');
+  console.log('Save this token now — it is shown once. Use in the LLMUX_TOKEN env var, the');
+  console.log('`Authorization: Bearer <token>` header, or paste it into the web gate page.');
+  if (!wasEnabled) {
+    console.log('');
+    console.log('Auth is now enabled. All non-localhost requests require this (or another) token.');
+  }
+  if (endpoint) {
+    printQr(endpoint.url, rec.token, endpoint.label);
+  }
+}
+
+export function handleTokenShow(args: ParsedArgs): void {
+  const tokens = authStore.listAuthTokens();
+  if (args.flags.json) {
+    const out = tokens.map((t) => ({ id: t.id, name: t.name, createdAt: t.createdAt, expiresAt: t.expiresAt }));
+    console.log(JSON.stringify(out, null, 2));
+    return;
+  }
+  if (tokens.length === 0) {
+    console.log('no tokens — auth is disabled. Create one with `llmuxd token create`.');
+    return;
+  }
+  const headers = ['ID', 'NAME', 'CREATED', 'EXPIRES'];
+  const rows = tokens.map((t) => [t.id, t.name ?? '-', t.createdAt, t.expiresAt ?? '-']);
+  const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i]!.length)));
+  console.log(headers.map((h, i) => h.padEnd(widths[i]!)).join('  '));
+  for (const r of rows) console.log(r.map((c, i) => c.padEnd(widths[i]!)).join('  '));
+}
+
+export function handleTokenRevoke(args: ParsedArgs): void {
+  // Accept the id at positional[0] (new flat dispatcher) OR positional[1] (legacy
+  // `llmuxd token revoke <id>` form where positional[0] was "revoke").
+  const idPrefix = args.positional[0] === 'revoke' ? args.positional[1] : args.positional[0];
+  if (!idPrefix) throw new Error('token revoke requires an <id> (the 8-char prefix shown by `token show`)');
+  const ok = authStore.revokeAuthToken(idPrefix);
+  if (!ok) throw new Error(`no token with id "${idPrefix}"`);
+  console.log(`revoked ${idPrefix}`);
+  if (!authStore.authEnabled()) {
+    console.log('No tokens remain — auth is now disabled.');
+  }
+}
+
+export function handleRespawn(args: ParsedArgs): void {
+  tmux.requireTmux();
+  const target = args.positional[0];
+  if (!target) throw new Error('respawn requires <session>');
+
+  const session = state.get(target);
+  if (!session) throw new Error(`no tracked session "${target}"`);
+
+  const agent = DEFAULT_AGENTS[session.agent];
+  if (!agent) throw new Error(`unknown agent "${session.agent}" — cannot respawn`);
+  if (!isAgentInstalled(agent)) {
+    throw new Error(`agent "${session.agent}" is not installed (looked for: ${agent.cmd})`);
+  }
+
+  // If the session is still running, kill it first so respawn = restart
+  // with the persisted config (parity with the web API's respawnSession).
+  if (tmux.hasSession(target)) {
+    tmux.killSession(target);
+  }
+
+  tmux.newSession({
+    name: session.name,
+    command: buildCommand(agent),
+    cwd: session.cwd,
+    env: { LLMUX_SESSION: session.name, LLMUX_AGENT: session.agent },
+  });
+  state.record({ ...session, createdAt: new Date().toISOString() });
+  console.log(`respawned ${target} (agent: ${session.agent}, cwd: ${session.cwd})`);
+}
+
+export function handleKill(args: ParsedArgs): void {
+  tmux.requireTmux();
+  const target = args.positional[0];
+  if (!target) throw new Error('kill requires <session> or `all`');
+  const cascade = Boolean(args.flags.cascade);
+
+  if (target === 'all') {
+    const all = state.list();
+    for (const s of all) {
+      tmux.killSession(s.name);
+      state.forget(s.name);
+      console.log(`killed ${s.name}`);
+    }
+    if (all.length === 0) console.log('no sessions to kill');
+    return;
+  }
+
+  const session = state.get(target);
+  if (!session) throw new Error(`no tracked session "${target}"`);
+
+  if (cascade) {
+    const queue: string[] = [target];
+    const killed = new Set<string>();
+    while (queue.length) {
+      const name = queue.shift()!;
+      if (killed.has(name)) continue;
+      for (const child of state.children(name)) queue.push(child.name);
+      tmux.killSession(name);
+      state.forget(name);
+      killed.add(name);
+      console.log(`killed ${name}`);
+    }
+    return;
+  }
+
+  tmux.killSession(target);
+  state.forget(target);
+  console.log(`killed ${target}`);
+}

package/src/daemon/net.ts

@@ -0,0 +1,113 @@
+import { networkInterfaces } from 'node:os';
+import { execSync } from 'node:child_process';
+
+export interface ReachableAddress {
+  label: string;
+  url: string;
+}
+
+const TAILSCALE_CGNAT = /^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\./;
+
+interface TailscaleServeConfig {
+  TCP?: Record<string, { HTTPS?: boolean; HTTP?: boolean }>;
+  Web?: Record<string, { Handlers?: Record<string, { Proxy?: string }> }>;
+}
+
+interface ServeMatch {
+  hostname: string;
+  hasHttp: boolean;
+  hasHttps: boolean;
+  httpPort?: string;
+  httpsPort?: string;
+}
+
+/**
+ * Returns the tailnet hostname + which schemes have a `tailscale serve` config
+ * that proxies to our local port. Empty when tailscale isn't installed or no
+ * serve config matches.
+ */
+function detectTailscaleServe(port: number): ServeMatch | undefined {
+  try {
+    const raw = execSync('tailscale serve status --json', {
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 1500,
+    })
+      .toString()
+      .trim();
+    if (!raw) return undefined;
+    const config: TailscaleServeConfig = JSON.parse(raw);
+    const targets = [`http://127.0.0.1:${port}`, `http://localhost:${port}`];
+    let hostname: string | undefined;
+    let hasHttp = false;
+    let hasHttps = false;
+    let httpPort: string | undefined;
+    let httpsPort: string | undefined;
+    for (const [hostPort, web] of Object.entries(config.Web ?? {})) {
+      for (const handler of Object.values(web.Handlers ?? {})) {
+        if (!handler.Proxy || !targets.includes(handler.Proxy)) continue;
+        const [host, p] = hostPort.split(':');
+        if (!host || !p) continue;
+        hostname = host;
+        const tcp = (config.TCP ?? {})[p];
+        if (tcp?.HTTPS) {
+          hasHttps = true;
+          httpsPort = p;
+        } else if (tcp?.HTTP) {
+          hasHttp = true;
+          httpPort = p;
+        }
+      }
+    }
+    if (!hostname) return undefined;
+    return { hostname, hasHttp, hasHttps, ...(httpPort ? { httpPort } : {}), ...(httpsPort ? { httpsPort } : {}) };
+  } catch {
+    return undefined;
+  }
+}
+
+function findTailscaleIp(): string | undefined {
+  for (const ifaces of Object.values(networkInterfaces())) {
+    for (const iface of ifaces ?? []) {
+      if (iface.family !== 'IPv4' || iface.internal) continue;
+      if (TAILSCALE_CGNAT.test(iface.address)) return iface.address;
+    }
+  }
+  return undefined;
+}
+
+/** Build the address list shown on `llmuxd serve` startup. */
+export function getAddresses(port: number): ReachableAddress[] {
+  const out: ReachableAddress[] = [];
+  const serve = detectTailscaleServe(port);
+  const tailscaleIp = findTailscaleIp();
+
+  // Tailscale HTTPS — only exists if `tailscale serve --https` is configured.
+  if (serve?.hasHttps) {
+    const portSuffix = serve.httpsPort && serve.httpsPort !== '443' ? `:${serve.httpsPort}` : '';
+    out.push({ label: 'Tailscale HTTPS', url: `https://${serve.hostname}${portSuffix}` });
+  }
+
+  // Tailscale HTTP — one entry whenever tailscale is up. Prefer the friendlier
+  // hostname-via-serve form when `tailscale serve --http` is configured; fall
+  // back to the direct IP+port form. Same conceptual slot either way.
+  if (serve?.hasHttp) {
+    const portSuffix = serve.httpPort && serve.httpPort !== '80' ? `:${serve.httpPort}` : '';
+    out.push({ label: 'Tailscale HTTP', url: `http://${serve.hostname}${portSuffix}` });
+  } else if (tailscaleIp) {
+    out.push({ label: 'Tailscale HTTP', url: `http://${tailscaleIp}:${port}` });
+  }
+
+  // Local
+  out.push({ label: 'Local', url: `http://localhost:${port}` });
+
+  // LAN — every non-internal, non-tailnet IPv4 interface
+  for (const ifaces of Object.values(networkInterfaces())) {
+    for (const iface of ifaces ?? []) {
+      if (iface.family !== 'IPv4' || iface.internal) continue;
+      if (TAILSCALE_CGNAT.test(iface.address)) continue;
+      out.push({ label: 'LAN', url: `http://${iface.address}:${port}` });
+    }
+  }
+
+  return out;
+}

package/src/daemon/state.ts

@@ -0,0 +1,78 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+export interface SessionState {
+  name: string;
+  agent: string;
+  cwd: string;
+  /** Override of the agent definition's default flags. undefined = use default. */
+  flags?: string;
+  /** Per-session environment variable overrides (merged over agent envDefaults). */
+  env?: Record<string, string>;
+  /** ID of the agent's prior conversation this session resumed from (if any). */
+  resumeFrom?: string;
+  createdAt: string;
+  parent: string | null;
+  restart: 'always' | 'on-failure' | 'never';
+}
+
+export interface State {
+  version: 1;
+  sessions: Record<string, SessionState>;
+}
+
+const EMPTY: State = { version: 1, sessions: {} };
+
+export function stateDir(): string {
+  const xdg = process.env.XDG_STATE_HOME;
+  return xdg ? join(xdg, 'llmuxd') : join(homedir(), '.local', 'state', 'llmuxd');
+}
+
+export function statePath(): string {
+  return join(stateDir(), 'sessions.json');
+}
+
+export function load(): State {
+  const path = statePath();
+  if (!existsSync(path)) return structuredClone(EMPTY);
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8')) as Partial<State>;
+    if (parsed.version !== 1 || typeof parsed.sessions !== 'object' || parsed.sessions === null) {
+      return structuredClone(EMPTY);
+    }
+    return { version: 1, sessions: parsed.sessions as Record<string, SessionState> };
+  } catch {
+    return structuredClone(EMPTY);
+  }
+}
+
+export function save(state: State): void {
+  const path = statePath();
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(state, null, 2) + '\n', { mode: 0o600 });
+}
+
+export function record(session: SessionState): void {
+  const state = load();
+  state.sessions[session.name] = session;
+  save(state);
+}
+
+export function forget(name: string): void {
+  const state = load();
+  delete state.sessions[name];
+  save(state);
+}
+
+export function get(name: string): SessionState | undefined {
+  return load().sessions[name];
+}
+
+export function list(): SessionState[] {
+  return Object.values(load().sessions);
+}
+
+export function children(parent: string): SessionState[] {
+  return list().filter((s) => s.parent === parent);
+}