@countersign-hub/cli 0.1.0 → 0.1.1

package/dist/bin.js

@@ -20231,6 +20231,7 @@ var init__esm = __esm(() => {
   init_createPublicClient();
   init_createWalletClient();
   init_http3();
+  init_abis();
   init_base();
   init_contract();
   init_decodeFunctionResult();
@@ -20247,6 +20248,7 @@ var init__esm = __esm(() => {
   init_parseSignature();
   init_recoverMessageAddress();
   init_recoverTypedDataAddress();
+  init_formatUnits();
 });
 
 // packages/core/src/canonical.ts
@@ -30237,7 +30239,9 @@ var init_known_escrows = __esm(() => {
   KNOWN_ESCROWS = [
     { chainId: 5042002, escrow: "0x19c27d770969291e6a0a305dc1be1a845e7c1b76", name: "Arc testnet, deployed through Arc Studio" },
     { chainId: 5042002, escrow: "0x44d11b8909485e3f575F6628b689383E4420f54a", name: "Arc testnet, forge deployment" },
-    { chainId: 1874, escrow: "0x9279D3edeef4c3738a0b200D762e2985Ff3B7eb4", name: "Whitechain Sepolia" }
+    { chainId: 5042002, escrow: "0x10A3c07cc6A519C0106e315D2C42010eCbEFF3CE", name: "Arc testnet, escrow v2" },
+    { chainId: 1874, escrow: "0x9279D3edeef4c3738a0b200D762e2985Ff3B7eb4", name: "Whitechain Sepolia" },
+    { chainId: 1874, escrow: "0x55b3d98C17Ba0878DC93fB1521c76c9a10778391", name: "Whitechain Sepolia, escrow v2" }
   ];
 });
 
@@ -30698,6 +30702,7 @@ var init_privateKeyToAccount = __esm(() => {
 // node_modules/viem/_esm/accounts/index.js
 var init_accounts = __esm(() => {
   init_privateKeyToAccount();
+  init_toAccount();
 });
 
 // node_modules/zod/v3/helpers/util.js
@@ -59072,6 +59077,28 @@ var init_known_rails = __esm(() => {
       tokenName: "Tether USD",
       tokenVersion: "1",
       rpcUrl: "https://rpc.testnet.whitechain.io"
+    },
+    {
+      network: "eip155:5042002",
+      scheme: "countersign",
+      chainId: 5042002,
+      escrow: "0x10A3c07cc6A519C0106e315D2C42010eCbEFF3CE",
+      token: "0x3600000000000000000000000000000000000000",
+      tokenName: "USDC",
+      tokenVersion: "2",
+      rpcUrl: "https://rpc.testnet.arc.network",
+      version: 2
+    },
+    {
+      network: "eip155:1874",
+      scheme: "countersign",
+      chainId: 1874,
+      escrow: "0x55b3d98C17Ba0878DC93fB1521c76c9a10778391",
+      token: "0xcedfB56113143d55b2358b8CFbB0dEB5Ad2f55a7",
+      tokenName: "Tether USD",
+      tokenVersion: "1",
+      rpcUrl: "https://rpc.testnet.whitechain.io",
+      version: 2
     }
   ];
   KNOWN_DIRECTS = [
@@ -59642,7 +59669,7 @@ var init_hub_client = __esm(() => {
 });
 
 // packages/buyer/src/journal.ts
-import { appendFileSync, closeSync, existsSync as existsSync3, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync4, unlinkSync, writeSync } from "node:fs";
+import { appendFileSync, closeSync as closeSync2, existsSync as existsSync4, mkdirSync as mkdirSync3, openSync as openSync2, readFileSync as readFileSync5, unlinkSync, writeSync as writeSync2 } from "node:fs";
 import { dirname as dirname2 } from "node:path";
 
 class Journal {
@@ -59654,14 +59681,14 @@ class Journal {
     return `${this.path}.lock`;
   }
   append(entry) {
-    mkdirSync2(dirname2(this.path), { recursive: true });
+    mkdirSync3(dirname2(this.path), { recursive: true });
     appendFileSync(this.path, `${JSON.stringify(entry)}
 `);
   }
   entries() {
-    if (!existsSync3(this.path))
+    if (!existsSync4(this.path))
       return [];
-    return readFileSync4(this.path, "utf8").split(`
+    return readFileSync5(this.path, "utf8").split(`
 `).filter((l) => l.trim() !== "").map((l) => JSON.parse(l));
   }
   reserve(entry, decide) {
@@ -59672,19 +59699,19 @@ class Journal {
         this.append({ ...entry, kind: "countersigned" });
       return decision;
     } finally {
-      closeSync(fd);
+      closeSync2(fd);
       try {
         unlinkSync(this.lockPath);
       } catch {}
     }
   }
   acquire() {
-    mkdirSync2(dirname2(this.path), { recursive: true });
+    mkdirSync3(dirname2(this.path), { recursive: true });
     const deadline = Date.now() + 5000;
     for (;; ) {
       try {
-        const fd = openSync(this.lockPath, "wx");
-        writeSync(fd, String(process.pid));
+        const fd = openSync2(this.lockPath, "wx");
+        writeSync2(fd, String(process.pid));
         return fd;
       } catch (e) {
         if (e.code !== "EEXIST")
@@ -59704,7 +59731,7 @@ class Journal {
   ownerIsGone() {
     let pid;
     try {
-      pid = Number(readFileSync4(this.lockPath, "utf8").trim());
+      pid = Number(readFileSync5(this.lockPath, "utf8").trim());
     } catch {
       return false;
     }
@@ -61269,6 +61296,161 @@ var init_payer2 = __esm(() => {
   init_known_rails();
 });
 
+// packages/buyer/src/remote-signer.ts
+function assertHubOrigin(hub) {
+  let url2;
+  try {
+    url2 = new URL(hub);
+  } catch {
+    throw new Error(HTTPS_ONLY);
+  }
+  if (url2.protocol === "https:")
+    return;
+  if (url2.protocol === "http:" && LOCAL_HOSTS.has(url2.hostname))
+    return;
+  throw new Error(HTTPS_ONLY);
+}
+function decimalStrings(value) {
+  if (typeof value === "bigint")
+    return value.toString(10);
+  if (Array.isArray(value))
+    return value.map((entry) => decimalStrings(entry));
+  if (value !== null && typeof value === "object") {
+    const copy = {};
+    for (const [key, entry] of Object.entries(value))
+      copy[key] = decimalStrings(entry);
+    return copy;
+  }
+  return value;
+}
+function messageOf4(body) {
+  if (body === null || typeof body !== "object")
+    return;
+  const message = body.message;
+  return typeof message === "string" ? message : undefined;
+}
+function remoteAccount(session, opts = {}) {
+  assertHubOrigin(session.hub);
+  const fetchImpl = opts.fetch ?? fetch;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const signTypedData4 = async (parameters) => {
+    const typedData = parameters;
+    const types3 = {};
+    for (const [name, fields] of Object.entries(typedData.types)) {
+      if (name !== "EIP712Domain")
+        types3[name] = fields;
+    }
+    const requestBody = JSON.stringify({
+      kind: "typed-data",
+      typedData: {
+        domain: decimalStrings(typedData.domain),
+        types: decimalStrings(types3),
+        primaryType: typedData.primaryType,
+        message: decimalStrings(typedData.message)
+      }
+    });
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let status;
+    let body;
+    try {
+      const response = await fetchImpl(`${session.hub.replace(/\/+$/, "")}/cli/sign`, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${session.token}`,
+          "content-type": "application/json"
+        },
+        body: requestBody,
+        signal: controller.signal
+      });
+      status = response.status;
+      body = await response.json().catch(() => {
+        return;
+      });
+    } catch {
+      throw new Error(NOT_REACHED);
+    } finally {
+      clearTimeout(timer);
+    }
+    if (status === 200) {
+      const result = body;
+      if (typeof result?.address !== "string" || result.address.toLowerCase() !== session.address.toLowerCase()) {
+        throw new Error("The hub signed with another wallet.");
+      }
+      const signature = result.signature;
+      if (typeof signature !== "string" || !SIGNATURE2.test(signature)) {
+        throw new Error(`The hub could not sign (${status}).`);
+      }
+      const signer = await recoverTypedDataAddress2({
+        ...parameters,
+        signature
+      });
+      if (signer.toLowerCase() !== session.address.toLowerCase()) {
+        throw new Error("The hub signed with another wallet.");
+      }
+      return signature;
+    }
+    if (status === 401)
+      throw new Error(NOT_SIGNED_IN3);
+    if (status === 403) {
+      const message = messageOf4(body) ?? "the hub refused the request.";
+      throw new Error(`Refused by the hub: ${message}`);
+    }
+    if (status === 502)
+      throw new Error("The hub could not sign (privy-failed).");
+    throw new Error(`The hub could not sign (${status}).`);
+  };
+  const unsupported = async () => {
+    throw new Error(TYPED_DATA_ONLY);
+  };
+  const source = {
+    address: session.address,
+    signMessage: unsupported,
+    signTransaction: unsupported,
+    signTypedData: signTypedData4
+  };
+  return toAccount(source);
+}
+async function sessionFromEnv(env = process.env, opts = {}) {
+  const token = env.CS_SESSION;
+  if (token === undefined || token === "")
+    return;
+  const hub = env.CS_HUB ?? DEFAULT_HUB;
+  delete env.CS_SESSION;
+  assertHubOrigin(hub);
+  const fetchImpl = opts.fetch ?? fetch;
+  let status;
+  let body;
+  try {
+    const response = await fetchImpl(`${hub.replace(/\/+$/, "")}/cli/session`, {
+      method: "GET",
+      headers: { authorization: `Bearer ${token}` }
+    });
+    status = response.status;
+    body = await response.json().catch(() => {
+      return;
+    });
+  } catch {
+    throw new Error("Could not read the countersign session (no response).");
+  }
+  if (status === 401)
+    return;
+  if (status !== 200)
+    throw new Error(`Could not read the countersign session (${status}).`);
+  const address = body?.address;
+  if (typeof address !== "string" || !isAddress(address)) {
+    throw new Error("The hub returned no valid wallet address.");
+  }
+  return { hub, token, address };
+}
+var NOT_SIGNED_IN3 = "Not signed in. Run: npx -y @countersign-hub/cli login", SIGNATURE2, DEFAULT_TIMEOUT_MS = 30000, DEFAULT_HUB = "https://hub-production-e85e.up.railway.app", NOT_REACHED = "The hub could not be reached to sign.", TYPED_DATA_ONLY = "This wallet signs only through the hub's typed-data route.", HTTPS_ONLY = "Refused: the countersign hub must be https.", LOCAL_HOSTS;
+var init_remote_signer = __esm(() => {
+  init__esm();
+  init_accounts();
+  SIGNATURE2 = /^0x[0-9a-fA-F]{130}$/;
+  LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]"]);
+});
+
 // packages/buyer/src/resume.ts
 async function readJobStatus(rail2, jobId) {
   const client = createPublicClient({ transport: http(rail2.rpcUrl) });
@@ -61406,27 +61588,27 @@ async function acceptJob(a) {
   const slip2 = heldSlip(a, jobId);
   const known = a.known ?? KNOWN_RAILS;
   if (slip2.hash.toLowerCase() !== slipHash(slip2.body).toLowerCase())
-    refuse("The slip's hash does not match its body.");
+    refuse2("The slip's hash does not match its body.");
   let seller;
   try {
     seller = await slipSigner(slip2);
   } catch {
-    refuse("The slip's seller signature does not parse.");
+    refuse2("The slip's seller signature does not parse.");
   }
   if (getAddress(seller) !== getAddress(slip2.body.seller))
-    refuse("The slip is not signed by its seller.");
+    refuse2("The slip is not signed by its seller.");
   if (slip2.body.jobId.toLowerCase() !== jobId)
-    refuse("The slip is for another job.");
+    refuse2("The slip is for another job.");
   if (getAddress(slip2.body.buyer) !== getAddress(a.signer.address))
-    refuse("The slip names another buyer.");
+    refuse2("The slip names another buyer.");
   if (!slip2.body.escrow || slip2.body.chainId === undefined)
-    refuse("The slip is not for an escrow job.");
+    refuse2("The slip is not for an escrow job.");
   const rail2 = pinned(known, slip2.body.chainId, slip2.body.escrow);
   if (!rail2)
-    refuse("The slip's escrow is not one this agent pins.");
+    refuse2("The slip's escrow is not one this agent pins.");
   const terms = slip2.payment?.payload?.terms;
   if (!terms || jobIdOf(terms, rail2.chainId, rail2.escrow).toLowerCase() !== jobId) {
-    refuse("The slip's countersigned terms do not derive this job on that escrow.");
+    refuse2("The slip's countersigned terms do not derive this job on that escrow.");
   }
   const signature = await a.signer.signTypedData(acceptTypedData(rail2.chainId, rail2.escrow, jobId, slip2.hash));
   await a.hub.acceptJob(jobId, signature);
@@ -61438,7 +61620,7 @@ async function disputeJob(a) {
   const known = a.known ?? KNOWN_RAILS;
   const entries = entriesFor(a.journal, jobId);
   if (entries.length === 0)
-    refuse("This agent's journal has no such job.");
+    refuse2("This agent's journal has no such job.");
   const { rail: rail2, status } = await fundedOn(a, jobId, entries, known);
   const signature = await a.signer.signTypedData(disputeTypedData(rail2.chainId, rail2.escrow, jobId, status));
   let transaction;
@@ -61465,7 +61647,7 @@ async function disputeJob(a) {
 async function submitDispute(a, rail2, jobId, status) {
   const account = a.account;
   if (!account)
-    refuse("The agent key is not available to send the dispute itself.");
+    refuse2("The agent key is not available to send the dispute itself.");
   return sendDispute(rail2, jobId, status, account, a.transport);
 }
 async function sendDispute(rail2, jobId, status, account, transport) {
@@ -61497,7 +61679,7 @@ async function fundedOn(a, jobId, entries, known) {
   if (recorded) {
     const rail2 = pinned(known, recorded.chainId, recorded.escrow);
     if (!rail2)
-      refuse("The job's escrow is not one this agent pins.");
+      refuse2("The job's escrow is not one this agent pins.");
     return { rail: rail2, status: await disputeStatus(a, rail2, jobId, entries) };
   }
   const network = entries.find((e) => e.network)?.network;
@@ -61513,7 +61695,7 @@ async function fundedOn(a, jobId, entries, known) {
     } catch {}
   }
   if (holding.length !== 1)
-    refuse("No single pinned escrow holds this job open for this agent.");
+    refuse2("No single pinned escrow holds this job open for this agent.");
   return holding[0];
 }
 async function disputeStatus(a, rail2, jobId, entries) {
@@ -61529,11 +61711,11 @@ async function disputeStatus(a, rail2, jobId, entries) {
 function heldSlip(a, jobId) {
   const entry = [...entriesFor(a.journal, jobId)].reverse().find((e) => e.slipHash);
   if (!entry?.slipHash)
-    refuse("This agent holds no slip for this job.");
+    refuse2("This agent holds no slip for this job.");
   try {
     return a.state.loadSlip(entry.slipHash);
   } catch {
-    refuse("This agent holds no slip for this job.");
+    refuse2("This agent holds no slip for this job.");
   }
 }
 function entriesFor(journal, jobId) {
@@ -61554,7 +61736,7 @@ function record3(a, jobId, entries) {
 function pinned(known, chainId, escrow2) {
   return known.find((rail2) => rail2.chainId === chainId && rail2.escrow.toLowerCase() === escrow2.toLowerCase());
 }
-function refuse(message) {
+function refuse2(message) {
   throw new ReviewError(`Refused. ${message}`);
 }
 var ReviewError, DISPUTE_ABI, DISPUTABLE;
@@ -61584,65 +61766,65 @@ var init_review = __esm(() => {
 
 // packages/buyer/src/state.ts
 import {
-  chmodSync,
-  closeSync as closeSync2,
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync3,
-  openSync as openSync2,
-  readFileSync as readFileSync5,
+  chmodSync as chmodSync2,
+  closeSync as closeSync3,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync4,
+  openSync as openSync3,
+  readFileSync as readFileSync6,
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync2,
-  writeSync as writeSync2
+  writeSync as writeSync3
 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join as join3 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
 
 class State {
   dir;
   constructor(dir) {
-    this.dir = dir ?? join3(homedir2(), ".countersign");
+    this.dir = dir ?? join4(homedir3(), ".countersign");
   }
   get envelopePath() {
-    return join3(this.dir, "envelope.json");
+    return join4(this.dir, "envelope.json");
   }
   get journalPath() {
-    return join3(this.dir, "journal.jsonl");
+    return join4(this.dir, "journal.jsonl");
   }
   get railsPath() {
-    return join3(this.dir, "rails.json");
+    return join4(this.dir, "rails.json");
   }
   get consumedApprovalsPath() {
-    return join3(this.dir, "approvals-consumed.json");
+    return join4(this.dir, "approvals-consumed.json");
   }
   slipPath(hash4) {
-    return join3(this.dir, "slips", `${hash4}.json`);
+    return join4(this.dir, "slips", `${hash4}.json`);
   }
   loadEnvelope() {
-    if (!existsSync4(this.envelopePath)) {
+    if (!existsSync5(this.envelopePath)) {
       throw new Error(`No envelope at ${this.envelopePath}. Create one with: countersign envelope set --cap <usd> --per-merchant <usd>`);
     }
-    return JSON.parse(readFileSync5(this.envelopePath, "utf8"));
+    return JSON.parse(readFileSync6(this.envelopePath, "utf8"));
   }
   saveEnvelope(env) {
-    mkdirSync3(this.dir, { recursive: true });
+    mkdirSync4(this.dir, { recursive: true });
     writeFileSync2(this.envelopePath, `${JSON.stringify(env, null, 2)}
 `);
   }
   loadRails() {
-    if (!existsSync4(this.railsPath))
+    if (!existsSync5(this.railsPath))
       return [];
-    const value = JSON.parse(readFileSync5(this.railsPath, "utf8"));
+    const value = JSON.parse(readFileSync6(this.railsPath, "utf8"));
     if (!Array.isArray(value))
       throw new Error(`${this.railsPath} must hold a JSON array of known rails.`);
     return value;
   }
   loadSlip(hash4) {
-    return JSON.parse(readFileSync5(this.slipPath(hash4), "utf8"));
+    return JSON.parse(readFileSync6(this.slipPath(hash4), "utf8"));
   }
   loadConsumedApprovals() {
-    if (!existsSync4(this.consumedApprovalsPath))
+    if (!existsSync5(this.consumedApprovalsPath))
       return [];
-    const value = JSON.parse(readFileSync5(this.consumedApprovalsPath, "utf8"));
+    const value = JSON.parse(readFileSync6(this.consumedApprovalsPath, "utf8"));
     if (!Array.isArray(value)) {
       throw new Error(`${this.consumedApprovalsPath} must hold a JSON array of approval ids.`);
     }
@@ -61660,10 +61842,10 @@ class State {
       ids.push(id);
       writeFileSync2(this.consumedApprovalsPath, `${JSON.stringify(ids, null, 2)}
 `, { mode: 384 });
-      chmodSync(this.consumedApprovalsPath, 384);
+      chmodSync2(this.consumedApprovalsPath, 384);
       return true;
     } finally {
-      closeSync2(fd);
+      closeSync3(fd);
       try {
         unlinkSync2(this.consumedLockPath);
       } catch {}
@@ -61673,12 +61855,12 @@ class State {
     return `${this.consumedApprovalsPath}.lock`;
   }
   acquireConsumedLock() {
-    mkdirSync3(this.dir, { recursive: true });
+    mkdirSync4(this.dir, { recursive: true });
     const deadline = Date.now() + 5000;
     for (;; ) {
       try {
-        const fd = openSync2(this.consumedLockPath, "wx");
-        writeSync2(fd, String(process.pid));
+        const fd = openSync3(this.consumedLockPath, "wx");
+        writeSync3(fd, String(process.pid));
         return fd;
       } catch (e) {
         if (e.code !== "EEXIST")
@@ -61699,7 +61881,7 @@ class State {
   consumedLockOwnerIsGone() {
     let pid;
     try {
-      pid = Number(readFileSync5(this.consumedLockPath, "utf8").trim());
+      pid = Number(readFileSync6(this.consumedLockPath, "utf8").trim());
     } catch {
       return false;
     }
@@ -61713,7 +61895,7 @@ class State {
     }
   }
   saveSlip(slip2) {
-    mkdirSync3(join3(this.dir, "slips"), { recursive: true });
+    mkdirSync4(join4(this.dir, "slips"), { recursive: true });
     writeFileSync2(this.slipPath(slip2.hash), `${JSON.stringify(slip2, null, 2)}
 `);
   }
@@ -61725,10 +61907,13 @@ var init_state = __esm(() => {
 
 // packages/buyer/src/cli.ts
 var exports_cli = {};
+__export(exports_cli, {
+  agentAccount: () => agentAccount
+});
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join4 } from "node:path";
-function parse6(argv) {
+import { chmodSync as chmodSync3, mkdirSync as mkdirSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join5 } from "node:path";
+function parse7(argv) {
   const pos = [];
   const flags = new Map;
   for (let i = 0;i < argv.length; i++) {
@@ -61750,14 +61935,21 @@ function parse6(argv) {
   }
   return { pos, flags };
 }
-function agentAccount() {
+async function agentAccount() {
+  cachedAccount ??= resolveAccount();
+  return await cachedAccount;
+}
+async function resolveAccount() {
   const key = process.env.CS_BUYER_KEY;
-  if (!key)
-    throw new Error("Set CS_BUYER_KEY to the agent's private key.");
-  return privateKeyToAccount(key.startsWith("0x") ? key : `0x${key}`);
+  if (key)
+    return privateKeyToAccount(key.startsWith("0x") ? key : `0x${key}`);
+  const session = await sessionFromEnv(process.env);
+  if (session !== undefined)
+    return remoteAccount(session);
+  throw new Error(NOT_SIGNED_IN3);
 }
 async function main2() {
-  const { pos, flags } = parse6(process.argv.slice(2));
+  const { pos, flags } = parse7(process.argv.slice(2));
   const one = (n) => flags.get(n)?.[0];
   let hub = new HubClient(one("hub") ?? "http://127.0.0.1:8787");
   const state = new State(one("state"));
@@ -61801,7 +61993,7 @@ async function main2() {
       throw new Error("Usage: buy <offerHash|callUrl> --input '<json>' [--approve] [--rail <id>] [--approvals hub]");
     const rail2 = parseRail(one("rail"));
     const approvals = parseApprovals(one("approvals"));
-    const account = agentAccount();
+    const account = await agentAccount();
     const result = await buy({
       hub,
       offerHash: hash4,
@@ -61830,9 +62022,9 @@ async function main2() {
     try {
       env = state.loadEnvelope();
     } catch {
-      env = { v: 1, agent: agentAccount().address, cap: "0", perMerchant: "0", allowlist: [], revoked: false };
+      env = { v: 1, agent: (await agentAccount()).address, cap: "0", perMerchant: "0", allowlist: [], revoked: false };
     }
-    env.agent = agentAccount().address;
+    env.agent = (await agentAccount()).address;
     const cap = one("cap");
     if (cap !== undefined)
       env.cap = parseUnits(cap, 6).toString(10);
@@ -61854,7 +62046,7 @@ async function main2() {
   } else if ((cmd === "accept" || cmd === "dispute") && pos[1] !== undefined) {
     if (!/^0x[0-9a-fA-F]{64}$/.test(pos[1]))
       throw new Error(`Usage: ${cmd} <jobId>`);
-    const account = agentAccount();
+    const account = await agentAccount();
     const args = { hub, journal, state, known, signer: account, jobId: pos[1], now: Math.floor(Date.now() / 1000) };
     if (cmd === "accept") {
       const done = await acceptJob(args);
@@ -61870,7 +62062,7 @@ async function main2() {
     for (const e of journal.entries())
       console.log(JSON.stringify(e));
   } else if (cmd === "publish-envelope") {
-    const account = agentAccount();
+    const account = await agentAccount();
     const ok2 = await publishEnvelope({
       hub,
       account,
@@ -61880,12 +62072,12 @@ async function main2() {
     });
     console.log(ok2 ? "Envelope published." : "Envelope publish failed.");
   } else if (cmd === "openai") {
-    const account = agentAccount();
+    const account = await agentAccount();
     const token = randomBytes2(32).toString("hex");
-    mkdirSync4(state.dir, { recursive: true });
-    const tokenPath = join4(state.dir, "openai.token");
+    mkdirSync5(state.dir, { recursive: true });
+    const tokenPath = join5(state.dir, "openai.token");
     writeFileSync3(tokenPath, token, { mode: 384 });
-    chmodSync2(tokenPath, 384);
+    chmodSync3(tokenPath, 384);
     const server = startOpenAIServer({
       hub,
       account,
@@ -61900,7 +62092,7 @@ async function main2() {
     console.log(`${server.url}/v1`);
     console.log(tokenPath);
   } else if (cmd === "resume") {
-    const mirror = flags.has("hub") ? { account: agentAccount(), envelope: state.loadEnvelope() } : undefined;
+    const mirror = flags.has("hub") ? { account: await agentAccount(), envelope: state.loadEnvelope() } : undefined;
     const rows = await resume({
       hub,
       journal,
@@ -61914,7 +62106,7 @@ async function main2() {
       console.log(`${r.jobId}  ${r.status}${r.appended ? `  -> ${r.appended}` : ""}`);
   } else {
     console.log("Usage: cli.ts discover [--catalogue <url|circle> [query] [--category <c>] [--limit <n>]] | buy <offerHash|callUrl> --input '<json>' [--approve] [--rail <id>] [--approvals hub] | accept <jobId> | dispute <jobId> [--direct] | envelope show|set | publish-envelope | journal | resume | openai [--port <n>]");
-    console.log("Flags: --hub <url> --state <dir>. The agent key comes from CS_BUYER_KEY.");
+    console.log("Flags: --hub <url> --state <dir>. Sign in once with: countersign login.");
   }
 }
 function parseApprovals(raw) {
@@ -61943,7 +62135,7 @@ function parseRail(raw) {
     throw new Error(`Unknown rail ${raw}.`);
   return raw;
 }
-var BOOLEAN, usd2 = (atomic) => formatUnits(BigInt(atomic), 6);
+var BOOLEAN, cachedAccount, usd2 = (atomic) => formatUnits(BigInt(atomic), 6);
 var init_cli = __esm(() => {
   init_accounts();
   init_src();
@@ -61955,6 +62147,7 @@ var init_cli = __esm(() => {
   init_mirror();
   init_server();
   init_payer2();
+  init_remote_signer();
   init_resume();
   init_review();
   init_state();
@@ -61967,7 +62160,7 @@ var init_cli = __esm(() => {
 
 // packages/verify/src/cli.ts
 var exports_cli2 = {};
-import { readFileSync as readFileSync6 } from "node:fs";
+import { readFileSync as readFileSync7 } from "node:fs";
 var args, file2, rpcAt, rpcUrl, mirrorAt, mirrorUrl, slip2, verdict, verdictLine;
 var init_cli2 = __esm(async () => {
   init_verify();
@@ -61982,7 +62175,7 @@ var init_cli2 = __esm(async () => {
     process.exit(2);
   }
   try {
-    slip2 = JSON.parse(readFileSync6(file2, "utf8"));
+    slip2 = JSON.parse(readFileSync7(file2, "utf8"));
   } catch (e) {
     console.error(`cannot read ${file2}: ${e.message}`);
     process.exit(2);
@@ -62079,6 +62272,7 @@ var init_src4 = __esm(() => {
   init_mirror();
   init_payer2();
   init_resume();
+  init_remote_signer();
   init_review();
   init_state();
   init_terms();
@@ -63381,7 +63575,7 @@ var init_mcp = __esm(() => {
 });
 
 // packages/mcp/src/server.ts
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 function assertHash(value, what) {
   if (!HASH.test(value))
     throw new Error(`Refused. ${what} must be 0x followed by 64 hex characters.`);
@@ -63408,11 +63602,16 @@ function searchText(offer2) {
 `).toLowerCase();
 }
 function createCountersignMcpServer(deps) {
-  const server = new McpServer({ name: "countersign", version: "0.1.0" });
+  const server = new McpServer({ name: "countersign", version: "0.1.1" });
   const clock = deps.now ?? (() => Math.floor(Date.now() / 1000));
   const verify2 = deps.verify ?? verifySlip;
+  const gate = () => {
+    if (deps.account !== undefined)
+      return;
+    return failure3(new Error(deps.problem === undefined ? NOT_SIGNED_IN3 : `${NOT_SIGNED_IN3} (${deps.problem})`));
+  };
   const loadSlip = async (hash4) => {
-    if (existsSync5(deps.state.slipPath(hash4)))
+    if (existsSync6(deps.state.slipPath(hash4)))
       return deps.state.loadSlip(hash4);
     const base2 = deps.hubUrl.replace(/\/+$/, "");
     const response = await fetch(`${base2}/slips/${hash4}`);
@@ -63428,6 +63627,9 @@ function createCountersignMcpServer(deps) {
       limit: exports_external.number().int().optional()
     }
   }, async ({ query, limit }) => {
+    const refused = gate();
+    if (refused !== undefined)
+      return refused;
     try {
       const listings = await deps.hub.listOffers();
       const needle = query?.toLowerCase();
@@ -63462,6 +63664,9 @@ function createCountersignMcpServer(deps) {
       offerHash: exports_external.string()
     }
   }, async ({ offerHash: offerHash2 }) => {
+    const refused = gate();
+    if (refused !== undefined)
+      return refused;
     try {
       assertHash(offerHash2, "offerHash");
       const listing = await deps.hub.getOffer(offerHash2);
@@ -63479,16 +63684,17 @@ function createCountersignMcpServer(deps) {
   });
   server.registerTool("buy", {
     title: "Buy an offer",
-    description: "Buy an offer under the agent's envelope and return the seller's output and slip. Requires CS_BUYER_KEY.",
+    description: "Buy an offer under the agent's envelope and return the seller's output and slip. Requires sign-in: npx -y @countersign-hub/cli login.",
     inputSchema: {
       offerHash: exports_external.string(),
       input: exports_external.unknown(),
       rail: exports_external.string().optional()
     }
   }, async ({ offerHash: offerHash2, input: input2, rail: rail2 }) => {
+    const refused = gate();
+    if (refused !== undefined)
+      return refused;
     const account = deps.account;
-    if (account === undefined)
-      return failure3(new Error(NO_KEY));
     if (rail2 !== undefined && !RAIL_IDS.includes(rail2)) {
       return failure3(new Error(`Unknown rail ${rail2}.`));
     }
@@ -63529,6 +63735,9 @@ function createCountersignMcpServer(deps) {
       slipHash: exports_external.string().optional()
     }
   }, async ({ slip: slip3, slipHash: slipHash2 }) => {
+    const refused = gate();
+    if (refused !== undefined)
+      return refused;
     if (slip3 === undefined === (slipHash2 === undefined)) {
       return failure3(new Error("Pass exactly one of slip or slipHash."));
     }
@@ -63546,6 +63755,9 @@ function createCountersignMcpServer(deps) {
     description: "Read the agent's envelope and what the journal says it has spent.",
     inputSchema: {}
   }, async () => {
+    const refused = gate();
+    if (refused !== undefined)
+      return refused;
     try {
       return text({ envelope: deps.state.loadEnvelope(), spent: deps.journal.spend() });
     } catch (error62) {
@@ -63559,6 +63771,9 @@ function createCountersignMcpServer(deps) {
       limit: exports_external.number().int().optional()
     }
   }, async ({ limit }) => {
+    const refused = gate();
+    if (refused !== undefined)
+      return refused;
     try {
       const entries = deps.journal.entries();
       const count = limit ?? 20;
@@ -63569,7 +63784,7 @@ function createCountersignMcpServer(deps) {
   });
   return server;
 }
-var HASH_MISMATCH = "Refused. The hub served an offer that does not match the hash asked for.", NO_KEY = "Set CS_BUYER_KEY to the agent's private key.", HASH;
+var HASH_MISMATCH = "Refused. The hub served an offer that does not match the hash asked for.", HASH;
 var init_server6 = __esm(() => {
   init_mcp();
   init_zod();
@@ -63582,14 +63797,15 @@ var init_server6 = __esm(() => {
 // packages/mcp/src/main.ts
 var exports_main = {};
 __export(exports_main, {
+  resolveAccount: () => resolveAccount2,
   main: () => main3
 });
 function fail(message) {
   console.error(message);
   process.exit(1);
 }
-function parse7(argv) {
-  const config2 = { hub: process.env.CS_HUB ?? DEFAULT_HUB };
+function parse8(argv) {
+  const config2 = { hub: process.env.CS_HUB ?? DEFAULT_HUB2 };
   if (process.env.CS_RPC_URL !== undefined)
     config2.rpcUrl = process.env.CS_RPC_URL;
   let help = false;
@@ -63615,18 +63831,45 @@ function parse7(argv) {
   }
   return { help, config: config2 };
 }
-function agentAccount2() {
-  const key = process.env.CS_BUYER_KEY;
+function ciAccount(env) {
+  const key = env.CS_BUYER_KEY;
   if (!key)
-    return;
+    return {};
   try {
-    return privateKeyToAccount(key.startsWith("0x") ? key : `0x${key}`);
+    return { account: privateKeyToAccount(key.startsWith("0x") ? key : `0x${key}`) };
   } catch {
-    return fail("CS_BUYER_KEY is not a valid private key.");
+    return { problem: "The configured signer is not valid." };
   }
 }
-async function main3(argv) {
-  const { help, config: config2 } = parse7(argv);
+function sessionProblem(error62) {
+  const message = error62 instanceof Error ? error62.message : String(error62);
+  const firstLine3 = message.split(`
+`)[0] ?? "";
+  return { problem: `Could not load the countersign session: ${firstLine3}` };
+}
+async function resolveAccount2(options, env) {
+  const sessionEnv = { CS_SESSION: env.CS_SESSION, CS_HUB: env.CS_HUB };
+  delete env.CS_SESSION;
+  if (options.loadAccount !== undefined) {
+    try {
+      const account = await options.loadAccount();
+      return account === undefined ? {} : { account };
+    } catch (error62) {
+      return sessionProblem(error62);
+    }
+  }
+  let session;
+  try {
+    session = await sessionFromEnv(sessionEnv);
+  } catch (error62) {
+    return sessionProblem(error62);
+  }
+  if (session !== undefined)
+    return { account: remoteAccount(session) };
+  return ciAccount(env);
+}
+async function main3(argv, options = {}) {
+  const { help, config: config2 } = parse8(argv);
   if (help) {
     console.log(USAGE);
     return;
@@ -63639,11 +63882,16 @@ async function main3(argv) {
   const state2 = new State(config2.state);
   const journal2 = new Journal(state2.journalPath);
   const hub = new HubClient(config2.hub);
-  const account = agentAccount2();
-  console.error(`countersign-mcp: hub ${hub.url}`);
-  console.error(`countersign-mcp: state ${state2.dir}`);
-  if (account !== undefined)
-    console.error(`countersign-mcp: agent ${account.address}`);
+  const { account, problem } = await resolveAccount2(options, process.env);
+  console.error(`countersign mcp: hub ${hub.url}`);
+  console.error(`countersign mcp: state ${state2.dir}`);
+  if (account !== undefined) {
+    console.error(`countersign mcp: agent ${account.address}`);
+  } else {
+    console.error("countersign mcp: not signed in. Run: npx -y @countersign-hub/cli login");
+    if (problem !== undefined)
+      console.error(`countersign mcp: ${problem}`);
+  }
   const server = createCountersignMcpServer({
     hub,
     state: state2,
@@ -63651,11 +63899,12 @@ async function main3(argv) {
     hubUrl: config2.hub,
     now: () => Math.floor(Date.now() / 1000),
     ...account !== undefined ? { account } : {},
+    ...problem !== undefined ? { problem } : {},
     ...config2.rpcUrl !== undefined ? { rpcUrl: config2.rpcUrl } : {}
   });
   await server.connect(new StdioServerTransport);
 }
-var DEFAULT_HUB = "https://hub-production-e85e.up.railway.app", USAGE;
+var DEFAULT_HUB2 = "https://hub-production-e85e.up.railway.app", USAGE;
 var init_main = __esm(() => {
   init_accounts();
   init_stdio2();
@@ -63666,17 +63915,18 @@ var init_main = __esm(() => {
 Usage: countersign mcp [--hub <url>] [--state <dir>] [--rpc <url>]
 
 Options:
-  --hub <url>    The countersign hub (env CS_HUB; default ${DEFAULT_HUB})
+  --hub <url>    The countersign hub (env CS_HUB; default ${DEFAULT_HUB2})
   --state <dir>  Where the envelope, journal and slips live (default ~/.countersign)
   --rpc <url>    The RPC verify_slip reads the chain from (env CS_RPC_URL), e.g. https://rpc.testnet.arc.network
   --help         Print this usage and exit
 
-Environment:
-  CS_BUYER_KEY   The agent's private key; without it, buy refuses.
-  CS_NETWORK     Must be unset or testnet.
+Sign in once: npx -y @countersign-hub/cli login. Your agent's wallet is a Privy server wallet that the countersign app controls;
+this server signs through the hub with your session, and no key is ever on this machine or in any config.
+
+CS_NETWORK must be unset or testnet.
 
-Install it from the countersign release tarball only. The npm packages named @countersign/*,
-countersign and countersign-mcp belong to other projects: never npx or npm install them.`;
+Install: npm i -g @countersign-hub/cli, then countersign mcp (or npx -y @countersign-hub/cli mcp).
+The npm packages named @countersign/*, countersign and countersign-mcp belong to other projects: never npx or npm install them.`;
 });
 
 // packages/runner/src/cli.ts
@@ -63957,8 +64207,11 @@ function setTermsArgs(command) {
 }
 async function bondFromEnv(args, log = console.log) {
   const key = process.env.CS_SELLER_KEY;
-  if (!key || !/^0x[0-9a-fA-F]{64}$/.test(key)) {
-    throw new Error("CS_SELLER_KEY must hold a 0x-prefixed 32-byte hex key.");
+  if (!key) {
+    throw new Error("Bond commands are not available from a signed-in session yet: they send transactions, and the hub only signs.");
+  }
+  if (!/^0x[0-9a-fA-F]{64}$/.test(key)) {
+    throw new Error("The CI signing override in this environment is malformed.");
   }
   await runBond(parseBondArgs(args), key, log);
 }
@@ -65153,12 +65406,183 @@ function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// packages/runner/src/remote-signer.ts
+init__esm();
+var NOT_SIGNED_IN = "Not signed in. Run: npx -y @countersign-hub/cli login";
+var BONDED_REMOTE_REFUSAL = "A bonded offer cannot be served from a signed-in session yet: the hub does not sign Lock for it.";
+var SIGNATURE = /^0x[0-9a-fA-F]{130}$/;
+var ADDRESS = /^0x[0-9a-fA-F]{40}$/;
+function hubFailure(reason) {
+  return new Error(`The hub could not sign right now (${reason}).`);
+}
+var WRONG_WALLET = "The hub signed with a different wallet.";
+function safeHub(hubUrl) {
+  let url2;
+  try {
+    url2 = new URL(hubUrl);
+  } catch {
+    throw new Error("The hub address is not a URL.");
+  }
+  const local = url2.hostname === "localhost" || url2.hostname === "127.0.0.1" || url2.hostname === "[::1]";
+  if (url2.protocol !== "https:" && !(url2.protocol === "http:" && local)) {
+    throw new Error("The session is sent only to an https hub.");
+  }
+  return hubUrl.replace(/\/+$/, "");
+}
+function decimalString(_key, value) {
+  return typeof value === "bigint" ? value.toString(10) : value;
+}
+function recordOf(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+function messageOf2(body) {
+  const message = recordOf(body)?.message;
+  return typeof message === "string" && message.length > 0 ? message : null;
+}
+function codeOf(body) {
+  const code = recordOf(body)?.code;
+  return typeof code === "string" && code.length > 0 ? code : null;
+}
+async function readJson(response) {
+  try {
+    return await response.json();
+  } catch {
+    return;
+  }
+}
+function remoteRunnerAccount(options) {
+  const hub = safeHub(options.hubUrl);
+  const fetchImpl = options.fetch ?? fetch;
+  const sign3 = async (payload, recover) => {
+    let response;
+    try {
+      response = await fetchImpl(`${hub}/cli/sign`, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${options.session}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify(payload, decimalString)
+      });
+    } catch {
+      throw hubFailure("unreachable");
+    }
+    const body = await readJson(response);
+    if (response.status === 200) {
+      const signed2 = recordOf(body);
+      const signature = signed2?.signature;
+      const address = signed2?.address;
+      if (typeof signature !== "string" || !SIGNATURE.test(signature) || typeof address !== "string" || address.toLowerCase() !== options.address.toLowerCase()) {
+        throw new Error(WRONG_WALLET);
+      }
+      let signer;
+      try {
+        signer = await recover(signature);
+      } catch {
+        throw new Error(WRONG_WALLET);
+      }
+      if (signer.toLowerCase() !== options.address.toLowerCase())
+        throw new Error(WRONG_WALLET);
+      return signature;
+    }
+    if (response.status === 401)
+      throw new Error(messageOf2(body) ?? NOT_SIGNED_IN);
+    if (response.status === 403) {
+      throw new Error(`The hub refused to sign this: ${codeOf(body) ?? "not-allowed"}`);
+    }
+    if (response.status === 502) {
+      throw new Error("The hub could not sign right now (privy-failed).");
+    }
+    throw hubFailure(response.status);
+  };
+  return {
+    kind: "remote",
+    address: options.address,
+    signMessage: (args) => sign3({ kind: "message", message: args.message }, (signature) => recoverMessageAddress2({ message: args.message, signature })),
+    signTypedData: (typedData) => sign3({ kind: "typed-data", typedData }, (signature) => recoverTypedDataAddress2({ ...typedData, signature }))
+  };
+}
+async function remoteAccountFromSession(options) {
+  const hub = safeHub(options.hubUrl);
+  const fetchImpl = options.fetch ?? fetch;
+  let response;
+  try {
+    response = await fetchImpl(`${hub}/cli/session`, {
+      headers: { authorization: `Bearer ${options.session}` }
+    });
+  } catch {
+    throw hubFailure("unreachable");
+  }
+  const body = await readJson(response);
+  if (response.status === 200) {
+    const address = recordOf(body)?.address;
+    if (typeof address !== "string" || !ADDRESS.test(address)) {
+      throw hubFailure("invalid-address");
+    }
+    return remoteRunnerAccount({ ...options, address });
+  }
+  if (response.status === 401)
+    throw new Error(messageOf2(body) ?? NOT_SIGNED_IN);
+  throw hubFailure(response.status);
+}
+function assertRemoteCanServe(account, offer2) {
+  if (account.kind !== "remote")
+    return;
+  let bonded = false;
+  try {
+    bonded = BigInt(offer2.bond) > 0n;
+  } catch {
+    bonded = false;
+  }
+  if (bonded)
+    throw new Error(BONDED_REMOTE_REFUSAL);
+}
+
 // packages/runner/src/daemon.ts
 var RECONNECT_DELAYS = [1, 2, 4, 8, 16, 30];
+var ATOMIC = /^(0|[1-9][0-9]*)$/;
+var ADDRESS2 = /^0x[0-9a-fA-F]{40}$/;
+function readLockTerms(value) {
+  if (value === null || typeof value !== "object")
+    return null;
+  const raw = value;
+  const buyer = raw.buyer;
+  const payee = raw.payee;
+  const amount2 = raw.amount;
+  const deadline = raw.deadline;
+  const salt = raw.salt;
+  const bond = raw.bond;
+  const reviewWindow = raw.reviewWindow;
+  if (typeof buyer !== "string" || !ADDRESS2.test(buyer))
+    return null;
+  if (typeof payee !== "string" || !ADDRESS2.test(payee))
+    return null;
+  if (typeof amount2 !== "string" || !ATOMIC.test(amount2))
+    return null;
+  if (typeof deadline !== "number" || !Number.isSafeInteger(deadline))
+    return null;
+  if (typeof salt !== "string" || !ATOMIC.test(salt))
+    return null;
+  if (typeof bond !== "string" || !ATOMIC.test(bond))
+    return null;
+  if (typeof reviewWindow !== "number" || !Number.isSafeInteger(reviewWindow))
+    return null;
+  return {
+    buyer,
+    payee,
+    amount: amount2,
+    deadline,
+    salt,
+    bond,
+    reviewWindow
+  };
+}
 function startRunner(cfg) {
   const clock = cfg.now ?? (() => Math.floor(Date.now() / 1000));
   const timeMs = cfg.limits?.timeMs ?? 30000;
   const maxOutputBytes = cfg.limits?.maxOutputBytes ?? 1e6;
+  for (const entry of cfg.served)
+    assertRemoteCanServe(cfg.account, entry.offer);
   const served = cfg.served.map((entry) => ({ ...entry, hash: offerHash(entry.offer) }));
   const url2 = connectUrl(cfg.hubUrl);
   const funding = cfg.funding === undefined ? null : { ...cfg.funding, read: fundingReader(cfg.funding) };
@@ -65215,9 +65639,51 @@ function startRunner(cfg) {
       });
       return;
     }
+    const refuse = (reason) => {
+      send(target, { t: "lock-refused", jobId: frame.jobId, reason });
+    };
+    const terms = readLockTerms(frame.terms);
+    if (terms === null) {
+      refuse("bad-terms");
+      return;
+    }
+    if (terms.payee.toLowerCase() !== cfg.account.address.toLowerCase()) {
+      refuse("not-payee");
+      return;
+    }
+    let bondAbove = false;
     try {
-      const typed = lockTypedData(frame.chainId, frame.escrow, frame.jobId, frame.funder);
-      const sig = await cfg.account.signTypedData(typed);
+      bondAbove = BigInt(terms.bond) > 0n;
+    } catch {
+      bondAbove = false;
+    }
+    if (terms.amount !== entry.offer.price || terms.bond !== entry.offer.bond || !bondAbove || terms.reviewWindow !== (entry.offer.reviewWindow ?? 0)) {
+      refuse("terms-mismatch");
+      return;
+    }
+    if (terms.deadline - clock() < 60) {
+      refuse("deadline-too-near");
+      return;
+    }
+    const escrow = frame.escrow;
+    const pinned = funding !== null && typeof escrow === "string" && funding.known.some((pin) => pin.chainId === frame.chainId && pin.escrow.toLowerCase() === escrow.toLowerCase());
+    if (!pinned) {
+      refuse("unknown-escrow");
+      return;
+    }
+    let rebuilt;
+    try {
+      rebuilt = jobIdOf({ offerHash: frame.offerHash, ...terms }, frame.chainId, frame.escrow);
+    } catch {
+      refuse("job-mismatch");
+      return;
+    }
+    if (typeof frame.jobId !== "string" || rebuilt.toLowerCase() !== frame.jobId.toLowerCase()) {
+      refuse("job-mismatch");
+      return;
+    }
+    try {
+      const sig = await cfg.account.signTypedData(lockTypedData(frame.chainId, frame.escrow, frame.jobId, frame.funder));
       send(target, { t: "locked", jobId: frame.jobId, sig });
     } catch {
       send(target, {
@@ -65272,7 +65738,7 @@ function startRunner(cfg) {
     try {
       output2 = await runInChild(substituteBuyer(entry.spec, order.buyer), order.input, { timeMs, maxOutputBytes }, [...order.lineage, order.jobId].join(","));
     } catch (error62) {
-      const reason = messageOf2(error62);
+      const reason = messageOf3(error62);
       notify(order, entry.offer.title, false, reason);
       return fail(target, order, reason);
     }
@@ -65308,7 +65774,7 @@ function startRunner(cfg) {
       });
       notify(order, entry.offer.title, true);
     } catch (error62) {
-      const reason = messageOf2(error62);
+      const reason = messageOf3(error62);
       notify(order, entry.offer.title, false, reason);
       fail(target, order, reason);
     }
@@ -65394,7 +65860,7 @@ function startRunner(cfg) {
       }
       handleMessage(target, message).catch((error62) => {
         if (message.t === "job")
-          fail(target, message.order, messageOf2(error62));
+          fail(target, message.order, messageOf3(error62));
       });
     });
     target.addEventListener("close", () => {
@@ -65487,7 +65953,7 @@ function connectUrl(hubUrl) {
   url2.pathname = `${url2.pathname.replace(/\/+$/, "")}${RUNNER_PATH}`;
   return url2.toString();
 }
-function messageOf2(error62) {
+function messageOf3(error62) {
   return error62 instanceof Error ? error62.message : String(error62);
 }
 
@@ -66127,6 +66593,7 @@ async function publishCommand(options) {
   console.log(offerHash2);
 }
 function publishWithState(options, account, offer2, skillSha256) {
+  assertRemoteCanServe(account, offer2);
   return publishOffer(options.hub, account, offer2, {
     ...options.state !== undefined ? { stateDir: options.state } : {},
     skillSha256
@@ -66229,11 +66696,22 @@ function makeOffer(seller, skill, options) {
   });
 }
 async function sellerAccount() {
+  const session = process.env.CS_SESSION;
+  delete process.env.CS_SESSION;
   const key = process.env.CS_SELLER_KEY;
-  if (!key || !/^0x[0-9a-fA-F]{64}$/.test(key)) {
-    throw new Error("CS_SELLER_KEY must hold a 0x-prefixed 32-byte hex key.");
+  if (key) {
+    if (!/^0x[0-9a-fA-F]{64}$/.test(key)) {
+      throw new Error("The CI signing override in this environment is malformed.");
+    }
+    return privateKeyToAccount(key);
   }
-  return privateKeyToAccount(key);
+  if (session) {
+    const issuer = process.env.CS_HUB;
+    if (!issuer)
+      throw new Error(NOT_SIGNED_IN);
+    return remoteAccountFromSession({ hubUrl: issuer, session });
+  }
+  throw new Error(NOT_SIGNED_IN);
 }
 function parseOptions(args) {
   const skills = [];
@@ -66449,30 +66927,458 @@ function parseRails(raw) {
 }
 if (false) {}
 
+// packages/cli/src/login.ts
+init__esm();
+import { spawn as spawn3 } from "node:child_process";
+
+// packages/cli/src/session.ts
+import { execFileSync } from "node:child_process";
+import {
+  chmodSync,
+  closeSync,
+  existsSync as existsSync3,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readFileSync as readFileSync4,
+  renameSync,
+  rmSync,
+  writeSync
+} from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join3 } from "node:path";
+var NOT_SIGNED_IN2 = "Not signed in. Run: npx -y @countersign-hub/cli login";
+var securityRun = (args, input2) => execFileSync("/usr/bin/security", args, { input: input2, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+function parse6(text) {
+  try {
+    const value = JSON.parse(text);
+    if (typeof value.token === "string" && typeof value.hub === "string" && typeof value.address === "string" && typeof value.expiresAt === "number") {
+      return value;
+    }
+  } catch {}
+  return null;
+}
+function refuse(path) {
+  process.stderr.write(`countersign: refusing the session at ${path}: symlink, non-regular file or unsafe permissions.
+`);
+  return null;
+}
+function fileSessionBackend(dir = join3(homedir2(), ".config", "countersign"), platform = process.platform) {
+  const path = join3(dir, "session.json");
+  return {
+    kind: "file",
+    where: () => path,
+    read() {
+      try {
+        if (lstatSync(dir).isSymbolicLink())
+          return refuse(dir);
+      } catch {
+        return null;
+      }
+      try {
+        const info = lstatSync(path);
+        const unsafeMode = platform !== "win32" && (info.mode & 63) !== 0;
+        if (info.isSymbolicLink() || !info.isFile() || unsafeMode)
+          return refuse(path);
+      } catch {
+        return null;
+      }
+      try {
+        return parse6(readFileSync4(path, "utf8"));
+      } catch {
+        return null;
+      }
+    },
+    write(session) {
+      mkdirSync2(dir, { recursive: true, mode: 448 });
+      chmodSync(dir, 448);
+      const tmp = `${path}.tmp`;
+      rmSync(tmp, { force: true });
+      const fd = openSync(tmp, "wx", 384);
+      try {
+        writeSync(fd, `${JSON.stringify(session)}
+`);
+      } finally {
+        closeSync(fd);
+      }
+      renameSync(tmp, path);
+    },
+    clear() {
+      rmSync(path, { force: true });
+    }
+  };
+}
+function keychainSessionBackend(run = securityRun) {
+  return {
+    kind: "keychain",
+    where: () => "the macOS login Keychain (service countersign, account session)",
+    read() {
+      try {
+        const hex3 = run(["find-generic-password", "-s", "countersign", "-a", "session", "-w"]).trim();
+        return hex3 === "" ? null : parse6(Buffer.from(hex3, "hex").toString("utf8"));
+      } catch {
+        return null;
+      }
+    },
+    write(session) {
+      const hex3 = Buffer.from(JSON.stringify(session), "utf8").toString("hex");
+      run(["-i"], `add-generic-password -U -s countersign -a session -w ${hex3}
+`);
+    },
+    clear() {
+      try {
+        run(["delete-generic-password", "-s", "countersign", "-a", "session"]);
+      } catch {}
+    }
+  };
+}
+function defaultSessionBackend(env = process.env) {
+  if (env.COUNTERSIGN_KEYSTORE === "file")
+    return fileSessionBackend();
+  if (process.platform === "darwin" && existsSync3("/usr/bin/security"))
+    return keychainSessionBackend();
+  return fileSessionBackend();
+}
+function loadSession(backend = defaultSessionBackend(), now = Math.floor(Date.now() / 1000)) {
+  const session = backend.read();
+  return session !== null && session.expiresAt > now ? session : null;
+}
+
+// packages/cli/src/login.ts
+var EXPIRED = `The login expired. Run countersign login again.
+`;
+var CONSOLE_ORIGIN = "https://web-production-a58de.up.railway.app";
+var UNSAFE_URL_CHARACTERS = /[&|^<>"%`;\s]/;
+var HUB_REFUSED = "Refused: the countersign hub must be https.";
+function safeConsoleUrl(url2, consoleOrigin = CONSOLE_ORIGIN) {
+  if (UNSAFE_URL_CHARACTERS.test(url2))
+    return null;
+  let parsed;
+  try {
+    parsed = new URL(url2);
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "https:")
+    return null;
+  if (parsed.origin !== consoleOrigin)
+    return null;
+  return url2;
+}
+function assertHubUrl(hub) {
+  let parsed;
+  try {
+    parsed = new URL(hub);
+  } catch {
+    throw new Error(HUB_REFUSED);
+  }
+  const local = parsed.protocol === "http:" && (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]");
+  if (parsed.protocol !== "https:" && !local)
+    throw new Error(HUB_REFUSED);
+  return parsed.origin;
+}
+function defaultOpen(url2) {
+  const windows = process.platform === "win32";
+  const command = windows ? "rundll32" : process.platform === "darwin" ? "open" : "xdg-open";
+  const args = windows ? ["url.dll,FileProtocolHandler", url2] : [url2];
+  const child = spawn3(command, args, { detached: true, stdio: "ignore", shell: false });
+  child.on("error", () => {});
+  child.unref();
+}
+function hubOrRefuse(hub) {
+  try {
+    return assertHubUrl(hub);
+  } catch (error62) {
+    process.stderr.write(`${error62 instanceof Error ? error62.message : String(error62)}
+`);
+    process.exitCode = 1;
+    return null;
+  }
+}
+function expired() {
+  process.stderr.write(EXPIRED);
+  process.exitCode = 1;
+}
+async function runLogin(_args, deps) {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const now = deps.now ?? (() => Math.floor(Date.now() / 1000));
+  const open2 = deps.open ?? defaultOpen;
+  const hub = hubOrRefuse(deps.hub);
+  if (hub === null)
+    return;
+  let start;
+  try {
+    const response = await fetchImpl(`${hub}/cli/login/start`, { method: "POST" });
+    if (!response.ok)
+      throw new Error("start refused");
+    start = await response.json();
+  } catch {
+    process.stderr.write(`The login could not start. Run countersign login again.
+`);
+    process.exitCode = 1;
+    return;
+  }
+  deps.write(`Open this link and sign in: ${start.verifyUrl}
+`);
+  deps.write(`The page will show this code: ${start.code}
+`);
+  const safeUrl = safeConsoleUrl(start.verifyUrl);
+  if (safeUrl !== null) {
+    try {
+      open2(safeUrl);
+    } catch {}
+  }
+  const interval = Number.isFinite(start.interval) && start.interval > 0 ? start.interval : 5;
+  while (now() < start.expiresAt) {
+    await sleep(interval * 1000);
+    if (now() >= start.expiresAt)
+      break;
+    let poll2;
+    try {
+      const response = await fetchImpl(`${hub}/cli/login/poll`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ deviceSecret: start.deviceSecret })
+      });
+      if (response.status === 410)
+        return expired();
+      if (!response.ok)
+        return expired();
+      poll2 = await response.json();
+    } catch {
+      continue;
+    }
+    if (poll2.status === "approved") {
+      const session = {
+        token: poll2.sessionToken,
+        hub,
+        address: poll2.address,
+        expiresAt: poll2.expiresAt
+      };
+      deps.backend.write(session);
+      deps.write(`Signed in. Your agent wallet: ${poll2.address}
+`);
+      deps.write(`Fund it: send testnet USDC to ${poll2.address} (Circle faucet: https://faucet.circle.com).
+`);
+      deps.write(`For Whitechain, get test WBT for gas at https://faucet.testnet.whitechain.io.
+`);
+      deps.write(`The session lasts 7 days; countersign logout ends it.
+`);
+      return;
+    }
+    if (poll2.status !== "pending")
+      return expired();
+  }
+  expired();
+}
+async function runLogout(_args, deps) {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const session = loadSession(deps.backend);
+  if (session === null) {
+    deps.backend.clear();
+    deps.write(`Not signed in.
+`);
+    return;
+  }
+  let confirmed = false;
+  try {
+    assertHubUrl(session.hub);
+    const response = await fetchImpl(`${session.hub}/cli/logout`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${session.token}` }
+    });
+    confirmed = response.ok;
+  } catch {}
+  deps.backend.clear();
+  if (confirmed) {
+    deps.write(`Signed out.
+`);
+  } else {
+    const expiry = new Date(session.expiresAt * 1000).toISOString();
+    deps.write(`Signed out here; the hub did not confirm, so the session stays valid until ${expiry}.
+`);
+  }
+}
+async function runWhoami(_args, deps) {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const readBalances = deps.balances ?? defaultBalances;
+  const session = loadSession(deps.backend);
+  if (session === null) {
+    process.stderr.write(`${NOT_SIGNED_IN2}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    assertHubUrl(session.hub);
+  } catch {
+    deps.backend.clear();
+    process.stderr.write(`${NOT_SIGNED_IN2}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  let response;
+  try {
+    response = await fetchImpl(`${session.hub}/cli/session`, {
+      headers: { Authorization: `Bearer ${session.token}` }
+    });
+  } catch {
+    process.stderr.write(`countersign whoami could not reach the hub.
+`);
+    process.exitCode = 1;
+    return;
+  }
+  if (response.status === 401) {
+    process.stderr.write(`${NOT_SIGNED_IN2}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  if (!response.ok) {
+    process.stderr.write(`countersign whoami could not read the session.
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const body = await response.json();
+  deps.write(`Signed in as ${body.address} until ${new Date(body.expiresAt * 1000).toISOString()}
+`);
+  deps.write(`${await readBalances(body.address)}
+`);
+}
+var BALANCE_CHAINS = [
+  {
+    name: "Arc",
+    symbol: "USDC",
+    token: "0x3600000000000000000000000000000000000000",
+    rpc: "https://rpc.testnet.arc.network"
+  },
+  {
+    name: "Whitechain",
+    symbol: "USDT",
+    token: "0xcedfB56113143d55b2358b8CFbB0dEB5Ad2f55a7",
+    rpc: "https://rpc.ankr.com/whitechain_testnet"
+  }
+];
+async function defaultBalances(address) {
+  const parts = await Promise.all(BALANCE_CHAINS.map(async (chain) => {
+    try {
+      const client = createPublicClient({ transport: http(chain.rpc) });
+      const balance = await client.readContract({
+        address: chain.token,
+        abi: erc20Abi,
+        functionName: "balanceOf",
+        args: [address]
+      });
+      return `${formatUnits3(balance, 6)} ${chain.symbol} on ${chain.name}`;
+    } catch {
+      return `unavailable ${chain.symbol} on ${chain.name}`;
+    }
+  }));
+  return parts.join(", ");
+}
+
 // packages/cli/src/cli.ts
-var VERSION = "0.1.0";
+var VERSION = "0.1.1";
+var DEFAULT_HUB3 = "https://hub-production-e85e.up.railway.app";
 var USAGE2 = `countersign ${VERSION}
 
-Sell. The runner dials out to the hub, so you open no port. The key comes from CS_SELLER_KEY.
+Sell. The runner dials out to the hub, so you open no port.
   countersign sell skill <SKILL.md> --hub <url> --price <atomic> [runner flags]
   countersign sell openapi --spec <spec.json> --operation <id> --hub <url> --price <atomic> [--base-url <url>] [runner flags]
   Add --publish-only to list the offer without serving it.
 
-Buy. The key comes from CS_BUYER_KEY.
+Buy.
   countersign discover|buy|envelope|journal [--hub <url>] [--state <dir>] ...
 
+Sign in, and check the session:
+  countersign login|logout|whoami
+
 Verify a slip offline:
   countersign verify <slip.json> [--rpc <url>]
 
 The buyer MCP server over stdio:
   countersign mcp [--hub <url>] [--state <dir>] [--rpc <url>]
+
+Start here: countersign login, then fund the printed address, then buy or sell.
+The default hub is ${DEFAULT_HUB3}.
 `;
+var COMMAND_USAGE = {
+  login: `Usage: countersign login
+  Opens a sign-in link; your agent wallet is a Privy server wallet, so no key is ever on this machine.
+`,
+  logout: `Usage: countersign logout
+  Ends the session on the hub and removes the stored token.
+`,
+  whoami: `Usage: countersign whoami
+  Shows the signed-in address, the session expiry and testnet balances.
+`,
+  sell: `Usage: countersign sell skill <SKILL.md> --hub <url> --price <atomic> [runner flags]
+       countersign sell openapi --spec <spec.json> --operation <id> --hub <url> --price <atomic> [--base-url <url>] [runner flags]
+  Add --publish-only to list the offer without serving it.
+`,
+  discover: `Usage: countersign discover [--hub <url>] [--state <dir>] [--catalogue <url|circle> [query] [--category <c>] [--limit <n>]]
+`,
+  buy: `Usage: countersign buy <offerHash|callUrl> --input '<json>' [--approve] [--rail <id>] [--approvals hub] [--hub <url>] [--state <dir>]
+`,
+  envelope: `Usage: countersign envelope show|set [--hub <url>] [--state <dir>]
+`,
+  journal: `Usage: countersign journal [--hub <url>] [--state <dir>]
+`,
+  verify: `Usage: countersign verify <slip.json> [--rpc <url>] [--mirror <url>]
+`,
+  mcp: `Usage: countersign mcp [--hub <url>] [--state <dir>] [--rpc <url>]
+`
+};
 var BUYER_COMMANDS = new Set(["discover", "buy", "envelope", "journal"]);
+function withHub(args2, env = process.env) {
+  for (const arg of args2) {
+    if (arg === "--hub" || arg.startsWith("--hub="))
+      return args2;
+  }
+  const hub = env.CS_HUB !== undefined && env.CS_HUB !== "" ? env.CS_HUB : DEFAULT_HUB3;
+  return [...args2, "--hub", hub];
+}
+function hubValue(args2, env = process.env) {
+  const settled = withHub(args2, env);
+  const last = settled.at(-1) ?? DEFAULT_HUB3;
+  return last.startsWith("--hub=") ? last.slice("--hub=".length) : last;
+}
+function useSession(env = process.env) {
+  if (env.CS_BUYER_KEY !== undefined || env.CS_SELLER_KEY !== undefined)
+    return true;
+  const session = loadSession();
+  if (session === null)
+    return false;
+  let hub;
+  try {
+    hub = assertHubUrl(session.hub);
+  } catch {
+    return false;
+  }
+  env.CS_SESSION = session.token;
+  env.CS_HUB = hub;
+  return true;
+}
 var DEFAULT_DEPS = {
-  runner: (argv) => main(argv),
-  loadBuyer: () => Promise.resolve().then(() => (init_cli(), exports_cli)),
+  runner: async (argv) => {
+    if (!useSession())
+      return requireLogin();
+    await main(withHub(argv));
+  },
+  loadBuyer: async () => {
+    if (!useSession() && needsSession())
+      return requireLogin();
+    setArgv(withHub(process.argv.slice(2)));
+    await Promise.resolve().then(() => (init_cli(), exports_cli));
+  },
   loadVerify: () => init_cli2().then(() => exports_cli2),
-  loadMcp: () => Promise.resolve().then(() => (init_main(), exports_main))
+  loadMcp: async () => {
+    useSession();
+    return Promise.resolve().then(() => (init_main(), exports_main));
+  }
 };
 function runnerArgs(rest) {
   const publishOnly = rest.includes("--publish-only");
@@ -66514,10 +67420,29 @@ async function run(argv, deps = DEFAULT_DEPS) {
 `);
     return;
   }
+  const commandUsage = COMMAND_USAGE[command];
+  if (commandUsage !== undefined && (rest.includes("--help") || rest.includes("-h"))) {
+    process.stdout.write(commandUsage);
+    return;
+  }
+  if (command === "login" || command === "logout" || command === "whoami") {
+    const loginDeps = {
+      backend: defaultSessionBackend(),
+      hub: hubValue(rest),
+      write: (t) => process.stdout.write(t)
+    };
+    if (command === "login")
+      await runLogin(rest, loginDeps);
+    else if (command === "logout")
+      await runLogout(rest, loginDeps);
+    else
+      await runWhoami(rest, loginDeps);
+    return;
+  }
   if (command === "sell") {
     const mapped = runnerArgs(rest);
     if (!mapped.ok)
-      return refuse2(mapped.error);
+      return refuse3(mapped.error);
     await deps.runner(mapped.args);
     return;
   }
@@ -66536,20 +67461,29 @@ async function run(argv, deps = DEFAULT_DEPS) {
     try {
       loaded = await deps.loadMcp();
     } catch {
-      return refuse2("countersign mcp could not load its MCP server.");
+      return refuse3("countersign mcp could not load its MCP server.");
     }
     const main4 = isRecord10(loaded) ? loaded.main : undefined;
     if (typeof main4 !== "function")
-      return refuse2("The MCP server has no main(argv) export.");
+      return refuse3("The MCP server has no main(argv) export.");
     await main4(rest);
     return;
   }
-  return refuse2(`countersign: unknown command '${command}'.`);
+  return refuse3(`countersign: unknown command '${command}'.`);
 }
 function setArgv(args2) {
   process.argv = [process.argv[0] ?? "node", "countersign", ...args2];
 }
-function refuse2(message) {
+function needsSession() {
+  const [command, verb] = process.argv.slice(2);
+  return command === "buy" || command === "journal" || command === "envelope" && verb === "set";
+}
+function requireLogin() {
+  process.stderr.write(`${NOT_SIGNED_IN2}
+`);
+  process.exitCode = 1;
+}
+function refuse3(message) {
   process.stderr.write(`${message}
 
 ${USAGE2}`);
@@ -66566,4 +67500,4 @@ run(process.argv.slice(2)).catch((error62) => {
   process.exitCode = 1;
 });
 
-//# debugId=B268FD45CC002A6364756E2164756E21
+//# debugId=086E31B6AC676B0A64756E2164756E21