@tinycloud/cli 1.3.5-beta.4 → 1.3.5-beta.6

package/dist/courier-entry.js

@@ -4,10 +4,10 @@ var EXT = "https://tinycloud.xyz/ext/courier/v0";
 var DEFAULT_HOST = "https://tee.node.tinycloud.xyz";
 var COURIER_SPACE = "agents";
 var AGENT_GRANT_EXPIRY = "30d";
-var kv = (path21, actions) => ({
+var kv = (path22, actions) => ({
   service: "tinycloud.kv",
   space: COURIER_SPACE,
-  path: `${PREFIX}/${path21}`,
+  path: `${PREFIX}/${path22}`,
   actions: actions.map((action) => `tinycloud.kv/${action}`)
 });
 var AGENT_GRANT = [
@@ -826,7 +826,7 @@ function authorityTuples(entries) {
   return tuples;
 }
 function renderTuples(tuples) {
-  const shown = tuples.slice(0, 3).map(({ service, space, path: path21, action }) => `${service} ${space} ${path21 || '""'} ${action}`);
+  const shown = tuples.slice(0, 3).map(({ service, space, path: path22, action }) => `${service} ${space} ${path22 || '""'} ${action}`);
   if (tuples.length > 3)
     shown.push(`(+${tuples.length - 3} more)`);
   return shown.join("; ");
@@ -899,9 +899,10 @@ import { TinyCloudNode, DelegatedAccess, NodeWasmBindings, activateValidatedRunt
 // ../courier/dist/profile.js
 import fs from "fs";
 import path from "path";
+import os from "os";
 import { randomBytes } from "crypto";
 function profileDir() {
-  return process.env.COURIER_HOME || path.join(process.env.HOME ?? ".", ".courier");
+  return process.env.COURIER_HOME || path.join(os.homedir(), ".courier");
 }
 function profilePath(name2, home = profileDir()) {
   return path.join(home, name2);
@@ -909,11 +910,13 @@ function profilePath(name2, home = profileDir()) {
 function profileExists() {
   return fs.existsSync(profilePath("profile.json"));
 }
-function ensureSecureDir() {
-  const dir = profileDir();
+function mkdirOwnerOnly(dir) {
   fs.mkdirSync(dir, { recursive: true, mode: 448 });
   fs.chmodSync(dir, 448);
 }
+function ensureSecureDir() {
+  mkdirOwnerOnly(profileDir());
+}
 function writeSecure(file, obj) {
   ensureSecureDir();
   const temp = `${file}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
@@ -1103,7 +1106,7 @@ async function peerHooks(node, profile, peer) {
 // ../courier/dist/args.js
 function parseArgs(argv) {
   const positional = [];
-  const BOOLS = { json: true, help: true, force: true, stdin: true, quiet: true, "rotate-key": true, paste: true, request: true, peek: true, resume: true, once: true, unguarded: true, "install-launchd": true, "install-systemd": true, "dry-run": true };
+  const BOOLS = { json: true, help: true, force: true, stdin: true, "code-stdin": true, quiet: true, "rotate-key": true, paste: true, request: true, peek: true, resume: true, once: true, unguarded: true, "install-launchd": true, "install-systemd": true, "dry-run": true };
   const flags = /* @__PURE__ */ new Map();
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
@@ -2255,7 +2258,7 @@ import path3 from "path";
 
 // ../courier/dist/guard/paths.js
 import fs2 from "fs";
-import os from "os";
+import os2 from "os";
 import path2 from "path";
 var CREDENTIAL_SUBSTRINGS = [
   ".config/gh",
@@ -2404,7 +2407,7 @@ function installRoots(entry) {
 function protectedSet(home, entry, extra = {}) {
   return {
     roots: [path2.resolve(home), ...installRoots(entry)],
-    homes: [.../* @__PURE__ */ new Set([os.homedir(), ...extra.agentHome ? [extra.agentHome] : []])]
+    homes: [.../* @__PURE__ */ new Set([os2.homedir(), ...extra.agentHome ? [extra.agentHome] : []])]
   };
 }
 function isProtectedRead(file, cwd, set) {
@@ -4940,7 +4943,7 @@ function analyzeScript(text, parent, inexact) {
 
 // ../courier/dist/guard/install.js
 import fs4 from "fs";
-import os2 from "os";
+import os3 from "os";
 import path6 from "path";
 import { createHash } from "crypto";
 var CREDENTIAL_FILES = [".config/gh/**", ".npmrc", ".netrc", ".ssh/**", ".aws/**", ".config/gcloud/**", ".docker/config.json", ".config/wrangler/**", ".config/.wrangler/**", ".git-credentials"];
@@ -4982,7 +4985,7 @@ var GATED_DENY = [
 ].map((prefix) => `Bash(${prefix}:*)`);
 var PRIVILEGE_DENY = ["sudo", "su", "doas", "pkexec", "tmux", "screen", "crontab", "systemctl", "ssh", "gh auth", "git credential", "secret-tool"].map((prefix) => `Bash(${prefix}:*)`);
 var shq = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
-function hookCommand(argv, home, realHome = os2.homedir()) {
+function hookCommand(argv, home, realHome = os3.homedir()) {
   return `COURIER_HOME=${shq(home)} COURIER_REAL_HOME=${shq(realHome)} ${argv.map(shq).join(" ")} || exit 2`;
 }
 var guardDir = (home) => path6.join(home, "guard");
@@ -5005,7 +5008,7 @@ function guardSettings(options) {
   for (const f of ["key.json", "grant.json"])
     deny2.push(`Read(${rulePath(path6.join(home, f))})`);
   for (const rel of CREDENTIAL_FILES)
-    deny2.push(`Read(${rulePath(path6.join(os2.homedir(), rel))})`);
+    deny2.push(`Read(${rulePath(path6.join(os3.homedir(), rel))})`);
   for (const prog of programs)
     for (const sub2 of ["pair", "revoke", "init", "pause", "resume", "watch"])
       deny2.push(`Bash(${prog} ${sub2}:*)`);
@@ -5185,7 +5188,7 @@ function courierEnvOverrides(base, home, extra = []) {
 // ../courier/dist/wake.js
 import { spawn } from "child_process";
 import fs7 from "fs";
-import os3 from "os";
+import os4 from "os";
 import path9 from "path";
 
 // ../courier/dist/guard/cleanhome.js
@@ -5564,7 +5567,7 @@ function createWaker(config, deps) {
     if (cwd === courier || cwd.startsWith(`${courier}${path9.sep}`))
       throw new Error("agent cwd must be outside the Courier tree");
     prepareCleanHome({
-      realHome: config.realHome ?? env.HOME ?? os3.homedir(),
+      realHome: config.realHome ?? env.HOME ?? os4.homedir(),
       cleanHome: agentHome(config.home),
       claude: config.adapter !== "exec"
     });
@@ -5656,7 +5659,7 @@ ${UNGUARDED_NOTICE}.`
     }
     const existing = agents.find((a) => typeof a.id === "string" && typeof a.provider === "string" && isClaudeProvider(a.provider) && typeof a.cwd === "string" && sameDir(a.cwd, config.cwd))?.id;
     if (existing) {
-      const dir = fs7.mkdtempSync(path9.join(os3.tmpdir(), "courier-wake-"));
+      const dir = fs7.mkdtempSync(path9.join(os4.tmpdir(), "courier-wake-"));
       const file = path9.join(dir, "prompt.txt");
       try {
         fs7.writeFileSync(file, prompt(request), { mode: 384 });
@@ -5800,7 +5803,7 @@ function createNotifier(config, deps) {
 
 // ../courier/dist/commands.js
 import fs9 from "fs";
-import os4 from "os";
+import os5 from "os";
 import path11 from "path";
 import { NodeWasmBindings as NodeWasmBindings2, activateValidatedRuntimeDelegation as activateValidatedRuntimeDelegation2, deserializeDelegation as deserializeDelegation2, serializeDelegation as serializeDelegation2 } from "@tinycloud/node-sdk";
 
@@ -6270,7 +6273,7 @@ async function cmdInit(args) {
     version: 3,
     host,
     openkeyHost,
-    label: labelFlag ?? `courier \xB7 ${os4.hostname()}`,
+    label: labelFlag ?? `courier \xB7 ${os5.hostname()}`,
     ...handleFlag ? { selfHandle: handleFlag } : {},
     courierDid: bareDid(key.did),
     status: "awaiting-grant",
@@ -6844,7 +6847,7 @@ ${DEFAULT_ORDERS}`);
 
 // ../courier/dist/watch-cmd.js
 import fs13 from "fs";
-import os7 from "os";
+import os8 from "os";
 import path16 from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 import { spawnSync as spawnSync4 } from "child_process";
@@ -7395,8 +7398,8 @@ var Watcher = class {
     const prefix = `${PREFIX}/to/${peer.handle}/threads/`;
     const keys = await listAll(this.deps.selfKv, prefix);
     const known = /* @__PURE__ */ new Set();
-    for (const path21 of keys) {
-      const match = /^([^/]+)\/(?:meta\.json|(?:msg|task)\/[^/]+\.json)$/.exec(path21.slice(prefix.length));
+    for (const path22 of keys) {
+      const match = /^([^/]+)\/(?:meta\.json|(?:msg|task)\/[^/]+\.json)$/.exec(path22.slice(prefix.length));
       if (match && SAFE_ID.test(match[1]))
         known.add(`${peer.handle}/${match[1]}`);
     }
@@ -8273,19 +8276,19 @@ var Watcher = class {
 
 // ../courier/dist/guard/command.js
 import fs11 from "fs";
-import os6 from "os";
+import os7 from "os";
 import path14 from "path";
 import { spawnSync as spawnSync3 } from "child_process";
 
 // ../courier/dist/broker-config.js
 import fs10 from "fs";
-import os5 from "os";
+import os6 from "os";
 import path12 from "path";
 var TEST_TOKEN = `ghp_${"d".repeat(36)}`;
 var ID = /^[a-f0-9]{24}$/;
 var PINNED = ["host", "openkeyHost", "spaceId", "ownerDid", "courierDid"];
 function brokerRoot(testOwnerRoot) {
-  const owner = os5.userInfo().homedir;
+  const owner = os6.userInfo().homedir;
   if (testOwnerRoot !== void 0) {
     const root = realpathBest(testOwnerRoot);
     const scratch = realpathBest(path12.join(owner, "scratch"));
@@ -8294,7 +8297,7 @@ function brokerRoot(testOwnerRoot) {
     }
     if (fs10.existsSync(root)) {
       const st = fs10.statSync(root);
-      if (st.uid !== os5.userInfo().uid || st.mode & 63)
+      if (st.uid !== os6.userInfo().uid || st.mode & 63)
         throw new CourierError("usage", "--test-owner-root must be owner-private (0700)");
     }
     const broker = realpathBest(path12.join(root, ".config/courier-broker"));
@@ -8350,7 +8353,7 @@ function loadBrokerConfig(id, testOwnerRoot) {
   try {
     for (const f of [path12.dirname(file), file]) {
       const st2 = fs10.lstatSync(f);
-      if (st2.isSymbolicLink() || st2.uid !== os5.userInfo().uid || st2.mode & 63)
+      if (st2.isSymbolicLink() || st2.uid !== os6.userInfo().uid || st2.mode & 63)
         throw Error("not owner-private");
     }
     const config = JSON.parse(fs10.readFileSync(file, "utf8"));
@@ -8503,8 +8506,8 @@ function realEnv(cwd, home = profileDir(), entry = process.argv[1] ?? "") {
     binaries: installed,
     resolveProgram: (word, dir) => binaryName(word, dir, searchPath, installed),
     literals: [...installLiterals(home, entry), brokerRoot()],
-    protectedRoots: [home, brokerRoot(), path14.join(os6.homedir(), ".courier")],
-    realHome: process.env.COURIER_REAL_HOME || os6.userInfo().homedir,
+    protectedRoots: [home, brokerRoot(), path14.join(os7.homedir(), ".courier")],
+    realHome: process.env.COURIER_REAL_HOME || os7.userInfo().homedir,
     courierEntries: installed.filter((b) => b.path === realpathBest(entry) && ["courier", "tc"].includes(b.name)).map((b) => b.path),
     readFile(file) {
       try {
@@ -8575,10 +8578,10 @@ async function cmdGuard(args) {
     const input = JSON.parse(readStdin());
     const home = profileDir();
     const entry = process.argv[1] ?? "";
-    const realHome = process.env.COURIER_REAL_HOME || os6.homedir();
+    const realHome = process.env.COURIER_REAL_HOME || os7.homedir();
     const deps = {
       env: realEnv(process.cwd(), home, entry),
-      protectedSet: { ...protectedSet(home, entry, { agentHome: os6.homedir() }), roots: [...protectedSet(home, entry).roots, brokerRoot(), path14.join(os6.homedir(), ".courier")], homes: [.../* @__PURE__ */ new Set([realHome, os6.homedir()])], realHome }
+      protectedSet: { ...protectedSet(home, entry, { agentHome: os7.homedir() }), roots: [...protectedSet(home, entry).roots, brokerRoot(), path14.join(os7.homedir(), ".courier")], homes: [.../* @__PURE__ */ new Set([realHome, os7.homedir()])], realHome }
     };
     const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error("timed out")), DEADLINE_MS).unref());
     const decision = await Promise.race([decide(input, deps), timeout]);
@@ -8947,7 +8950,7 @@ async function installService(args, config) {
     logFile: path16.join(profileDir(), `watch${name2 ? `-${name2}` : ""}.log`),
     name: name2
   };
-  const plan = launchd ? launchdPlan(spec, os7.homedir(), process.getuid?.() ?? 0) : systemdPlan(spec, os7.homedir());
+  const plan = launchd ? launchdPlan(spec, os8.homedir(), process.getuid?.() ?? 0) : systemdPlan(spec, os8.homedir());
   if (dry) {
     process.stdout.write(renderPlan(plan));
     return;
@@ -9054,36 +9057,36 @@ function parseEntry(value2) {
     return void 0;
   return { tier, ratePerHour, outPerHour };
 }
-function loadPeers(path21, ownerUid2 = process.getuid?.()) {
+function loadPeers(path22, ownerUid2 = process.getuid?.()) {
   let fd;
   try {
-    fd = fs14.openSync(path21, fs14.constants.O_RDONLY | fs14.constants.O_NOFOLLOW);
+    fd = fs14.openSync(path22, fs14.constants.O_RDONLY | fs14.constants.O_NOFOLLOW);
   } catch (error) {
     const code = error.code;
     if (code === "ENOENT")
       return /* @__PURE__ */ Object.create(null);
     if (code === "ELOOP")
-      throw new CourierError("insecure-peers", `${path21} is a symbolic link; point the flag at the file itself.`);
+      throw new CourierError("insecure-peers", `${path22} is a symbolic link; point the flag at the file itself.`);
     throw error;
   }
   try {
     const stat = fs14.fstatSync(fd);
     if (!stat.isFile())
-      throw new CourierError("insecure-peers", `${path21} is not a regular file.`);
+      throw new CourierError("insecure-peers", `${path22} is not a regular file.`);
     if (ownerUid2 !== void 0 && stat.uid !== ownerUid2) {
-      throw new CourierError("insecure-peers", `${path21} is not owned by the peers owner (uid ${ownerUid2}); pass --peers-owner or chown the file.`);
+      throw new CourierError("insecure-peers", `${path22} is not owned by the peers owner (uid ${ownerUid2}); pass --peers-owner or chown the file.`);
     }
     if ((stat.mode & 18) !== 0) {
-      throw new CourierError("insecure-peers", `${path21} is writable by group or others; restrict it to the owner (chmod 600).`);
+      throw new CourierError("insecure-peers", `${path22} is writable by group or others; restrict it to the owner (chmod 600).`);
     }
     const parsed = JSON.parse(fs14.readFileSync(fd, "utf8"));
     if (!isRecord(parsed))
-      throw new CourierError("bad-peers", `${path21} must be a JSON object keyed by peer id.`);
+      throw new CourierError("bad-peers", `${path22} must be a JSON object keyed by peer id.`);
     const peers = /* @__PURE__ */ Object.create(null);
     for (const [peerId, value2] of Object.entries(parsed)) {
       const policy = parseEntry(value2);
       if (!policy)
-        throw new CourierError("bad-peers", `${path21} has an invalid policy for peer "${peerId}"; fix the entry. Nothing was loaded.`);
+        throw new CourierError("bad-peers", `${path22} has an invalid policy for peer "${peerId}"; fix the entry. Nothing was loaded.`);
       peers[peerId] = policy;
     }
     return peers;
@@ -10749,7 +10752,7 @@ ${targetHelp()}`);
 // ../courier/dist/broker.js
 import { execFile } from "child_process";
 import fs18 from "fs";
-import os8 from "os";
+import os9 from "os";
 import path20 from "path";
 var MAX_OUTPUT = 4e3;
 var EXEC_TIMEOUT_MS = 12e4;
@@ -10758,7 +10761,7 @@ var validToken = (token2) => TOKEN.test(token2);
 async function loadBrokerCredential(config, exec = execFileRunner) {
   if (config.testToken === TEST_TOKEN)
     return { ghBin: config.ghBin, token: TEST_TOKEN };
-  const ownerHome = os8.userInfo().homedir;
+  const ownerHome = os9.userInfo().homedir;
   const result = await exec(config.ghBin, ["auth", "token", "--hostname", "github.com"], {
     cwd: ownerHome,
     timeoutMs: 1e4,
@@ -10968,6 +10971,308 @@ async function cmdBroker(args) {
 `);
 }
 
+// ../courier/dist/credential.js
+import { createPrivateKey, sign as cryptoSign } from "crypto";
+import { createInterface as createInterface2 } from "readline";
+import { completeEmailProof, createEd25519HolderSigner, EmailProofError, emailProofRequirement, requestEmailProofCode } from "@tinycloud/node-sdk/credentials";
+import { createFileEmailProofPendingStore, PendingStoreError } from "@tinycloud/node-sdk/credential-pending-store";
+import { credentialRequirementDigest } from "@tinycloud/sdk-core";
+
+// ../courier/dist/credential-source.js
+import fs19 from "fs";
+import path21 from "path";
+import { createHash as createHash4, randomBytes as randomBytes5 } from "crypto";
+import { createStoredCredentialRecord, credentialMatchesRequirement } from "@tinycloud/sdk-core";
+var DIR_NAME = "credentials";
+function credentialsDir(home) {
+  return path21.join(home, DIR_NAME);
+}
+function sha256Hex(text) {
+  return createHash4("sha256").update(text).digest("hex");
+}
+function credentialFile(home, holderDid, requirementDigest) {
+  return path21.join(credentialsDir(home), `credential-${sha256Hex(`${holderDid}
+${requirementDigest}`)}.json`);
+}
+function lstatOrUndefined2(file) {
+  try {
+    return fs19.lstatSync(file);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return void 0;
+    throw error;
+  }
+}
+function assertOwnerOnly(st, label2, expectedMode) {
+  const mode = st.mode & 511;
+  if ((mode & 63) !== 0) {
+    throw new CourierError("credential-permissions", `${label2} must be owner-only (mode ${expectedMode}); found mode ${mode.toString(8)}.`);
+  }
+  assertOwnedByCurrentUser(st, label2);
+}
+function assertOwnedByCurrentUser(st, label2) {
+  if (typeof process.getuid === "function" && st.uid !== process.getuid()) {
+    throw new CourierError("credential-permissions", `${label2} is not owned by the current user.`);
+  }
+}
+function ensureSecureDir2(home) {
+  const dir = credentialsDir(home);
+  mkdirOwnerOnly(dir);
+  const st = fs19.lstatSync(dir);
+  if (!st.isDirectory())
+    throw new CourierError("credential-permissions", `${dir} must be a real directory, not a symlink or file.`);
+  assertOwnedByCurrentUser(st, dir);
+  fs19.chmodSync(dir, 448);
+}
+function checkSecureDir(home) {
+  const dir = credentialsDir(home);
+  const st = lstatOrUndefined2(dir);
+  if (!st)
+    return false;
+  if (!st.isDirectory())
+    throw new CourierError("credential-permissions", `${dir} must be a real directory, not a symlink or file.`);
+  assertOwnerOnly(st, dir, "0700");
+  return true;
+}
+function writeOwnerOnly(home, file, obj) {
+  ensureSecureDir2(home);
+  const existing = lstatOrUndefined2(file);
+  if (existing && !existing.isFile()) {
+    throw new CourierError("credential-permissions", `${path21.basename(file)} exists and is not a regular file; refusing to replace it.`);
+  }
+  const temp = `${file}.${process.pid}.${randomBytes5(6).toString("hex")}.tmp`;
+  let fd;
+  try {
+    fd = fs19.openSync(temp, fs19.constants.O_WRONLY | fs19.constants.O_CREAT | fs19.constants.O_EXCL | fs19.constants.O_NOFOLLOW, 384);
+    fs19.writeFileSync(fd, JSON.stringify(obj, null, 2) + "\n");
+    fs19.fchmodSync(fd, 384);
+    fs19.fsyncSync(fd);
+    fs19.closeSync(fd);
+    fd = void 0;
+    fs19.renameSync(temp, file);
+  } finally {
+    if (fd !== void 0)
+      fs19.closeSync(fd);
+    try {
+      fs19.unlinkSync(temp);
+    } catch {
+    }
+  }
+}
+function readOwnerOnly(home, file) {
+  if (!checkSecureDir(home))
+    return void 0;
+  const label2 = path21.basename(file);
+  const before = lstatOrUndefined2(file);
+  if (!before)
+    return void 0;
+  if (!before.isFile())
+    throw new CourierError("credential-permissions", `${label2} must be a regular file; symlinks are refused.`);
+  assertOwnerOnly(before, label2, "0600");
+  const fd = fs19.openSync(file, fs19.constants.O_RDONLY | fs19.constants.O_NOFOLLOW);
+  let text;
+  try {
+    const opened = fs19.fstatSync(fd);
+    if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino) {
+      throw new CourierError("credential-permissions", `${label2} changed while it was being opened.`);
+    }
+    if (opened.nlink !== 1)
+      throw new CourierError("credential-permissions", `${label2} has multiple hard links; refusing to read it.`);
+    assertOwnerOnly(opened, label2, "0600");
+    text = fs19.readFileSync(fd, "utf8");
+  } finally {
+    fs19.closeSync(fd);
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new CourierError("credential-store-invalid", `Invalid credential store file ${label2}.`);
+  }
+}
+function removeFile(file) {
+  fs19.rmSync(file, { force: true });
+}
+var StoredCredentialSource = class {
+  home;
+  constructor(home = profileDir()) {
+    this.home = home;
+  }
+  async find(input) {
+    const file = credentialFile(this.home, input.holderDid, input.requirementDigest);
+    const record = readOwnerOnly(this.home, file);
+    if (!record)
+      return void 0;
+    const now = input.now ?? /* @__PURE__ */ new Date();
+    if (!credentialMatchesRequirement(input.requirement, record, input.holderDid, now)) {
+      removeFile(file);
+      return void 0;
+    }
+    return record;
+  }
+  async store(input) {
+    const record = await createStoredCredentialRecord({
+      verified: input.verified,
+      ownerDid: input.holderDid,
+      requirement: input.requirement,
+      requirementDigest: input.requirementDigest,
+      storedAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString()
+    });
+    writeOwnerOnly(this.home, credentialFile(this.home, input.holderDid, input.requirementDigest), record);
+    return record;
+  }
+};
+
+// ../courier/dist/credential.js
+var acquireUsage = () => `Usage: ${cmd("credential acquire --email <addr> [--code-stdin]")}`;
+var showUsage = () => `Usage: ${cmd("credential show --email <addr>")}`;
+var credentialUsage = () => `${acquireUsage()}
+${showUsage()}`;
+function holderFor(key) {
+  let privateKey;
+  try {
+    privateKey = createPrivateKey({ key: key.jwk, format: "jwk" });
+  } catch {
+    throw new CourierError("credential.request.HOLDER_INVALID", "Agent signing key is unusable.");
+  }
+  try {
+    return createEd25519HolderSigner(key.did, async (bytes) => new Uint8Array(cryptoSign(null, bytes, privateKey)));
+  } catch (error) {
+    throw mapEmailProofError(error, "request");
+  }
+}
+function isEmailProofError(error) {
+  return error instanceof EmailProofError;
+}
+function mapEmailProofError(error, fallbackStep) {
+  if (isEmailProofError(error))
+    return new CourierError(`credential.${error.step}.${error.code}`, error.message);
+  return new CourierError(`credential.${fallbackStep}.FAILED`, "Email verification failed.");
+}
+function keepsPendingAfterFailure(error) {
+  return isEmailProofError(error) && error.recoverable;
+}
+async function withStoreErrors(run2) {
+  try {
+    return await run2();
+  } catch (error) {
+    if (error instanceof PendingStoreError)
+      throw new CourierError(error.code, error.message);
+    throw error;
+  }
+}
+async function readStdinFirstLine() {
+  const rl = createInterface2({ input: process.stdin, crlfDelay: Infinity });
+  for await (const line of rl) {
+    rl.close();
+    return line;
+  }
+  return "";
+}
+async function acquire(args, deps) {
+  const address = requireFlag(args, "email", acquireUsage()).trim();
+  if (args.has("code"))
+    throw new CourierError("usage", `--code is refused: it puts the code on argv. Enter the code with --code-stdin. ${acquireUsage()}`);
+  const key = deps.loadKey(deps.home);
+  const holder = holderFor(key);
+  const store = createFileEmailProofPendingStore({ home: deps.home });
+  if (!args.has("code-stdin")) {
+    const older = await withStoreErrors(() => store.findLive(address, deps.now()));
+    let pending2;
+    try {
+      pending2 = await deps.requestCode({ address, holder, fetch: deps.fetch, now: deps.now });
+    } catch (error) {
+      throw mapEmailProofError(error, "request");
+    }
+    await withStoreErrors(async () => {
+      await store.put(pending2);
+      if (older && older.requestId !== pending2.requestId)
+        await store.delete(older.requestId);
+    });
+    deps.out(`Verification code sent to ${address}. Run \`${cmd(`credential acquire --email ${address} --code-stdin`)}\` and enter the code within 15 minutes.
+`);
+    return;
+  }
+  const code = (await deps.readStdinLine()).trim();
+  if (!/^\d{8}$/.test(code))
+    throw new CourierError("credential.code.CODE_INVALID", "Verification code must be 8 digits.");
+  const pending = await withStoreErrors(() => store.findLive(address, deps.now()));
+  if (!pending) {
+    throw new CourierError("credential-request-missing", `No pending verification for ${address}. Run \`${cmd(`credential acquire --email ${address}`)}\` first.`);
+  }
+  if (pending.holderDid !== holder.did) {
+    await withStoreErrors(() => store.delete(pending.requestId));
+    throw new CourierError("credential.session.SESSION_INVALID", "Pending verification belongs to a different agent key. Request a new code.");
+  }
+  let result;
+  try {
+    result = await deps.completeProof({ pending, code, holder, fetch: deps.fetch, now: deps.now });
+  } catch (error) {
+    if (keepsPendingAfterFailure(error)) {
+      const mapped = mapEmailProofError(error, "credential");
+      throw new CourierError(mapped.code, `${mapped.message} Retry with --code-stdin before ${pending.expiresAt}.`);
+    }
+    await withStoreErrors(() => store.delete(pending.requestId));
+    throw mapEmailProofError(error, "credential");
+  }
+  const requirement = emailProofRequirement(address);
+  const requirementDigest = await credentialRequirementDigest(requirement);
+  await new StoredCredentialSource(deps.home).store({
+    verified: result.verified,
+    requirement,
+    requirementDigest,
+    holderDid: holder.did,
+    now: deps.now()
+  });
+  await withStoreErrors(() => store.delete(pending.requestId));
+  deps.out(`Email credential stored for ${address}. It is valid for up to 1 hour from issuance.
+`);
+}
+async function show(args, deps) {
+  const address = requireFlag(args, "email", showUsage()).trim();
+  const holder = holderFor(deps.loadKey(deps.home));
+  const requirement = emailProofRequirement(address);
+  const requirementDigest = await credentialRequirementDigest(requirement);
+  const record = await new StoredCredentialSource(deps.home).find({
+    requirement,
+    requirementDigest,
+    holderDid: holder.did,
+    now: deps.now()
+  });
+  if (!record) {
+    throw new CourierError("credential.show.NOT_FOUND", `No valid stored email credential for ${address}. Run \`${cmd(`credential acquire --email ${address}`)}\`.`);
+  }
+  deps.out([
+    `email: ${record.claims.email}`,
+    `credentialId: ${record.credentialId}`,
+    `issuedAt: ${record.issuedAt}`,
+    `expiresAt: ${record.expiresAt}`,
+    `status: ${record.status.method}`,
+    ""
+  ].join("\n"));
+}
+async function cmdCredential(args, deps = {}) {
+  const resolved = {
+    home: deps.home ?? profileDir(),
+    now: deps.now ?? (() => /* @__PURE__ */ new Date()),
+    fetch: deps.fetch,
+    loadKey: deps.loadKey ?? ((home) => loadKey(home)),
+    requestCode: deps.requestCode ?? requestEmailProofCode,
+    completeProof: deps.completeProof ?? completeEmailProof,
+    readStdinLine: deps.readStdinLine ?? readStdinFirstLine,
+    out: deps.out ?? ((text) => {
+      process.stdout.write(text);
+    })
+  };
+  switch (args.positional[0]) {
+    case "acquire":
+      return acquire(args, resolved);
+    case "show":
+      return show(args, resolved);
+    default:
+      throw new CourierError("usage", credentialUsage());
+  }
+}
+
 // ../courier/dist/main.js
 function usage() {
   const name2 = programName();
@@ -11066,6 +11371,11 @@ Delivery (one watcher per person per machine; never calls a model):
                                    Sender: accept one-line item requests over a Unix socket and send the
                                    named outbox item. Replies are ok or refused:<code>.
 
+  credential acquire --email <addr> [--code-stdin]
+                                   Email proof: send a verification code to the address, then enter it with
+                                   --code-stdin (reads one line from stdin; keeps the code off argv).
+  credential show --email <addr>   Show the stored email credential for this agent key (no secret printed).
+
   pause <peer> <threadId> [--reason "\u2026"]   Humans: stop waking your agent for a thread; tells the peer
   resume <peer> <threadId>                 Humans: wake it again (the wake budget starts over)
 
@@ -11123,6 +11433,8 @@ async function run(argv) {
       return cmdPause(sub2);
     case "resume":
       return cmdResume(sub2);
+    case "credential":
+      return cmdCredential(sub2);
     case "guard":
       return cmdGuard(sub2);
     case "run-approved":