dsh-dispatch 0.1.0

package/dist/index.js

@@ -0,0 +1,1240 @@
+// src/approvals.ts
+import { randomUUID } from "crypto";
+
+// ../shared/src/crypto.ts
+import nacl from "tweetnacl";
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var KEY_PREFIX = encoder.encode("dsh-dispatch/key");
+var ROOM_PREFIX = encoder.encode("dsh-dispatch/room");
+var NONCE_LENGTH = nacl.secretbox.nonceLength;
+function concat(a, b) {
+  const out = new Uint8Array(a.length + b.length);
+  out.set(a, 0);
+  out.set(b, a.length);
+  return out;
+}
+var B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function toBase64(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b0 = bytes[i];
+    const b1 = bytes[i + 1];
+    const b2 = bytes[i + 2];
+    out += B64_ALPHABET[b0 >> 2];
+    out += B64_ALPHABET[(b0 & 3) << 4 | (b1 ?? 0) >> 4];
+    out += b1 === void 0 ? "=" : B64_ALPHABET[(b1 & 15) << 2 | (b2 ?? 0) >> 6];
+    out += b2 === void 0 ? "=" : B64_ALPHABET[b2 & 63];
+  }
+  return out;
+}
+function fromBase64(text) {
+  const clean = text.replace(/=+$/, "");
+  if (!/^[A-Za-z0-9+/]*$/.test(clean)) return null;
+  const out = new Uint8Array(Math.floor(clean.length * 3 / 4));
+  let bits = 0;
+  let value = 0;
+  let index = 0;
+  for (const char of clean) {
+    value = value << 6 | B64_ALPHABET.indexOf(char);
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out[index++] = value >> bits & 255;
+    }
+  }
+  return out.slice(0, index);
+}
+function toBase64Url(bytes) {
+  return toBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function generateSecret() {
+  return nacl.randomBytes(32);
+}
+function deriveKey(secret) {
+  return nacl.hash(concat(KEY_PREFIX, secret)).slice(0, nacl.secretbox.keyLength);
+}
+function deriveRoomId(secret) {
+  return toBase64Url(nacl.hash(concat(ROOM_PREFIX, secret)).slice(0, 16));
+}
+function seal(message, key) {
+  const nonce = nacl.randomBytes(NONCE_LENGTH);
+  const box = nacl.secretbox(encoder.encode(JSON.stringify(message)), nonce, key);
+  return toBase64(concat(nonce, box));
+}
+function open(payload, key) {
+  const bytes = fromBase64(payload);
+  if (bytes === null || bytes.length < NONCE_LENGTH + nacl.secretbox.overheadLength) return null;
+  const box = nacl.secretbox.open(bytes.slice(NONCE_LENGTH), bytes.slice(0, NONCE_LENGTH), key);
+  if (box === null) return null;
+  try {
+    return JSON.parse(decoder.decode(box));
+  } catch {
+    return null;
+  }
+}
+function encodePairing(info) {
+  const json = JSON.stringify({
+    v: 1,
+    relay: info.relay,
+    secret: toBase64Url(info.secret),
+    machine: info.machine
+  });
+  return toBase64Url(encoder.encode(json));
+}
+
+// ../shared/src/limits.ts
+var MAX_ENVELOPE_BYTES = 16 * 1024;
+var MAX_DETAIL_CHARS = 8 * 1024;
+var MAX_SUMMARY_CHARS = 4 * 1024;
+var MAX_PROMPT_CHARS = 8 * 1024;
+var MAX_PROMPT_BYTES = 10 * 1024;
+var MAX_FIELD_BYTES = 10 * 1024;
+var MAX_PUSH_BYTES = 3 * 1024;
+var TRUNCATION_SUFFIX = "\u2026[truncated]";
+function truncate(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars - TRUNCATION_SUFFIX.length) + TRUNCATION_SUFFIX;
+}
+var byteEncoder = new TextEncoder();
+function utf8Length(text) {
+  return byteEncoder.encode(text).length;
+}
+function clampBytes(text, maxBytes) {
+  if (utf8Length(text) <= maxBytes) return text;
+  const budget = maxBytes - utf8Length(TRUNCATION_SUFFIX);
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (utf8Length(text.slice(0, mid)) <= budget) low = mid;
+    else high = mid - 1;
+  }
+  const tail = text.charCodeAt(low - 1);
+  if (tail >= 55296 && tail <= 56319) low -= 1;
+  return text.slice(0, low) + TRUNCATION_SUFFIX;
+}
+
+// src/approvals.ts
+var TITLE_CHARS = 200;
+var REMINDER_MS = 5 * 6e4;
+var MAX_REMINDERS = 6;
+function installApprovals(hub) {
+  const pending = /* @__PURE__ */ new Map();
+  hub.ctx.on("approval/request", (request, next) => {
+    if (!hub.pairing.everPaired || !hub.relay.connected) return next();
+    if (request.signal?.aborted === true) return Promise.resolve("cancelled");
+    return forward(hub, pending, request, next);
+  });
+  return {
+    respond(message) {
+      const entry = pending.get(message.approvalId);
+      if (entry === void 0) {
+        hub.relay.send(closedMsg(message.approvalId, "expired"));
+        return;
+      }
+      entry.settle(message.decision === "allow" ? "allowed-once" : "rejected", message.decision);
+    },
+    resendPending() {
+      for (const entry of pending.values()) hub.relay.send(entry.frame, entry.push);
+    },
+    openCount: () => pending.size
+  };
+}
+function forward(hub, pending, request, next) {
+  const approvalId = randomUUID();
+  const sessionId = request.agent.id;
+  const frame = buildRequestMsg(approvalId, sessionId, request);
+  const push = buildPush(sessionId, frame.title);
+  if (!hub.relay.send(frame, push)) {
+    hub.report("approval", `\u5BA1\u6279 ${frame.title} \u672A\u80FD\u63A8\u9001\u5230\u624B\u673A\uFF08relay \u672A\u8FDE\u63A5\uFF09\uFF0C\u5DF2\u4EA4\u56DE\u672C\u673A\u5904\u7406`);
+    return next();
+  }
+  return race(hub, pending, { approvalId, sessionId, frame, push }, request, next);
+}
+function race(hub, pending, forwarded, request, next) {
+  const { approvalId, sessionId } = forwarded;
+  return new Promise((resolve3) => {
+    let settled = false;
+    const settle = (outcome, resolution) => {
+      if (settled) return;
+      settled = true;
+      const entry2 = pending.get(approvalId);
+      if (entry2?.timer !== void 0) clearTimeout(entry2.timer);
+      pending.delete(approvalId);
+      request.signal?.removeEventListener("abort", onAbort);
+      hub.sessions.approvalClosed(sessionId);
+      hub.relay.send(closedMsg(approvalId, resolution));
+      resolve3(outcome);
+    };
+    function onAbort() {
+      settle("cancelled", "superseded");
+    }
+    request.signal?.addEventListener("abort", onAbort, { once: true });
+    const entry = { ...forwarded, settle, reminders: 0, timer: void 0 };
+    pending.set(approvalId, entry);
+    hub.sessions.approvalOpened(sessionId);
+    armReminder(hub, entry);
+    void next().then(
+      (outcome) => {
+        if (outcome !== "unavailable") settle(outcome, "local");
+      },
+      (error) => {
+        hub.fail(`approval ${approvalId}: local answerer failed`, error);
+      }
+    );
+  });
+}
+function armReminder(hub, entry) {
+  entry.timer = setTimeout(() => {
+    entry.timer = void 0;
+    entry.reminders += 1;
+    hub.relay.send(entry.frame, entry.push);
+    if (entry.reminders >= MAX_REMINDERS) {
+      hub.log.warn(
+        "approval %s still unanswered after %d reminders; it stays open (never auto-approved)",
+        entry.frame.approvalId,
+        entry.reminders
+      );
+      return;
+    }
+    armReminder(hub, entry);
+  }, REMINDER_MS);
+  entry.timer.unref?.();
+}
+function buildRequestMsg(approvalId, sessionId, request) {
+  return {
+    v: 1,
+    ts: Date.now(),
+    type: "approval.request",
+    approvalId,
+    sessionId,
+    title: truncate(request.toolName, TITLE_CHARS),
+    // Chars first (protocol conformance), then bytes: 8 192 chars of CJK is
+    // ~24 KB of UTF-8, which base64 would expand past the 16 KB envelope.
+    detail: clampBytes(truncate(buildDetail(request), MAX_DETAIL_CHARS), MAX_FIELD_BYTES),
+    createdAt: Date.now()
+  };
+}
+function buildDetail(request) {
+  const parts = [`\u5DE5\u5177: ${request.toolName}`];
+  if (request.reason !== void 0 && request.reason !== "") parts.push(`\u539F\u56E0: ${request.reason}`);
+  const args = toolCallArguments(request.agent, request.callId);
+  parts.push(args === void 0 ? "\u53C2\u6570: (\u8C03\u7528\u672A\u8BB0\u5F55\u53C2\u6570)" : `\u53C2\u6570:
+${args}`);
+  return parts.join("\n\n");
+}
+function toolCallArguments(agent, callId) {
+  if (callId === void 0) return void 0;
+  const events = agent.session.events;
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index];
+    if (event?.type === "tool/call" && event.data.callId === callId) return event.data.arguments;
+  }
+  return void 0;
+}
+function buildPush(sessionId, title) {
+  return { v: 1, ts: Date.now(), type: "push", kind: "approval", sessionId, title };
+}
+function closedMsg(approvalId, resolution) {
+  return { v: 1, ts: Date.now(), type: "approval.closed", approvalId, resolution };
+}
+
+// src/commands.ts
+function installCommands(hub, deps) {
+  hub.ctx.effect(() => hub.ctx.commands.register({
+    name: "dispatch-pair",
+    description: "Show the dsh-dispatch pairing code for this machine",
+    handler: () => pairingResult(hub)
+  }), "dsh-dispatch: /dispatch-pair");
+  hub.ctx.effect(() => hub.ctx.commands.register({
+    name: "dispatch-repair",
+    description: "Generate a new dsh-dispatch pairing secret (invalidates every paired phone)",
+    handler: () => {
+      hub.relay.rekey(hub.pairing.regenerate());
+      hub.log.warn("pairing secret regenerated; every previously paired phone is now locked out");
+      return pairingResult(hub, "\u65E7\u914D\u5BF9\u7801\u5DF2\u4F5C\u5E9F\uFF0C\u8BF7\u5728\u6BCF\u53F0\u624B\u673A\u4E0A\u91CD\u65B0\u626B\u7801\u3002\n\n");
+    }
+  }), "dsh-dispatch: /dispatch-repair");
+  hub.ctx.effect(() => hub.ctx.commands.register({
+    name: "dispatch-status",
+    description: "Show the dsh-dispatch relay connection and remote session state",
+    handler: () => ({ kind: "success", text: statusText(hub, deps) })
+  }), "dsh-dispatch: /dispatch-status");
+}
+function pairingResult(hub, prefix = "") {
+  if (hub.config.relay === "") {
+    return {
+      kind: "error",
+      text: "relay \u672A\u914D\u7F6E\uFF1A\u8BF7\u5728 profile \u7684 cordis.patch.yml \u4E2D\u4E3A dsh-dispatch \u8BBE\u7F6E relay: 'wss://\u2026'"
+    };
+  }
+  const code = hub.pairing.pairingCode(hub.config.relay, hub.config.machineName);
+  return {
+    kind: "success",
+    text: `${prefix}\u914D\u5BF9\u7801\uFF08${hub.config.machineName}\uFF09\uFF1A
+${code}
+
+\u6216\u5728\u624B\u673A\u4E0A\u6253\u5F00\uFF1A
+${hub.config.pwaUrl}/#pair=${code}
+
+\u26A0\uFE0F \u6B64\u7801\u7B49\u540C\u4E8E\u672C\u673A\u7684\u63A7\u5236\u6743\uFF1A\u6301\u6709\u8005\u53EF\u4EE5\u6279\u51C6\u5DE5\u5177\u8C03\u7528\u5E76\u5728\u5141\u8BB8\u76EE\u5F55\u4E2D\u6D3E\u53D1\u4EFB\u52A1\u3002\u4E0D\u8981\u53D1\u5230\u7FA4\u91CC\u6216\u622A\u56FE\u5916\u4F20\uFF1B\u4E00\u65E6\u6CC4\u9732\u7ACB\u5373\u8FD0\u884C /dispatch-repair\u3002`
+  };
+}
+function statusText(hub, deps) {
+  const status = hub.relay.status();
+  const link = hub.config.relay === "" ? "\u672A\u914D\u7F6E\uFF08\u8BF7\u8BBE\u7F6E relay\uFF09" : status.connected ? `\u5DF2\u8FDE\u63A5 ${hub.config.relay}` : status.gaveUp ? `\u8FDE\u63A5\u5931\u8D25 ${String(status.consecutiveFailures)} \u6B21\uFF0C\u4ECD\u5728\u6BCF 60s \u91CD\u8BD5 \u2014 \u8BF7\u68C0\u67E5 relay` : `\u672A\u8FDE\u63A5\uFF08\u91CD\u8BD5\u4E2D\uFF0C\u5DF2\u5931\u8D25 ${String(status.consecutiveFailures)} \u6B21\uFF09`;
+  return [
+    `relay:      ${link}`,
+    `\u623F\u95F4:       ${status.room.slice(0, 8)}\u2026`,
+    `\u5DF2\u914D\u5BF9:     ${hub.pairing.everPaired ? "yes" : "no"}${status.phoneOnline ? "\uFF08\u624B\u673A\u5728\u7EBF\uFF09" : "\uFF08\u624B\u673A\u79BB\u7EBF\uFF09"}`,
+    `\u5F85\u6279\u5BA1\u6279:   ${String(deps.approvals.openCount())}`,
+    `\u6D3E\u53D1\u4F1A\u8BDD:   ${String(deps.dispatch.dispatchedCount())}`,
+    `\u89E3\u5BC6\u5931\u8D25:   ${String(status.decryptFailures)}${status.decryptFailures > 0 ? " \u2014 \u5BC6\u94A5\u4E0D\u5339\u914D\uFF0C\u8BF7\u91CD\u65B0\u914D\u5BF9" : ""}`,
+    `allowedRoots: ${hub.config.allowedRoots.length === 0 ? "(\u7A7A \u2014 \u8FDC\u7A0B\u6D3E\u4EFB\u52A1\u5DF2\u7981\u7528)" : hub.config.allowedRoots.join(", ")}`
+  ].join("\n");
+}
+
+// src/dispatch.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { isAbsolute, resolve as resolve2, sep } from "path";
+import { installModelSelection } from "@deepseek-ai/dsh-agent";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { SessionId } from "@deepseek-ai/dsh-session";
+
+// src/pairing.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join, resolve } from "path";
+var SECRET_FILE = "secret";
+var PAIRED_FILE = "paired.json";
+var SECRET_BYTES = 32;
+function expandHome(input) {
+  if (input === "~") return homedir();
+  if (input.startsWith("~/")) return join(homedir(), input.slice(2));
+  return resolve(input);
+}
+var PairingStore = class _PairingStore {
+  dataDir;
+  #secret;
+  #pairedAt;
+  constructor(dataDir, secret, pairedAt) {
+    this.dataDir = dataDir;
+    this.#secret = secret;
+    this.#pairedAt = pairedAt;
+  }
+  /** Load the stored secret, generating and persisting one on first start. */
+  static open(dataDir, log) {
+    const dir = expandHome(dataDir);
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    const secretPath = join(dir, SECRET_FILE);
+    let secret = null;
+    if (existsSync(secretPath)) {
+      secret = fromBase64(readFileSync(secretPath, "utf8").trim());
+      if (secret === null || secret.length !== SECRET_BYTES) {
+        throw new Error(
+          `dsh-dispatch: ${secretPath} is not a valid pairing secret. Delete the file to generate a new one (this invalidates existing pairings).`
+        );
+      }
+    } else {
+      secret = generateSecret();
+      writeSecret(secretPath, secret);
+    }
+    return new _PairingStore(dir, secret, readPairedAt(join(dir, PAIRED_FILE), log));
+  }
+  get secret() {
+    return this.#secret;
+  }
+  /**
+   * Whether a phone has ever completed a pairing with this machine. Approval
+   * forwarding stays out of the way entirely until this is true, so an
+   * unpaired machine pays zero added approval latency.
+   */
+  get everPaired() {
+    return this.#pairedAt !== void 0;
+  }
+  get pairedAt() {
+    return this.#pairedAt;
+  }
+  /** Record the first sighting of a phone in this room. Idempotent. */
+  markPaired() {
+    if (this.#pairedAt !== void 0) return;
+    this.#pairedAt = Date.now();
+    writeFileSync(join(this.dataDir, PAIRED_FILE), JSON.stringify({ pairedAt: this.#pairedAt }), {
+      mode: 384
+    });
+  }
+  /** Replace the secret, invalidating every existing pairing. */
+  regenerate() {
+    this.#secret = generateSecret();
+    writeSecret(join(this.dataDir, SECRET_FILE), this.#secret);
+    this.#pairedAt = void 0;
+    rmSync(join(this.dataDir, PAIRED_FILE), { force: true });
+    return this.#secret;
+  }
+  /** The out-of-band pairing payload: relay + secret + machine name. */
+  pairingCode(relay, machine) {
+    return encodePairing({ relay, secret: this.#secret, machine });
+  }
+};
+function writeSecret(path, secret) {
+  writeFileSync(path, toBase64(secret), { mode: 384 });
+  chmodSync(path, 384);
+}
+function readPairedAt(path, log) {
+  if (!existsSync(path)) return void 0;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    const value = parsed.pairedAt;
+    return typeof value === "number" ? value : void 0;
+  } catch (error) {
+    log.error("pairing: %s is unreadable, treating this machine as never paired: %s", path, error);
+    return void 0;
+  }
+}
+
+// src/worktree.ts
+import { execFile } from "child_process";
+import { randomBytes } from "crypto";
+import { join as join2 } from "path";
+import { promisify } from "util";
+var run = promisify(execFile);
+var STDERR_TAIL = 500;
+var WorktreeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WorktreeError";
+  }
+};
+async function prepareWorkspace(options) {
+  if (!options.worktree) return { cwd: options.cwd };
+  if (!await isGitRepo(options.cwd)) {
+    return {
+      cwd: options.cwd,
+      note: `\u5DF2\u964D\u7EA7\uFF1A${options.cwd} \u4E0D\u662F git \u4ED3\u5E93\uFF0C\u4EFB\u52A1\u76F4\u63A5\u5728\u8BE5\u76EE\u5F55\u8FD0\u884C\uFF08\u672A\u521B\u5EFA worktree\uFF09`
+    };
+  }
+  const root = join2(options.dataDir, "worktrees");
+  try {
+    return await addWorktree(options.cwd, root, freshSlug());
+  } catch (error) {
+    const stderr = stderrOf(error);
+    if (!isCollision(stderr)) throw new WorktreeError(stderr);
+    return await addWorktree(options.cwd, root, freshSlug()).catch((retry) => {
+      throw new WorktreeError(stderrOf(retry));
+    });
+  }
+}
+async function addWorktree(cwd, root, slug) {
+  const target = join2(root, slug);
+  const branch = `dsh-dispatch/${slug}`;
+  await run("git", ["-C", cwd, "worktree", "add", target, "-b", branch]);
+  return { cwd: target, branch };
+}
+async function isGitRepo(cwd) {
+  try {
+    const { stdout } = await run("git", ["-C", cwd, "rev-parse", "--is-inside-work-tree"]);
+    return stdout.trim() === "true";
+  } catch {
+    return false;
+  }
+}
+function freshSlug() {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\..+$/, "");
+  return `${stamp}-${randomBytes(3).toString("hex")}`;
+}
+function isCollision(stderr) {
+  return /already exists|already used by worktree|already checked out/i.test(stderr);
+}
+function stderrOf(error) {
+  const raw = error.stderr;
+  const text = typeof raw === "string" && raw.trim() !== "" ? raw.trim() : error instanceof Error ? error.message : String(error);
+  return text.length <= STDERR_TAIL ? text : text.slice(-STDERR_TAIL);
+}
+
+// src/dispatch.ts
+var SEEN_LIMIT = 256;
+var DISPATCH_DISABLED = "dispatch \u672A\u542F\u7528\uFF1A\u8BF7\u5728\u63D2\u4EF6\u914D\u7F6E\u4E2D\u8BBE\u7F6E allowedRoots";
+var NO_REMOTE_FOLLOWUP = "\u8BE5\u4F1A\u8BDD\u4E0D\u652F\u6301\u8FDC\u7A0B\u8FFD\u52A0";
+function installDispatch(hub) {
+  const state = {
+    handles: /* @__PURE__ */ new Map(),
+    seen: new ResultCache(),
+    inflight: /* @__PURE__ */ new Map(),
+    loaderReady: void 0
+  };
+  hub.ctx.on("agent/turn-stopping", ({ agent }) => {
+    if (!hub.sessions.isDispatched(agent.id)) return;
+    hub.sessions.markTurnComplete(agent.id);
+    void reportTurnFinal(hub, agent.id).catch((error) => {
+      hub.fail(`turn.final for ${agent.id}`, error);
+    });
+  });
+  hub.ctx.on("agent/disposed", ({ agent }) => {
+    state.handles.delete(agent.id);
+  });
+  return {
+    request: (message) => handleRequest(hub, state, message),
+    followup: (message) => handleFollowup(hub, state, message),
+    dispatchedCount: () => state.handles.size
+  };
+}
+async function handleRequest(hub, state, message) {
+  const replay = state.seen.get(message.requestId);
+  if (replay !== void 0) {
+    if (replay !== null) hub.relay.send(replay);
+    return;
+  }
+  const pending = state.inflight.get(message.requestId) ?? startSession(hub, state, message);
+  state.inflight.set(message.requestId, pending);
+  try {
+    const result = await pending;
+    state.seen.set(message.requestId, result);
+    hub.relay.send(result);
+  } finally {
+    state.inflight.delete(message.requestId);
+  }
+}
+async function startSession(hub, state, message) {
+  const prompt = message.prompt;
+  const oversized = overLimit("prompt", prompt);
+  if (oversized !== void 0) return failure(message.requestId, oversized);
+  const target = resolveCwd(hub, message.cwd);
+  if (typeof target !== "string") return failure(message.requestId, target.error);
+  try {
+    const workspace = await prepareWorkspace({
+      cwd: target,
+      dataDir: hub.pairing.dataDir,
+      worktree: message.worktree
+    });
+    state.loaderReady ??= Promise.resolve(hub.ctx.get("loader")?.await()).then(() => void 0);
+    await state.loaderReady;
+    const handle = await createSession(hub.ctx, workspace.cwd, prompt);
+    state.handles.set(handle.agent.id, handle);
+    hub.sessions.markDispatched(handle.agent.id, prompt);
+    const result = ok(message.requestId, handle.agent.id);
+    return workspace.note === void 0 ? result : { ...result, note: workspace.note };
+  } catch (error) {
+    const detail = error instanceof WorktreeError ? error.message : String(error);
+    hub.log.error("dispatch %s failed: %s", message.requestId, detail);
+    return failure(message.requestId, detail);
+  }
+}
+async function handleFollowup(hub, state, message) {
+  const oversized = overLimit("\u6D88\u606F", message.text);
+  if (oversized !== void 0) {
+    hub.report(`session.message ${message.sessionId}`, oversized);
+    return;
+  }
+  if (state.seen.get(message.requestId) !== void 0) return;
+  state.seen.set(message.requestId, null);
+  const agent = state.handles.get(message.sessionId)?.agent ?? hub.sessions.agentOf(message.sessionId);
+  if (agent === void 0) {
+    hub.report(`session.message ${message.sessionId}`, NO_REMOTE_FOLLOWUP);
+    return;
+  }
+  agent.followup(createUserMessage({
+    content: [{ type: "text", text: message.text }],
+    source: { kind: "user" }
+  }));
+}
+function overLimit(field, text) {
+  const tail = "\u8BF7\u5728\u624B\u673A\u7AEF\u7F29\u77ED\u540E\u91CD\u53D1\u3002";
+  if (text.length > MAX_PROMPT_CHARS) {
+    return `${field} \u8D85\u957F\uFF1A${String(text.length)} \u5B57\u7B26\uFF0C\u4E0A\u9650 ${String(MAX_PROMPT_CHARS)} \u5B57\u7B26\u3002${tail}`;
+  }
+  const bytes = utf8Length(text);
+  if (bytes > MAX_PROMPT_BYTES) {
+    return `${field} \u8D85\u957F\uFF1A${String(bytes)} \u5B57\u8282\uFF08UTF-8\uFF09\uFF0C\u4E0A\u9650 ${String(MAX_PROMPT_BYTES)} \u5B57\u8282\u3002${tail}`;
+  }
+  return void 0;
+}
+async function composeAgent(ctx, selection) {
+  const install = (agentCtx) => {
+    if (selection === void 0) return;
+    installModelSelection(agentCtx, { current: selection, assembled: void 0 });
+  };
+  const presets = ctx.get("agentPresets");
+  if (presets === void 0) {
+    return { setup: (agentCtx) => {
+      install(agentCtx);
+      return Promise.resolve();
+    } };
+  }
+  const resolvedId = (await presets.resolve()).id;
+  return {
+    agentPreset: resolvedId,
+    setup: async (agentCtx) => {
+      install(agentCtx);
+      await presets.mount(agentCtx, resolvedId);
+    }
+  };
+}
+async function createSession(ctx, cwd, prompt) {
+  const selection = ctx.get("agentDefaultModel")?.currentSelection();
+  const composition = await composeAgent(ctx, selection);
+  const handle = await ctx.agents.create({
+    sessionId: SessionId(`session-${randomUUID2()}`),
+    // The preset is recorded on the header so a later cold resume rebuilds the
+    // composition this session's history was actually produced under.
+    meta: composition.agentPreset === void 0 ? { cwd } : { cwd, agentPreset: composition.agentPreset },
+    agentOptions: selection === void 0 ? void 0 : { provider: selection.provider, model: selection.model },
+    setup: composition.setup
+  });
+  await handle.agent.whenIdle();
+  handle.agent.followup(createUserMessage({
+    content: [{ type: "text", text: prompt }],
+    source: { kind: "user" }
+  }));
+  return handle;
+}
+function resolveCwd(hub, requested) {
+  const roots = hub.config.allowedRoots.map((root) => resolve2(expandHome(root)));
+  if (roots.length === 0) return { error: DISPATCH_DISABLED };
+  const first = roots[0];
+  if (requested === void 0) return first === void 0 ? { error: DISPATCH_DISABLED } : first;
+  const target = resolve2(isAbsolute(requested) ? requested : expandHome(requested));
+  const inside = roots.some((root) => target === root || target.startsWith(root + sep));
+  return inside ? target : { error: `cwd \u4E0D\u5728\u5141\u8BB8\u76EE\u5F55\u5185\uFF1A${target}` };
+}
+async function reportTurnFinal(hub, sessionId) {
+  const snapshot = await hub.ctx.sessionQuery.readSurface(SessionId(sessionId));
+  const ok2 = !hub.sessions.hasError(sessionId);
+  const summary = clampBytes(
+    truncate(lastAssistantText(snapshot.events), MAX_SUMMARY_CHARS),
+    MAX_FIELD_BYTES
+  );
+  hub.relay.send(
+    { v: 1, ts: Date.now(), type: "turn.final", sessionId, ok: ok2, summary },
+    {
+      v: 1,
+      ts: Date.now(),
+      type: "push",
+      kind: ok2 ? "done" : "error",
+      sessionId,
+      title: truncate(summary.split("\n", 1)[0] ?? "", 120)
+    }
+  );
+}
+function lastAssistantText(events) {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index];
+    if (event?.type !== "assistant/message") continue;
+    const text = event.data.message.content.filter((block) => block.type === "text").map((block) => block.text).join("").trim();
+    if (text !== "") return text;
+  }
+  return "\uFF08\u672C\u8F6E\u6CA1\u6709\u4EA7\u751F\u52A9\u624B\u6587\u672C\uFF09";
+}
+function ok(requestId, sessionId) {
+  return { v: 1, ts: Date.now(), type: "dispatch.result", requestId, ok: true, sessionId };
+}
+function failure(requestId, error) {
+  return { v: 1, ts: Date.now(), type: "dispatch.result", requestId, ok: false, error };
+}
+var ResultCache = class {
+  #entries = /* @__PURE__ */ new Map();
+  get(requestId) {
+    return this.#entries.get(requestId);
+  }
+  set(requestId, value) {
+    this.#entries.delete(requestId);
+    this.#entries.set(requestId, value);
+    while (this.#entries.size > SEEN_LIMIT) {
+      const oldest = this.#entries.keys().next();
+      if (oldest.done === true) break;
+      this.#entries.delete(oldest.value);
+    }
+  }
+};
+
+// src/hub.ts
+var ERROR_CHARS = 1e3;
+function createHub(parts) {
+  const report = (context, message) => {
+    parts.log.error("%s: %s", context, message);
+    parts.relay.send({
+      v: 1,
+      ts: Date.now(),
+      type: "error",
+      message: truncate(message, ERROR_CHARS),
+      context
+    });
+  };
+  return {
+    ...parts,
+    report,
+    fail(context, error) {
+      report(context, error instanceof Error ? error.message : String(error));
+    }
+  };
+}
+
+// src/relay-client.ts
+var BACKOFF_BASE_MS = 500;
+var BACKOFF_MAX_MS = 3e4;
+var GIVE_UP_AFTER = 10;
+var GIVE_UP_RETRY_MS = 6e4;
+var TAMPER_LOG_WINDOW_MS = 3e4;
+var RelayClient = class {
+  #options;
+  #key;
+  #room;
+  #socket;
+  #retry;
+  #stopped = true;
+  #connected = false;
+  #phoneOnline = false;
+  #failures = 0;
+  #gaveUp = false;
+  #tamperBurst = 0;
+  #tamperWindowStart = 0;
+  #tamperTotal = 0;
+  constructor(options) {
+    this.#options = options;
+    this.#key = deriveKey(options.secret);
+    this.#room = deriveRoomId(options.secret);
+  }
+  get connected() {
+    return this.#connected;
+  }
+  get phoneOnline() {
+    return this.#phoneOnline;
+  }
+  status() {
+    return {
+      connected: this.#connected,
+      phoneOnline: this.#phoneOnline,
+      consecutiveFailures: this.#failures,
+      gaveUp: this.#gaveUp,
+      room: this.#room,
+      decryptFailures: this.#tamperTotal
+    };
+  }
+  start() {
+    if (!this.#stopped) return;
+    this.#stopped = false;
+    this.#connect();
+  }
+  stop() {
+    this.#stopped = true;
+    if (this.#retry !== void 0) clearTimeout(this.#retry);
+    this.#retry = void 0;
+    this.#teardownSocket();
+    this.#connected = false;
+    this.#phoneOnline = false;
+  }
+  /** Adopt a freshly generated secret: new room, new key, new connection. */
+  rekey(secret) {
+    this.#key = deriveKey(secret);
+    this.#room = deriveRoomId(secret);
+    this.#failures = 0;
+    this.#gaveUp = false;
+    if (this.#stopped) return;
+    this.stop();
+    this.start();
+  }
+  /**
+   * Seal and send one inner message. `push` rides along so the relay can wake
+   * an offline phone through Web Push without ever seeing the plaintext.
+   * @returns whether the frame reached the socket.
+   */
+  send(message, push) {
+    const socket = this.#socket;
+    if (socket === void 0 || !this.#connected) return false;
+    const frame = {
+      kind: "msg",
+      room: this.#room,
+      payload: seal(message, this.#key),
+      push: push === void 0 ? null : { payload: seal(push, this.#key), tag: push.kind }
+    };
+    const text = JSON.stringify(frame);
+    if (text.length > MAX_ENVELOPE_BYTES) {
+      this.#options.log.error(
+        "relay: refusing to send an oversized %s envelope (%d bytes > %d); this is a truncation bug",
+        message.type,
+        text.length,
+        MAX_ENVELOPE_BYTES
+      );
+      return false;
+    }
+    socket.send(text);
+    return true;
+  }
+  #connect() {
+    if (this.#stopped) return;
+    let socket;
+    try {
+      socket = new WebSocket(this.#options.url);
+    } catch (error) {
+      this.#options.log.error("relay: cannot open %s: %s", this.#options.url, error);
+      this.#scheduleRetry();
+      return;
+    }
+    this.#socket = socket;
+    socket.addEventListener("open", () => {
+      socket.send(JSON.stringify({ kind: "hello", room: this.#room, role: "machine" }));
+    });
+    socket.addEventListener("message", (event) => {
+      this.#onFrame(event.data);
+    });
+    socket.addEventListener("error", () => {
+    });
+    socket.addEventListener("close", (event) => {
+      if (this.#socket !== socket) return;
+      const code = event.code;
+      this.#onDown(`socket closed (${String(code ?? "no code")})`);
+    });
+  }
+  #onFrame(data) {
+    if (typeof data !== "string") return;
+    let frame;
+    try {
+      frame = JSON.parse(data);
+    } catch (error) {
+      this.#options.log.error("relay: dropped an unparseable frame: %s", error);
+      return;
+    }
+    const kind = frame.kind;
+    if (kind === "hello-ok") this.#onHelloOk(frame);
+    else if (kind === "presence") this.#onPresence(frame);
+    else if (kind === "msg") this.#onData(frame);
+    else if (kind === "error") {
+      const code = String(frame.code ?? "unknown");
+      this.#options.log.error('relay: rejected our frame with code "%s"', code);
+    } else {
+      this.#options.log.warn('relay: ignoring unknown frame kind "%s"', String(kind));
+    }
+  }
+  #onHelloOk(frame) {
+    this.#connected = true;
+    this.#failures = 0;
+    this.#gaveUp = false;
+    const peers = frame.peers;
+    const phones = typeof peers?.phone === "number" ? peers.phone : 0;
+    this.#options.log.info("relay: connected (room %s\u2026, phones online: %d)", this.#room.slice(0, 8), phones);
+    this.#options.onConnected();
+    if (phones > 0) this.#setPhoneOnline(true);
+  }
+  #onPresence(frame) {
+    const { role, online } = frame;
+    if (role !== "phone" || typeof online !== "boolean") return;
+    this.#setPhoneOnline(online);
+  }
+  #setPhoneOnline(online) {
+    if (this.#phoneOnline === online) return;
+    this.#phoneOnline = online;
+    this.#options.onPhonePresence(online);
+  }
+  #onData(frame) {
+    const payload = frame.payload;
+    if (typeof payload !== "string") {
+      this.#options.log.error("relay: dropped a msg frame with no payload");
+      return;
+    }
+    const plain = open(payload, this.#key);
+    if (plain === null) {
+      this.#onTamper();
+      return;
+    }
+    const message = parseInbound(plain);
+    if (message === null) {
+      this.#options.log.warn(
+        'relay: ignoring inner message of type "%s" \u2014 unknown type or missing/invalid fields (the phone may be newer than this plugin)',
+        String(plain.type)
+      );
+      return;
+    }
+    this.#options.onMessage(message);
+  }
+  /** Decryption failure is never silent: it means tampering or a stale pairing. */
+  #onTamper() {
+    this.#tamperTotal += 1;
+    this.#tamperBurst += 1;
+    const now = Date.now();
+    if (now - this.#tamperWindowStart < TAMPER_LOG_WINDOW_MS) return;
+    this.#tamperWindowStart = now;
+    this.#options.log.error(
+      "relay: %d message(s) failed to decrypt \u2014 wrong key or tampering. Re-pair with /dispatch-repair and re-scan the QR on every phone.",
+      this.#tamperBurst
+    );
+    this.#tamperBurst = 0;
+  }
+  #onDown(reason) {
+    this.#teardownSocket();
+    if (this.#stopped) return;
+    this.#connected = false;
+    this.#setPhoneOnline(false);
+    this.#failures += 1;
+    this.#options.log.debug("relay: %s, attempt %d", reason, this.#failures);
+    this.#scheduleRetry();
+  }
+  #scheduleRetry() {
+    if (this.#stopped || this.#retry !== void 0) return;
+    if (this.#failures >= GIVE_UP_AFTER && !this.#gaveUp) {
+      this.#gaveUp = true;
+      this.#options.log.error(
+        "relay: %d consecutive failures connecting to %s \u2014 check that the relay is reachable. Still retrying every %ds.",
+        this.#failures,
+        this.#options.url,
+        GIVE_UP_RETRY_MS / 1e3
+      );
+    }
+    this.#retry = setTimeout(() => {
+      this.#retry = void 0;
+      this.#connect();
+    }, this.#backoffMs());
+    this.#retry.unref?.();
+  }
+  #backoffMs() {
+    if (this.#gaveUp) return GIVE_UP_RETRY_MS;
+    const exponential = Math.min(BACKOFF_BASE_MS * 2 ** this.#failures, BACKOFF_MAX_MS);
+    return Math.round(exponential * (0.75 + Math.random() * 0.5));
+  }
+  #teardownSocket() {
+    const socket = this.#socket;
+    this.#socket = void 0;
+    if (socket === void 0) return;
+    try {
+      socket.close();
+    } catch (error) {
+      this.#options.log.debug("relay: error closing socket: %s", error);
+    }
+  }
+};
+var INBOUND_FIELDS = {
+  "sessions.get": [],
+  "approval.respond": ["requestId", "approvalId", "decision"],
+  "dispatch.request": ["requestId", "prompt"],
+  "session.message": ["requestId", "sessionId", "text"]
+};
+function parseInbound(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const record = value;
+  if (record["v"] !== 1) return null;
+  const type = record["type"];
+  if (typeof type !== "string" || !(type in INBOUND_FIELDS)) return null;
+  const required = INBOUND_FIELDS[type];
+  for (const field of required) {
+    if (typeof record[field] !== "string" || record[field] === "") return null;
+  }
+  if (type === "approval.respond" && record["decision"] !== "allow" && record["decision"] !== "deny") {
+    return null;
+  }
+  if (type === "dispatch.request" && typeof record["worktree"] !== "boolean") return null;
+  return record;
+}
+
+// src/sessions.ts
+import { SessionId as SessionId2 } from "@deepseek-ai/dsh-session";
+var TITLE_CHARS2 = 80;
+var SessionTracker = class {
+  #ctx;
+  #relay;
+  #log;
+  #tracked = /* @__PURE__ */ new Map();
+  #published = /* @__PURE__ */ new Map();
+  constructor(ctx, relay, log) {
+    this.#ctx = ctx;
+    this.#relay = relay;
+    this.#log = log;
+  }
+  /** Subscribe the agent lifecycle. Registrations unwind with the plugin. */
+  install() {
+    this.#ctx.on("agent/created", ({ agent }) => {
+      this.#adopt(agent);
+      this.#publish(agent.id);
+      void this.#refreshTitle(agent);
+    });
+    this.#ctx.on("agent/session-start", ({ agent }) => {
+      void this.#refreshTitle(agent);
+    });
+    this.#ctx.on("agent/status", ({ agent, status }) => {
+      this.#update(agent.id, (entry) => {
+        if (status === "idle" && entry.finalized) return;
+        entry.finalized = false;
+        entry.base = status;
+      });
+    });
+    this.#ctx.on("agent/error", ({ agent, error }) => {
+      this.#log.error("session %s: agent error: %s", agent.id, error);
+      this.#update(agent.id, (entry) => {
+        entry.base = "error";
+      });
+    });
+    this.#ctx.on("agent/turn-stopping", ({ agent }) => {
+      void this.#refreshTitle(agent);
+    });
+    this.#ctx.on("agent/disposed", ({ agent }) => {
+      this.#update(agent.id, (entry) => {
+        entry.base = "done";
+      });
+      this.#tracked.delete(agent.id);
+      this.#published.delete(agent.id);
+    });
+  }
+  /** Mark a session as started by us, with the dispatch prompt as its title. */
+  markDispatched(sessionId, prompt) {
+    this.#update(sessionId, (entry) => {
+      entry.dispatched = true;
+      entry.title = truncate(prompt.trim().split("\n", 1)[0] ?? "", TITLE_CHARS2);
+    });
+  }
+  isDispatched(sessionId) {
+    return this.#tracked.get(sessionId)?.dispatched ?? false;
+  }
+  /**
+   * A dispatched turn has closed and its `turn.final` is on its way. Latch the
+   * card at done/error so the trailing idle status cannot demote it.
+   */
+  markTurnComplete(sessionId) {
+    this.#update(sessionId, (entry) => {
+      entry.finalized = true;
+      if (entry.base !== "error") entry.base = "done";
+    });
+  }
+  hasError(sessionId) {
+    return this.#tracked.get(sessionId)?.base === "error";
+  }
+  /** The live agent for a session id, or undefined when it is not live. */
+  agentOf(sessionId) {
+    return this.#ctx.agents.get(SessionId2(sessionId));
+  }
+  /** An approval for this session is now waiting on a human. */
+  approvalOpened(sessionId) {
+    this.#update(sessionId, (entry) => {
+      entry.openApprovals += 1;
+    });
+  }
+  approvalClosed(sessionId) {
+    this.#update(sessionId, (entry) => {
+      entry.openApprovals = Math.max(0, entry.openApprovals - 1);
+    });
+  }
+  /** Active sessions only — the phone board never shows cold history. */
+  async snapshot() {
+    const records = await this.#ctx.sessionQuery.listSessions();
+    const wire = [];
+    for (const record of records) {
+      if (!record.live) continue;
+      const id = record.header.id;
+      const known = this.#tracked.get(id) ?? this.#adopt(this.#ctx.agents.get(id));
+      wire.push(known === void 0 ? this.#fallbackWire(id, record.header.cwd ?? "", record.header.createdAt) : toWire(known));
+    }
+    return wire;
+  }
+  #fallbackWire(sessionId, cwd, createdAt) {
+    return {
+      sessionId,
+      title: truncate(sessionId, TITLE_CHARS2),
+      cwd,
+      state: "idle",
+      lastActivity: createdAt,
+      dispatched: false
+    };
+  }
+  #adopt(agent) {
+    if (agent === void 0) return void 0;
+    const existing = this.#tracked.get(agent.id);
+    if (existing !== void 0) return existing;
+    const entry = {
+      sessionId: agent.id,
+      title: truncate(firstPrompt(agent) ?? agent.id, TITLE_CHARS2),
+      cwd: agent.session.header.cwd ?? "",
+      base: agent.status,
+      openApprovals: 0,
+      lastActivity: Date.now(),
+      dispatched: false,
+      finalized: false
+    };
+    this.#tracked.set(agent.id, entry);
+    return entry;
+  }
+  #update(sessionId, mutate) {
+    const entry = this.#tracked.get(sessionId) ?? this.#adopt(this.#ctx.agents.get(SessionId2(sessionId)));
+    if (entry === void 0) return;
+    mutate(entry);
+    entry.lastActivity = Date.now();
+    this.#publish(sessionId);
+  }
+  /** Emit `session.update` only when the phone-visible projection changed. */
+  #publish(sessionId) {
+    const entry = this.#tracked.get(sessionId);
+    if (entry === void 0) return;
+    const session = toWire(entry);
+    const fingerprint = `${session.state}|${session.title}|${session.cwd}|${String(session.dispatched)}`;
+    if (this.#published.get(sessionId) === fingerprint) return;
+    this.#published.set(sessionId, fingerprint);
+    this.#relay.send({ v: 1, ts: Date.now(), type: "session.update", session });
+  }
+  async #refreshTitle(agent) {
+    const entry = this.#tracked.get(agent.id);
+    if (entry === void 0 || entry.dispatched) return;
+    try {
+      const snapshot = await this.#ctx.sessionQuery.readTitle(SessionId2(agent.id));
+      const title = snapshot?.title ?? firstPrompt(agent);
+      if (title === void 0 || title === "") return;
+      entry.title = truncate(title, TITLE_CHARS2);
+      this.#publish(agent.id);
+    } catch (error) {
+      this.#log.error("session %s: could not read title: %s", agent.id, error);
+    }
+  }
+};
+function toWire(entry) {
+  return {
+    sessionId: entry.sessionId,
+    title: entry.title,
+    cwd: entry.cwd,
+    state: stateOf(entry),
+    lastActivity: entry.lastActivity,
+    dispatched: entry.dispatched
+  };
+}
+function stateOf(entry) {
+  if (entry.base === "done" || entry.base === "error") return entry.base;
+  return entry.openApprovals > 0 ? "awaiting_approval" : entry.base;
+}
+function firstPrompt(agent) {
+  for (const event of agent.session.events) {
+    if (event.type !== "user/message") continue;
+    const text = event.data.content.filter((block) => block.type === "text").map((block) => block.text).join("").trim();
+    if (text !== "") return text.split("\n", 1)[0];
+  }
+  return void 0;
+}
+
+// src/version.ts
+var PLUGIN_VERSION = "0.1.0";
+
+// src/config.ts
+import { hostname } from "os";
+import z from "@deepseek-ai/schemastery";
+var Config = z.object({
+  relay: z.string().required(),
+  machineName: z.string().default(hostname()),
+  allowedRoots: z.array(z.string()).default([]),
+  dataDir: z.string().default("~/.dsh-dispatch"),
+  pwaUrl: z.string().default("http://localhost:5173")
+});
+
+// src/index.ts
+var name = "dsh-dispatch";
+var inject = ["agents", "commands", "sessionQuery"];
+var STATUS_INTERVAL_MS = 6e4;
+function apply(ctx, config) {
+  const log = ctx.logger("dsh-dispatch");
+  const pairing = PairingStore.open(config.dataDir, log);
+  const deferred = { message(_) {
+  }, hello() {
+  } };
+  const relay = new RelayClient({
+    url: config.relay,
+    secret: pairing.secret,
+    log,
+    onMessage: (message) => {
+      deferred.message(message);
+    },
+    onConnected: () => {
+      deferred.hello();
+    },
+    onPhonePresence: (online) => {
+      if (!online) {
+        log.info("relay: phone left the room");
+        return;
+      }
+      pairing.markPaired();
+      log.info("relay: phone joined the room");
+      deferred.hello();
+    }
+  });
+  const sessions = new SessionTracker(ctx, relay, log);
+  const hub = createHub({ ctx, config, log, relay, sessions, pairing });
+  const approvals = installApprovals(hub);
+  const dispatch = installDispatch(hub);
+  deferred.message = (message) => {
+    route(hub, approvals, dispatch, message);
+  };
+  deferred.hello = () => {
+    publishStatus(hub);
+    approvals.resendPending();
+    void publishSnapshot(hub);
+  };
+  sessions.install();
+  installCommands(hub, { approvals, dispatch });
+  startRelay(hub);
+}
+function startRelay(hub) {
+  const url = hub.config.relay;
+  if (url === "") {
+    hub.log.error(
+      "relay is not configured: set `relay: 'wss://\u2026'` on the dsh-dispatch row in your profile's cordis.patch.yml. Approval forwarding and dispatch stay off until then."
+    );
+    return;
+  }
+  if (!/^wss?:\/\//.test(url)) {
+    hub.log.error('relay "%s" is not a ws:// or wss:// URL; refusing to connect', url);
+    return;
+  }
+  hub.ctx.effect(() => {
+    hub.relay.start();
+    return () => {
+      hub.relay.stop();
+    };
+  }, "dsh-dispatch: relay client");
+  hub.ctx.effect(() => {
+    const timer = setInterval(() => {
+      publishStatus(hub);
+    }, STATUS_INTERVAL_MS);
+    timer.unref?.();
+    return () => {
+      clearInterval(timer);
+    };
+  }, "dsh-dispatch: status heartbeat");
+}
+function route(hub, approvals, dispatch, message) {
+  switch (message.type) {
+    case "sessions.get":
+      void publishSnapshot(hub);
+      return;
+    case "approval.respond":
+      approvals.respond(message);
+      return;
+    case "dispatch.request":
+      void dispatch.request(message).catch((error) => {
+        hub.fail(`dispatch.request ${message.requestId}`, error);
+      });
+      return;
+    case "session.message":
+      void dispatch.followup(message).catch((error) => {
+        hub.fail(`session.message ${message.requestId}`, error);
+      });
+  }
+}
+function publishStatus(hub) {
+  hub.relay.send({
+    v: 1,
+    ts: Date.now(),
+    type: "machine.status",
+    machine: hub.config.machineName,
+    pluginVersion: PLUGIN_VERSION
+  });
+}
+async function publishSnapshot(hub) {
+  try {
+    hub.relay.send({
+      v: 1,
+      ts: Date.now(),
+      type: "session.snapshot",
+      sessions: await hub.sessions.snapshot()
+    });
+  } catch (error) {
+    hub.fail("session.snapshot", error);
+  }
+}
+export {
+  Config,
+  apply,
+  inject,
+  name
+};
+//# sourceMappingURL=index.js.map