@tarfa/cli 0.1.4 → 0.1.6

package/dist/cli.js

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 import {
   CodexAppServer,
+  DICTATION_PROVIDERS,
   FileClaudeSessionsStore,
   FileDeviceStore,
+  FileDictationKeysStore,
   FileHiddenFoldersStore,
   FilePairingStore,
   FileParkedStore,
@@ -17,11 +19,13 @@ import {
   STATE_DIR,
   ShortWorkspaceIds,
   TmuxAdapter,
-  addPairing,
   agentEnvFile,
+  atomicWrite,
   browseDir,
+  changeDictationKey,
   childEnv,
   cloneOfUnit,
+  codexVersions,
   createWithFreshId,
   createWorkspace,
   describeStep,
@@ -36,23 +40,27 @@ import {
   isEntrypoint,
   isHiddenPath,
   isMachineUrl,
-  isPairingPath,
   listWorkspaces,
   loadConfig,
   loadOrCreateAgentKeys,
   locateAgentEnv,
+  loginShell,
   loginShellResolver,
   mainCheckout,
   migrateStateDir,
+  mintPairing,
   packageRoot,
   packageVersion,
+  pairingCode,
   pairingLink,
+  pairingName,
   parseEnvFile,
-  parsePairingLink,
   parseSetupFlags,
   planCli,
   planSetup,
+  providerOf,
   renderService,
+  resolveCodexHome,
   resolveStateDir,
   revokeDevice,
   sanitizeDeviceName,
@@ -63,13 +71,13 @@ import {
   unitRunsLauncher,
   withEnrolmentMode,
   withLegacyEnv
-} from "./chunk-OC5VX7K3.js";
+} from "./chunk-UPCCR4ZA.js";
 
 // src/cli.ts
 import { randomBytes } from "node:crypto";
 import { homedir, hostname, userInfo } from "node:os";
-import { readFile as readFile6, mkdir as mkdir4, realpath as realpath2 } from "node:fs/promises";
-import { dirname as dirname4, join as joinPath, resolve as resolvePath } from "node:path";
+import { readFile as readFile6, mkdir as mkdir3, realpath as realpath2 } from "node:fs/promises";
+import { dirname as dirname3, join as joinPath, resolve as resolvePath } from "node:path";
 
 // src/application/format-workspace-table.ts
 var TITLE_MAX = 40;
@@ -241,10 +249,9 @@ async function readOrNull(path) {
     throw err;
   }
 }
-function hooksFiles(home, hooksDir, port) {
+function hooksFiles(home, hooksDir, port, codexHome) {
   const settingsPath = join(home, ".claude", "settings.json");
-  const codexDir = join(home, ".codex");
-  const codexHooksPath = join(codexDir, "hooks.json");
+  const codexHooksPath = join(codexHome, "hooks.json");
   async function wanted() {
     const files = [];
     for (const script of SCRIPTS) {
@@ -254,7 +261,7 @@ function hooksFiles(home, hooksDir, port) {
     const settings = await readOrNull(settingsPath);
     const merged = installHooks({ settings: settings === null ? {} : JSON.parse(settings) }, { hookCommand: HOOK_COMMAND, guardCommand: GUARD_COMMAND, port });
     files.push({ path: settingsPath, current: settings, text: JSON.stringify(merged, null, 2) });
-    if (await fsIsDirectory(codexDir)) {
+    if (await fsIsDirectory(codexHome)) {
       const codex = await readOrNull(codexHooksPath);
       const codexMerged = installHooks(
         { settings: codex === null ? {} : JSON.parse(codex) },
@@ -651,29 +658,13 @@ async function firstOnPath(name, pathVar) {
   return null;
 }
 
-// src/infrastructure/atomic-write.ts
-import { chmod as chmod3, mkdir as mkdir3, rename as rename2, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname3 } from "node:path";
-async function atomicWrite(path, text, mode) {
-  await mkdir3(dirname3(path), { recursive: true });
-  const temp = `${path}.tmp-${process.pid}`;
-  try {
-    await writeFile2(temp, text, { mode });
-    await chmod3(temp, mode);
-    await rename2(temp, path);
-  } catch (err) {
-    await rm2(temp, { force: true });
-    throw err;
-  }
-}
-
 // src/infrastructure/agent-log.ts
 import { open, readFile as readFile4, stat as stat3 } from "node:fs/promises";
 import { join as join5 } from "node:path";
 
 // src/infrastructure/service-install.ts
 import { execFile as execFile2 } from "node:child_process";
-import { chmod as chmod4, cp, copyFile as copyFile3, readFile as readFile3, rm as rm3, stat as stat2 } from "node:fs/promises";
+import { chmod as chmod3, cp, copyFile as copyFile3, readFile as readFile3, rm as rm2, stat as stat2 } from "node:fs/promises";
 import { join as join4 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 var exec2 = promisify2(execFile2);
@@ -703,7 +694,7 @@ async function backupFile(path) {
   if (!await exists(path)) return null;
   const copy = `${path}.bak-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
   await copyFile3(path, copy);
-  await chmod4(copy, (await stat2(path)).mode & 511);
+  await chmod3(copy, (await stat2(path)).mode & 511);
   return copy;
 }
 var LABEL_GONE_MS = 1e4;
@@ -757,7 +748,7 @@ function serviceInstall(options) {
         return [`launchctl bootout ${domain}/${LEGACY_LABEL}`];
       },
       async removeLegacy() {
-        await rm3(legacyPlist, { force: true });
+        await rm2(legacyPlist, { force: true });
         return [`removed ${legacyPlist}`];
       }
     };
@@ -809,9 +800,9 @@ function serviceInstall(options) {
       return ran.map(([command, args]) => `${command} ${args.join(" ")}`);
     },
     async removeLegacy() {
-      await rm3(legacyUnit, { force: true });
+      await rm2(legacyUnit, { force: true });
       if (await exists(legacyDropIns) && !await exists(dropIns)) await cp(legacyDropIns, dropIns, { recursive: true });
-      await rm3(legacyDropIns, { recursive: true, force: true });
+      await rm2(legacyDropIns, { recursive: true, force: true });
       await run4("systemctl", ["--user", "daemon-reload"]);
       return [`removed ${legacyUnit} and its drop-ins`, "systemctl --user daemon-reload"];
     }
@@ -978,29 +969,50 @@ function attempt(port, ms) {
   });
 }
 
-// src/cli.ts
-import encodeQR from "qr";
-
-// src/application/pairing-link.ts
-var GENERIC_MACHINE_IDS = /* @__PURE__ */ new Set(["", "local", "localhost"]);
-function pairingName(machineId, hostname2) {
-  return GENERIC_MACHINE_IDS.has(machineId) ? hostname2.split(".")[0] : machineId;
-}
-async function mintPairingLink(deps, input) {
-  if (deps.defaultPath !== void 0 && !isPairingPath(deps.defaultPath)) {
-    throw new Error(`TARFA_DEFAULT_PATH must be an absolute path of at most 128 characters (got ${deps.defaultPath})`);
+// src/infrastructure/read-secret.ts
+async function readSecret(prompt) {
+  const stdin = process.stdin;
+  if (!stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of stdin) chunks.push(chunk);
+    return Buffer.concat(chunks).toString("utf8");
+  }
+  process.stderr.write(prompt);
+  stdin.setRawMode(true);
+  stdin.resume();
+  stdin.setEncoding("utf8");
+  try {
+    return await new Promise((resolve2, reject) => {
+      let typed = "";
+      const onData = (data) => {
+        for (const ch of data) {
+          if (ch === "\r" || ch === "\n" || ch === "") {
+            stdin.off("data", onData);
+            resolve2(typed);
+            return;
+          }
+          if (ch === "") {
+            stdin.off("data", onData);
+            reject(new Error("cancelled"));
+            return;
+          }
+          if (ch === "\x7F" || ch === "\b") typed = typed.slice(0, -1);
+          else typed += ch;
+        }
+      };
+      stdin.on("data", onData);
+      stdin.once("end", () => reject(new Error("cancelled")));
+    });
+  } finally {
+    stdin.setRawMode(false);
+    stdin.pause();
+    process.stderr.write("\n");
   }
-  const secret = deps.newSecret();
-  await deps.pairings.update((list) => addPairing(list, secret, deps.now(), deps.ttlMs));
-  return pairingLink(input.pwaOrigin, {
-    urls: input.phoneUrls,
-    agentKey: deps.keys.x25519.publicKey,
-    secret,
-    name: deps.machineId,
-    ...deps.defaultPath !== void 0 ? { defaultPath: deps.defaultPath } : {}
-  });
 }
 
+// src/cli.ts
+import encodeQR from "qr";
+
 // src/infrastructure/agent-service.ts
 import { execFile as execFile5 } from "node:child_process";
 import { promisify as promisify5 } from "node:util";
@@ -1078,12 +1090,13 @@ async function spawnCodex(deps, input) {
     firstMessage: input.brief.replace(/\n+$/, "")
   });
   if (!/^[0-9A-Za-z-]+$/.test(thread)) throw new Error(`the Codex app server named an unexpected thread id: ${thread}`);
+  const codexHome = await deps.codex.home();
   const lockTitle = await titleLock(deps, title);
   const command = `codex resume ${thread}`;
   const id = await createWithFreshId(
     deps.ids,
     cwd,
-    (id2) => deps.tmux.createSession({ name: id2, cwd, command, codexThread: thread, ...parent ? { parent: parent.id } : {} })
+    (id2) => deps.tmux.createSession({ name: id2, cwd, command, codexThread: thread, env: { CODEX_HOME: codexHome }, ...parent ? { parent: parent.id } : {} })
   );
   return finishLaunch(deps, id, title, lockTitle, ` (Codex thread ${thread})`);
 }
@@ -1133,35 +1146,6 @@ function denySettings(denyPath) {
   };
 }
 
-// src/infrastructure/codex-versions.ts
-import { execFile as execFile6 } from "node:child_process";
-function loginShell(shell = process.env.SHELL || "/bin/sh") {
-  return (script) => new Promise((resolve2, reject) => {
-    execFile6(shell, ["-lc", script], { env: childEnv(), timeout: 15e3 }, (err, stdout) => err ? reject(err) : resolve2(stdout));
-  });
-}
-function codexVersions(run4 = loginShell()) {
-  return async () => {
-    const [cliOut, daemonOut] = await Promise.all([
-      run4("codex --version").catch((err) => {
-        throw new Error(`cannot run codex --version: ${err.message}`);
-      }),
-      run4("codex app-server daemon version").catch((err) => {
-        throw new Error(`cannot read the Codex app server's version: ${err.message}`);
-      })
-    ]);
-    const cli = cliOut.trim().split(/\s+/).pop() ?? "";
-    let appServer;
-    try {
-      appServer = JSON.parse(daemonOut).appServerVersion;
-    } catch {
-      appServer = void 0;
-    }
-    if (typeof appServer !== "string" || appServer === "") throw new Error("the Codex app server is not running");
-    return { cli, appServer };
-  };
-}
-
 // src/application/workspace-role.ts
 var WORKSPACE_ROLES = ["orchestrator", "child", "normal"];
 function workspaceRole(w, all) {
@@ -1266,7 +1250,7 @@ async function run3(argv, rawEnv, home, io = {}) {
       return JSON.stringify(await browseDir({ lister, hidden }, path, config.projectRoots), null, 2);
     }
     case "install-hooks": {
-      const hooks = hooksFiles(home, HOOKS_DIR, config.port);
+      const hooks = hooksFiles(home, HOOKS_DIR, config.port, await resolveCodexHome({ ...env, ...await agentEnvValues(env, home) }, home, io.loginShell));
       const { codex } = await hooks.install();
       if (!codex) return JSON.stringify({ installed: hooks.settingsPath, scriptPath: hooks.scriptPath });
       return JSON.stringify({
@@ -1278,6 +1262,8 @@ async function run3(argv, rawEnv, home, io = {}) {
     }
     case "devices":
       return devices(new FileDeviceStore(config.devicesPath), rest);
+    case "dictation-key":
+      return dictationKey(new FileDictationKeysStore(config.dictationKeysPath), rest, io.secret ?? readSecret);
     default:
       throw new UsageError(`unknown command: ${command} (run \`tarfa --help\`)`);
   }
@@ -1286,8 +1272,9 @@ var HELP = `usage: tarfa <command> [options]   (\`tarfa setup --help\`, \`tarfa
 
 Set up this machine:
   setup          write agent.env, the agent key, the service and the hooks, then check the phone port
-  pair           print a one-time pairing link and QR code for a phone
+  pair           print a one-time pairing code and QR code for a phone (--link: a link, for an older app)
   devices        list, revoke or forget paired phones; open or close enrolment
+  dictation-key  store the ElevenLabs or OpenRouter key every paired phone dictates with
   update         install the newest @tarfa/cli and apply it (package installs)
   apply          rewrite the launcher and service if they changed, reinstall the hooks, restart
   install-hooks  install the Claude Code and Codex hooks that report each workspace's status
@@ -1313,6 +1300,7 @@ var COMMANDS = /* @__PURE__ */ new Set([
   "connect",
   "relay-key",
   "devices",
+  "dictation-key",
   "install-hooks",
   "ls",
   "spawn",
@@ -1413,7 +1401,7 @@ async function orchestration(command, argv, env, home, io) {
           nonce: () => randomBytes(6).toString("hex"),
           sleep: io.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms))),
           spawnDir: joinPath(config.stateDir, "spawn"),
-          codex: io.codex ?? { versions: codexVersions(), createThread: (input) => new CodexAppServer().createThread(input) }
+          codex: io.codex ?? codexSpawn({ ...env, ...values }, home, io)
         },
         {
           projectPath,
@@ -1613,7 +1601,8 @@ async function readStdin(ttyError) {
   return Buffer.concat(chunks).toString("utf8");
 }
 var RELAYS_GONE = "relays are gone: tarfa setup sets a machine up for phones, and tarfa pair pairs one";
-var PAIR_USAGE = "usage: tarfa pair [--pwa <PWA origin>] [--ttl <minutes, 1-10, default 10>]";
+var MAX_PAIRING_NAME = 64;
+var PAIR_USAGE = `usage: tarfa pair [--pwa <PWA origin>] [--ttl <minutes, 1-${PAIRING_TTL_MS / 6e4}, default ${PAIRING_TTL_MS / 6e4}>] [--link]`;
 function takeOption(args, name, usage, Failure = Error) {
   const at = args.indexOf(name);
   if (at === -1) return void 0;
@@ -1633,6 +1622,15 @@ function pwaOrigin(value) {
   if (url.protocol !== "https:" && url.protocol !== "http:") throw new Error(`--pwa must be an http(s) origin (got ${value})`);
   return url.origin;
 }
+function codexSpawn(env, home, io) {
+  let codexHome;
+  const resolve2 = () => codexHome ??= resolveCodexHome(env, home, io.loginShell);
+  return {
+    home: resolve2,
+    versions: async () => codexVersions(loginShell(void 0, { CODEX_HOME: await resolve2() }))(),
+    createThread: async (input) => new CodexAppServer({ codexHome: await resolve2() }).createThread(input)
+  };
+}
 async function agentEnvValues(env, home) {
   try {
     return withLegacyEnv(parseEnvFile(await readFile6(await locateAgentEnv(env, home), "utf8")));
@@ -1646,6 +1644,8 @@ async function pair(argv, env, home) {
   const config = loadConfig({ ...env, ...await agentEnvValues(env, home) }, home);
   let origin = pwaOrigin(takeOption(args, "--pwa", PAIR_USAGE));
   const ttl = takeOption(args, "--ttl", PAIR_USAGE) ?? String(PAIRING_TTL_MS / 6e4);
+  const linkAt = args.indexOf("--link");
+  if (linkAt !== -1) args.splice(linkAt, 1);
   const minutes = Number(ttl);
   if (!/^\d+$/.test(ttl) || minutes < 1 || minutes * 6e4 > PAIRING_TTL_MS) throw new Error(`--ttl takes whole minutes from 1 to ${PAIRING_TTL_MS / 6e4} (got ${ttl})`);
   if (args.length > 0) throw new Error(PAIR_USAGE);
@@ -1660,19 +1660,21 @@ async function pair(argv, env, home) {
   const bad = config.phoneAddresses.find((url) => !isMachineUrl(url));
   if (bad) throw new Error(`TARFA_PHONE_ADDRESSES holds ${bad}, which a phone refuses: wss://<host>[:port][/<slug>] (run tarfa setup)`);
   if (config.phoneAddresses.length > MAX_ADDRESSES) throw new Error(`TARFA_PHONE_ADDRESSES holds more than ${MAX_ADDRESSES} addresses`);
-  const link = await mintPairingLink(
+  const machineId = pairingName(config.machineId, hostname());
+  if (machineId.trim().length > MAX_PAIRING_NAME) throw new Error(`TARFA_MACHINE_ID must be at most ${MAX_PAIRING_NAME} characters, the name phones show (got ${machineId.length})`);
+  const pairing = await mintPairing(
     {
       keys: await loadOrCreateAgentKeys(config.agentKeyPath),
-      machineId: pairingName(config.machineId, hostname()),
+      machineId,
       ...config.defaultPath ? { defaultPath: config.defaultPath } : {},
       pairings: new FilePairingStore(config.pairingPath),
       newSecret: generatePairingSecret,
       now: () => /* @__PURE__ */ new Date(),
       ttlMs: minutes * 6e4
     },
-    { phoneUrls: config.phoneAddresses, pwaOrigin: origin }
+    { phoneUrls: config.phoneAddresses }
   );
-  return pairingInstructions(link, minutes);
+  return pairingInstructions(pairing, { origin, minutes, link: linkAt !== -1 });
 }
 var WaitTimeout = class extends Error {
   exitCode = 124;
@@ -1692,11 +1694,16 @@ replace anything it did not make (an agent key, another tailscale serve entry).
 
   --machine-id <id>             the name phones show for this machine
   --project-roots <dir,dir>     absolute folders new workspaces may be made in
-  --default-path <dir>          where a phone resolves relative paths (in pairing links)
+  --default-path <dir>          where a phone resolves relative paths (sent when pairing)
   --phone-port <n>              loopback port phones reach (default 8797); every Linux user on one
                                 machine needs their own, e.g. 8797 and 8798
-  --tailscale serve|funnel|none publish the phone port on the tailnet (serve), also on the public
-                                internet (funnel), or not at all (none, the default)
+  --tailscale funnel|serve|none how phones reach this machine: with or without Tailscale (funnel,
+                                public through Funnel), only with Tailscale on (serve), or through an
+                                address published some other way (none, with --address). Ask the
+                                operator. Without it, setup keeps the TARFA_PHONE_ADDRESSES or the
+                                serve handler for the phone port the machine already has, picks
+                                funnel for a machine phones reached through a relay, and otherwise
+                                refuses. Every run prints a reachability: line saying which
   --tailscale-port <n>          the HTTPS port Tailscale serves it on (default 443 for serve, 10000
                                 for funnel; Funnel allows only 443, 8443 and 10000)
   --slug <name>                 serve under /<name>, so several agents share one port
@@ -1704,7 +1711,7 @@ replace anything it did not make (an agent key, another tailscale serve entry).
                                 4 in all), e.g. a reverse proxy
   --pwa <origin>                where phones open the app (default https://tarfa.app; an existing
                                 TARFA_PWA_ORIGIN is kept unless this is given)
-  --pair                        print a pairing link and QR code at the end
+  --pair                        print a pairing code and QR code at the end
   --adopt                       a machine whose service runs a clone's deploy/run-agent.sh: move it to
                                 the installed package (copies deploy/agent.env to ~/.tarfa/agent.env,
                                 keeps the original, repoints the service, replaces the ~/.local/bin links
@@ -1790,7 +1797,7 @@ ${SETUP_USAGE.split("\n")[0]}
   const config = loadConfig({ ...withLegacyEnv(parseEnvFile(envText ?? "")), TARFA_MACHINE_ID: flags.machineId }, home);
   const tailscale = fx.tailscale ?? tailscaleCli();
   const owner = fx.portOwner ?? portOwner;
-  const hooks = hooksFiles(home, HOOKS_DIR, config.port);
+  const hooks = hooksFiles(home, HOOKS_DIR, config.port, await resolveCodexHome({ ...env, ...withLegacyEnv(parseEnvFile(envText ?? "")) }, home, io.loginShell));
   const devices2 = new FileDeviceStore(config.devicesPath);
   const hasRoster = await readFile6(config.devicesPath).then(() => true, () => false);
   const agentLivePath = cloneRepo === null ? "" : joinPath(cloneRepo, "deploy", "agent-live");
@@ -1812,9 +1819,10 @@ ${SETUP_USAGE.split("\n")[0]}
     stateDir: stateDirLayout(home),
     phonePortOwner: await owner(flags.phonePort),
     hooksPortOwner: await owner(config.port),
-    tailscale: flags.tailscale === "none" ? null : await tailscale.status(),
-    // Under --tailscale none, read only to word the operator's line: unreadable means the serve form.
-    serve: flags.tailscale === "none" && !flags.slug ? null : await tailscale.serveStatus(),
+    // Read whatever --tailscale says: they settle how the port is published when no flag does, and word
+    // whether phones need Tailscale. Both answer null when Tailscale is absent or will not tell.
+    tailscale: await tailscale.status(),
+    serve: await tailscale.serveStatus(),
     cli: kind === "package" ? await cliState(home, env) : null,
     adoption: cloneRepo === null ? null : { repo: cloneRepo, copyEnv, agentLive: { path: agentLivePath, kind: await linkKind(agentLivePath) } }
   };
@@ -1830,7 +1838,7 @@ ${SETUP_USAGE.split("\n")[0]}
         await loadOrCreateAgentKeys(config.agentKeyPath);
       },
       writeRoster: async () => {
-        await mkdir4(dirname4(config.devicesPath), { recursive: true, mode: 448 });
+        await mkdir3(dirname3(config.devicesPath), { recursive: true, mode: 448 });
         await devices2.update((roster) => roster);
       },
       writeLauncher: (path, text) => atomicWrite(path, text, 493),
@@ -1916,7 +1924,7 @@ async function apply2(argv, env, home, io) {
   if (envText === null) throw new Error(`failed: check: no agent config at ${envPath}: run tarfa setup`);
   const config = loadConfig(withLegacyEnv(parseEnvFile(envText)), home);
   const service = fx.service ?? serviceInstall({ home, user: userInfo().username, uid: process.getuid?.() ?? 0 });
-  const hooks = hooksFiles(home, HOOKS_DIR, config.port);
+  const hooks = hooksFiles(home, HOOKS_DIR, config.port, await resolveCodexHome({ ...env, ...withLegacyEnv(parseEnvFile(envText)) }, home, io.loginShell));
   const launcherPath = joinPath(home, ".tarfa", "bin", "tarfa-agent");
   const log = fx.agentLog ?? agentLog({ home });
   const result = await runApply(
@@ -1963,20 +1971,52 @@ async function apply2(argv, env, home, io) {
   if (!result.ok) throw new Error(result.lines.join("\n"));
   return result.lines.join("\n");
 }
-function pairingInstructions(link, minutes = PAIRING_TTL_MS / 6e4) {
-  return [
+function pairingInstructions(pairing, options) {
+  const { origin, minutes } = options;
+  const text = options.link ? pairingLink(origin, pairing) : pairingCode(pairing);
+  const how = options.link ? [
     "On the phone, in Tarfa: Settings \u2192 Scan QR code, then scan this. Or open the link below on the",
-    "phone (Android opens the installed app; on an iPhone copy it and use Settings \u2192 Paste pairing link).",
+    "phone (Android opens the installed app; on an iPhone copy it and use Settings \u2192 Paste pairing link)."
+  ] : [
+    `On the phone, open the Tarfa app (install it from ${origin} first), then Settings \u2192 Add machine:`,
+    "Scan QR code and scan this, or copy the code below to the phone and tap Paste pairing code."
+  ];
+  return [
+    ...how,
     "",
     // Half-height blocks: about 60 columns, where `term` needs twice that.
-    encodeQR(link, "ascii", { ecc: "low" }),
-    link,
+    encodeQR(text, "ascii", { ecc: "low" }),
+    text,
     "",
     // The phone asks before pairing and shows this fingerprint: they must match.
-    `The phone will show machine key ${deviceFingerprint(parsePairingLink(link).agentKey)}; check it matches.`,
+    `The phone will show machine key ${deviceFingerprint(pairing.agentKey)}; check it matches.`,
     `It works once, for ${minutes} minute${minutes === 1 ? "" : "s"}. \`tarfa pair\` makes another.`
   ].join("\n");
 }
+var DICTATION_KEY_USAGE = [
+  `usage: tarfa dictation-key [status | set ${DICTATION_PROVIDERS.join("|")} | remove ${DICTATION_PROVIDERS.join("|")}]`,
+  "  set     reads the key on stdin, or asks for it with echo off; never as an argument",
+  "  every phone paired with this machine dictates into its workspaces with it, at its next connect"
+].join("\n");
+async function dictationKey(store, [action = "status", name, ...extra], secret) {
+  if (action === "status") {
+    if (name !== void 0) throw new UsageError(DICTATION_KEY_USAGE);
+    const loaded2 = await store.load();
+    if ("problem" in loaded2) throw new Error(loaded2.problem);
+    return DICTATION_PROVIDERS.map((p) => `${p}  ${loaded2.keys[p] ? "set" : "not set"}`).join("\n");
+  }
+  if (action !== "set" && action !== "remove") throw new UsageError(DICTATION_KEY_USAGE);
+  if (action === "set" && extra.length > 0) {
+    throw new UsageError("pass the key on stdin or type it at the prompt, never as an argument: any local user can read a process's arguments");
+  }
+  const provider = name ? providerOf(name) : null;
+  if (!provider || extra.length > 0) throw new UsageError(DICTATION_KEY_USAGE);
+  const loaded = await store.load();
+  if ("problem" in loaded) throw new Error(loaded.problem);
+  const result = await changeDictationKey(store, provider, action === "remove" ? null : await secret(`${provider} key: `));
+  if (!result.ok) throw new Error(result.error);
+  return action === "remove" ? `${provider}: removed; phones stop getting it at their next connect. Rotate it at the provider if a phone that had it is lost` : `${provider}: stored; every phone paired with this machine gets it at its next connect`;
+}
 var DEVICES_USAGE = [
   "usage: tarfa devices [list | revoke <id|key> | forget <id|key> | enrolment open|closed]",
   "  enrolment open    a pairing code from `tarfa pair` enrols a new phone",

package/dist/serve.js

@@ -6,6 +6,7 @@ import {
   DEVICE_REFUSED,
   FileClaudeSessionsStore,
   FileDeviceStore,
+  FileDictationKeysStore,
   FileHiddenFoldersStore,
   FilePairingStore,
   FileParkedStore,
@@ -25,9 +26,11 @@ import {
   ShortWorkspaceIds,
   TmuxAdapter,
   WrongStaticKeyError,
+  announcedAddresses,
   audioMediaType,
   b64url,
   browseDir,
+  changeDictationKey,
   childEnv,
   cliOfCommand,
   configWarnings,
@@ -39,6 +42,7 @@ import {
   enrolDevice,
   enrolmentMode,
   exactTarget,
+  exposedFiles,
   formatAgentMessage,
   fsIsDirectory,
   getRecentPaths,
@@ -65,6 +69,7 @@ import {
   readHandshakeFrame,
   redeemPairing,
   relationOf,
+  resolveCodexHome,
   runsClaude,
   sessionOfCodexThread,
   standingOf,
@@ -73,7 +78,7 @@ import {
   systemPathResolver,
   withLegacyEnv,
   writeFileAtomic
-} from "./chunk-OC5VX7K3.js";
+} from "./chunk-UPCCR4ZA.js";
 
 // src/serve.ts
 import { homedir as homedir2 } from "node:os";
@@ -1283,6 +1288,7 @@ var PRE_AUTH_MAX_MESSAGE_BYTES = 8 * 1024;
 var MAX_AUTH_ATTEMPTS = 3;
 var MAX_HELD_MESSAGES = 16;
 var PAIRING_SECRET = /^[A-Za-z0-9_-]{43}$/;
+var FEATURES = [AGENT_FEATURES.lastReply, AGENT_FEATURES.dictationKeys, AGENT_FEATURES.setDictationKey];
 var NoiseClientConnection = class {
   constructor(socket, staticPrivate, options) {
     this.socket = socket;
@@ -1331,7 +1337,15 @@ var NoiseClientConnection = class {
       return;
     }
     if (message.type === "authResult" && message.ok) {
-      const accepted = { ...message, agent: { protocol: PROTOCOL_VERSION, ...this.options.agentVersion ? { version: this.options.agentVersion } : {}, features: [AGENT_FEATURES.lastReply] } };
+      const { agentVersion: agentVersion2, phoneAddresses } = this.options;
+      const features = [...this.options.features ?? FEATURES];
+      const agent = {
+        protocol: PROTOCOL_VERSION,
+        ...agentVersion2 ? { version: agentVersion2 } : {},
+        features: phoneAddresses ? [...features, AGENT_FEATURES.addresses] : features,
+        ...phoneAddresses ? { addresses: phoneAddresses } : {}
+      };
+      const accepted = { ...message, agent };
       message = accepted;
       if (!this.awaitingPhone) this.cancelDeadline();
       this.session.raiseCap(MAX_MESSAGE_BYTES);
@@ -2385,6 +2399,12 @@ var ConnectionHandler = class {
         this.conn.send({ type: "keyterms", keyterms: await this.deps.keyterms.list() });
         return;
       }
+      case "getDictationKeys":
+        this.conn.send({ type: "dictationKeys", ...await this.deps.dictationKeys?.read() });
+        return;
+      case "setDictationKey":
+        this.conn.send({ type: "dictationKeySet", id: message.id, provider: message.provider, ...await this.setDictationKey(message.provider, message.key) });
+        return;
       case "readFile": {
         const { binary, data, truncated } = await readFile10({ reader }, message.path, await this.allowedRoots());
         this.conn.send({ type: "fileContents", path: message.path, data, truncated, binary });
@@ -2678,6 +2698,17 @@ var ConnectionHandler = class {
     });
     this.conn.send({ type: "attached", workspaceId });
   }
+  // Any enrolled phone of this machine may change its key: it can already run anything in a
+  // terminal here. A thrown error may name the file, never the key, but is worded here anyway.
+  async setDictationKey(provider, key) {
+    const store = this.deps.dictationKeys;
+    if (!store) return { ok: false, error: "this agent keeps no dictation keys" };
+    try {
+      return await changeDictationKey(store, provider, key);
+    } catch {
+      return { ok: false, error: "the keys file could not be written" };
+    }
+  }
   // A dictation lives only as long as its attachment: without one the held spaces go nowhere,
   // and the machine's one dictation slot would stay taken.
   cancelVoice(reason) {
@@ -3875,7 +3906,7 @@ function startDeviceGate(deps) {
   return {
     staticPrivate: b64url.decode(keys.x25519.privateKey),
     devices,
-    options: (extra) => ({ devices, log, refusalLog, pushBudget, agentVersion: deps.agentVersion, ...extra }),
+    options: (extra) => ({ devices, log, refusalLog, pushBudget, agentVersion: deps.agentVersion, phoneAddresses: deps.phoneAddresses, ...extra }),
     roster: () => last,
     pollRoster: () => monitor.poll(),
     stop: () => clearInterval(poll)
@@ -4126,13 +4157,6 @@ import { join as join6 } from "node:path";
 
 // src/infrastructure/private-dir.ts
 import { chmod, mkdir as mkdir7, stat as stat4 } from "node:fs/promises";
-
-// src/application/private-files.ts
-function exposedFiles(files) {
-  return files.filter(({ mode }) => (mode & 63) !== 0).map(({ path, mode }) => `${path} is readable or writable by other users (mode ${(mode & 511).toString(8)}): run \`chmod 600 ${path}\``);
-}
-
-// src/infrastructure/private-dir.ts
 async function securePrivateDir(dir) {
   await mkdir7(dir, { recursive: true, mode: 448 });
   await chmod(dir, 448);
@@ -4185,6 +4209,9 @@ async function main() {
   const env = withLegacyEnv(process.env);
   const config = loadConfig(env, homedir2());
   for (const warning of configWarnings(process.env)) process.stderr.write(`${warning}
+`);
+  const codexHome = await resolveCodexHome(env, homedir2());
+  process.stdout.write(`tarfa agent: Codex home ${codexHome}
 `);
   await securePrivateDir(config.stateDir);
   await assertPrivateFiles([
@@ -4192,6 +4219,7 @@ async function main() {
     config.devicesPath,
     config.pairingPath,
     join7(config.stateDir, "token"),
+    config.dictationKeysPath,
     // The launcher sources it: whoever can write it runs code as this user.
     await locateAgentEnv(env, homedir2())
   ]);
@@ -4234,6 +4262,8 @@ async function main() {
     launchers: new FileLaunchersStore(config.launchersPath),
     detectInstalled: (names) => detectInstalled(names, loginShellResolver()),
     keyterms: new FileKeytermsStore(config.keytermsPath),
+    dictationKeys: new FileDictationKeysStore(config.dictationKeysPath, (problem) => process.stderr.write(`tarfa agent: no dictation keys sent: ${problem}
+`)),
     clientLog: new FileClientLogStore(config.clientLogPath),
     hookEventLog: new FileHookEventLog(config.hookEventLogPath),
     messaging: {
@@ -4241,7 +4271,7 @@ async function main() {
       delivery: new CompositeDelivery({
         claude: new ClaudeInboxDelivery(claudeSessions, async (id) => await tmux.firstPaneId?.(id) ?? null),
         pi: new PiInboxDelivery(config.inboxDir),
-        codex: new CodexDelivery(new CodexAppServer())
+        codex: new CodexDelivery(new CodexAppServer({ codexHome }))
       }),
       log: new FileMessageLog(config.messageLogPath)
     },
@@ -4273,7 +4303,8 @@ async function main() {
     pairings: new FilePairingStore(config.pairingPath),
     log,
     rosterPollMs: ROSTER_POLL_MS,
-    agentVersion
+    agentVersion,
+    phoneAddresses: announcedAddresses(config.phoneAddresses)
   });
   try {
     const phones = await startPhoneListener({