very-happy-cli 0.2.159 → 0.2.161

package/dist/remoteSessionClient-CO7qOjR0.mjs

@@ -0,0 +1,612 @@
+import { r as resumeDaemonSession, l as listDaemonSessions } from './controlClient-DjoKTtgK.mjs';
+import { d as archiveSession, u as unarchiveSession, h as sessionLiveness, g as sendUserMessage, i as readSessionState, o as openUserScopedSocket } from './sessionOps-C_f1wKOr.mjs';
+import { d as delay } from './time-BZNdNiIV.mjs';
+import axios from 'axios';
+import { hostname } from 'node:os';
+import { c as configuration } from './configuration-DoWFJUPm.mjs';
+import { readSettings, readCredentialsForConfiguredRelay } from './persistence-oET5n61f.mjs';
+import { randomUUID } from 'node:crypto';
+
+const ACTIVE_FRESH_WINDOW_MS = 15 * 60 * 1e3;
+const DEFAULT_RESUME_WAIT_MS = 3e4;
+const DEFAULT_RESUME_POLL_MS = 1e3;
+function classifySessionState(input) {
+  const { liveHere, server, now } = input;
+  if (!server.found) return "not_found";
+  if (typeof server.archivedAt === "number") return "archived";
+  if (liveHere) return "live";
+  if (server.active && typeof server.activeAt === "number" && now - server.activeAt <= ACTIVE_FRESH_WINDOW_MS) return "live";
+  return "offline";
+}
+function explainNotLive(sessionId, status, resumeHint) {
+  switch (status) {
+    case "archived":
+      return `Session ${sessionId} is archived \u2014 no live wrapper will receive this message. ${resumeHint}`;
+    case "offline":
+      return `Session ${sessionId} is offline (its wrapper exited or timed out) \u2014 no live wrapper will receive this message. ${resumeHint}`;
+    case "not_found":
+      return `Session ${sessionId} was not found on this account \u2014 it cannot be messaged or resumed. Spawn a new session instead.`;
+  }
+}
+const CLI_RESUME_HINT = "Use --resume to bring it back on this machine, or spawn a new session.";
+const defaultDeps$1 = {
+  listLive: () => listDaemonSessions(),
+  readState: (sessionId, persisted) => readSessionState(sessionId, persisted),
+  send: (sessionId, persisted, text, client, options) => sendUserMessage(sessionId, persisted, text, client, options),
+  unarchive: unarchiveSession,
+  archive: archiveSession,
+  resume: resumeDaemonSession,
+  sleep: (ms) => delay(ms).then(() => void 0),
+  now: () => Date.now()
+};
+async function deliverToSession(sessionId, persisted, text, client, options = {}, deps = {}) {
+  const d = { ...defaultDeps$1, ...deps };
+  const resumeHint = options.resumeHint ?? CLI_RESUME_HINT;
+  const classify = async () => {
+    const [live, server] = await Promise.all([d.listLive(), d.readState(sessionId, persisted)]);
+    return classifySessionState({ liveHere: sessionLiveness(live, sessionId).live, server, now: d.now() });
+  };
+  let status = await classify();
+  let resumed = false;
+  let resumeOutcome;
+  if (status !== "live") {
+    if (!options.resume || status === "not_found") {
+      return { sessionId, status, delivered: false, resumed: false, stored: false, error: explainNotLive(sessionId, status, resumeHint) };
+    }
+    const wasArchived = status === "archived";
+    if (wasArchived) {
+      try {
+        await d.unarchive(sessionId);
+      } catch (error) {
+        const message = `unarchive failed: ${error instanceof Error ? error.message : String(error)}`;
+        return { sessionId, status, delivered: false, resumed: false, stored: false, error: message, resume: { ok: false, error: message } };
+      }
+    }
+    const outcome = await d.resume(sessionId, {
+      ...typeof options.model === "string" ? { model: options.model } : {},
+      ...options.permissionMode !== void 0 ? { permissionMode: options.permissionMode } : {}
+    });
+    if (!outcome.success) {
+      let message = outcome.error ?? "resume failed";
+      if (wasArchived) {
+        try {
+          await d.archive(sessionId);
+        } catch (error) {
+          message += `; failed to restore archive state: ${error instanceof Error ? error.message : String(error)}`;
+        }
+      }
+      return { sessionId, status, delivered: false, resumed: false, stored: false, error: message, resume: { ok: false, error: message } };
+    }
+    resumed = true;
+    resumeOutcome = { ok: true };
+    status = await waitUntilLive(classify, d, options);
+    if (status !== "live") {
+      const waited = Math.round((options.waitMs ?? DEFAULT_RESUME_WAIT_MS) / 1e3);
+      return {
+        sessionId,
+        status,
+        delivered: false,
+        resumed,
+        stored: false,
+        resume: resumeOutcome,
+        error: `Session ${sessionId} was resumed but no live wrapper showed up within ${waited}s (state: ${status}); message not sent`
+      };
+    }
+  }
+  await d.send(sessionId, persisted, text, client, {
+    ...options.model !== void 0 ? { model: options.model } : {},
+    ...options.sentFrom !== void 0 ? { sentFrom: options.sentFrom } : {}
+  });
+  let after = "live";
+  try {
+    after = await classify();
+  } catch {
+    after = "live";
+  }
+  if (after !== "live") {
+    return {
+      sessionId,
+      status: after,
+      delivered: false,
+      resumed,
+      stored: true,
+      ...resumeOutcome ? { resume: resumeOutcome } : {},
+      error: `Session ${sessionId} went ${after} while sending: the message is stored server-side but no wrapper is attached to read it. ${after === "not_found" ? "Spawn a new session." : resumeHint}`
+    };
+  }
+  return { sessionId, status: "live", delivered: true, resumed, stored: true, ...resumeOutcome ? { resume: resumeOutcome } : {} };
+}
+async function waitUntilLive(classify, d, options) {
+  const waitMs = options.waitMs ?? DEFAULT_RESUME_WAIT_MS;
+  const pollMs = options.pollMs ?? DEFAULT_RESUME_POLL_MS;
+  const deadline = d.now() + waitMs;
+  let status = await classify();
+  while (status !== "live" && d.now() < deadline) {
+    await d.sleep(pollMs);
+    status = await classify();
+  }
+  return status;
+}
+
+const REMOTE_SESSION_OPS_MIN_CLI_VERSION = "0.2.157";
+const REMOTE_OPS_PROTOCOL_VERSION = 1;
+const REMOTE_TEXT_MAX_BYTES = 64 * 1024;
+const REMOTE_TRANSCRIPT_MAX_BYTES = 200 * 1024;
+const REMOTE_CALLS_PER_MINUTE = 60;
+const REMOTE_WRITE_CALLS_PER_MINUTE = 30;
+const REMOTE_LOCATE_MAX_IDS = 200;
+const REMOTE_OP_DEADLINE_MS = 25e3;
+const REMOTE_SEND_COMMIT_DEADLINE_MS = 18e3;
+const REMOTE_RESUME_WAIT_MS = 1e4;
+const REMOTE_WAIT_POLL_MS = 5e3;
+const REMOTE_ANSWER_MAX_BYTES = 64 * 1024;
+const REMOTE_TITLE_MAX_BYTES = 1024;
+const REMOTE_SENT_FROM_ALLOWED = ["cli", "assistant", "automation"];
+const LOCAL_ID_RE = /^[a-zA-Z0-9_.:-]{1,128}$/;
+function remoteError(code, message) {
+  return { ok: false, error: { code, message } };
+}
+const SESSION_ID_RE = /^[a-zA-Z0-9_-]{1,128}$/;
+const PEER_SCOPES = ["repo", "cwd", "machine"];
+function isSessionId(value) {
+  return typeof value === "string" && SESSION_ID_RE.test(value);
+}
+function utf8Bytes(text) {
+  return Buffer.byteLength(text, "utf8");
+}
+function sanitizeSender(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  if (typeof r.sessionId !== "string" || r.sessionId.length === 0 || r.sessionId.length > 128) return null;
+  const optional = (key, max) => typeof r[key] === "string" && r[key].length > 0 ? { [key]: r[key].slice(0, max) } : {};
+  return {
+    sessionId: r.sessionId,
+    ...optional("title", 200),
+    ...optional("flavor", 32),
+    ...optional("cwd", 1024),
+    ...optional("machine", 128)
+  };
+}
+function guardRemoteSessionOpsRequest(method, raw, options) {
+  if (!options.enabled) {
+    return remoteError("disabled", 'Remote session operations are turned off on this machine (settings.json remoteSessionOps = "off")');
+  }
+  if (!raw || typeof raw !== "object") return remoteError("bad_request", "Request must be an object");
+  const r = raw;
+  if (r.v !== REMOTE_OPS_PROTOCOL_VERSION) return remoteError("bad_request", `Unsupported protocol version ${String(r.v)} (this daemon speaks v${REMOTE_OPS_PROTOCOL_VERSION})`);
+  const from = r.from;
+  if (!from || typeof from !== "object" || typeof from.host !== "string" || from.host.length === 0 || typeof from.cli !== "string") {
+    return remoteError("bad_request", "from.host and from.cli are required");
+  }
+  const caller = {
+    host: from.host.slice(0, 128),
+    cli: from.cli.slice(0, 32),
+    ...typeof from.machineId === "string" && from.machineId.length > 0 ? { machineId: from.machineId.slice(0, 128) } : {},
+    ...isSessionId(from.sessionId) ? { sessionId: from.sessionId } : {}
+  };
+  const args = r.args && typeof r.args === "object" ? r.args : {};
+  const limit = typeof args.limit === "number" && Number.isFinite(args.limit) && args.limit >= 1 ? Math.floor(args.limit) : void 0;
+  let clean;
+  switch (method) {
+    case "sessions.list": {
+      if (args.ids !== void 0) {
+        if (!Array.isArray(args.ids) || !args.ids.every(isSessionId)) return remoteError("bad_request", "ids must be an array of session ids");
+        if (args.ids.length > REMOTE_LOCATE_MAX_IDS) return remoteError("too_large", `ids: at most ${REMOTE_LOCATE_MAX_IDS} per call`);
+      }
+      const out = {
+        ...args.ids !== void 0 ? { ids: args.ids } : {},
+        ...args.all === true ? { all: true } : {},
+        ...typeof args.tag === "string" && args.tag.length > 0 ? { tag: args.tag.slice(0, 128) } : {},
+        ...limit !== void 0 ? { limit } : {}
+      };
+      clean = out;
+      break;
+    }
+    case "sessions.read": {
+      if (!isSessionId(args.sessionId)) return remoteError("bad_request", "sessionId is required");
+      const out = { sessionId: args.sessionId, ...limit !== void 0 ? { limit } : {}, ...args.full === true ? { full: true } : {} };
+      clean = out;
+      break;
+    }
+    case "sessions.send": {
+      if (!isSessionId(args.sessionId)) return remoteError("bad_request", "sessionId is required");
+      if (typeof args.text !== "string" || args.text.trim().length === 0) return remoteError("bad_request", "text must be non-empty");
+      if (utf8Bytes(args.text) > REMOTE_TEXT_MAX_BYTES) return remoteError("too_large", `text exceeds ${REMOTE_TEXT_MAX_BYTES} bytes`);
+      if (args.localId !== void 0 && (typeof args.localId !== "string" || !LOCAL_ID_RE.test(args.localId))) return remoteError("bad_request", "localId must be a short id");
+      const out = {
+        sessionId: args.sessionId,
+        text: args.text,
+        ...args.resume === true ? { resume: true } : {},
+        ...args.model === null || typeof args.model === "string" && args.model.length <= 128 ? { model: args.model } : {},
+        ...REMOTE_SENT_FROM_ALLOWED.includes(args.sentFrom) ? { sentFrom: args.sentFrom } : {},
+        ...typeof args.localId === "string" ? { localId: args.localId } : {}
+      };
+      clean = out;
+      break;
+    }
+    case "sessions.peers": {
+      if (args.scope !== void 0 && !PEER_SCOPES.includes(args.scope)) return remoteError("bad_request", `scope must be one of ${PEER_SCOPES.join(", ")}`);
+      const out = {
+        ...args.scope !== void 0 ? { scope: args.scope } : {},
+        ...typeof args.cwd === "string" && args.cwd.length > 0 ? { cwd: args.cwd.slice(0, 4096) } : {}
+      };
+      clean = out;
+      break;
+    }
+    case "sessions.message": {
+      if (!isSessionId(args.to)) return remoteError("bad_request", "to is required");
+      if (typeof args.body !== "string" || args.body.trim().length === 0) return remoteError("bad_request", "body must be non-empty");
+      if (utf8Bytes(args.body) > REMOTE_TEXT_MAX_BYTES) return remoteError("too_large", `body exceeds ${REMOTE_TEXT_MAX_BYTES} bytes`);
+      const sender = sanitizeSender(args.from);
+      if (!sender) return remoteError("bad_request", "from.sessionId (the sender) is required");
+      const out = {
+        to: args.to,
+        body: args.body,
+        ...typeof args.replyTo === "string" && args.replyTo.length > 0 ? { replyTo: args.replyTo.slice(0, 64) } : {},
+        // The recipient's header names the machine the call came
+        // from, as the caller identified itself — never a value the
+        // sender picked for someone else.
+        from: { ...sender, machine: caller.host }
+      };
+      clean = out;
+      break;
+    }
+  }
+  return { ok: true, request: { v: REMOTE_OPS_PROTOCOL_VERSION, from: caller, args: clean } };
+}
+class RemoteCallBudget {
+  constructor(perMinute = REMOTE_CALLS_PER_MINUTE, now = Date.now) {
+    this.perMinute = perMinute;
+    this.now = now;
+    this.tokens = perMinute;
+    this.lastRefill = now();
+  }
+  tokens;
+  lastRefill;
+  /** Take one token; false = over budget (with ms until the next token). */
+  take() {
+    if (this.perMinute <= 0) return { ok: true };
+    const t = this.now();
+    const refill = (t - this.lastRefill) / 6e4 * this.perMinute;
+    if (refill > 0) {
+      this.tokens = Math.min(this.perMinute, this.tokens + refill);
+      this.lastRefill = t;
+    }
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return { ok: true };
+    }
+    return { ok: false, retryAfterMs: Math.ceil((1 - this.tokens) / this.perMinute * 6e4) };
+  }
+}
+function sanitizeAuditValue(value, max = 64) {
+  if (typeof value !== "string" || value.length === 0) return "?";
+  return value.slice(0, max).replace(/[^\x20-\x7e]/g, "?");
+}
+function formatRemoteAuditLine(input) {
+  const from = input.from;
+  const opt = (value) => value === void 0 ? "-" : sanitizeAuditValue(value);
+  return `[REMOTE SESSION OPS] ${sanitizeAuditValue(input.method)} from machine=${sanitizeAuditValue(from?.machineId)} host=${sanitizeAuditValue(from?.host)} cli=${sanitizeAuditValue(from?.cli, 32)} session=${opt(from?.sessionId)} target=${opt(input.sessionId)} \u2192 ${input.outcome} (${Math.max(0, Math.round(input.durationMs))}ms)`;
+}
+function capRemoteText(text, maxBytes, keep = "head") {
+  if (utf8Bytes(text) <= maxBytes) return text;
+  const buffer = Buffer.from(text, "utf8");
+  const marker = "\u2026";
+  const room = Math.max(0, maxBytes - Buffer.byteLength(marker));
+  const slice = keep === "head" ? buffer.subarray(0, room) : buffer.subarray(buffer.length - room);
+  const clean = slice.toString("utf8").replace(/^�+|�+$/g, "");
+  return keep === "head" ? clean + marker : marker + clean;
+}
+function capRemoteTranscript(transcript, maxBytes = REMOTE_TRANSCRIPT_MAX_BYTES) {
+  if (utf8Bytes(transcript) <= maxBytes) return { transcript, truncated: false };
+  const buffer = Buffer.from(transcript, "utf8");
+  const marker = "\u2026 [truncated by the remote machine: transcript exceeded the RPC budget; use --limit] \u2026\n";
+  const tail = buffer.subarray(buffer.length - (maxBytes - Buffer.byteLength(marker))).toString("utf8");
+  return { transcript: marker + tail.replace(/^�+/, ""), truncated: true };
+}
+function parseHappyClientVersion(value) {
+  if (typeof value !== "string") return null;
+  const match = value.match(/(\d+)\.(\d+)\.(\d+)/);
+  return match ? `${match[1]}.${match[2]}.${match[3]}` : null;
+}
+function compareVersions(a, b) {
+  const pa = a.split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const pb = b.split(".").map((n) => Number.parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d;
+  }
+  return 0;
+}
+function supportsRemoteSessionOps(cliVersion) {
+  if (!cliVersion) return null;
+  return compareVersions(cliVersion, REMOTE_SESSION_OPS_MIN_CLI_VERSION) >= 0;
+}
+
+const REMOTE_CLIENT_TAG = "session-ops";
+const REMOTE_RPC_TIMEOUT_MS = 3e4;
+const REMOTE_LOCATE_MAX_MACHINES = 8;
+class RemoteSessionOpsError extends Error {
+  constructor(code, message, machineId, ambiguous = false) {
+    super(message);
+    this.code = code;
+    this.machineId = machineId;
+    this.ambiguous = ambiguous;
+  }
+}
+async function bearerToken() {
+  const credentials = await readCredentialsForConfiguredRelay();
+  if (!credentials) throw new Error("CLI is not authenticated (no ~/.happy/access.key)");
+  return credentials.token;
+}
+async function listAccountMachines() {
+  const token = await bearerToken();
+  const response = await axios.get(`${configuration.serverUrl}/v1/machines`, {
+    headers: { "Authorization": `Bearer ${token}`, "X-Happy-Client": `${REMOTE_CLIENT_TAG}/${configuration.currentCliVersion}` },
+    timeout: 15e3
+  });
+  const rows = Array.isArray(response.data) ? response.data : [];
+  return rows.filter((row) => !!row && typeof row === "object" && typeof row.id === "string").map((row) => ({
+    id: row.id,
+    active: row.active === true,
+    ...typeof row.activeAt === "number" ? { activeAt: row.activeAt } : {},
+    cliVersion: parseHappyClientVersion(row.lastHappyClient)
+  }));
+}
+async function callerIdentity(env = process.env) {
+  const settings = await readSettings().catch(() => null);
+  const sessionId = env.VH_PEER_SESSION_ID;
+  return {
+    ...settings?.machineId ? { machineId: settings.machineId } : {},
+    host: hostname(),
+    cli: configuration.currentCliVersion,
+    ...sessionId && /^[a-zA-Z0-9_-]{1,128}$/.test(sessionId) ? { sessionId } : {}
+  };
+}
+const defaultDeps = {
+  listMachines: listAccountMachines,
+  selfMachineId: async () => (await readSettings().catch(() => null))?.machineId,
+  openTransport: async () => {
+    const socket = await openUserScopedSocket(await bearerToken());
+    return {
+      call: (method, paramsJson) => socket.rpcCall({ method, params: paramsJson }, REMOTE_RPC_TIMEOUT_MS),
+      close: () => socket.close()
+    };
+  },
+  caller: () => callerIdentity(),
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  now: () => Date.now()
+};
+function withDefaults(deps) {
+  return { ...defaultDeps, ...deps };
+}
+function pickRemoteCandidates(machines, selfId) {
+  const candidates = [];
+  const skipped = [];
+  for (const machine of machines) {
+    if (selfId && machine.id === selfId) {
+      skipped.push({ machine, reason: "self" });
+      continue;
+    }
+    if (!machine.active) {
+      skipped.push({ machine, reason: "offline" });
+      continue;
+    }
+    if (supportsRemoteSessionOps(machine.cliVersion) === false) {
+      skipped.push({ machine, reason: "too_old" });
+      continue;
+    }
+    candidates.push(machine);
+  }
+  candidates.sort((a, b) => (b.activeAt ?? 0) - (a.activeAt ?? 0));
+  return { candidates: candidates.slice(0, REMOTE_LOCATE_MAX_MACHINES), skipped };
+}
+function describeAge(activeAt, now) {
+  if (activeAt === void 0) return "never seen";
+  const minutes = Math.round((now - activeAt) / 6e4);
+  if (minutes < 2) return "seen just now";
+  if (minutes < 120) return `last seen ${minutes}m ago`;
+  if (minutes < 48 * 60) return `last seen ${Math.round(minutes / 60)}h ago`;
+  return `last seen ${Math.round(minutes / 1440)}d ago`;
+}
+async function resolveExplicitMachine(machineId, deps) {
+  const machines = await deps.listMachines();
+  const machine = machines.find((row) => row.id === machineId);
+  if (!machine) throw new RemoteSessionOpsError("unknown_machine", `Machine ${machineId} is not on this account`, machineId);
+  if (!machine.active) throw new RemoteSessionOpsError("offline", `Machine ${machineId} is offline (${describeAge(machine.activeAt, deps.now())}); its sessions cannot be reached until its daemon reconnects`, machineId);
+  if (supportsRemoteSessionOps(machine.cliVersion) === false) {
+    throw new RemoteSessionOpsError("too_old", `Machine ${machineId} runs CLI ${machine.cliVersion}; cross-machine session operations need \u2265 ${REMOTE_SESSION_OPS_MIN_CLI_VERSION} on the target`, machineId);
+  }
+  return machine;
+}
+async function callRemoteSessionOp(transport, machineId, method, args, from) {
+  const params = JSON.stringify({ v: REMOTE_OPS_PROTOCOL_VERSION, from, args });
+  let ack;
+  try {
+    ack = await transport.call(`${machineId}:${method}`, params);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new RemoteSessionOpsError("unreachable", `Machine ${machineId} did not answer ${method} (${reason})`, machineId, true);
+  }
+  if (!ack?.ok) {
+    const reason = ack?.error ?? "no ack";
+    if (/not available/i.test(reason)) {
+      throw new RemoteSessionOpsError("unreachable", `Machine ${machineId} did not answer ${method}: its daemon is offline, restarting, or runs a CLI older than ${REMOTE_SESSION_OPS_MIN_CLI_VERSION}`, machineId);
+    }
+    throw new RemoteSessionOpsError("unreachable", `Machine ${machineId}: ${reason}`, machineId, true);
+  }
+  let envelope;
+  try {
+    envelope = typeof ack.result === "string" ? JSON.parse(ack.result) : ack.result;
+  } catch {
+    throw new RemoteSessionOpsError("unreachable", `Machine ${machineId} returned an unreadable ${method} response`, machineId);
+  }
+  if (!envelope || typeof envelope !== "object") throw new RemoteSessionOpsError("unreachable", `Machine ${machineId} returned an empty ${method} response`, machineId);
+  if ("ok" in envelope) {
+    if (envelope.ok) return envelope.result;
+    throw new RemoteSessionOpsError(envelope.error.code, `Machine ${machineId}: ${envelope.error.message}`, machineId);
+  }
+  throw new RemoteSessionOpsError("internal", `Machine ${machineId}: ${envelope.error ?? "remote handler failed"}`, machineId);
+}
+async function locateRemoteSession(transport, sessionId, options, deps) {
+  const from = await deps.caller();
+  if (options.machineId) {
+    const machine = await resolveExplicitMachine(options.machineId, deps);
+    const listing = await callRemoteSessionOp(transport, machine.id, "sessions.list", { ids: [sessionId] }, from);
+    if (!listing.sessions.some((row) => row.id === sessionId)) {
+      throw new RemoteSessionOpsError("no_local_key", `Machine ${machine.id} (${listing.host}) has no key for session ${sessionId}: it was not spawned there (or is older than 14 days)`, machine.id);
+    }
+    return { machine, host: listing.host };
+  }
+  const { candidates, skipped } = pickRemoteCandidates(await deps.listMachines(), await deps.selfMachineId());
+  const failures = [];
+  for (const machine of candidates) {
+    try {
+      const listing = await callRemoteSessionOp(transport, machine.id, "sessions.list", { ids: [sessionId] }, from);
+      if (listing.sessions.some((row) => row.id === sessionId)) return { machine, host: listing.host };
+      failures.push(`${listing.host || machine.id}: not there`);
+    } catch (error) {
+      failures.push(`${machine.id}: ${error instanceof RemoteSessionOpsError ? error.code : error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  const skippedText = skipped.filter((s) => s.reason !== "self").map((s) => `${s.machine.id}: ${s.reason}`);
+  const detail = [...failures, ...skippedText];
+  throw new RemoteSessionOpsError(
+    "not_located",
+    `Session ${sessionId} is not on this machine and no online machine of this account reports it${detail.length ? ` (${detail.join("; ")})` : " (no other machines are online)"}. Pass --machine <id> to name one, or bring its machine online.`
+  );
+}
+async function withRemoteTransport(deps, fn) {
+  const transport = await deps.openTransport();
+  try {
+    return await fn(transport);
+  } finally {
+    try {
+      transport.close();
+    } catch {
+    }
+  }
+}
+async function readRemoteTranscript(sessionId, options = {}, overrides = {}) {
+  const deps = withDefaults(overrides);
+  return withRemoteTransport(deps, async (transport) => {
+    const located = await locateRemoteSession(transport, sessionId, { machineId: options.machineId }, deps);
+    return callRemoteSessionOp(transport, located.machine.id, "sessions.read", {
+      sessionId,
+      ...options.limit !== void 0 ? { limit: options.limit } : {},
+      ...options.full ? { full: true } : {}
+    }, await deps.caller());
+  });
+}
+async function waitForRemoteTurnEnd(sessionId, options, overrides = {}) {
+  const deps = withDefaults(overrides);
+  const pollMs = options.pollMs ?? REMOTE_WAIT_POLL_MS;
+  return withRemoteTransport(deps, async (transport) => {
+    const located = await locateRemoteSession(transport, sessionId, { machineId: options.machineId }, deps);
+    const from = await deps.caller();
+    const deadline = deps.now() + options.timeoutMs;
+    const args = { sessionId, ...options.limit !== void 0 ? { limit: options.limit } : {}, ...options.full ? { full: true } : {} };
+    while (true) {
+      const read = await callRemoteSessionOp(transport, located.machine.id, "sessions.read", args, from);
+      if (read.turn.ended) return { read, timedOut: false };
+      if (deps.now() + pollMs > deadline) return { read, timedOut: true };
+      await deps.sleep(pollMs);
+    }
+  });
+}
+async function sendRemoteMessage(sessionId, text, options = {}, overrides = {}) {
+  const deps = withDefaults(overrides);
+  return withRemoteTransport(deps, async (transport) => {
+    const located = await locateRemoteSession(transport, sessionId, { machineId: options.machineId }, deps);
+    const from = await deps.caller();
+    const localId = options.localId ?? `remote-send-${randomUUID()}`;
+    const args = {
+      sessionId,
+      text,
+      localId,
+      ...options.resume ? { resume: true } : {},
+      ...options.model !== void 0 ? { model: options.model } : {},
+      ...options.sentFrom !== void 0 ? { sentFrom: options.sentFrom } : {}
+    };
+    const attempt = () => callRemoteSessionOp(transport, located.machine.id, "sessions.send", args, from);
+    let result;
+    try {
+      result = await attempt();
+    } catch (error) {
+      const retryable = error instanceof RemoteSessionOpsError && (error.ambiguous || error.code === "timeout");
+      if (!retryable) throw error;
+      result = await attempt();
+    }
+    return { ...result, machine: { id: located.machine.id, host: located.host } };
+  });
+}
+async function sendRemotePeerMessage(args, options = {}, overrides = {}) {
+  const deps = withDefaults(overrides);
+  return withRemoteTransport(deps, async (transport) => {
+    const located = await locateRemoteSession(transport, args.to, { machineId: options.machineId }, deps);
+    const caller = await deps.caller();
+    const result = await callRemoteSessionOp(transport, located.machine.id, "sessions.message", {
+      to: args.to,
+      body: args.body,
+      ...args.replyTo ? { replyTo: args.replyTo } : {},
+      from: { ...args.from, machine: args.from.machine ?? caller.host }
+    }, caller);
+    return { ...result, machine: { id: located.machine.id, host: located.host } };
+  });
+}
+async function listRemotePeers(machineId, options = {}, overrides = {}) {
+  const deps = withDefaults(overrides);
+  return withRemoteTransport(deps, async (transport) => {
+    const machine = await resolveExplicitMachine(machineId, deps);
+    return callRemoteSessionOp(transport, machine.id, "sessions.peers", {
+      ...options.scope ? { scope: options.scope } : {},
+      ...options.cwd ? { cwd: options.cwd } : {}
+    }, await deps.caller());
+  });
+}
+async function listRemoteSessions(machineId, options = {}, overrides = {}) {
+  const deps = withDefaults(overrides);
+  return withRemoteTransport(deps, async (transport) => {
+    const machine = await resolveExplicitMachine(machineId, deps);
+    return callRemoteSessionOp(transport, machine.id, "sessions.list", {
+      ...options.tag ? { tag: options.tag } : {},
+      ...options.limit !== void 0 ? { limit: options.limit } : {}
+    }, await deps.caller());
+  });
+}
+async function fillForeignAccountRows(rows, overrides = {}) {
+  const deps = withDefaults(overrides);
+  const pending = new Set(rows.filter((row) => !row.decryptable).map((row) => row.id));
+  const asked = [];
+  if (pending.size === 0) return { rows, asked, skipped: [] };
+  const { candidates, skipped } = pickRemoteCandidates(await deps.listMachines(), await deps.selfMachineId());
+  const filled = /* @__PURE__ */ new Map();
+  if (candidates.length > 0) {
+    await withRemoteTransport(deps, async (transport) => {
+      const from = await deps.caller();
+      for (const machine of candidates) {
+        if (pending.size === 0) break;
+        try {
+          const listing = await callRemoteSessionOp(transport, machine.id, "sessions.list", { ids: [...pending], all: true }, from);
+          let count = 0;
+          for (const row of listing.sessions) {
+            if (!pending.has(row.id)) continue;
+            pending.delete(row.id);
+            count++;
+            filled.set(row.id, { ...row, decryptable: false, readable: true, via: machine.id, machine: { id: machine.id, host: listing.host } });
+          }
+          asked.push({ machineId: machine.id, host: listing.host, filled: count });
+        } catch (error) {
+          asked.push({ machineId: machine.id, filled: 0, error: error instanceof Error ? error.message : String(error) });
+        }
+      }
+    });
+  }
+  return {
+    rows: rows.map((row) => filled.get(row.id) ?? row),
+    asked,
+    skipped: skipped.filter((s) => s.reason !== "self").map((s) => ({ machineId: s.machine.id, reason: s.reason }))
+  };
+}
+
+export { RemoteSessionOpsError as R, listRemotePeers as a, sendRemotePeerMessage as b, RemoteCallBudget as c, deliverToSession as d, REMOTE_WRITE_CALLS_PER_MINUTE as e, fillForeignAccountRows as f, guardRemoteSessionOpsRequest as g, remoteError as h, REMOTE_OP_DEADLINE_MS as i, formatRemoteAuditLine as j, REMOTE_SEND_COMMIT_DEADLINE_MS as k, listRemoteSessions as l, REMOTE_RESUME_WAIT_MS as m, capRemoteTranscript as n, capRemoteText as o, REMOTE_ANSWER_MAX_BYTES as p, REMOTE_TITLE_MAX_BYTES as q, readRemoteTranscript as r, sendRemoteMessage as s, waitForRemoteTurnEnd as w };