conductor-remote 1.116.0 → 1.118.0

package/dist-node/scripts/service/network.js

@@ -0,0 +1,244 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { exposeStorePath, FUNNEL_PORTS, freeServePort, magicDnsName, normalizeExposeMode, parseServeStatus, relayServeState, serveUrl, tailscaleBin, writeUrlHost } from "../../src/host/tailscale.js";
+import { RELAY_PORT } from "./environment.js";
+import { sleepSync } from "./launch-agent.js";
+/**
+ * Resolve the expose mode. Precedence: `EXPOSE` env (public|funnel / tailnet|serve|private) > persisted
+ * choice > 'public' default. An explicit env value is persisted so re-deploys don't silently flip posture.
+ * (The read-only counterpart used by the runtime watchdog is readExposeMode() in src/host/tailscale.ts.)
+ */
+export function resolveExposeMode() {
+    const fromEnv = normalizeExposeMode(process.env.EXPOSE);
+    if (fromEnv) {
+        try {
+            const file = exposeStorePath();
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            fs.writeFileSync(file, fromEnv);
+        }
+        catch {
+            // persistence is a convenience; ignore failures
+        }
+        return fromEnv;
+    }
+    if (process.env.EXPOSE)
+        console.info(`  ⚠ unrecognized EXPOSE=${process.env.EXPOSE} — expected public|tailnet.`);
+    try {
+        const saved = normalizeExposeMode(fs.readFileSync(exposeStorePath(), 'utf8'));
+        if (saved)
+            return saved;
+    }
+    catch {
+        // no saved choice yet
+    }
+    return 'public';
+}
+/**
+ * Live serve/funnel state for this node as it concerns the relay: the HTTPS port fronting it (any port, not
+ * only :443), whether that port is public, and which ports carry mounts that are not the relay's. A status
+ * that cannot be read counts as nothing fronting — the same answer the old reader gave, and one that only
+ * ever leads to a mount on a port nobody holds.
+ */
+export function tailscaleState(bin, port = RELAY_PORT) {
+    try {
+        const out = execFileSync(bin, ['serve', 'status', '--json'], { encoding: 'utf8', stdio: 'pipe' });
+        return relayServeState(parseServeStatus(out), port);
+    }
+    catch {
+        return relayServeState({}, port);
+    }
+}
+export function rawTailscaleStatus(bin) {
+    try {
+        return parseServeStatus(execFileSync(bin, ['serve', 'status', '--json'], { encoding: 'utf8', stdio: 'pipe' }));
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * The one Tailscale write here: `tailscale <serve|funnel> --bg --https=<port> <relay port>`. Always scoped
+ * to a port the relay owns outright or nobody holds — the callers check, this does not. Serving a port
+ * Funnel currently exposes drops that port's Funnel flag and touches no other port, which is what made
+ * the old `funnel reset` (every mount on the node, gone) unnecessary. Returns the CLI's error, or null.
+ */
+export function mountRelay(bin, kind, port) {
+    try {
+        execFileSync(bin, [kind, '--bg', '--yes', `--https=${port}`, RELAY_PORT], { stdio: 'pipe' });
+        return null;
+    }
+    catch (err) {
+        return err instanceof Error ? err.message.trim() : String(err);
+    }
+}
+function byHand(kind, port) {
+    return `tailscale ${kind} --bg --yes --https=${port} ${RELAY_PORT}`;
+}
+function describeTaken(state, port) {
+    return (state.taken.get(port) ?? []).join(', ');
+}
+/** A port the relay shares is left exactly as found: Funnel is per port, so a change would drag the rest along. */
+function leaveShared(url, state, want) {
+    console.info(`\n  ⚠ ${url} fronts the relay, but :${state.port} also carries ${state.shared.join(', ')}.`);
+    console.info(`    Funnel is per port, so making the relay ${want} would take those mounts along. Left as is.`);
+    console.info(`    To change it, move the relay to a port of its own:  ${byHand(want === 'public' ? 'funnel' : 'serve', '<port>')}`);
+}
+function refuseNoPort(state, candidates) {
+    const held = candidates.map(p => `:${p} → ${describeTaken(state, p)}`).join('; ');
+    console.info(`\n  ⚠ every port the relay could take already carries another service (${held}). Not touching them.`);
+    console.info(`    Free one, then run \`yarn deploy\` again — or mount by hand:  ${byHand('serve', '<port>')}`);
+}
+/**
+ * Assert a tailnet-only `serve` proxy in front of the relay — tailnet mode, and the fallback when Funnel is
+ * refused. Non-destructive by construction: a mapping is kept wherever it already lives (:443 or not), a
+ * shared port is reported rather than rewritten, and a fresh mount steps around any port someone else holds.
+ * The order of candidates is 443 (the default, unchanged), then the relay's own port number — the memorable
+ * choice, and it leaves 8443/10000 for services that need Funnel — then the remaining Funnel ports.
+ */
+function ensureServeOnly(bin, dns, state) {
+    const host = dns ?? '<node>';
+    if (state.port !== null) {
+        const url = serveUrl(host, state.port);
+        if (!state.funnelOn) {
+            console.info(`✓ tailscale serve fronts ${url} → 127.0.0.1:${RELAY_PORT} (tailnet-only)`);
+            return;
+        }
+        if (state.shared.length) {
+            leaveShared(url, state, 'tailnet-only');
+            return;
+        }
+        const failed = mountRelay(bin, 'serve', state.port);
+        if (failed) {
+            console.info(`\n  ⚠ could not take Funnel off ${url} (${failed}). Run by hand:\n      ${byHand('serve', state.port)}`);
+            return;
+        }
+        console.info(`✓ tailscale serve → ${url} is tailnet-only again → 127.0.0.1:${RELAY_PORT}`);
+        return;
+    }
+    const candidates = [443, Number(RELAY_PORT), ...FUNNEL_PORTS.filter(p => p !== 443)];
+    const port = freeServePort(state, candidates);
+    if (port === null) {
+        refuseNoPort(state, candidates);
+        return;
+    }
+    if (port !== 443)
+        console.info(`  :443 carries ${describeTaken(state, 443)}, so the relay goes on :${port} instead.`);
+    const url = serveUrl(host, port);
+    const failed = mountRelay(bin, 'serve', port);
+    if (failed) {
+        console.info(`\n  ⚠ could not configure tailscale serve (${failed}). Run by hand:\n      ${byHand('serve', port)}`);
+        return;
+    }
+    console.info(`✓ tailscale serve → ${url} proxies 127.0.0.1:${RELAY_PORT} (tailnet-only)`);
+}
+/**
+ * Persist a stable Tailscale device name so this node's MagicDNS URL — the origin the installed PWA is
+ * bolted to — can't drift out from under it. Tailscale otherwise *derives* the name from the Mac's
+ * LocalHostName, which a macOS update or a network/settings reset can silently clear; the name then moves
+ * (e.g. `mac` → `macbook-pro`), the URL changes, and every home-screen PWA pinned to the old origin dies
+ * with an unexplained "failed to fetch". We pin `--hostname`/`RELAY_HOSTNAME` when given (also the way to
+ * *rename* — `--hostname mac` restores a drifted node), else re-pin whatever name the node already has: a
+ * no-op on today's URL, but it turns an auto-derived name into an explicit one Tailscale won't re-derive.
+ * Best-effort — a failure just leaves the name auto-derived, exactly as before this ran.
+ */
+function pinHostname(bin) {
+    const label = (dns) => (dns ?? '').split('.')[0];
+    const current = label(magicDnsName(bin));
+    const desired = (process.env.RELAY_HOSTNAME ?? '').trim() || current;
+    if (!desired)
+        return; // node name unknown and none requested — nothing to pin
+    try {
+        execFileSync(bin, ['set', `--hostname=${desired}`], { stdio: 'pipe' });
+    }
+    catch (err) {
+        console.info(`  ⚠ could not pin tailscale hostname to "${desired}" (${err instanceof Error ? err.message.trim() : err}) — name stays auto-derived.`);
+        return;
+    }
+    if (desired === current) {
+        console.info(`✓ tailscale device name pinned to "${desired}" (won't drift on an OS hostname change)`);
+        return;
+    }
+    // A rename: wait briefly for MagicDNS to reflect it, so the URL and Funnel cert below use the new name.
+    for (let i = 0; i < 12 && label(magicDnsName(bin)) !== desired; i++)
+        sleepSync(500);
+    const actual = label(magicDnsName(bin));
+    if (actual === desired)
+        console.info(`✓ tailscale device renamed "${current || '<derived>'}" → "${desired}" and pinned`);
+    else
+        console.info(`  ⚠ requested hostname "${desired}" but the tailnet assigned "${actual}" (name likely already taken) — your URL is https://${actual}.…`);
+}
+/**
+ * Front the loopback relay with a stable HTTPS URL, either publicly (`tailscale funnel`, the default) or
+ * tailnet-only (`tailscale serve`), per resolveExposeMode(). Idempotent — flips Funnel off when switching
+ * back to tailnet — and non-fatal: the relay binds loopback regardless, so a failure here just means the
+ * phone URL isn't wired yet and we print how to do it by hand. Real TLS also satisfies the PWA's
+ * secure-context requirement (a service worker won't register over plain http on a 100.x IP).
+ *
+ * PUBLIC IS INTERNET-FACING: the 128-bit token on every /api/* request is the only gate. Funnel must be
+ * enabled for the tailnet (Admin console) or the funnel command fails — we then fall back to tailnet-only.
+ */
+export function ensureTailscale() {
+    const bin = tailscaleBin();
+    if (!bin) {
+        console.info('\n  ⚠ tailscale CLI not found — skipped URL setup. Once Tailscale is installed, run:');
+        console.info(`      tailscale funnel --bg ${RELAY_PORT}   # public, or \`serve\` for tailnet-only`);
+        return;
+    }
+    pinHostname(bin);
+    const dns = magicDnsName(bin);
+    if (dns)
+        writeUrlHost(dns); // baseline for drift detection (server startup + `service status` compare against this)
+    const host = dns ?? '<node>';
+    const mode = resolveExposeMode();
+    const state = tailscaleState(bin);
+    if (mode === 'tailnet') {
+        ensureServeOnly(bin, dns, state);
+        return;
+    }
+    // public (Funnel)
+    if (state.port !== null) {
+        const url = serveUrl(host, state.port);
+        if (state.funnelOn) {
+            console.info(`✓ tailscale funnel already exposes ${url} → 127.0.0.1:${RELAY_PORT} (public, token-gated)`);
+            return;
+        }
+        if (state.shared.length) {
+            leaveShared(url, state, 'public');
+            return;
+        }
+        if (!FUNNEL_PORTS.includes(state.port)) {
+            console.info(`\n  ⚠ the relay is fronted tailnet-only at ${url}, and Funnel cannot listen on :${state.port}`);
+            console.info(`    (only ${FUNNEL_PORTS.join(', ')}). Left as is — \`conductor-remote config\` will show the mismatch.`);
+            console.info(`    To go public, move it to a Funnel port by hand:  ${byHand('funnel', '<443|8443|10000>')}`);
+            return;
+        }
+        const failed = mountRelay(bin, 'funnel', state.port);
+        if (failed) {
+            funnelRefused(failed);
+            ensureServeOnly(bin, dns, state);
+            return;
+        }
+        console.info(`✓ tailscale funnel → ${url} now public over the internet (token-gated) → 127.0.0.1:${RELAY_PORT}`);
+        return;
+    }
+    const port = freeServePort(state, FUNNEL_PORTS);
+    if (port === null) {
+        refuseNoPort(state, FUNNEL_PORTS);
+        return;
+    }
+    if (port !== 443)
+        console.info(`  :443 carries ${describeTaken(state, 443)}, so the relay goes on :${port} instead.`);
+    const failed = mountRelay(bin, 'funnel', port);
+    if (failed) {
+        funnelRefused(failed);
+        ensureServeOnly(bin, dns, state);
+        return;
+    }
+    console.info(`✓ tailscale funnel → ${serveUrl(host, port)} now public over the internet (token-gated) → 127.0.0.1:${RELAY_PORT}`);
+}
+function funnelRefused(error) {
+    console.info(`\n  ⚠ could not enable Funnel (${error}).`);
+    console.info('    Funnel must be enabled for this tailnet: open the URL Tailscale printed above, or add the');
+    console.info('    "funnel" nodeAttr in Admin console ▸ Access controls. Falling back to tailnet-only for now.');
+}

package/dist-node/scripts/service/presentation.js

@@ -0,0 +1,101 @@
+import { execFileSync, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { driftWarningLines, magicDnsName, relayServeState, serveUrl, tailscaleBin } from "../../src/host/tailscale.js";
+import { readVoiceConfig } from "../../src/voice/config.js";
+import { inspectVoiceFunnel, readVoiceFunnelReceipt } from "../../src/voice/funnel.js";
+import { qrLines } from "../qr.js";
+import { currentToken, domain, LABEL, logDir, plistPath, RELAY_PORT, readPlistEnv } from "./environment.js";
+import { rawTailscaleStatus, tailscaleState } from "./network.js";
+/** Print a scannable QR of `url` (theme-independent black-on-white). Never fatal — QR is a convenience. */
+function printQr(url) {
+    try {
+        console.info(`\n${qrLines(url).join('\n')}`);
+    }
+    catch (err) {
+        console.info(`  (QR skipped: ${err instanceof Error ? err.message : err})`);
+    }
+}
+export function printUrl(loopbackPort = RELAY_PORT) {
+    const token = currentToken();
+    const frag = `#token=${token ?? '<starts on first run>'}`;
+    const bin = tailscaleBin();
+    if (bin) {
+        const drift = driftWarningLines(bin);
+        if (drift.length)
+            console.info(`\n${drift.join('\n')}`);
+    }
+    const dns = bin ? magicDnsName(bin) : null;
+    const state = bin ? tailscaleState(bin, loopbackPort) : relayServeState({}, loopbackPort);
+    if (dns && state.port !== null) {
+        const scope = state.funnelOn ? 'public — any browser, token-gated' : 'same Tailnet only';
+        const url = `${serveUrl(dns, state.port)}${frag}`;
+        console.info(`\n  Phone URL (HTTPS, ${scope}):\n    ${url}`);
+        if (token) {
+            console.info('\n  Scan to open on your phone:');
+            printQr(url);
+        }
+        return;
+    }
+    // Nothing fronting yet — the relay is only on loopback.
+    console.info(`\n  Local URL:\n    http://127.0.0.1:${loopbackPort}/${frag}`);
+    console.info(`\n  ⚠ Not reachable from your phone yet. Run \`yarn deploy\` (it picks a free port), or by hand \`tailscale funnel --bg ${loopbackPort}\` (public) / \`tailscale serve --bg ${loopbackPort}\` (tailnet)${dns ? ` → https://${dns}/` : ''}, then \`yarn service status\`.`);
+}
+/** Report the public voice path independently of the relay's tailnet-only phone URL. */
+export function printVoiceRoute(loopbackPort, listenerPort) {
+    const voice = readVoiceConfig();
+    if (!voice.publicBaseUrl) {
+        console.info('voice:     disabled (set voice.public-url to enable)');
+        return;
+    }
+    const bin = tailscaleBin();
+    if (!bin) {
+        console.info(`voice:     configured at ${voice.publicBaseUrl}, but Tailscale is unavailable`);
+        return;
+    }
+    const inspected = inspectVoiceFunnel(rawTailscaleStatus(bin), listenerPort, loopbackPort, readVoiceFunnelReceipt());
+    if (inspected.owned && inspected.targetMatches && inspected.funnelOn && !inspected.relayAtRoot) {
+        console.info(`voice:     ${voice.publicBaseUrl} (public) → 127.0.0.1:${listenerPort}`);
+        return;
+    }
+    console.info(`voice:     ${voice.publicBaseUrl} configured, but its isolated Funnel mount is not live`);
+}
+export function status() {
+    const installed = fs.existsSync(plistPath);
+    console.info(`plist:     ${installed ? plistPath : '(not installed)'}`);
+    if (!installed)
+        return;
+    try {
+        const out = execFileSync('launchctl', ['print', `${domain}/${LABEL}`], { encoding: 'utf8', stdio: 'pipe' });
+        const state = out.match(/state = (\S+)/)?.[1] ?? 'unknown';
+        const pid = out.match(/pid = (\d+)/)?.[1] ?? '—';
+        console.info(`state:     ${state}  (pid ${pid})`);
+    }
+    catch {
+        console.info('state:     loaded but not running (check logs)');
+    }
+    const env = readPlistEnv();
+    const relayPort = env.RELAY_PORT ?? '8787';
+    printUrl(relayPort);
+    printVoiceRoute(relayPort, env.VOICE_PORT ?? '8788');
+}
+/**
+ * Stream the LaunchAgent's stdout+stderr logs (the same files the plist points at). Follows both by default
+ * — `--no-follow` for a one-shot tail, `-n N` for depth. Pure `tail` passthrough so Ctrl-C just detaches.
+ */
+export function logs() {
+    const files = ['relay.log', 'relay.err.log'].map(f => path.join(logDir, f)).filter(f => fs.existsSync(f));
+    if (files.length === 0) {
+        console.info(`no logs yet in ${logDir}/ — the relay writes there once the LaunchAgent is running (\`conductor-remote service install\`).`);
+        return;
+    }
+    const argv = process.argv.slice(3);
+    const follow = !argv.includes('--no-follow');
+    const nAt = argv.indexOf('-n');
+    const count = nAt !== -1 && argv[nAt + 1] ? argv[nAt + 1] : '200';
+    const args = ['-n', count, ...(follow ? ['-F'] : []), ...files];
+    const res = spawnSync('tail', args, { stdio: 'inherit' });
+    // tail exits 0 normally; Ctrl-C kills it via SIGINT (null status). Only surface a genuine non-zero exit.
+    if (typeof res.status === 'number' && res.status !== 0)
+        process.exit(res.status);
+}

package/dist-node/scripts/service/voice.js

@@ -0,0 +1,113 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import { freeServePort, magicDnsName, relayServeState, tailscaleBin } from "../../src/host/tailscale.js";
+import { readVoiceConfig } from "../../src/voice/config.js";
+import { inspectVoiceFunnel, readVoiceFunnelReceipt, voiceFunnelReceiptPath, writeVoiceFunnelReceipt } from "../../src/voice/funnel.js";
+import { RELAY_PORT, VOICE_PORT } from "./environment.js";
+import { mountRelay, rawTailscaleStatus } from "./network.js";
+/**
+ * Give OpenAI the only public route it needs while keeping the control panel tailnet-only.
+ * Port-wide changes happen only when every live handler is either the relay root or the exact
+ * voice target named by our receipt; a foreign or merely manual mount is left untouched.
+ */
+export function ensureVoiceFunnel() {
+    const voice = readVoiceConfig();
+    const bin = tailscaleBin();
+    if (!voice.publicBaseUrl) {
+        const receipt = readVoiceFunnelReceipt();
+        if (!bin || !receipt)
+            return;
+        const inspected = inspectVoiceFunnel(rawTailscaleStatus(bin), VOICE_PORT, RELAY_PORT, receipt);
+        if (!inspected.owned || inspected.relayAtRoot || inspected.conflicts.length)
+            return;
+        try {
+            execFileSync(bin, ['serve', '--yes', '--https=443', 'off'], { stdio: 'pipe' });
+            fs.rmSync(voiceFunnelReceiptPath());
+            console.info('✓ removed the receipt-owned voice Funnel mount');
+        }
+        catch (error) {
+            console.info(`  ⚠ could not remove the receipt-owned voice Funnel (${error instanceof Error ? error.message : error})`);
+        }
+        return;
+    }
+    if (!bin) {
+        console.info(`\n  ⚠ voice is configured but Tailscale is unavailable. Mount by hand:`);
+        console.info(`      tailscale funnel --bg --yes --https=443 --set-path=/voice ${VOICE_PORT}`);
+        return;
+    }
+    const dns = magicDnsName(bin);
+    if (!dns) {
+        console.info('\n  ⚠ voice is configured but this node has no MagicDNS name; Funnel was not changed.');
+        return;
+    }
+    let configuredHost;
+    try {
+        configuredHost = new URL(voice.publicBaseUrl).hostname;
+    }
+    catch {
+        console.info('\n  ⚠ voice.public-url is invalid; Funnel was not changed.');
+        return;
+    }
+    if (configuredHost !== dns) {
+        console.info(`\n  ⚠ voice.public-url names ${configuredHost}, but this node is ${dns}; Funnel was not changed.`);
+        console.info(`    Fix with: conductor-remote config set voice.public-url https://${dns}/voice`);
+        return;
+    }
+    let status = rawTailscaleStatus(bin);
+    const oldReceipt = readVoiceFunnelReceipt();
+    let inspected = inspectVoiceFunnel(status, VOICE_PORT, RELAY_PORT, oldReceipt);
+    if (inspected.conflicts.length) {
+        console.info(`\n  ⚠ :443 carries ${inspected.conflicts.join(', ')}. It is not owned by this receipt; left as is.`);
+        return;
+    }
+    if (inspected.owned && inspected.targetMatches && inspected.funnelOn && !inspected.relayAtRoot) {
+        console.info(`✓ voice Funnel already exposes https://${dns}/voice → 127.0.0.1:${VOICE_PORT}`);
+        return;
+    }
+    if (inspected.relayAtRoot) {
+        const state = relayServeState(status, RELAY_PORT);
+        const candidates = [Number(RELAY_PORT), 8443, 10000].filter((port, index, all) => Number.isInteger(port) && port !== 443 && all.indexOf(port) === index);
+        const destination = freeServePort(state, candidates);
+        if (destination === null) {
+            console.info(`\n  ⚠ the relay must leave :443 for voice, but ${candidates.map(p => `:${p}`).join(', ')} are occupied.`);
+            return;
+        }
+        const failed = mountRelay(bin, 'serve', destination);
+        if (failed) {
+            console.info(`\n  ⚠ could not move the relay to tailnet-only :${destination} (${failed}). Voice was not changed.`);
+            return;
+        }
+        try {
+            execFileSync(bin, ['serve', '--yes', '--https=443', 'off'], { stdio: 'pipe' });
+        }
+        catch (error) {
+            console.info(`\n  ⚠ relay moved, but :443 could not be cleared (${error instanceof Error ? error.message : error}).`);
+            return;
+        }
+        console.info(`✓ relay moved to https://${dns}:${destination}/ (tailnet-only) so voice can own :443`);
+    }
+    try {
+        execFileSync(bin, ['funnel', '--bg', '--yes', '--https=443', '--set-path=/voice', VOICE_PORT], {
+            stdio: 'pipe'
+        });
+    }
+    catch (error) {
+        console.info(`\n  ⚠ could not mount voice Funnel (${error instanceof Error ? error.message : error}).`);
+        console.info(`    Run by hand: tailscale funnel --bg --yes --https=443 --set-path=/voice ${VOICE_PORT}`);
+        return;
+    }
+    const receipt = {
+        version: 1,
+        host: dns,
+        path: '/voice',
+        target: `http://127.0.0.1:${VOICE_PORT}`
+    };
+    status = rawTailscaleStatus(bin);
+    inspected = inspectVoiceFunnel(status, VOICE_PORT, RELAY_PORT, receipt);
+    if (!inspected.owned || !inspected.targetMatches || !inspected.funnelOn || inspected.relayAtRoot) {
+        console.info('\n  ⚠ Tailscale accepted the voice command, but the isolated public mount could not be verified.');
+        return;
+    }
+    writeVoiceFunnelReceipt(receipt);
+    console.info(`✓ voice Funnel exposes https://${dns}/voice → 127.0.0.1:${VOICE_PORT} (receipt recorded)`);
+}