@tarfa/cli 0.1.5 → 0.1.7

package/dist/cli.js

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 import {
   CodexAppServer,
+  DICTATION_PROVIDERS,
   FileClaudeSessionsStore,
   FileDeviceStore,
+  FileDictationKeysStore,
   FileHiddenFoldersStore,
   FilePairingStore,
   FileParkedStore,
@@ -17,9 +19,10 @@ import {
   STATE_DIR,
   ShortWorkspaceIds,
   TmuxAdapter,
-  addPairing,
   agentEnvFile,
+  atomicWrite,
   browseDir,
+  changeDictationKey,
   childEnv,
   cloneOfUnit,
   codexVersions,
@@ -37,7 +40,6 @@ import {
   isEntrypoint,
   isHiddenPath,
   isMachineUrl,
-  isPairingPath,
   listWorkspaces,
   loadConfig,
   loadOrCreateAgentKeys,
@@ -46,14 +48,18 @@ import {
   loginShellResolver,
   mainCheckout,
   migrateStateDir,
+  mintPairing,
   packageRoot,
   packageVersion,
+  pairingCode,
   pairingLink,
+  pairingName,
   parseEnvFile,
-  parsePairingLink,
   parseSetupFlags,
   planCli,
   planSetup,
+  providerOf,
+  readAgentPublicKey,
   renderService,
   resolveCodexHome,
   resolveStateDir,
@@ -65,14 +71,15 @@ import {
   systemPathResolver,
   unitRunsLauncher,
   withEnrolmentMode,
-  withLegacyEnv
-} from "./chunk-KTUXNG4Q.js";
+  withLegacyEnv,
+  workspaceLink
+} from "./chunk-4M2ZRGQR.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;
@@ -653,29 +660,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);
@@ -705,7 +696,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;
@@ -759,7 +750,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}`];
       }
     };
@@ -811,9 +802,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"];
     }
@@ -980,29 +971,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";
@@ -1186,7 +1198,7 @@ async function run3(argv, rawEnv, home, io = {}) {
     throw new UsageError(RELAYS_GONE);
   }
   if (argv[0] === "pair") return pair(argv.slice(1), env, home);
-  if (argv[0] === "ls" || argv[0] === "spawn" || argv[0] === "peek" || argv[0] === "unpark" || argv[0] === "rename" || argv[0] === "send" || argv[0] === "close" || argv[0] === "wait") {
+  if (argv[0] === "ls" || argv[0] === "spawn" || argv[0] === "peek" || argv[0] === "unpark" || argv[0] === "rename" || argv[0] === "link" || argv[0] === "send" || argv[0] === "close" || argv[0] === "wait") {
     return orchestration(argv[0], argv.slice(1), env, home, io);
   }
   const config = loadConfig({ ...env, ...await agentEnvValues(env, home) }, home);
@@ -1252,6 +1264,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\`)`);
   }
@@ -1260,8 +1274,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
@@ -1275,6 +1290,7 @@ Workspaces on this machine:
   send           send a message to another workspace
   unpark         reopen parked workspaces
   rename         rename a workspace (without an id: this one)
+  link           print a link that opens a workspace in the app (without an id: this one)
   close          close workspaces
   list, create, recent, browse   the agent's own views, as JSON
 
@@ -1287,12 +1303,14 @@ var COMMANDS = /* @__PURE__ */ new Set([
   "connect",
   "relay-key",
   "devices",
+  "dictation-key",
   "install-hooks",
   "ls",
   "spawn",
   "peek",
   "unpark",
   "rename",
+  "link",
   "send",
   "close",
   "wait",
@@ -1307,6 +1325,7 @@ var SPAWN_CLIS = ["claude", "codex", "pi"];
 var PEEK_USAGE = "usage: tarfa peek <workspace id> [-n <lines>]";
 var UNPARK_USAGE = "usage: tarfa unpark <workspace id>...";
 var RENAME_USAGE = "usage: tarfa rename [<workspace id>] <title>   (without an id: the workspace this runs in)";
+var LINK_USAGE = "usage: tarfa link [<workspace id>] [--pwa <PWA origin>]   (without an id: the workspace this runs in)";
 var SEND_USAGE = 'usage: tarfa send <workspace id> "<message>"   (or the message on stdin)';
 var CLOSE_USAGE = "usage: tarfa close <workspace id>...";
 var WAIT_USAGE = "usage: tarfa wait <workspace id>... [--timeout <seconds, at least 10>]";
@@ -1469,6 +1488,18 @@ async function orchestration(command, argv, env, home, io) {
       const done = `${id}: renamed to "${title.trim()}"`;
       return locked ? done : `${done} (this tmux cannot lock a title, so Claude may rename it again)`;
     }
+    case "link": {
+      const origin = pwaOrigin(takeOption(args, "--pwa", LINK_USAGE));
+      if (args.length > 1 || args.some((a) => a.startsWith("-"))) throw new Error(LINK_USAGE);
+      const id = args[0] ?? await callerWorkspace(env, tmux, config.sessionPrefix);
+      const workspace = (await listAll()).find((w) => w.id === id);
+      if (!workspace) throw new Error(`no workspace ${id} (see tarfa ls)`);
+      if (isHiddenPath(workspace.projectPath, await new FileHiddenFoldersStore(config.hiddenFoldersPath).list())) {
+        throw new Error(`${id} is in a hidden folder, which phones do not list`);
+      }
+      const agentKey = await readAgentPublicKey(config.agentKeyPath);
+      return workspaceLink(origin ?? pwaOrigin(config.pwaOrigin), { agentKey, workspaceId: id });
+    }
     case "close": {
       if (args.length === 0 || args.some((id) => id.startsWith("-"))) throw new UsageError(CLOSE_USAGE);
       const self = await callerWorkspace(env, tmux, config.sessionPrefix).catch(() => void 0);
@@ -1587,7 +1618,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;
@@ -1629,6 +1661,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);
@@ -1643,19 +1677,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;
@@ -1675,11 +1711,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
@@ -1687,7 +1728,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
@@ -1795,9 +1836,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) } }
   };
@@ -1813,7 +1855,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),
@@ -1946,20 +1988,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,
@@ -74,7 +78,7 @@ import {
   systemPathResolver,
   withLegacyEnv,
   writeFileAtomic
-} from "./chunk-KTUXNG4Q.js";
+} from "./chunk-4M2ZRGQR.js";
 
 // src/serve.ts
 import { homedir as homedir2 } from "node:os";
@@ -1284,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;
@@ -1332,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);
@@ -2386,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 });
@@ -2679,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) {
@@ -3876,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)
@@ -4127,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);
@@ -4196,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())
   ]);
@@ -4238,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: {
@@ -4277,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({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tarfa/cli",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Tarfa agent and CLI: serves your Claude Code terminal sessions (tmux workspaces) to the Tarfa phone app.",
   "repository": {
     "type": "git",