zas-agent 0.1.0

package/dist/cli.js

@@ -0,0 +1,1931 @@
+#!/usr/bin/env node
+import { createRequire as __cr } from "node:module"; const require = __cr(import.meta.url);
+
+// src/cli.ts
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/shared/agent.ts
+import { p256 } from "@noble/curves/nist.js";
+import { sha256 as sha2562 } from "@noble/hashes/sha2";
+
+// src/shared/hash.ts
+import { blake3 } from "hash-wasm";
+import { hkdf } from "@noble/hashes/hkdf";
+import { sha512 } from "@noble/hashes/sha2";
+import { hmac } from "@noble/hashes/hmac";
+import { sha256 } from "@noble/hashes/sha2";
+async function blake3Bytes(data) {
+  const hex = await blake3(data, 256);
+  return hexToBytes(hex);
+}
+async function blake3Hex(data) {
+  return blake3(data, 256);
+}
+function hkdf512(ikm, info, length) {
+  return hkdf(sha512, ikm, void 0, new TextEncoder().encode(info), length);
+}
+function hmacSha256(key, data) {
+  return hmac(sha256, key, data);
+}
+function hexToBytes(hex) {
+  const out = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < out.length; i++) out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  return out;
+}
+function bytesToHex(bytes) {
+  let s = "";
+  for (const b of bytes) s += b.toString(16).padStart(2, "0");
+  return s;
+}
+function bytesToB64(bytes) {
+  let bin = "";
+  for (const b of bytes) bin += String.fromCharCode(b);
+  const b64 = typeof btoa !== "undefined" ? btoa(bin) : Buffer.from(bytes).toString("base64");
+  return b64;
+}
+function b64ToBytes(b64) {
+  if (typeof atob !== "undefined") {
+    const bin = atob(b64);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+    return out;
+  }
+  return new Uint8Array(Buffer.from(b64, "base64"));
+}
+function concatBytes(...arrays) {
+  const total = arrays.reduce((n, a) => n + a.length, 0);
+  const out = new Uint8Array(total);
+  let off = 0;
+  for (const a of arrays) {
+    out.set(a, off);
+    off += a.length;
+  }
+  return out;
+}
+
+// src/shared/agent.ts
+var AGENT_KINDS = ["claude_code", "codex", "other"];
+function isAgentKind(value) {
+  return typeof value === "string" && AGENT_KINDS.includes(value);
+}
+var AGENT_PAIRING_TTL_MS = 10 * 60 * 1e3;
+var AGENT_CHALLENGE_TTL_MS = 60 * 1e3;
+var AGENT_TOKEN_TTL_SEC = 3600;
+var AGENT_LAST_SEEN_BUCKET_MS = 5 * 60 * 1e3;
+var AGENT_HOST_MAX = 60;
+var AGENT_CHALLENGE_DOMAIN = "ZAS-AGENT-CHALLENGE-V1";
+var text = new TextEncoder();
+function field(bytes) {
+  const length = new Uint8Array(4);
+  new DataView(length.buffer).setUint32(0, bytes.length, false);
+  return concatBytes(length, bytes);
+}
+function agentChallengeBytes(agentUid, challengeId, nonce) {
+  return sha2562(concatBytes(
+    field(text.encode(AGENT_CHALLENGE_DOMAIN)),
+    field(text.encode(agentUid)),
+    field(text.encode(challengeId)),
+    field(nonce)
+  ));
+}
+function signAgentChallenge(privateKey, agentUid, challengeId, nonce) {
+  return p256.sign(agentChallengeBytes(agentUid, challengeId, nonce), privateKey, { lowS: true }).toCompactRawBytes();
+}
+function agentFingerprintShort(fingerprint) {
+  return fingerprint.slice(0, 16).match(/.{4}/g).join(" ");
+}
+function agentSendIdempotencyKey(channelId, contentHashHex, title) {
+  return bytesToHex(sha2562(text.encode(`${channelId}\0${contentHashHex}\0${title}`))).slice(0, 32);
+}
+
+// src/errors.ts
+var RENAMES = {
+  storage_limit: "quota_exceeded",
+  file_too_large: "file_too_big",
+  read_only: "send_forbidden",
+  unknown_channel: "grant_missing",
+  no_account: "grant_missing"
+};
+var ZasError = class extends Error {
+  constructor(code, status, message, retryAfterMs, serverCode) {
+    super(message ?? code);
+    this.code = code;
+    this.status = status;
+    this.retryAfterMs = retryAfterMs;
+    this.serverCode = serverCode;
+    this.name = "ZasError";
+  }
+};
+var SIGN_IN_CODES = /* @__PURE__ */ new Set([
+  "bad_signature",
+  "rate_limited",
+  "feature_disabled",
+  "missing_token",
+  "agent_revoked",
+  "agent_forbidden"
+]);
+function errorFromResponse(status, body) {
+  const fields = body && typeof body === "object" ? body : {};
+  const raw = typeof fields.error === "string" ? fields.error : `http_${status}`;
+  const retryAfterMs = typeof fields.retry_after_ms === "number" && Number.isFinite(fields.retry_after_ms) ? fields.retry_after_ms : void 0;
+  const renamed = RENAMES[raw] ?? raw;
+  const known = Object.prototype.hasOwnProperty.call(SENTENCES, renamed) || SIGN_IN_CODES.has(renamed);
+  const code = known ? renamed : status < 500 ? "upload_failed" : "network";
+  return new ZasError(code, status, raw, retryAfterMs, raw);
+}
+var SENTENCES = {
+  identity_corrupt: { es: "El archivo de identidad del agente est\xE1 da\xF1ado: {path}. Restauralo o borralo y volv\xE9 a emparejar.", en: "The agent identity file is damaged: {path}. Restore it, or delete it and pair again." },
+  not_paired: { es: "Este agente todav\xEDa no est\xE1 emparejado. Corr\xE9 \xABnpx -y zas-agent pair\xBB en la terminal.", en: "This agent is not paired yet. Run \u201Cnpx -y zas-agent pair\u201D in the terminal." },
+  internal: { es: "Algo fall\xF3 dentro del agente. Prob\xE1 de nuevo.", en: "Something failed inside the agent. Try again." },
+  agent_forbidden: { es: "Este agente no puede hacer eso; solo el due\xF1o de la cuenta.", en: "This agent cannot do that; only the account owner can." },
+  agent_revoked: { es: "El due\xF1o revoc\xF3 este agente. Volv\xE9 a emparejar con \xABzas-agent pair\xBB.", en: "The owner revoked this agent. Pair again with \u201Czas-agent pair\u201D." },
+  grant_missing: { es: "Este agente no tiene acceso a ese canal. El due\xF1o lo agrega desde Ajustes \u2192 Agentes.", en: "This agent has no access to that channel. The owner adds it from Settings \u2192 Agents." },
+  not_found: { es: "Ese \xEDtem no est\xE1 en el canal.", en: "That item is not in the channel." },
+  invalid_cap: { es: "Ese archivo ya no est\xE1 disponible.", en: "That file is no longer available." },
+  write_failed: { es: "No se pudo guardar el archivo en el destino.", en: "The file could not be saved to the destination." },
+  send_forbidden: { es: "Este agente no puede enviar a ese canal.", en: "This agent cannot send to that channel." },
+  read_forbidden: { es: "Este agente no puede leer ese canal.", en: "This agent cannot read that channel." },
+  direct_mode: { es: "Ese canal est\xE1 en modo Directo. Us\xE1 zas_send_direct.", en: "That channel is in Directo mode. Use zas_send_direct." },
+  not_direct_mode: { es: "Ese canal no est\xE1 en modo Directo. Us\xE1 zas_send_file.", en: "That channel is not in Directo mode. Use zas_send_file." },
+  key_stale: { es: "La clave del canal cambi\xF3. El due\xF1o la renueva al abrir Zas.", en: "The channel key changed. The owner refreshes it by opening Zas." },
+  quota_exceeded: { es: "La cuenta lleg\xF3 a su l\xEDmite de almacenamiento.", en: "The account reached its storage limit." },
+  rate_limited: { es: "Demasiados env\xEDos seguidos. Esper\xE1 un momento.", en: "Too many sends in a row. Wait a moment." },
+  file_too_big: { es: "El archivo supera el m\xE1ximo del plan.", en: "The file is over the plan limit." },
+  duplicate: { es: "Ese \xEDtem ya est\xE1 en el canal.", en: "That item is already in the channel." },
+  pairing_expired: { es: "El emparejamiento venci\xF3. Corr\xE9 \xABzas-agent pair\xBB de nuevo.", en: "The pairing expired. Run \u201Czas-agent pair\u201D again." },
+  pairing_cancelled: { es: "El due\xF1o cancel\xF3 el emparejamiento.", en: "The owner cancelled the pairing." },
+  feature_disabled: { es: "Los agentes todav\xEDa no est\xE1n habilitados para esta cuenta.", en: "Agents are not enabled for this account yet." },
+  upload_failed: { es: "No se pudo subir el archivo. Prob\xE1 de nuevo.", en: "The upload failed. Try again." },
+  oprf_failed: { es: "Zas no respondi\xF3 bien al preparar el archivo. Prob\xE1 de nuevo.", en: "Zas did not answer correctly while preparing the file. Try again." },
+  network: { es: "No hay conexi\xF3n con Zas. Prob\xE1 de nuevo en un momento.", en: "Zas cannot be reached. Try again in a moment." },
+  sign_in_failed: { es: "Zas no acept\xF3 la sesi\xF3n de este agente. Prob\xE1 de nuevo o volv\xE9 a emparejar.", en: "Zas did not accept this agent session. Try again, or pair again." },
+  bad_signature: { es: "Zas rechaz\xF3 la firma de este agente. Emparejalo de nuevo.", en: "Zas rejected this agent's signature. Pair it again." },
+  missing_token: { es: "Falta el token de sesi\xF3n. Emparej\xE1 el agente de nuevo.", en: "The session token is missing. Pair the agent again." }
+};
+function humanSentence(error, locale = "es") {
+  const sentence = SENTENCES[error.code]?.[locale];
+  if (sentence) return sentence.replace("{path}", () => error.message);
+  return locale === "es" ? `Zas respondi\xF3 ${error.code} (${error.status}).` : `Zas answered ${error.code} (${error.status}).`;
+}
+
+// src/identity.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { x25519 } from "@noble/curves/ed25519";
+import { p256 as p2562 } from "@noble/curves/nist.js";
+var IDENTITY_FILE = "identity.json";
+var PENDING_FILE = "pending.json";
+var GRANTS_FILE = "grants.json";
+var FINGERPRINTS_FILE = "fingerprints.json";
+function agentHome() {
+  return process.env.ZAS_AGENT_HOME || join(homedir(), ".zas", "agent");
+}
+var PROFILE_RE = /^(?!\.)[A-Za-z0-9._-]{1,64}$/;
+function profileDir(profile) {
+  if (!PROFILE_RE.test(profile)) throw new ZasError("internal", 0, `Perfil inv\xE1lido: ${profile}`);
+  return join(agentHome(), profile);
+}
+function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  if (process.platform !== "win32") chmodSync(dir, 448);
+}
+function writePrivate(dir, name, value) {
+  ensureDir(dir);
+  const target = join(dir, name);
+  const tmp = `${target}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+  if (process.platform !== "win32") chmodSync(tmp, 384);
+  renameSync(tmp, target);
+}
+function readText(path) {
+  try {
+    return readFileSync(path, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+function readCache(dir, name) {
+  const target = join(dir, name);
+  if (!existsSync(target)) return null;
+  try {
+    return JSON.parse(readFileSync(target, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function readSecret(dir, name) {
+  const target = resolve(join(dir, name));
+  const text2 = readText(target);
+  if (text2 === null) return null;
+  let parsed = null;
+  try {
+    parsed = JSON.parse(text2);
+  } catch {
+    parsed = null;
+  }
+  if (!parsed || typeof parsed !== "object") throw new ZasError("identity_corrupt", 0, target);
+  return parsed;
+}
+function newKeyMaterial() {
+  const x = x25519.utils.randomSecretKey();
+  const p = p2562.utils.randomSecretKey();
+  return {
+    x25519_private: bytesToB64(x),
+    x25519_public: bytesToB64(x25519.getPublicKey(x)),
+    p256_private: bytesToB64(p),
+    // Uncompressed: 65 bytes is what the server stores and verifies against.
+    p256_public: bytesToB64(p2562.getPublicKey(p, false))
+  };
+}
+function loadIdentity(profile) {
+  return readSecret(profileDir(profile), IDENTITY_FILE);
+}
+function saveIdentity(profile, identity) {
+  writePrivate(profileDir(profile), IDENTITY_FILE, identity);
+}
+function savePending(profile, pending) {
+  writePrivate(profileDir(profile), PENDING_FILE, pending);
+}
+function clearPending(profile) {
+  rmSync(join(profileDir(profile), PENDING_FILE), { force: true });
+}
+function loadGrants(profile) {
+  return readCache(profileDir(profile), GRANTS_FILE);
+}
+function saveGrants(profile, cache) {
+  writePrivate(profileDir(profile), GRANTS_FILE, cache);
+}
+var isPlainObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+function loadFingerprints(profile) {
+  const cached = readCache(profileDir(profile), FINGERPRINTS_FILE);
+  if (!isPlainObject(cached) || !isPlainObject(cached.entries)) return { entries: {} };
+  return { entries: cached.entries };
+}
+function saveFingerprints(profile, cache) {
+  writePrivate(profileDir(profile), FINGERPRINTS_FILE, cache);
+}
+function defaultEndpoints() {
+  return {
+    api_base: process.env.ZAS_API_BASE || "https://zas.red/api",
+    token_base: process.env.ZAS_TOKEN_BASE || "https://zas.red/anon-token",
+    oprf_base: process.env.ZAS_OPRF_BASE || "https://zas.red/oprf",
+    firestore_project: process.env.ZAS_FIREBASE_PROJECT || "zas-me"
+  };
+}
+
+// src/pair.ts
+import { hostname } from "node:os";
+
+// src/client.ts
+var REFRESH_MARGIN_MS = 5 * 60 * 1e3;
+async function readBody(res) {
+  const text2 = await res.text();
+  if (!text2) return {};
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return {};
+  }
+}
+function jsonInit(method, body, headers) {
+  return {
+    method,
+    headers: { ...body === void 0 ? {} : { "Content-Type": "application/json" }, ...headers },
+    ...body === void 0 ? {} : { body: JSON.stringify(body) }
+  };
+}
+async function apiPublic(base, method, path, body, headers = {}, fetchImpl) {
+  const call = fetchImpl ?? ((input, init) => fetch(input, init));
+  const res = await call(`${base}${path}`, jsonInit(method, body, headers));
+  const parsed = res.status === 204 ? void 0 : await readBody(res);
+  if (!res.ok) throw errorFromResponse(res.status, parsed);
+  return parsed;
+}
+var ZasClient = class _ZasClient {
+  constructor(identity, opts = {}) {
+    this.identity = identity;
+    this.call = opts.fetch ?? ((input, init) => fetch(input, init));
+    this.now = opts.now ?? (() => Date.now());
+  }
+  call;
+  now;
+  /** No refresh token: the agent re-signs in from its P-256 key, which it has
+   *  on disk anyway, so keeping a long-lived credential in memory would buy
+   *  nothing and widen what a crash dump holds. */
+  session = null;
+  /** Concurrent callers wait on the one sign-in instead of racing three. */
+  pendingSignIn = null;
+  async signIn() {
+    const { agent_uid, owner_uid, token_base, p256_private } = this.identity;
+    const chal = await apiPublic(
+      token_base,
+      "POST",
+      "/v1/agents/challenge",
+      { agent_uid, owner_uid },
+      {},
+      this.call
+    );
+    const signature = bytesToB64(
+      signAgentChallenge(b64ToBytes(p256_private), agent_uid, chal.challenge_id, b64ToBytes(chal.nonce))
+    );
+    const tok = await apiPublic(
+      token_base,
+      "POST",
+      "/v1/agents/token",
+      { agent_uid, owner_uid, challenge_id: chal.challenge_id, signature },
+      {},
+      this.call
+    );
+    const res = await this.call(`${_ZasClient.identityToolkitBase()}/accounts:signInWithCustomToken?key=${_ZasClient.apiKey()}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ token: tok.token, returnSecureToken: true })
+    });
+    if (!res.ok) throw new ZasError("sign_in_failed", res.status);
+    const data = await res.json();
+    const seconds = Number(data.expiresIn);
+    const ttl = Number.isFinite(seconds) && seconds > 0 ? seconds : AGENT_TOKEN_TTL_SEC;
+    this.session = { idToken: data.idToken, expiresAt: this.now() + ttl * 1e3 };
+  }
+  async idToken() {
+    if (!this.session || this.session.expiresAt - this.now() <= REFRESH_MARGIN_MS) {
+      await this.signInOnce();
+    }
+    return this.session.idToken;
+  }
+  async signInOnce() {
+    if (!this.pendingSignIn) {
+      this.pendingSignIn = this.signIn().finally(() => {
+        this.pendingSignIn = null;
+      });
+    }
+    await this.pendingSignIn;
+  }
+  async api(method, path, body, headers = {}) {
+    const res = await this.authedRetrying(`${this.identity.api_base}/v1${path}`, method, body, headers);
+    const parsed = res.status === 204 ? void 0 : await readBody(res);
+    if (!res.ok) throw errorFromResponse(res.status, parsed);
+    return parsed;
+  }
+  async authed(url, method, body, headers) {
+    const token = await this.idToken();
+    return this.call(url, jsonInit(method, body, { Authorization: `Bearer ${token}`, ...headers }));
+  }
+  /** One authenticated call, with one fresh sign-in if the token is rejected.
+   *  A 401 on a token the clock said was young means a revoked session or a
+   *  server that restarted; both are fixed by signing in again, and neither is
+   *  fixed by doing it twice. The API and the OPRF service both call through
+   *  here, so a token that dies mid-send costs one retry, not the send. */
+  async authedRetrying(url, method, body, headers) {
+    const res = await this.authed(url, method, body, headers);
+    if (res.status !== 401) return res;
+    await res.body?.cancel().catch(() => {
+    });
+    this.session = null;
+    return this.authed(url, method, body, headers);
+  }
+  async oprfEvaluate(blinded) {
+    const res = await this.authedRetrying(`${this.identity.oprf_base}/evaluate`, "POST", { blinded }, {});
+    const parsed = await readBody(res);
+    if (!res.ok) throw errorFromResponse(res.status, parsed);
+    return parsed.evaluated ?? [];
+  }
+  /** Firestore REST runQuery. `parentPath` is relative to the documents root
+   *  ('' for the root itself); the rows without a `document` are the read-time
+   *  metadata Firestore interleaves, and they are dropped. */
+  async firestoreRunQuery(parentPath, query) {
+    const base = _ZasClient.firestoreBase(this.identity.firestore_project);
+    const url = `${base}${parentPath ? `/${parentPath}` : ""}:runQuery`;
+    const res = await this.authed(url, "POST", { structuredQuery: query }, {});
+    const parsed = await readBody(res);
+    if (!res.ok) throw errorFromResponse(res.status, parsed);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((row) => !!row && typeof row === "object" && "document" in row).map((row) => row.document);
+  }
+  /** The web app's public config value. It identifies the project, it is not a secret. */
+  static apiKey() {
+    return process.env.ZAS_FIREBASE_API_KEY || "AIzaSyAiZbAPrxH7EKaJftJoGcEVEL0h6rAVcvE";
+  }
+  static identityToolkitBase() {
+    const host = process.env.FIREBASE_AUTH_EMULATOR_HOST;
+    return host ? `http://${host}/identitytoolkit.googleapis.com/v1` : "https://identitytoolkit.googleapis.com/v1";
+  }
+  static firestoreBase(project) {
+    const host = process.env.FIRESTORE_EMULATOR_HOST;
+    const root = host ? `http://${host}` : "https://firestore.googleapis.com";
+    return `${root}/v1/projects/${project}/databases/(default)/documents`;
+  }
+};
+
+// src/snippets.ts
+function packageName() {
+  return true ? "zas-agent" : "zas-agent";
+}
+function claudeSnippet(profile) {
+  return `claude mcp add zas -- npx -y ${packageName()} --profile ${profile}`;
+}
+function codexSnippet(profile) {
+  return `codex mcp add zas -- npx -y ${packageName()} --profile ${profile}`;
+}
+function kindForProfile(profile) {
+  if (profile === "claude-code") return "claude_code";
+  if (profile === "codex") return "codex";
+  return "other";
+}
+
+// src/pair.ts
+var POLL_INTERVAL_MS = 2e3;
+function pairUrl(webBase, pairingId) {
+  return `${webBase}/agents/pair?p=${pairingId}`;
+}
+function formatCode(code) {
+  return `${code.slice(0, 4)}-${code.slice(4)}`;
+}
+var defaultSleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
+async function runPair(opts) {
+  const sleep2 = opts.sleep ?? defaultSleep;
+  const now = opts.now ?? (() => Date.now());
+  const existing = loadIdentity(opts.profile);
+  if (existing) {
+    opts.log(
+      `Este perfil ya est\xE1 emparejado como \xAB${existing.name}\xBB. Se va a crear un agente nuevo; revoc\xE1 el anterior desde Ajustes \u2192 Agentes.`
+    );
+  }
+  const host = (opts.host ?? hostname()).slice(0, AGENT_HOST_MAX);
+  const keys = newKeyMaterial();
+  const endpoints = { ...defaultEndpoints(), api_base: opts.apiBase };
+  const created = await apiPublic(
+    opts.apiBase,
+    "POST",
+    "/v1/agents/pairings",
+    { kind: opts.kind, host, x25519_public: keys.x25519_public, p256_public: keys.p256_public },
+    {},
+    opts.fetch
+  );
+  const pending = {
+    version: 1,
+    profile: opts.profile,
+    pairing_id: created.pairing_id,
+    poll_secret: created.poll_secret,
+    code: created.code,
+    fingerprint: created.fingerprint,
+    expires_at: created.expires_at,
+    kind: opts.kind,
+    host,
+    ...keys,
+    ...endpoints,
+    created_at: now()
+  };
+  savePending(opts.profile, pending);
+  const minutesLeft = Math.max(0, Math.round((created.expires_at - now()) / 6e4));
+  opts.log(
+    [
+      "Abr\xED esta p\xE1gina con tu cuenta de Zas:",
+      `  ${pairUrl(opts.webBase, created.pairing_id)}`,
+      `C\xF3digo:  ${formatCode(created.code)}`,
+      `Huella:  ${agentFingerprintShort(created.fingerprint)}`,
+      `Esperando la aprobaci\xF3n\u2026 (vence en ${minutesLeft} minutos)`
+    ].join("\n")
+  );
+  let approved = null;
+  for (; ; ) {
+    let answer;
+    try {
+      answer = await apiPublic(
+        opts.apiBase,
+        "POST",
+        `/v1/agents/pairings/${created.pairing_id}/poll`,
+        void 0,
+        { "X-Zas-Poll-Secret": created.poll_secret },
+        opts.fetch
+      );
+    } catch (err) {
+      if (!(err instanceof ZasError) || err.code !== "rate_limited") throw err;
+      if (now() >= created.expires_at) throw new ZasError("pairing_expired", 410);
+      await sleep2(err.retryAfterMs ?? 1e4);
+      continue;
+    }
+    if (answer.status === "approved") {
+      approved = { agent_uid: answer.agent_uid, owner_uid: answer.owner_uid };
+      break;
+    }
+    if (answer.status === "expired" || answer.status === "cancelled") {
+      clearPending(opts.profile);
+      throw new ZasError(`pairing_${answer.status}`, 410);
+    }
+    await sleep2(POLL_INTERVAL_MS);
+  }
+  const baseIdentity = {
+    version: 1,
+    agent_uid: approved.agent_uid,
+    owner_uid: approved.owner_uid,
+    name: "",
+    kind: opts.kind,
+    host,
+    ...keys,
+    ...endpoints
+  };
+  const client = new ZasClient(baseIdentity, { fetch: opts.fetch, now });
+  await client.signIn();
+  const me = await client.api("GET", "/agents/me");
+  const identity = { ...baseIdentity, name: me.name };
+  saveIdentity(opts.profile, identity);
+  clearPending(opts.profile);
+  const claudeLines = (lead) => [lead, `  ${claudeSnippet(opts.profile)}`];
+  const codexLines = (lead) => [lead, `  ${codexSnippet(opts.profile)}`];
+  const install = opts.kind === "claude_code" ? claudeLines("Agregalo a Claude Code:") : opts.kind === "codex" ? codexLines("Agregalo a Codex:") : [...claudeLines("Agregalo a Claude Code:"), ...codexLines("O a Codex:")];
+  opts.log(
+    [
+      `Listo: el agente \xAB${identity.name}\xBB qued\xF3 emparejado con tu cuenta.`,
+      ...install
+    ].join("\n")
+  );
+  return identity;
+}
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+// src/shared/manifest.ts
+import { xchacha20poly1305 } from "@noble/ciphers/chacha";
+
+// src/shared/constants.ts
+var CHUNKER_VERSION = "chunker_v1";
+var CHUNK_MIN = 1 * 1024 * 1024;
+var CHUNK_AVG_BITS = 22;
+var CHUNK_MAX = 8 * 1024 * 1024;
+var STORAGE_V2_PART_BYTES = 16 * 1024 * 1024;
+var GEAR_SEED = "zas-gear-v1:";
+var HKDF_INFO_CHUNK_KEY = "zas-chunk-key-v1";
+var HKDF_INFO_CHUNK_NONCE = "zas-chunk-nonce-v1";
+var OPRF_CONTEXT = "OPRFV1-\0-ristretto255-SHA512";
+var MANIFEST_VERSION = 1;
+var ANON_EMPTY_TTL_MS = 30 * 60 * 1e3;
+var FREE_RELAY_MAX_BYTES = 50 * 1024 * 1024;
+var SAFE_STORED_FILE_LIMITS = {
+  anon: 30 * 1024 * 1024,
+  free: FREE_RELAY_MAX_BYTES,
+  pro: 200 * 1024 * 1024,
+  max: 200 * 1024 * 1024
+};
+var STORED_FILE_LIMITS_V2 = {
+  anon: 30 * 1024 * 1024,
+  free: FREE_RELAY_MAX_BYTES,
+  pro: 5 * 1024 * 1024 * 1024,
+  max: 20 * 1024 * 1024 * 1024
+};
+var STORAGE_LIMITS = {
+  anon: 30 * 1024 * 1024,
+  free: 100 * 1024 * 1024,
+  pro: null,
+  max: null
+};
+var THUMBNAIL_MAX_EDGE = 640;
+var THUMBNAIL_MAX_BYTES = 14e4;
+
+// src/shared/manifest.ts
+function newManifest(partial) {
+  return { v: MANIFEST_VERSION, chunker: CHUNKER_VERSION, ...partial };
+}
+var ENVELOPE_MAGIC = 90;
+var KEY_VERSION_LEGACY = 1;
+function envelopeVersion(sealed) {
+  if (sealed.length > 26 && sealed[0] === ENVELOPE_MAGIC && sealed[1] >= 1) return sealed[1];
+  return KEY_VERSION_LEGACY;
+}
+function sealBytes(key, version, plain) {
+  if (version < 1 || version > 255) throw new Error("key version out of range");
+  const nonce = new Uint8Array(24);
+  crypto.getRandomValues(nonce);
+  const ct = xchacha20poly1305(key, nonce).encrypt(plain);
+  return concatBytes(new Uint8Array([ENVELOPE_MAGIC, version]), nonce, ct);
+}
+function openSealed(key, sealed) {
+  const versioned = envelopeVersion(sealed) !== KEY_VERSION_LEGACY || sealed[0] === ENVELOPE_MAGIC;
+  if (versioned && sealed.length > 26) {
+    try {
+      return xchacha20poly1305(key, sealed.slice(2, 26)).decrypt(sealed.slice(26));
+    } catch {
+    }
+  }
+  return xchacha20poly1305(key, sealed.slice(0, 24)).decrypt(sealed.slice(24));
+}
+function sealManifest(channelKey, manifest, version = KEY_VERSION_LEGACY) {
+  return sealBytes(channelKey, version, new TextEncoder().encode(JSON.stringify(manifest)));
+}
+function openManifest(channelKey, sealed) {
+  const m = JSON.parse(new TextDecoder().decode(openSealed(channelKey, sealed)));
+  if (!Array.isArray(m.chunks)) m.chunks = [];
+  return m;
+}
+function decryptChannelName(channelKey, sealed) {
+  return new TextDecoder().decode(openSealed(channelKey, sealed));
+}
+
+// src/shared/sharedchannel.ts
+import { xchacha20poly1305 as xchacha20poly13052 } from "@noble/ciphers/chacha";
+import { x25519 as x255192 } from "@noble/curves/ed25519";
+var ASSIGNMENT_MAGIC = new Uint8Array([90, 67, 1]);
+var ASSIGNMENT_HEADER_BYTES = 3 + 1 + 32 + 24;
+function assignmentEnvelope(envelope) {
+  return envelope.length >= ASSIGNMENT_HEADER_BYTES + 16 && envelope[0] === ASSIGNMENT_MAGIC[0] && envelope[1] === ASSIGNMENT_MAGIC[1] && envelope[2] === ASSIGNMENT_MAGIC[2];
+}
+function openChannelAssignment(privateKey, envelope) {
+  if (!assignmentEnvelope(envelope)) throw new Error("bad envelope");
+  const ephemeralPublic = envelope.slice(4, 36);
+  const nonce = envelope.slice(36, 60);
+  const shared = x255192.getSharedSecret(privateKey, ephemeralPublic);
+  const key = hkdf512(shared, "ZAS-CHANNEL-ASSIGNMENT-ENVELOPE-V1", 32);
+  const plain = xchacha20poly13052(key, nonce).decrypt(envelope.slice(60));
+  shared.fill(0);
+  key.fill(0);
+  if (plain.length !== 32) throw new Error("bad channel key");
+  return plain;
+}
+
+// src/grants.ts
+var GRANTS_MAX_AGE_MS = 6e4;
+async function refreshGrants(client, profile) {
+  const me = await client.api("GET", "/agents/me");
+  const grants = Array.isArray(me.grants) ? me.grants : [];
+  saveGrants(profile, { fetched_at: Date.now(), agent_uid: client.identity.agent_uid, grants });
+  return grants;
+}
+async function grantsFor(client, profile, maxAgeMs = GRANTS_MAX_AGE_MS) {
+  const cached = loadGrants(profile);
+  const fresh = cached && cached.agent_uid === client.identity.agent_uid && Array.isArray(cached.grants) && Date.now() - cached.fetched_at < maxAgeMs;
+  return fresh ? cached.grants : refreshGrants(client, profile);
+}
+function channelKeyOf(identity, grant) {
+  try {
+    return openChannelAssignment(b64ToBytes(identity.x25519_private), b64ToBytes(grant.wrapped_key));
+  } catch {
+    throw new ZasError("key_stale", 0);
+  }
+}
+function channelNameOf(identity, grant) {
+  try {
+    return decryptChannelName(channelKeyOf(identity, grant), b64ToBytes(grant.name_enc));
+  } catch (err) {
+    if (err instanceof ZasError) throw err;
+    throw new ZasError("key_stale", 0);
+  }
+}
+var fold = (value) => value.trim().toLowerCase();
+function resolveChannel(identity, grants, channel) {
+  if (channel === void 0 || fold(channel) === "") {
+    if (grants.length === 1) return grants[0];
+    throw new ZasError("grant_missing", 0);
+  }
+  const wanted = channel.trim();
+  const byId = grants.find((g) => g.channel_id === wanted);
+  if (byId) return byId;
+  const folded = fold(wanted);
+  const byName = grants.filter((g) => {
+    try {
+      return fold(channelNameOf(identity, g)) === folded;
+    } catch {
+      return false;
+    }
+  });
+  if (byName.length === 1) return byName[0];
+  throw new ZasError("grant_missing", 0);
+}
+
+// src/jobs.ts
+import { randomUUID } from "node:crypto";
+var DEFAULT_WAIT_MS = 6e4;
+var HISTORY = 50;
+var JobRunner = class {
+  now;
+  waitMs;
+  /** Newest first, and trimmed. */
+  jobs = [];
+  /** Keyed on the job object, not its id, so a caller holding a job that has
+   *  already aged out of the list can still wait for it to finish. */
+  settled = /* @__PURE__ */ new WeakMap();
+  constructor(opts = {}) {
+    this.now = opts.now ?? (() => Date.now());
+    this.waitMs = opts.waitMs ?? DEFAULT_WAIT_MS;
+  }
+  start(kind, title, channel, work) {
+    const job = {
+      id: randomUUID(),
+      kind,
+      title,
+      channel,
+      started_at: this.now(),
+      phase: null,
+      status: "running"
+    };
+    this.jobs.unshift(job);
+    this.jobs.length = Math.min(this.jobs.length, HISTORY);
+    const report = (phase) => {
+      if (job.status === "running") job.phase = phase;
+    };
+    this.settled.set(job, work(report).then(
+      (result) => {
+        job.status = "done";
+        job.result = result;
+        return job;
+      },
+      (error) => {
+        job.status = "failed";
+        job.error = error instanceof ZasError ? {
+          code: error.code,
+          status: error.status,
+          sentence: humanSentence(error),
+          message: error.message,
+          ...error.retryAfterMs !== void 0 ? { retryAfterMs: error.retryAfterMs } : {},
+          ...error.serverCode !== void 0 ? { serverCode: error.serverCode } : {}
+        } : { code: "upload_failed", status: 0, sentence: humanSentence(new ZasError("upload_failed", 0)) };
+        return job;
+      }
+    ));
+    return job;
+  }
+  /** Resolves when the work settles, or when the wait runs out — the same job
+   *  object either way, so the caller reads `status` rather than guessing. */
+  async wait(job) {
+    const settled = this.settled.get(job);
+    if (!settled) return job;
+    let timer;
+    const deadline = new Promise((resolve2) => {
+      timer = setTimeout(() => resolve2(job), this.waitMs);
+    });
+    try {
+      return await Promise.race([settled, deadline]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  list() {
+    return this.jobs.slice(0, HISTORY);
+  }
+  get(id) {
+    return this.jobs.find((job) => job.id === id);
+  }
+};
+
+// src/read.ts
+import { randomBytes } from "node:crypto";
+import {
+  closeSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  mkdtempSync,
+  openSync,
+  renameSync as renameSync2,
+  rmdirSync,
+  statSync,
+  unlinkSync,
+  writeSync
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, extname, join as join2 } from "node:path";
+
+// src/shared/mle.ts
+import { xchacha20poly1305 as xchacha20poly13053 } from "@noble/ciphers/chacha";
+function chunkKeyFromF(f) {
+  return {
+    key: hkdf512(f, HKDF_INFO_CHUNK_KEY, 32),
+    nonce: hkdf512(f, HKDF_INFO_CHUNK_NONCE, 24)
+  };
+}
+async function encryptChunk(f, plaintext) {
+  const { key, nonce } = chunkKeyFromF(f);
+  const ciphertext = xchacha20poly13053(key, nonce).encrypt(plaintext);
+  const blobId = await blake3Hex(ciphertext);
+  return { ciphertext, blobId, key, nonce };
+}
+function decryptChunk(key, nonce, ciphertext) {
+  return xchacha20poly13053(key, nonce).decrypt(ciphertext);
+}
+
+// src/read.ts
+var DEFAULT_LIMIT = 20;
+var MAX_LIMIT = 50;
+var DOWNLOAD_PREFIX = "zas-agent-";
+var ID_SEGMENT = /^(?!__)[A-Za-z0-9_-]{1,128}$/;
+var MAX_CHUNKS = 8192;
+var MAX_DUPLICATES = 100;
+function stringOf(value) {
+  return typeof value?.stringValue === "string" ? value.stringValue : void 0;
+}
+function timeOf(value) {
+  const parsed = typeof value?.timestampValue === "string" ? Date.parse(value.timestampValue) : NaN;
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function rowOf(doc) {
+  const document = doc ?? {};
+  const name = typeof document.name === "string" ? document.name : "";
+  const fields = document.fields && typeof document.fields === "object" ? document.fields : {};
+  return {
+    id: name.slice(name.lastIndexOf("/") + 1),
+    manifestEnc: stringOf(fields.manifest_enc),
+    agent: stringOf(fields.agent),
+    createdAt: timeOf(fields.created_at),
+    expiresAt: timeOf(fields.expires_at),
+    bar: fields.bar?.booleanValue === true
+  };
+}
+function readable(row) {
+  if (!row.id || row.bar || !row.manifestEnc) return false;
+  return row.expiresAt === null || row.expiresAt > Date.now();
+}
+function openFor(channelKey, row) {
+  try {
+    return openManifest(channelKey, b64ToBytes(row.manifestEnc));
+  } catch {
+    return null;
+  }
+}
+function summaryOf(row, manifest) {
+  const kind = manifest.kind === "text" ? "text" : "file";
+  const name = typeof manifest.name === "string" ? manifest.name : "";
+  return {
+    id: row.id,
+    kind,
+    // Absence means "show the file name": the sender chose no title.
+    title: manifest.title ?? name,
+    name,
+    mime: typeof manifest.mime === "string" ? manifest.mime : "application/octet-stream",
+    size: typeof manifest.size === "number" ? manifest.size : 0,
+    // The sealed time is the sender's own; the row's is the server's, and it
+    // only answers for a manifest that carries none.
+    created_at: typeof manifest.created_at === "string" && manifest.created_at ? manifest.created_at : row.createdAt !== null ? new Date(row.createdAt).toISOString() : "",
+    by_agent: row.agent !== void 0,
+    ...kind === "text" ? { text: manifest.text ?? "" } : {}
+  };
+}
+async function readGrant(ctx, channel) {
+  const grant = resolveChannel(ctx.identity, await grantsFor(ctx.client, ctx.profile), channel);
+  if (!grant.read) throw new ZasError("read_forbidden", 403);
+  return grant;
+}
+function nameFrom(channelKey, grant) {
+  try {
+    return decryptChannelName(channelKey, b64ToBytes(grant.name_enc));
+  } catch {
+    throw new ZasError("key_stale", 0);
+  }
+}
+function linksParent(identity, grant) {
+  return `accounts/${identity.owner_uid}/channels/${grant.channel_id}`;
+}
+function linkPath(identity, grant, id) {
+  return `projects/${identity.firestore_project}/databases/(default)/documents/${linksParent(identity, grant)}/links/${id}`;
+}
+async function queryLinks(ctx, grant, query) {
+  try {
+    return await ctx.client.firestoreRunQuery(linksParent(ctx.identity, grant), query);
+  } catch (err) {
+    if (err instanceof ZasError && err.status === 403) throw new ZasError("read_forbidden", 403);
+    throw err;
+  }
+}
+function clampLimit(limit) {
+  if (limit === void 0 || !Number.isFinite(limit)) return DEFAULT_LIMIT;
+  return Math.min(MAX_LIMIT, Math.max(1, Math.trunc(limit)));
+}
+async function listItems(ctx, channel, limit) {
+  const grant = await readGrant(ctx, channel);
+  const channelKey = channelKeyOf(ctx.identity, grant);
+  const docs = await queryLinks(ctx, grant, {
+    from: [{ collectionId: "links" }],
+    orderBy: [{ field: { fieldPath: "created_at" }, direction: "DESCENDING" }],
+    limit: clampLimit(limit)
+  });
+  const items = [];
+  for (const doc of docs) {
+    const row = rowOf(doc);
+    if (!readable(row)) continue;
+    const manifest = openFor(channelKey, row);
+    if (!manifest) continue;
+    items.push(summaryOf(row, manifest));
+  }
+  return {
+    channel_id: grant.channel_id,
+    channel_name: nameFrom(channelKey, grant),
+    items
+  };
+}
+function redeemFailure(status) {
+  if (status === 429) return new ZasError("rate_limited", 429);
+  if (status >= 500) return new ZasError("network", status);
+  return new ZasError("invalid_cap", 403);
+}
+async function fetchChunk(ctx, chunk) {
+  if (typeof chunk.cap !== "string" || chunk.cap === "") throw new ZasError("invalid_cap", 403);
+  let headers = {};
+  try {
+    headers = { Authorization: `Bearer ${await ctx.client.idToken()}` };
+  } catch {
+    headers = {};
+  }
+  let url;
+  try {
+    const redeemed = await apiPublic(
+      ctx.identity.api_base,
+      "POST",
+      "/v1/blobs/redeem",
+      { cap: chunk.cap },
+      headers
+    );
+    url = typeof redeemed.url === "string" ? redeemed.url : "";
+  } catch (err) {
+    if (err instanceof ZasError) throw redeemFailure(err.status);
+    throw err;
+  }
+  if (url === "") throw new ZasError("invalid_cap", 403);
+  const res = await fetch(url);
+  if (!res.ok) {
+    await res.body?.cancel().catch(() => void 0);
+    throw res.status >= 500 ? new ZasError("network", res.status) : new ZasError("invalid_cap", 403);
+  }
+  const ciphertext = new Uint8Array(await res.arrayBuffer());
+  try {
+    return decryptChunk(b64ToBytes(chunk.key), b64ToBytes(chunk.nonce), ciphertext);
+  } catch {
+    throw new ZasError("invalid_cap", 403);
+  }
+}
+function safeName(name, fallback) {
+  const base = (typeof name === "string" ? name : "").split(/[\\/]/).pop() ?? "";
+  return base.replace(/^\.+/, "").trim() || fallback;
+}
+function freeName(target) {
+  if (!existsSync2(target)) return target;
+  const ext = extname(target);
+  const stem = target.slice(0, target.length - ext.length);
+  for (let n = 1; n <= MAX_DUPLICATES; n++) {
+    const candidate = `${stem} (${n})${ext}`;
+    if (!existsSync2(candidate)) return candidate;
+  }
+  throw new ZasError("write_failed", 0, target);
+}
+function destinationOf(dest, name, fallback) {
+  const base = safeName(name, fallback);
+  if (dest === void 0) {
+    const created = mkdtempSync(join2(tmpdir(), DOWNLOAD_PREFIX));
+    return { target: freeName(join2(created, base)), created };
+  }
+  const at = statSync(dest, { throwIfNoEntry: false })?.isDirectory() ? join2(dest, base) : dest;
+  return { target: freeName(at) };
+}
+async function getItem(ctx, channel, id, dest) {
+  const grant = await readGrant(ctx, channel);
+  if (!ID_SEGMENT.test(id)) throw new ZasError("not_found", 404);
+  const channelKey = channelKeyOf(ctx.identity, grant);
+  const docs = await queryLinks(ctx, grant, {
+    from: [{ collectionId: "links" }],
+    where: {
+      fieldFilter: {
+        field: { fieldPath: "__name__" },
+        op: "EQUAL",
+        value: { referenceValue: linkPath(ctx.identity, grant, id) }
+      }
+    },
+    limit: 1
+  });
+  const row = docs.length > 0 ? rowOf(docs[0]) : null;
+  if (!row || !readable(row)) throw new ZasError("not_found", 404);
+  const manifest = openFor(channelKey, row);
+  if (!manifest) throw new ZasError("not_found", 404);
+  if (manifest.kind === "text") {
+    const text2 = manifest.text ?? "";
+    return { text: text2, bytes: new TextEncoder().encode(text2).length };
+  }
+  if (manifest.chunks.length === 0) throw new ZasError("not_found", 404);
+  if (manifest.chunks.length > MAX_CHUNKS) throw new ZasError("not_found", 404);
+  let target;
+  let created;
+  let tmp;
+  let fd;
+  let written = 0;
+  try {
+    const chosen = destinationOf(dest, manifest.name, row.id);
+    target = chosen.target;
+    created = chosen.created;
+    mkdirSync2(dirname(target), { recursive: true, mode: 448 });
+    tmp = `${target}.${randomBytes(6).toString("hex")}.tmp`;
+    fd = openSync(tmp, "wx", 384);
+    for (const chunk of manifest.chunks) {
+      written += writeSync(fd, await fetchChunk(ctx, chunk));
+    }
+    const size = typeof manifest.size === "number" ? manifest.size : 0;
+    if (size > 0 && written !== size) throw new ZasError("not_found", 404);
+    closeSync(fd);
+    fd = void 0;
+    renameSync2(tmp, target);
+  } catch (err) {
+    if (err instanceof ZasError) throw err;
+    const failure = err;
+    if (typeof failure.syscall === "string" || typeof failure.errno === "number") {
+      throw new ZasError("write_failed", 0, failure.message);
+    }
+    throw new ZasError("network", 0, String(err?.message ?? err));
+  } finally {
+    if (fd !== void 0) try {
+      closeSync(fd);
+    } catch {
+    }
+    if (tmp !== void 0 && existsSync2(tmp)) try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    if (created !== void 0) try {
+      rmdirSync(created);
+    } catch {
+    }
+  }
+  return { path: target, bytes: written };
+}
+
+// src/send.ts
+import { promises as fsp } from "node:fs";
+import { basename, extname as extname2 } from "node:path";
+
+// src/shared/chunker.ts
+import { blake3 as blake32 } from "hash-wasm";
+var gearPromise = null;
+function gearTable() {
+  if (!gearPromise) {
+    gearPromise = (async () => {
+      const table = new Uint32Array(256);
+      for (let i = 0; i < 256; i++) {
+        const hex = await blake32(new TextEncoder().encode(GEAR_SEED + i), 256);
+        table[i] = parseInt(hex.slice(0, 8), 16) >>> 0;
+      }
+      return table;
+    })();
+  }
+  return gearPromise;
+}
+var AVG = 1 << CHUNK_AVG_BITS;
+var MASK_S = (1 << CHUNK_AVG_BITS + 2) - 1;
+var MASK_L = (1 << CHUNK_AVG_BITS - 2) - 1;
+function cutPoint(buf, gear, eof) {
+  const len = Math.min(buf.length, CHUNK_MAX);
+  if (buf.length < CHUNK_MAX && !eof) {
+    if (buf.length <= CHUNK_MIN) return null;
+  }
+  if (eof && len <= CHUNK_MIN) return len > 0 ? len : null;
+  let hash = 0;
+  const normal = Math.min(AVG, len);
+  let i = CHUNK_MIN;
+  for (; i < normal; i++) {
+    hash = (hash << 1 >>> 0) + gear[buf[i]] >>> 0;
+    if ((hash & MASK_S) === 0) return i + 1;
+  }
+  for (; i < len; i++) {
+    hash = (hash << 1 >>> 0) + gear[buf[i]] >>> 0;
+    if ((hash & MASK_L) === 0) return i + 1;
+  }
+  if (len === CHUNK_MAX) return CHUNK_MAX;
+  if (eof) return len > 0 ? len : null;
+  return null;
+}
+async function* chunkStream(source) {
+  const gear = await gearTable();
+  let pending = [];
+  let pendingLen = 0;
+  const compact = () => {
+    if (pending.length === 1) return pending[0];
+    const merged = new Uint8Array(pendingLen);
+    let off = 0;
+    for (const p of pending) {
+      merged.set(p, off);
+      off += p.length;
+    }
+    pending = [merged];
+    return merged;
+  };
+  const drain = function* (eof) {
+    while (pendingLen > 0) {
+      const buf = compact();
+      const cut = cutPoint(buf, gear, eof);
+      if (cut === null) return;
+      yield buf.slice(0, cut);
+      pending = cut < buf.length ? [buf.slice(cut)] : [];
+      pendingLen = buf.length - cut;
+    }
+  };
+  for await (const piece of source) {
+    if (piece.length === 0) continue;
+    pending.push(piece);
+    pendingLen += piece.length;
+    if (pendingLen >= CHUNK_MAX) yield* drain(false);
+  }
+  yield* drain(true);
+}
+
+// src/shared/oprf.ts
+import { RistrettoPoint } from "@noble/curves/ed25519";
+import { sha512 as sha5122 } from "@noble/hashes/sha2";
+import { invert, mod } from "@noble/curves/abstract/modular";
+var ORDER = 2n ** 252n + 27742317777372353535851937790883648493n;
+var te = new TextEncoder();
+function i2osp(value, length) {
+  const out = new Uint8Array(length);
+  for (let i = length - 1; i >= 0; i--) {
+    out[i] = value & 255;
+    value >>>= 8;
+  }
+  return out;
+}
+function expandMessageXmd(msg, dst, lenInBytes) {
+  const bInBytes = 64;
+  const rInBytes = 128;
+  const ell = Math.ceil(lenInBytes / bInBytes);
+  if (ell > 255) throw new Error("expand_message_xmd: ell too large");
+  const dstPrime = concatBytes(dst, i2osp(dst.length, 1));
+  const zPad = new Uint8Array(rInBytes);
+  const lIbStr = i2osp(lenInBytes, 2);
+  const msgPrime = concatBytes(zPad, msg, lIbStr, i2osp(0, 1), dstPrime);
+  const b0 = sha5122(msgPrime);
+  const b = [];
+  b[0] = sha5122(concatBytes(b0, i2osp(1, 1), dstPrime));
+  for (let i = 2; i <= ell; i++) {
+    const xored = new Uint8Array(bInBytes);
+    for (let j = 0; j < bInBytes; j++) xored[j] = b0[j] ^ b[i - 2][j];
+    b[i - 1] = sha5122(concatBytes(xored, i2osp(i, 1), dstPrime));
+  }
+  return concatBytes(...b).slice(0, lenInBytes);
+}
+function bytesToBigIntBE(bytes) {
+  let v = 0n;
+  for (const byte of bytes) v = v << 8n | BigInt(byte);
+  return v;
+}
+function hashToGroup(input) {
+  const dst = te.encode("HashToGroup-" + OPRF_CONTEXT);
+  const uniform = expandMessageXmd(input, dst, 64);
+  return RistrettoPoint.hashToCurve(uniform);
+}
+function randomScalar() {
+  const bytes = new Uint8Array(64);
+  crypto.getRandomValues(bytes);
+  const s = mod(bytesToBigIntBE(bytes), ORDER);
+  return s === 0n ? 1n : s;
+}
+function oprfBlind(input) {
+  const blind = randomScalar();
+  const P = hashToGroup(input);
+  return { blind, blindedElement: P.multiply(blind).toRawBytes() };
+}
+function oprfFinalize(input, blind, evaluatedElement) {
+  const E = RistrettoPoint.fromHex(evaluatedElement);
+  const N = E.multiply(invert(blind, ORDER));
+  const unblinded = N.toRawBytes();
+  const hashInput = concatBytes(
+    i2osp(input.length, 2),
+    input,
+    i2osp(unblinded.length, 2),
+    unblinded,
+    te.encode("Finalize")
+  );
+  return sha5122(hashInput);
+}
+
+// src/thumbnail.ts
+import { Jimp } from "jimp";
+var PREFIX = "data:image/jpeg;base64,";
+var READABLE = /* @__PURE__ */ new Set(["image/jpeg", "image/png", "image/bmp", "image/gif", "image/tiff"]);
+var QUALITY_STEPS = [85, 70, 55, 40];
+var MAX_INPUT_BYTES = 80 * 1024 * 1024;
+function thumbnailable(mime) {
+  return READABLE.has(mime.split(";")[0].trim().toLowerCase());
+}
+async function thumbnailFor(bytes, mime) {
+  if (!thumbnailable(mime)) return void 0;
+  if (bytes.length > MAX_INPUT_BYTES) return void 0;
+  try {
+    const image = await Jimp.read(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+    if (Math.max(image.width, image.height) > THUMBNAIL_MAX_EDGE) {
+      image.scaleToFit({ w: THUMBNAIL_MAX_EDGE, h: THUMBNAIL_MAX_EDGE });
+    }
+    for (const quality of QUALITY_STEPS) {
+      const jpeg = await image.getBuffer("image/jpeg", { quality });
+      const uri = PREFIX + Buffer.from(jpeg).toString("base64");
+      if (uri.length <= THUMBNAIL_MAX_BYTES) return uri;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/send.ts
+var MAX_FILE_BYTES = 5 * 1024 * 1024 * 1024;
+var REPLAY_WINDOW_MS = 10 * 60 * 1e3;
+var UPLOAD_CONCURRENCY = 4;
+var OPRF_PROBE_BATCH = 200;
+var MAX_REFUSALS_PER_SEND = 8;
+var NOTE_NAME_MAX = 40;
+function batches(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+  return out;
+}
+function sliceSize(ctx) {
+  return Math.max(1, Math.floor(ctx.batch ?? OPRF_PROBE_BATCH));
+}
+var MIME = new Map(Object.entries({
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  gif: "image/gif",
+  webp: "image/webp",
+  bmp: "image/bmp",
+  tif: "image/tiff",
+  tiff: "image/tiff",
+  svg: "image/svg+xml",
+  pdf: "application/pdf",
+  txt: "text/plain",
+  md: "text/markdown",
+  csv: "text/csv",
+  json: "application/json",
+  html: "text/html",
+  zip: "application/zip",
+  gz: "application/gzip",
+  tar: "application/x-tar",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ppt: "application/vnd.ms-powerpoint",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  ts: "text/typescript",
+  js: "text/javascript",
+  py: "text/x-python",
+  go: "text/x-go",
+  rs: "text/x-rust",
+  java: "text/x-java",
+  c: "text/x-c",
+  h: "text/x-c",
+  cpp: "text/x-c++",
+  sh: "application/x-sh",
+  yml: "application/yaml",
+  yaml: "application/yaml",
+  toml: "application/toml",
+  xml: "application/xml"
+}));
+function mimeFor(path) {
+  return MIME.get(extname2(path).slice(1).toLowerCase()) ?? "application/octet-stream";
+}
+async function mapLimit(items, limit, work) {
+  const out = new Array(items.length);
+  let next = 0;
+  const runner = async () => {
+    for (; ; ) {
+      const index = next++;
+      if (index >= items.length) return;
+      out[index] = await work(items[index], index);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, runner));
+  return out;
+}
+async function grantFor(ctx, channel) {
+  const grant = resolveChannel(ctx.identity, await grantsFor(ctx.client, ctx.profile), channel);
+  if (!grant.send || grant.mode === "view") throw new ZasError("send_forbidden", 403);
+  if (grant.direct_mode) throw new ZasError("direct_mode", 409);
+  return grant;
+}
+async function receiptKey(ctx, channelId, contentHash, title) {
+  const raw = `${ctx.identity.agent_uid}\0${channelId}\0${contentHash}\0${title}`;
+  return blake3Hex(new TextEncoder().encode(raw));
+}
+function receiptFor(ctx, key) {
+  const entries = loadFingerprints(ctx.profile).entries;
+  if (!Object.prototype.hasOwnProperty.call(entries, key)) return void 0;
+  const entry = entries[key];
+  if (!entry || typeof entry.at !== "number" || Date.now() - entry.at >= REPLAY_WINDOW_MS) return void 0;
+  return entry;
+}
+function remember(ctx, key, receipt) {
+  const cutoff = Date.now() - REPLAY_WINDOW_MS;
+  const entries = {};
+  for (const [k, v] of Object.entries(loadFingerprints(ctx.profile).entries)) {
+    if (v && typeof v.at === "number" && v.at >= cutoff) entries[k] = v;
+  }
+  entries[key] = receipt;
+  saveFingerprints(ctx.profile, { entries });
+}
+function sleep(ms) {
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, ms);
+  });
+}
+var CHUNK_PUT_RETRY_DELAY_MS = 1e3;
+async function putWithRetry(url, body) {
+  for (let attempt = 0; ; attempt++) {
+    let res;
+    try {
+      res = await fetch(url, { method: "PUT", body });
+    } catch {
+      if (attempt > 0) throw new ZasError("upload_failed", 0);
+      await sleep(CHUNK_PUT_RETRY_DELAY_MS);
+      continue;
+    }
+    if (res.ok || res.status < 500 || attempt > 0) return res;
+    await res.body?.cancel().catch(() => void 0);
+    await sleep(CHUNK_PUT_RETRY_DELAY_MS);
+  }
+}
+var COMMIT_ATTEMPTS = 4;
+var COMMIT_RETRY_BASE_MS = 250;
+async function commitChunk(ctx, blobId, uploadId) {
+  for (let attempt = 0; attempt < COMMIT_ATTEMPTS; attempt++) {
+    try {
+      const { cap } = await ctx.client.api(
+        "POST",
+        `/blobs/${blobId}/commit`,
+        { upload_id: uploadId }
+      );
+      return cap;
+    } catch (err) {
+      if (!(err instanceof ZasError) || err.serverCode !== "commit_pending") throw err;
+      if (attempt === COMMIT_ATTEMPTS - 1) break;
+      await sleep(COMMIT_RETRY_BASE_MS * 2 ** attempt);
+    }
+  }
+  throw new ZasError("upload_failed", 409);
+}
+async function uploadChunk(ctx, enc) {
+  const reserved = await ctx.client.api(
+    "POST",
+    `/blobs/${enc.blobId}/upload-url`,
+    { size: enc.ciphertext.length }
+  );
+  if (typeof reserved.url !== "string" || typeof reserved.upload_id !== "string") {
+    throw new ZasError("upload_failed", 0);
+  }
+  const put = await putWithRetry(reserved.url, enc.ciphertext);
+  if (!put.ok) {
+    await put.body?.cancel().catch(() => void 0);
+    throw new ZasError("upload_failed", put.status);
+  }
+  return commitChunk(ctx, enc.blobId, reserved.upload_id);
+}
+async function proveChunk(ctx, enc, challenge) {
+  const samples = challenge.offsets.map((o) => enc.ciphertext.slice(o, o + challenge.sample_len));
+  try {
+    const { cap } = await ctx.client.api("POST", `/blobs/${enc.blobId}/prove`, {
+      challenge_id: challenge.challenge_id,
+      mac: bytesToHex(hmacSha256(b64ToBytes(challenge.nonce), concatBytes(...samples)))
+    });
+    return cap;
+  } catch (err) {
+    if (!(err instanceof ZasError) || err.serverCode !== "proof_failed") throw err;
+    return null;
+  }
+}
+async function placeSlice(ctx, slice, into, budget) {
+  const probe = await ctx.client.api("POST", "/blobs/probe", {
+    ids: slice.map((e) => e.blobId)
+  });
+  const results = probe.results ?? {};
+  const challenges = probe.challenges ?? {};
+  for (const enc of slice) {
+    if (results[enc.blobId] === "blocked") throw new ZasError("upload_failed", 451);
+  }
+  const provable = [];
+  const upload = [];
+  for (const enc of slice) {
+    if (results[enc.blobId] === "prove" && challenges[enc.blobId]) provable.push(enc);
+    else upload.push(enc);
+  }
+  let refused = budget.refusals >= MAX_REFUSALS_PER_SEND;
+  const prove = async (enc) => {
+    if (refused) {
+      upload.push(enc);
+      return;
+    }
+    const cap = await proveChunk(ctx, enc, challenges[enc.blobId]);
+    if (cap === null) {
+      refused = true;
+      budget.refusals += 1;
+      upload.push(enc);
+      return;
+    }
+    into.set(enc.blobId, { cap, proven: true });
+  };
+  if (provable.length > 0) await prove(provable[0]);
+  await mapLimit(provable.slice(1), UPLOAD_CONCURRENCY, prove);
+  await mapLimit(upload, UPLOAD_CONCURRENCY, async (enc) => {
+    into.set(enc.blobId, { cap: await uploadChunk(ctx, enc), proven: false });
+  });
+}
+async function placeChunks(ctx, encs) {
+  if (encs.length === 0) return [];
+  const distinct = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const enc of encs) {
+    if (seen.has(enc.blobId)) continue;
+    seen.add(enc.blobId);
+    distinct.push(enc);
+  }
+  const placements = /* @__PURE__ */ new Map();
+  const budget = { refusals: 0 };
+  for (const slice of batches(distinct, sliceSize(ctx))) await placeSlice(ctx, slice, placements, budget);
+  return encs.map((enc) => {
+    const placement = placements.get(enc.blobId);
+    if (!placement) throw new ZasError("upload_failed", 0);
+    return {
+      entry: {
+        blob_id: enc.blobId,
+        key: bytesToB64(enc.key),
+        nonce: bytesToB64(enc.nonce),
+        size: enc.ciphertext.length,
+        cap: placement.cap
+      },
+      proven: placement.proven
+    };
+  });
+}
+async function postLink(ctx, grant, manifest, placed, idempotencyKey) {
+  const channelKey = channelKeyOf(ctx.identity, grant);
+  const sealed = sealManifest(channelKey, manifest, grant.key_version);
+  const created = await ctx.client.api("POST", "/links", {
+    channel_id: grant.channel_id,
+    manifest_enc: bytesToB64(sealed),
+    caps: placed.map((p) => p.entry.cap).filter((cap) => typeof cap === "string"),
+    // Every chunk now arrives with a cap, proven or uploaded, so there is
+    // nothing left for the server to verify here. The field stays because the
+    // server reads it, and an absent array is not the same as an empty one.
+    proofs: [],
+    idempotency_key: idempotencyKey
+  });
+  const bound = created.caps ?? {};
+  let patched = false;
+  for (const p of placed) {
+    const cap = bound[p.entry.blob_id];
+    if (cap) {
+      p.entry.cap = cap;
+      patched = true;
+    }
+  }
+  if (patched) {
+    await ctx.client.api("PATCH", `/links/${grant.channel_id}/${created.link_id}`, {
+      manifest_enc: bytesToB64(sealManifest(channelKey, manifest, grant.key_version))
+    });
+  }
+  return created.link_id;
+}
+async function sendFile(ctx, input, onPhase) {
+  const stat = await fsp.stat(input.path).catch(() => {
+    throw new ZasError("upload_failed", 400);
+  });
+  if (!stat.isFile()) throw new ZasError("upload_failed", 400);
+  if (stat.size > MAX_FILE_BYTES) throw new ZasError("file_too_big", 413);
+  const grant = await grantFor(ctx, input.channel);
+  const name = basename(input.path);
+  const title = input.title ?? name;
+  const file = await fsp.readFile(input.path);
+  if (file.byteLength > MAX_FILE_BYTES) throw new ZasError("file_too_big", 413);
+  const bytes = new Uint8Array(file.buffer, file.byteOffset, file.byteLength);
+  const contentHash = await blake3Hex(bytes);
+  const key = await receiptKey(ctx, grant.channel_id, contentHash, title);
+  const stored = receiptFor(ctx, key);
+  if (stored) {
+    return {
+      link_id: stored.link_id,
+      channel_id: grant.channel_id,
+      channel_name: channelNameOf(ctx.identity, grant),
+      bytes: stored.bytes,
+      chunks: stored.chunks,
+      deduplicated: stored.deduplicated,
+      replayed: true
+    };
+  }
+  onPhase?.("hashing");
+  const plains = [];
+  for await (const piece of chunkStream([bytes])) plains.push(piece);
+  const hashes = await Promise.all(plains.map((p) => blake3Bytes(p)));
+  const blinds = hashes.map((h) => oprfBlind(h));
+  const evaluated = [];
+  for (const slice of batches(blinds.map((b) => bytesToB64(b.blindedElement)), sliceSize(ctx))) {
+    const answers = await ctx.client.oprfEvaluate(slice);
+    if (answers.length !== slice.length) throw new ZasError("oprf_failed", 0);
+    for (const one of answers) evaluated.push(one);
+  }
+  onPhase?.("encrypting");
+  const encs = await Promise.all(plains.map(
+    (plain, i) => encryptChunk(oprfFinalize(hashes[i], blinds[i].blind, b64ToBytes(evaluated[i])), plain)
+  ));
+  onPhase?.("uploading");
+  const placed = await placeChunks(ctx, encs);
+  onPhase?.("finishing");
+  const mime = mimeFor(input.path);
+  const thumb = await thumbnailFor(bytes, mime);
+  const manifest = newManifest({
+    kind: "file",
+    name,
+    // Only when the caller chose one: absence means "show the file name", and
+    // writing the file name into `title` would make a rename look deliberate.
+    ...input.title !== void 0 ? { title: input.title } : {},
+    mime,
+    size: bytes.length,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...thumb ? { thumb_data: thumb } : {},
+    chunks: placed.map((p) => p.entry)
+  });
+  const linkId = await postLink(
+    ctx,
+    grant,
+    manifest,
+    placed,
+    agentSendIdempotencyKey(grant.channel_id, contentHash, title)
+  );
+  const deduplicated = placed.filter((p) => p.proven).length;
+  remember(ctx, key, {
+    link_id: linkId,
+    bytes: bytes.length,
+    chunks: placed.length,
+    deduplicated,
+    at: Date.now()
+  });
+  return {
+    link_id: linkId,
+    channel_id: grant.channel_id,
+    channel_name: channelNameOf(ctx.identity, grant),
+    bytes: bytes.length,
+    chunks: placed.length,
+    deduplicated,
+    replayed: false
+  };
+}
+function noteName(text2) {
+  return text2.split("\n", 1)[0].trim().slice(0, NOTE_NAME_MAX) || "nota";
+}
+async function sendNote(ctx, input) {
+  const grant = await grantFor(ctx, input.channel);
+  const name = input.title ?? noteName(input.text);
+  const encoded = new TextEncoder().encode(input.text);
+  const contentHash = await blake3Hex(new TextEncoder().encode(
+    `${input.lang ?? ""}\0${input.secret ? "1" : "0"}\0${input.text}`
+  ));
+  const key = await receiptKey(ctx, grant.channel_id, contentHash, name);
+  const stored = receiptFor(ctx, key);
+  if (stored) {
+    return {
+      link_id: stored.link_id,
+      channel_id: grant.channel_id,
+      channel_name: channelNameOf(ctx.identity, grant),
+      bytes: stored.bytes,
+      chunks: 0,
+      deduplicated: 0,
+      replayed: true
+    };
+  }
+  const manifest = newManifest({
+    kind: "text",
+    name,
+    ...input.title !== void 0 ? { title: input.title } : {},
+    mime: "text/plain",
+    size: encoded.length,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    text: input.text,
+    ...input.lang ? { code: { lang: input.lang, auto: false } } : {},
+    // Only ever true or absent, exactly as the note cover is defined: absent is
+    // "the sender did not classify", which no receiver may read as safe.
+    ...input.secret ? { sensitive: true } : {},
+    chunks: []
+  });
+  const linkId = await postLink(
+    ctx,
+    grant,
+    manifest,
+    [],
+    agentSendIdempotencyKey(grant.channel_id, contentHash, name)
+  );
+  remember(ctx, key, {
+    link_id: linkId,
+    bytes: encoded.length,
+    chunks: 0,
+    deduplicated: 0,
+    at: Date.now()
+  });
+  return {
+    link_id: linkId,
+    channel_id: grant.channel_id,
+    channel_name: channelNameOf(ctx.identity, grant),
+    bytes: encoded.length,
+    chunks: 0,
+    deduplicated: 0,
+    replayed: false
+  };
+}
+
+// src/server.ts
+function agentVersion() {
+  return true ? "0.1.0" : "0.0.0-dev";
+}
+var AGENT_CUE = " The owner sees every item this agent sends with the >_ agent mark and this agent's name, on every device.";
+var PAIR_ANNOUNCE_MS = 15e3;
+var NOTE_LABEL_MAX = 40;
+var delay = (ms) => new Promise((resolve2) => {
+  setTimeout(resolve2, ms);
+});
+function rightsOf(grant) {
+  const rights = [];
+  if (grant.send && grant.mode !== "view" && !grant.direct_mode) rights.push("env\xEDa");
+  if (grant.read) rights.push("lee");
+  return rights.length > 0 ? rights.join(" \xB7 ") : "sin permisos";
+}
+function buildServer(profile, deps = {}) {
+  const server = new McpServer({ name: "zas", version: agentVersion() });
+  const runner = deps.runner ?? new JobRunner();
+  let client = null;
+  const ctx = () => {
+    const identity = deps.identity ?? loadIdentity(profile);
+    if (!identity) throw new ZasError("not_paired", 0);
+    if (deps.client) return { identity, client: deps.client, profile };
+    if (!client || client.identity.agent_uid !== identity.agent_uid) client = new ZasClient(identity);
+    return { identity, client, profile };
+  };
+  const text2 = (value) => ({
+    content: [{
+      type: "text",
+      text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+    }]
+  });
+  const failed = (e) => {
+    const err = e instanceof ZasError ? e : new ZasError("internal", 0, String(e));
+    return { isError: true, ...text2(`${err.code}: ${humanSentence(err, "es")} / ${humanSentence(err, "en")}`) };
+  };
+  const settled = (job) => {
+    if (job.status === "done") return text2(job.result);
+    if (job.status === "failed") {
+      const e = job.error;
+      return failed(e ? new ZasError(e.code, e.status, e.message, e.retryAfterMs, e.serverCode) : new ZasError("internal", 0));
+    }
+    return text2({ job_id: job.id, status: "running", phase: job.phase });
+  };
+  server.registerTool("zas_status", {
+    description: "Say whether this machine is paired with a Zas account, and list the owner's channels this agent may send to or read from." + AGENT_CUE
+  }, async () => {
+    try {
+      if (!(deps.identity ?? loadIdentity(profile))) {
+        return text2(humanSentence(new ZasError("not_paired", 0), "es"));
+      }
+      const c = ctx();
+      const grants = await grantsFor(c.client, profile);
+      const lines = grants.map((grant) => {
+        let name = grant.channel_id;
+        try {
+          name = channelNameOf(c.identity, grant);
+        } catch {
+        }
+        return `  ${name} \xB7 ${rightsOf(grant)}`;
+      });
+      return text2([
+        `Emparejado como \xAB${c.identity.name}\xBB (${c.identity.kind}) con la cuenta ${c.identity.owner_uid}.`,
+        grants.length > 0 ? "Canales:" : "Sin canales: el due\xF1o todav\xEDa no le dio acceso a ninguno.",
+        ...lines,
+        `${packageName()} ${agentVersion()} \xB7 perfil ${profile}`
+      ].join("\n"));
+    } catch (e) {
+      return failed(e);
+    }
+  });
+  let pairing = null;
+  server.registerTool("zas_pair", {
+    description: "Pair this machine with a Zas account. The first call returns a URL and a code for the owner to approve; a later call says whether they did." + AGENT_CUE
+  }, async () => {
+    if (!pairing) {
+      const state = { logs: [], status: "running" };
+      pairing = state;
+      (deps.runPair ?? runPair)({
+        profile,
+        kind: kindForProfile(profile),
+        webBase: process.env.ZAS_WEB_BASE || "https://zas.red",
+        // Read now, not at import: an MCP server is started by a client that
+        // may have set the environment after this module was loaded.
+        apiBase: defaultEndpoints().api_base,
+        log: (line) => {
+          state.logs.push(line);
+        }
+      }).then(
+        (identity) => {
+          state.status = "paired";
+          state.identity = identity;
+        },
+        (error) => {
+          state.status = "failed";
+          state.error = error;
+        }
+      );
+      const until = Date.now() + (deps.announceMs ?? PAIR_ANNOUNCE_MS);
+      while (state.status === "running" && !state.logs.some(hasPairUrl) && Date.now() < until) {
+        await delay(50);
+      }
+      if (state.status === "failed") {
+        pairing = null;
+        return failed(state.error);
+      }
+      return text2(state.logs.join("\n") || "Abriendo el emparejamiento\u2026");
+    }
+    if (pairing.status === "paired") return text2(`paired as ${pairing.identity?.name ?? ""}`.trim());
+    if (pairing.status === "failed") {
+      const error = pairing.error;
+      pairing = null;
+      return failed(error);
+    }
+    return text2(["pending", ...pairing.logs].join("\n"));
+  });
+  server.registerTool("zas_send_file", {
+    description: "Send a file from this machine into one of the owner's Zas channels. Returns the item id, or a job id when the upload takes longer than a minute. Sends any file this process can read; confirm with the owner before sending secrets, keys or credentials." + AGENT_CUE,
+    inputSchema: {
+      path: z.string().describe("Absolute or relative path of the file to send."),
+      channel: z.string().optional().describe("Channel name or id. Optional when the agent holds exactly one channel."),
+      title: z.string().optional().describe("Label for the item. Defaults to the file name.")
+    }
+  }, async (input) => {
+    try {
+      const c = ctx();
+      const job = runner.start(
+        "file",
+        input.title ?? input.path,
+        input.channel ?? "",
+        (report) => sendFile(c, input, report)
+      );
+      return settled(await runner.wait(job));
+    } catch (e) {
+      return failed(e);
+    }
+  });
+  server.registerTool("zas_send_note", {
+    description: "Send a note \u2014 plain text, or a code snippet with its language \u2014 into one of the owner's Zas channels." + AGENT_CUE,
+    inputSchema: {
+      text: z.string().describe("The body of the note."),
+      channel: z.string().optional().describe("Channel name or id. Optional when the agent holds exactly one channel."),
+      title: z.string().optional().describe("Label for the item. Defaults to the first line."),
+      lang: z.string().optional().describe('Language of the snippet, for highlighting (for example "ts", "py").'),
+      secret: z.boolean().optional().describe("Hide the body behind a cover until the reader opens it.")
+    }
+  }, async (input) => {
+    try {
+      const c = ctx();
+      const job = runner.start(
+        "note",
+        input.title ?? input.text.split("\n", 1)[0].slice(0, NOTE_LABEL_MAX),
+        input.channel ?? "",
+        () => sendNote(c, input)
+      );
+      return settled(await runner.wait(job));
+    } catch (e) {
+      return failed(e);
+    }
+  });
+  server.registerTool("zas_list_items", {
+    description: "List the most recent items in one of the owner's Zas channels. Needs a grant that includes reading." + AGENT_CUE,
+    inputSchema: {
+      channel: z.string().describe("Channel name or id."),
+      limit: z.number().int().min(1).max(50).optional().describe("How many items, 1 to 50. Defaults to 20.")
+    }
+  }, async (input) => {
+    try {
+      return text2(await listItems(ctx(), input.channel, input.limit));
+    } catch (e) {
+      return failed(e);
+    }
+  });
+  server.registerTool("zas_get_item", {
+    description: "Fetch one item from a Zas channel. A note comes back as text; a file is written to disk. Returns the path written; it can differ from `dest` when a file with that name already exists. Writes a new file under `dest` (or the system temp directory); it never overwrites an existing file." + AGENT_CUE,
+    inputSchema: {
+      channel: z.string().describe("Channel name or id."),
+      id: z.string().describe("Item id, as `zas_list_items` reports it."),
+      dest: z.string().optional().describe('Where to write a file. A directory means "inside it". Defaults to a fresh temporary directory.')
+    }
+  }, async (input) => {
+    try {
+      return text2(await getItem(ctx(), input.channel, input.id, input.dest));
+    } catch (e) {
+      return failed(e);
+    }
+  });
+  server.registerTool("zas_jobs", {
+    description: "List the sends this server started, newest first, with the phase each one reached and how it ended \u2014 including any `job_id` a send returned; a finished job keeps its result here." + AGENT_CUE
+  }, async () => text2(runner.list()));
+  return server;
+}
+var hasPairUrl = (line) => line.includes("/agents/pair?p=");
+
+// src/cli.ts
+var DEFAULT_PROFILE = "claude-code";
+function parseArgs(argv) {
+  const parsed = { command: "serve", profile: DEFAULT_PROFILE };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const eq = arg.indexOf("=");
+    const name = arg.startsWith("--") && eq > 0 ? arg.slice(0, eq) : arg;
+    const inline = arg.startsWith("--") && eq > 0 ? arg.slice(eq + 1) : void 0;
+    const take = () => inline !== void 0 ? inline : argv[++i] ?? "";
+    if (name === "pair") parsed.command = "pair";
+    else if (name === "--version" || name === "-v") parsed.command = "version";
+    else if (name === "--help" || name === "-h") parsed.command = "help";
+    else if (name === "--profile") {
+      parsed.profile = take() || DEFAULT_PROFILE;
+      if (!PROFILE_RE.test(parsed.profile)) {
+        return { ...parsed, command: "invalid", message: `Perfil inv\xE1lido: ${parsed.profile}` };
+      }
+    } else if (name === "--kind") {
+      const kind = take();
+      if (!isAgentKind(kind)) return { ...parsed, command: "help", unknown: `--kind ${kind}` };
+      parsed.kind = kind;
+    } else if (name === "--host") parsed.host = take() || void 0;
+    else return { ...parsed, command: "help", unknown: arg };
+  }
+  return parsed;
+}
+var USAGE = [
+  "zas-agent \u2014 send files and notes from a coding agent into your Zas channels.",
+  "",
+  "  zas-agent [--profile <name>]                serve the MCP tools over stdio",
+  "  zas-agent pair [--profile <name>]           pair this machine with a Zas account",
+  "                 [--kind claude_code|codex|other] [--host <name>]",
+  "  zas-agent --version"
+].join("\n");
+async function main(argv, log = (l) => console.error(l)) {
+  const args = parseArgs(argv);
+  if (args.command === "version") {
+    console.log(agentVersion());
+    return 0;
+  }
+  if (args.command === "invalid") {
+    log(args.message ?? "");
+    return 2;
+  }
+  if (args.command === "help") {
+    if (args.unknown) log(`No entiendo \xAB${args.unknown}\xBB.`);
+    log(USAGE);
+    return args.unknown ? 2 : 0;
+  }
+  if (args.command === "pair") {
+    try {
+      await runPair({
+        profile: args.profile,
+        kind: args.kind ?? kindForProfile(args.profile),
+        ...args.host !== void 0 ? { host: args.host } : {},
+        webBase: process.env.ZAS_WEB_BASE || "https://zas.red",
+        apiBase: defaultEndpoints().api_base,
+        log
+      });
+    } catch (e) {
+      const err = e instanceof ZasError ? e : new ZasError("internal", 0, String(e));
+      log(humanSentence(err, "es"));
+      return 1;
+    }
+    return 0;
+  }
+  await buildServer(args.profile).connect(new StdioServerTransport());
+  return 0;
+}
+var real = (path) => {
+  try {
+    return realpathSync(path);
+  } catch {
+    return "";
+  }
+};
+function isInvokedDirectly(argv1, selfUrl) {
+  if (argv1 === void 0 || argv1 === "") return false;
+  const entry = real(argv1);
+  if (entry === "") return false;
+  let self = "";
+  try {
+    self = real(fileURLToPath(selfUrl));
+  } catch {
+    return false;
+  }
+  return self !== "" && self === entry;
+}
+if (isInvokedDirectly(process.argv[1], import.meta.url)) {
+  main(process.argv.slice(2)).then(
+    (code) => {
+      if (code !== 0) process.exitCode = code;
+    },
+    (error) => {
+      console.error(String(error?.stack ?? error));
+      process.exitCode = 1;
+    }
+  );
+}
+export {
+  isInvokedDirectly,
+  main,
+  parseArgs
+};