fedipod-server 0.11.0 → 0.13.0

package/lib/device/cli/commands/run.mjs

@@ -0,0 +1,278 @@
+// run.mjs — starting and stopping: up, start, stop, status, https.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { identityHomes, rootOf, profileHome, recordLastUsed } from '../../home.mjs';
+import { portFree, freePortFrom } from '../../ports.mjs';
+import { localFetch } from '../../../client/localapi.mjs';
+import { flag, has, portFlag, PROFILE, AP_ROOT, DEFAULT_ISSUE, HOME, PORT, recordedAgent, recordedPort, recordAgent, useProfile, requireHandle, requireIdentity, ask, endAsking, agentOn, openBrowser } from '../context.mjs';
+
+export async function up() {
+// A signup page may have arranged an identity already: the installer records
+// its parameters in first-run.json beside this script's package, and the
+// carry-over outranks the last-used identity — whether this machine is fresh
+// or already full of accounts, `npm start` right after the installer brings
+// up the identity the signup arranged, beside any that exist. An explicitly
+// named profile or home still means exactly what it says.
+const firstRunFile = process.env.AP_FIRST_RUN
+  || new URL('../../../../first-run.json', import.meta.url).pathname;
+const explicitHome = !!(PROFILE || flag('home', null) || process.env.AP_HOME);
+let firstRun = null;
+if (!explicitHome) {
+  try { firstRun = JSON.parse(fs.readFileSync(firstRunFile, 'utf8')); } catch { /* none */ }
+}
+if (firstRun?.handle) {
+  const carried = String(firstRun.handle);
+  requireHandle(carried);
+  if (fs.existsSync(path.join(profileHome(AP_ROOT, carried), 'credential.json'))) {
+    console.error(`the signup carried the name "${carried}", but an identity with that name already exists here.`);
+    console.error('To attach the existing identity instead, use the signup page\'s Manage → Attach —');
+    console.error(`then remove ${firstRunFile} and run this again.`);
+    process.exit(2);
+  }
+  useProfile(carried);
+  process.env.AP_FIRST_RUN = firstRunFile;
+} else if (DEFAULT_ISSUE && !identityHomes(AP_ROOT).some(h => fs.existsSync(path.join(h.dir, 'credential.json')))) {
+  // A fresh machine has no identity, and an identity is named after its
+  // handle, so there is no home to start in until that is asked. One
+  // question, the same one `setup` opens with — `npm start` stays the
+  // single command it was.
+  if (!process.stdin.isTTY) {
+    console.error('no identities yet — fedipod setup');
+    process.exit(2);
+  }
+  const first = await ask('handle (the name in your address; permanent)');
+  endAsking();
+  if (!first) { console.error('a handle is required'); process.exit(2); }
+  requireHandle(first);
+  useProfile(first);
+} else {
+  requireIdentity();
+}
+if (rootOf(HOME) === AP_ROOT) recordLastUsed(AP_ROOT, path.basename(HOME));
+const preferred = Number(portFlag() || process.env.AP_PORT || recordedPort() || 8030);
+const configured = fs.existsSync(path.join(HOME, 'credential.json'));
+const { hostLabel } = await import(new URL('../../../../lib/shared/guard.mjs', import.meta.url));
+
+let port = preferred;
+let already = null;
+if (!await portFree(preferred)) {
+  already = await agentOn(preferred);
+  // Ours already — nothing to start. The directory door yields to a real
+  // owner of its port. Anything else is simply not this port; walking on is
+  // what "occupied" has always meant here.
+  if (!already) {
+    const { yieldDirectory } = await import(new URL('../../../../lib/gateway/directory.mjs', import.meta.url));
+    if (!await yieldDirectory(preferred, { portFree })) {
+      port = await freePortFrom(preferred + 1);
+      // The shared helper returns null; the message is this command's to write.
+      if (port == null) throw new Error(`no free port between ${preferred + 1} and ${preferred + 51}`);
+    }
+  }
+}
+
+// Both branches take the named origin: setup at the shared one would file the
+// first login under localhost:<port>, and the identity is stuck with it.
+// The profile name is the handle — that is what naming identities after them
+// bought — so the named origin works on the very first run, before anything
+// has been recorded.
+const label = hostLabel(recordedAgent().handle || path.basename(HOME));
+// One listener, one scheme: the port the agent was given is the port you
+// browse, over https.
+const originNow = () => `https://${label ? label + '.' : ''}localhost:${port}`;
+
+if (already) {
+  console.log(`already running on port ${port}`);
+} else {
+  // The handle too, not just the port: the agent seeds its allowed hosts
+  // from agent.json, and without it the named origin this command is about
+  // to open would be refused on the very first run.
+  recordAgent(recordedAgent().handle ? { port } : { port, handle: path.basename(HOME) });
+  const child = spawn(process.execPath, [new URL('../../../../run-agent.mjs', import.meta.url).pathname], {
+    detached: true, stdio: 'ignore',
+    env: { ...process.env, AP_HOME: HOME, AP_PORT: String(port) },
+  });
+  child.on('error', (e) => { console.error(`could not start the agent: ${e.message}`); process.exit(1); });
+  child.unref();
+  // Wait for it to answer before pointing a browser at it, or the first
+  // load races the listen and shows a connection error.
+  let up = false;
+  for (let i = 0; i < 60 && !up; i++) {
+    await new Promise(r => setTimeout(r, 250));
+    up = !!await agentOn(port);
+  }
+  if (!up) {
+    console.error(`the agent did not come up on port ${port} — see ${path.join(HOME, 'agent.log')}`);
+    process.exit(1);
+  }
+  console.log(`agent running on port ${port} (pid in ${path.join(HOME, 'agent.pid')})`);
+  if (port !== preferred) console.log(`port ${preferred} was taken, so it moved to ${port}`);
+}
+// The client pinned to this actor, not the bare root — root serves vendored
+// Phanpy with no account bound, which reads as the wrong app entirely.
+const url = configured ? `${originNow()}/admin/client/` : `${originNow()}/admin/setup/`;
+console.log(`\n  ${url}\n`);
+console.log(configured ? 'stop it with:  fedipod stop'
+  : 'setup continues in the browser. Stop it with:  fedipod stop');
+if (!has('no-open')) openBrowser(url);
+process.exit(0);
+}
+
+export async function start() {
+requireIdentity();
+// Starting one is what makes it the default — so `--profile group start`
+// today is what a plain command means tomorrow. Recorded before the agent
+// comes up, because a start that fails still expressed the intent.
+if (rootOf(HOME) === AP_ROOT) recordLastUsed(AP_ROOT, path.basename(HOME));
+// This flag is read only by setup; it silently did nothing here, while the
+// key guard's own error message told people to use it.
+if (has('rotate-key')) {
+  console.error('start does not rotate keys — use:  fedipod rotate-key');
+  process.exit(2);
+}
+if (portFlag()) recordAgent({ port: PORT });   // `start --port N` (or bare N) moves it for good
+
+// Something already on the port? Offer to take it over rather than dying
+// with "address in use" and leaving the user to hunt the process down.
+const answering = await localFetch(HOME, PORT, `/status`)
+  .then(r => r.status).catch(() => null);
+if (answering !== null) {
+  const pidFile = path.join(HOME, 'agent.pid');
+  let pid = null;
+  try { pid = Number(fs.readFileSync(pidFile, 'utf8').trim()) || null; } catch {}
+  const who = pid ? `pid ${pid}` : 'started elsewhere';
+  if (!has('replace') && !process.stdin.isTTY) {
+    console.error(`an agent is already running on port ${PORT} (${who}).`);
+    console.error('Stop it with `fedipod stop`, or start this one with --replace.');
+    process.exit(1);
+  }
+  const ans = has('replace')
+    ? 'y'
+    : await ask(`an agent is already running on port ${PORT} (${who}) — stop it and start this one? (y/n)`, 'y');
+  endAsking();
+  if (!/^y/i.test(ans)) { console.log('left the running agent alone'); process.exit(0); }
+
+  await localFetch(HOME, PORT, `/shutdown`, { method: 'POST' }).catch(() => {});
+  if (pid) { try { process.kill(pid, 'SIGTERM'); } catch {} }
+  const freed = await (async () => {                 // give it a few seconds
+    for (let i = 0; i < 30; i++) {
+      await new Promise(r => setTimeout(r, 300));
+      const still = await localFetch(HOME, PORT, `/status`).then(() => true).catch(() => false);
+      if (!still) return true;
+    }
+    return false;
+  })();
+  if (!freed && pid) { try { process.kill(pid, 'SIGKILL'); } catch {} await new Promise(r => setTimeout(r, 500)); }
+  const clear = await localFetch(HOME, PORT, `/status`).then(() => false).catch(() => true);
+  if (!clear) {
+    console.error(`could not stop whatever is on port ${PORT}. Find it with:  ss -tlnp | grep :${PORT}`);
+    process.exit(1);
+  }
+  console.log('previous agent stopped');
+}
+
+const { startAgent } = await import(new URL('../../../../run-agent.mjs', import.meta.url));
+const startHandle = recordedAgent().handle || null;
+await startAgent({
+  home: HOME, port: PORT, name: flag('name') || null,
+  takeover: has('takeover'),      // claim a lease whose holder is gone
+  handle: startHandle,            // the named origin, before pod state is read
+});
+{
+  const { hostLabel } = await import(new URL('../../../../lib/shared/guard.mjs', import.meta.url));
+  const label = hostLabel(startHandle);
+  const named = label ? `https://${label}.localhost:${PORT}/` : null;
+  const plain = `https://localhost:${PORT}/`;
+  // One origin per identity is the point of the named form: a browser keeps
+  // its storage per origin, so two agents stop sharing one Phanpy login.
+  if (named) {
+    const pad = Math.max(named.length, plain.length);
+    console.log(`\n  ${named.padEnd(pad)}   <- browse it here`);
+    console.log(`  ${plain.padEnd(pad)}   <- the same agent, if that name will not resolve\n`);
+  } else {
+    console.log(`\n  ${plain}\n`);
+  }
+  // Printed, not opened. `start` is run by supervisors and on every restart;
+  // a window arriving unasked over whatever you were doing is not a feature.
+  // `setup` opens one because that is the whole point of `setup`.
+  if (has('open')) openBrowser(named || plain);
+}
+}
+
+export async function stop() {
+requireIdentity();
+const pidFile = path.join(HOME, 'agent.pid');
+let pid = null;
+try { pid = Number(fs.readFileSync(pidFile, 'utf8').trim()); } catch {}
+if (!pid) {
+  // The agent may still be listening even with no pidfile — an older
+  // build, a deleted file, or one started detached from any terminal
+  // (where Ctrl-C can never reach it). Ask it to stop over the API.
+  const asked = await localFetch(HOME, PORT, `/shutdown`, { method: 'POST' })
+    .then(r => r.ok).catch(() => false);
+  if (asked) { console.log(`agent on port ${PORT} asked to stop`); process.exit(0); }
+  console.error(`no agent found: no pidfile at ${pidFile}, nothing answering on port ${PORT}.`);
+  console.error('If it is on another port, add --port N; a service install stops with:');
+  console.error('  systemctl --user stop fedipod-<name>');
+  process.exit(1);
+}
+try { process.kill(pid, 'SIGTERM'); } catch {
+  // Stale pidfile, but something may still hold the port.
+  const asked = await localFetch(HOME, PORT, `/shutdown`, { method: 'POST' })
+    .then(r => r.ok).catch(() => false);
+  fs.rmSync(pidFile, { force: true });
+  console.log(asked ? `agent on port ${PORT} asked to stop (pidfile was stale)` : 'agent was not running (stale pidfile)');
+  process.exit(0);
+}
+const t0 = Date.now();
+while (Date.now() - t0 < 10_000) {
+  await new Promise(r => setTimeout(r, 300));
+  try { process.kill(pid, 0); } catch { console.log('agent stopped'); process.exit(0); }
+}
+console.error('agent did not exit within 10s — kill it with: kill -9 ' + pid);
+process.exit(1);
+}
+
+export async function status() {
+requireIdentity();
+try {
+  const res = await localFetch(HOME, PORT, `/status`);
+  console.log(JSON.stringify(await res.json(), null, 2));
+} catch (e) {
+  console.error(`agent not reachable on :${PORT} (${e.message})`);
+  process.exit(1);
+}
+}
+
+export async function https() {
+// Agents serve https beside http with a certificate minted on this machine
+// (never packaged — a shipped key would be one key for every install).
+// Plain: self-signed, a client may ask once. --trust: a local CA signs it,
+// and the CA certificate is what a trust store accepts — for clients that
+// refuse self-signed outright.
+const { ensureLocalTls, enableTrust, certPaths } = await import(new URL('../../../../lib/device/certs.mjs', import.meta.url));
+const certDir = path.join(rootOf(HOME), 'certs');   // same resolution the agent uses
+if (has('trust')) {
+  const t = enableTrust(certDir, { log: console.log });   // mints, signs, installs in NSS
+  console.log(`CA certificate: ${t.caCertPath}`);
+  if (process.platform === 'linux') {
+    console.log('for the system store, run:');
+    console.log(`  sudo cp ${t.caCertPath} /usr/local/share/ca-certificates/fedipod-local-ca.crt && sudo update-ca-certificates`);
+  } else if (process.platform === 'darwin') {
+    console.log('to trust it system-wide, run:');
+    console.log(`  sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain ${t.caCertPath}`);
+  } else if (process.platform === 'win32') {
+    console.log('to trust it, run:');
+    console.log(`  certutil -addstore -user Root "${t.caCertPath}"`);
+  }
+  console.log('restart your agents to serve the CA-signed certificate');
+} else {
+  const tls = ensureLocalTls(certDir, { log: console.log });
+  const paths2 = certPaths(certDir);
+  console.log(`certificate: ${paths2.cert}`);
+  console.log(`  ${tls.trust ? 'signed by the local CA' : 'self-signed'}, ${tls.expiresInDays} days left`);
+  console.log('agents serve https on the port they were given — e.g. https://localhost:8030');
+  console.log('strict clients: `fedipod https --trust` mints a local CA your trust store can accept');
+}
+}

package/lib/device/cli/commands/service.mjs

@@ -0,0 +1,221 @@
+// service.mjs — the machine's service manager and the update: update,
+// install-service, uninstall-service.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { identityHomes } from '../../home.mjs';
+import { portFree } from '../../ports.mjs';
+import { localFetch } from '../../../client/localapi.mjs';
+import { cmd, has, AP_ROOT, HOME, agentOn } from '../context.mjs';
+
+export async function update() {
+// Pull the latest published FediPod into this checkout and restart the
+// agents — what re-running the installer does, as one command.
+const { checkLatest, runUpdate, restartAgents } = await import(new URL('../../../../lib/device/update.mjs', import.meta.url));
+const u = await checkLatest();
+if (u && !u.available) console.log(`already current: ${u.current}`);
+const r = runUpdate({ log: console.log });
+if (!r.ok) { console.error(r.note); process.exit(1); }
+console.log(r.note);
+if (restartAgents({ log: console.log }) === 'self') {
+  console.log('no managed agents found — restart any running agent to serve the new version');
+}
+process.exit(0);
+}
+
+export async function service() {
+const { execFileSync } = await import('node:child_process');
+const runAgentPath = new URL('../../../../run-agent.mjs', import.meta.url).pathname;
+const sh = (file, a) => { try { execFileSync(file, a, { stdio: 'pipe' }); return true; } catch { return false; } };
+// Every identity with a credential gets a service of its own: a stopped
+// actor's pod goes on collecting deliveries, so "installed" means ALL of
+// them start at boot, each on its recorded port.
+const identities = [];
+for (const { name, dir } of identityHomes(AP_ROOT)) {
+  if (!fs.existsSync(path.join(dir, 'credential.json'))) continue;
+  let rec = {};
+  try { rec = JSON.parse(fs.readFileSync(path.join(dir, 'agent.json'), 'utf8')) || {}; } catch { /* no record yet */ }
+  if (!Number(rec.port)) {
+    console.log(`${name}: no recorded port — start it once (\`up --profile ${name}\`), then re-run install-service`);
+    continue;
+  }
+  identities.push({ name, dir, port: Number(rec.port), handle: rec.handle || name });
+}
+if (cmd === 'install-service' && !identities.length) {
+  console.error('no identities with a credential and a recorded port — nothing to install');
+  process.exit(2);
+}
+// Graceful handover: an identity already running outside the service is
+// stopped through its own /shutdown so the unit can take the port.
+const handOver = async ({ name, port }) => {
+  if (!await agentOn(port)) return;
+  await localFetch(HOME, port, `/shutdown`, { method: 'POST' }).catch(() => {});
+  for (let i = 0; i < 20 && !await portFree(port); i++) await new Promise(r => setTimeout(r, 250));
+  console.log(`${name}: was running detached — stopped for the service to take over`);
+};
+
+if (process.platform === 'linux') {
+  const unitDir = path.join(os.homedir(), '.config/systemd/user');
+  const unitOf = (name) => `fedipod-${name}.service`;
+  // Old shapes are cleared on both paths: units under the pre-rename names
+  // (activitypod, solid-activitypub), single-identity units, and any
+  // per-identity unit for an identity that no longer exists here.
+  const dropOld = () => {
+    const keep = new Set(cmd === 'install-service' ? identities.map(i => unitOf(i.name)) : []);
+    let units = [];
+    try { units = fs.readdirSync(unitDir).filter(u => /^(activitypod|solid-activitypub|fedipod)(-.+)?\.service$/.test(u)); } catch { /* no unit dir */ }
+    for (const u of units) {
+      if (keep.has(u)) continue;
+      sh('systemctl', ['--user', 'disable', '--now', u]);
+      fs.rmSync(path.join(unitDir, u), { force: true });
+      console.log(`removed ${u}`);
+    }
+  };
+  if (cmd === 'uninstall-service') {
+    dropOld();
+    sh('systemctl', ['--user', 'daemon-reload']);
+    console.log('service(s) removed');
+  } else {
+    fs.mkdirSync(unitDir, { recursive: true });
+    dropOld();
+    for (const id of identities) {
+      fs.writeFileSync(path.join(unitDir, unitOf(id.name)), `[Unit]
+Description=FediPod agent — ${id.handle}
+After=network-online.target
+
+[Service]
+ExecStart=${process.execPath} ${runAgentPath}
+Environment=AP_HOME=${id.dir}
+Environment=AP_PORT=${id.port}
+Restart=on-failure
+RestartSec=30
+# A crash loop must not become a request loop against the pod.
+StartLimitIntervalSec=600
+StartLimitBurst=5
+
+[Install]
+WantedBy=default.target
+`);
+    }
+    sh('systemctl', ['--user', 'daemon-reload']);
+    sh('loginctl', ['enable-linger', os.userInfo().username]);   // keep running while logged out
+    for (const id of identities) {
+      sh('systemctl', ['--user', 'enable', unitOf(id.name)]);
+      await handOver(id);
+      if (await portFree(id.port)) {
+        sh('systemctl', ['--user', 'start', unitOf(id.name)]);
+        console.log(`${id.handle}: installed, enabled and started on port ${id.port}`);
+      } else {
+        console.log(`${id.handle}: installed + enabled (starts at next boot). Port ${id.port} is held by something that is not ours — free it, then: systemctl --user start ${unitOf(id.name)}`);
+      }
+    }
+    console.log('logs: journalctl --user -u fedipod-<name> -f');
+  }
+} else if (process.platform === 'darwin') {
+  const agents = path.join(os.homedir(), 'Library/LaunchAgents');
+  const plistOf = (name) => path.join(agents, `net.fedipod.${name}.agent.plist`);
+  // Old shapes are cleared on both paths: plists under the pre-rename names
+  // (net.activitypod, net.solid-activitypub), single-identity plists, and any
+  // per-identity plist for an identity that no longer exists here.
+  const dropOld = () => {
+    const keep = new Set(cmd === 'install-service' ? identities.map(i => plistOf(i.name)) : []);
+    let plists = [];
+    try {
+      plists = fs.readdirSync(agents)
+        .filter(f => /^net\.(activitypod|solid-activitypub|fedipod)(\..+)?\.agent\.plist$/.test(f))
+        .map(f => path.join(agents, f));
+    } catch { /* no LaunchAgents dir */ }
+    for (const p of plists) {
+      if (keep.has(p)) continue;
+      sh('launchctl', ['unload', p]);
+      fs.rmSync(p, { force: true });
+      console.log(`removed ${path.basename(p)}`);
+    }
+  };
+  if (cmd === 'uninstall-service') {
+    dropOld();
+    console.log('service(s) removed');
+  } else {
+    fs.mkdirSync(agents, { recursive: true });
+    dropOld();
+    for (const id of identities) {
+      const plist = plistOf(id.name);
+      sh('launchctl', ['unload', plist]);      // replacing our own older copy
+      fs.writeFileSync(plist, `<?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>net.fedipod.${id.name}.agent</string>
+<key>ProgramArguments</key><array>
+  <string>${process.execPath}</string><string>${runAgentPath}</string>
+</array>
+<key>EnvironmentVariables</key><dict>
+  <key>AP_HOME</key><string>${id.dir}</string>
+  <key>AP_PORT</key><string>${id.port}</string>
+</dict>
+<key>RunAtLoad</key><true/>
+<key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict>
+<key>ThrottleInterval</key><integer>30</integer>
+</dict></plist>
+`);
+      await handOver(id);
+      sh('launchctl', ['load', plist]);
+      console.log(`${id.handle}: installed and loaded (starts at login)`);
+    }
+  }
+} else if (process.platform === 'win32') {
+  // schtasks is scriptable, but this path is UNTESTED here (no Windows
+  // machine); the equivalent command is printed either way so a failure
+  // is actionable rather than mysterious.
+  const taskOf = (name) => `fedipod-${name}`;
+  // Pre-rename names, single-identity and per-identity, cleared on both paths.
+  const dropOld = () => {
+    sh('schtasks', ['/delete', '/tn', 'activitypod', '/f']);
+    sh('schtasks', ['/delete', '/tn', 'solid-activitypub', '/f']);
+    for (const id of identities) sh('schtasks', ['/delete', '/tn', `solid-activitypub-${id.name}`, '/f']);
+  };
+  if (cmd === 'uninstall-service') {
+    dropOld();
+    for (const id of identities) sh('schtasks', ['/delete', '/tn', taskOf(id.name), '/f']);
+    console.log('scheduled task(s) removed');
+  } else {
+    dropOld();
+    for (const id of identities) {
+      const tr = `"${process.execPath}" "${runAgentPath}"`;
+      const made = sh('schtasks', ['/create', '/tn', taskOf(id.name), '/tr', tr, '/sc', 'onlogon', '/rl', 'limited', '/f']);
+      if (made) {
+        console.log(`${id.handle}: scheduled task created — starts at log on (untested on Windows; please report)`);
+        console.log(`  set AP_HOME=${id.dir} and AP_PORT=${id.port} in the task's environment`);
+      } else {
+        console.log(`${id.handle}: could not create the task automatically. Run this in an elevated prompt:`);
+        console.log(`  schtasks /create /tn ${taskOf(id.name)} /tr ${tr} /sc onlogon /rl limited /f`);
+        console.log(`  with AP_HOME=${id.dir} AP_PORT=${id.port}.`);
+      }
+    }
+  }
+} else if (process.platform === 'android' || process.env.PREFIX?.includes('com.termux')) {
+  // Android has no user service manager: running at boot needs the
+  // separate termux-boot app, supervision needs the termux-services
+  // package. Neither can be installed from here, so print the recipe.
+  // The agent is designed for this: whatever Android kills, the pod
+  // buffered, and the next start catches up.
+  if (cmd === 'uninstall-service') {
+    console.log('Termux: remove ~/.termux/boot/fedipod.sh (solid-activitypub.sh or activitypod.sh on an older install, and `sv-disable` the matching service if you used termux-services).');
+  } else {
+    const boot = path.join(os.homedir(), '.termux/boot');
+    console.log('Android/Termux has no service manager. To start at boot:');
+    console.log('  1. install the Termux:Boot app (F-Droid), open it once');
+    console.log(`  2. mkdir -p ${boot} && cat > ${boot}/fedipod.sh <<'EOF'`);
+    console.log('#!/data/data/com.termux/files/usr/bin/sh');
+    console.log('termux-wake-lock');
+    for (const id of identities) console.log(`AP_HOME=${id.dir} AP_PORT=${id.port} ${process.execPath} ${runAgentPath} &`);
+    console.log('EOF');
+    console.log(`  3. chmod +x ${boot}/fedipod.sh`);
+    console.log('\nWithout Termux:Boot, run `termux-wake-lock` then `fedipod run` —');
+    console.log('anything Android kills is buffered on the pod and catches up next start.');
+  }
+} else {
+  console.log(`no service integration for platform "${process.platform}". Run each yourself with:`);
+  for (const id of identities) console.log(`  AP_HOME=${id.dir} AP_PORT=${id.port} ${process.execPath} ${runAgentPath}`);
+}
+}