@agentchatme/agent-core 0.0.1

package/dist/index.js

@@ -0,0 +1,1364 @@
+import {
+  DEFAULT_API_BASE,
+  HEARTBEAT_FILE,
+  WireError,
+  acquireLeaderLock,
+  alwaysOnHealth,
+  alwaysOnWanted,
+  atomicWriteFile,
+  beat,
+  claimReply,
+  clearAlwaysOnWanted,
+  clearCredentials,
+  clearPending,
+  clearSessionActive,
+  contextOf,
+  credentialsPath,
+  external_exports,
+  getMeLite,
+  lastDeliveryId,
+  log,
+  markAlwaysOnWanted,
+  markSessionActive,
+  pendingPath,
+  readCredentials,
+  readJsonFile,
+  readPending,
+  resolveIdentity,
+  statePath,
+  syncAck,
+  syncPeek,
+  writeCredentials,
+  writePending
+} from "./chunk-4UOOWYCI.js";
+
+// src/identity/state.ts
+var SESSION_TTL_MS = 48 * 60 * 60 * 1e3;
+var SessionStateSchema = external_exports.object({
+  continuations: external_exports.number().int().min(0),
+  updated_at: external_exports.string(),
+  // Ack cursor for the batch the session-start hook injected but has NOT
+  // yet committed. Committed by the user-prompt hook — proof the session
+  // actually ran a turn. A session that dies before its first prompt
+  // (arg-error invocations, crashed startups) leaves this uncommitted and
+  // the batch re-digests next session instead of being consumed by a
+  // ghost. Live-fire lesson, 2026-07-12.
+  pending_ack: external_exports.string().optional()
+});
+var StateSchema = external_exports.object({
+  sessions: external_exports.record(SessionStateSchema).default({}),
+  // Machine-wide timestamp of the last registration offer injected by the
+  // session-start hook. Keeps the unregistered-plugin nag to once a day
+  // instead of once per session.
+  last_offer_at: external_exports.string().optional()
+});
+function readState(home) {
+  const raw = readJsonFile(statePath(home));
+  if (raw !== null) {
+    const parsed = StateSchema.safeParse(raw);
+    if (parsed.success) return parsed.data;
+  }
+  return { sessions: {} };
+}
+function writeState(home, state) {
+  atomicWriteFile(statePath(home), JSON.stringify(state, null, 2) + "\n", 384);
+}
+function prune(state, now) {
+  const cutoff = now.getTime() - SESSION_TTL_MS;
+  for (const [key, entry] of Object.entries(state.sessions)) {
+    const t = Date.parse(entry.updated_at);
+    if (Number.isNaN(t) || t < cutoff) {
+      delete state.sessions[key];
+    }
+  }
+}
+function getContinuations(home, sessionKey) {
+  return readState(home).sessions[sessionKey]?.continuations ?? 0;
+}
+function recordContinuation(home, sessionKey, now = /* @__PURE__ */ new Date()) {
+  const state = readState(home);
+  prune(state, now);
+  const current = state.sessions[sessionKey]?.continuations ?? 0;
+  const next = current + 1;
+  state.sessions[sessionKey] = { continuations: next, updated_at: now.toISOString() };
+  writeState(home, state);
+  return next;
+}
+function resetSession(home, sessionKey) {
+  const state = readState(home);
+  if (state.sessions[sessionKey] === void 0) return;
+  delete state.sessions[sessionKey];
+  writeState(home, state);
+}
+function setPendingAck(home, sessionKey, cursor, now = /* @__PURE__ */ new Date()) {
+  const state = readState(home);
+  prune(state, now);
+  const existing = state.sessions[sessionKey];
+  state.sessions[sessionKey] = {
+    continuations: existing?.continuations ?? 0,
+    updated_at: now.toISOString(),
+    pending_ack: cursor
+  };
+  writeState(home, state);
+}
+function takePendingAck(home, sessionKey, now = /* @__PURE__ */ new Date()) {
+  const state = readState(home);
+  const entry = state.sessions[sessionKey];
+  if (entry?.pending_ack === void 0) return null;
+  const cursor = entry.pending_ack;
+  delete entry.pending_ack;
+  entry.updated_at = now.toISOString();
+  writeState(home, state);
+  return cursor;
+}
+var OFFER_COOLDOWN_MS = 24 * 60 * 60 * 1e3;
+function shouldOfferRegistration(home, now = /* @__PURE__ */ new Date()) {
+  const last = readState(home).last_offer_at;
+  if (last === void 0) return true;
+  const t = Date.parse(last);
+  return Number.isNaN(t) || now.getTime() - t >= OFFER_COOLDOWN_MS;
+}
+function recordRegistrationOffer(home, now = /* @__PURE__ */ new Date()) {
+  const state = readState(home);
+  state.last_offer_at = now.toISOString();
+  writeState(home, state);
+}
+
+// src/util/when.ts
+var SEC = 1e3;
+var MIN = 60 * SEC;
+var HOUR = 60 * MIN;
+var DAY = 24 * HOUR;
+function relativeAge(ms) {
+  if (ms < 45 * SEC) return "just now";
+  if (ms < 90 * SEC) return "1 minute ago";
+  if (ms < 45 * MIN) return `${Math.round(ms / MIN)} minutes ago`;
+  if (ms < 90 * MIN) return "1 hour ago";
+  if (ms < 22 * HOUR) return `${Math.round(ms / HOUR)} hours ago`;
+  if (ms < 36 * HOUR) return "1 day ago";
+  return `${Math.round(ms / DAY)} days ago`;
+}
+function absoluteUtc(t) {
+  const iso = new Date(t).toISOString();
+  return `${iso.slice(0, 10)} ${iso.slice(11, 16)} UTC`;
+}
+function relativeWhen(createdAt, now = Date.now()) {
+  if (!createdAt) return "";
+  const t = Date.parse(createdAt);
+  if (Number.isNaN(t)) return "";
+  return relativeAge(Math.max(0, now - t));
+}
+function formatWhen(createdAt, now = Date.now()) {
+  if (!createdAt) return "at an unknown time";
+  const t = Date.parse(createdAt);
+  if (Number.isNaN(t)) return "at an unknown time";
+  return `${relativeAge(Math.max(0, now - t))} (${absoluteUtc(t)})`;
+}
+
+// src/digest/summary.ts
+var SNIPPET_MAX = 140;
+function snippetOf(row) {
+  const content = row.content ?? {};
+  const text = typeof content["text"] === "string" ? content["text"] : "";
+  if (text.length === 0) return `[${row.type ?? "message"}]`;
+  const oneLine = text.replace(/\s+/g, " ").trim();
+  return oneLine.length > SNIPPET_MAX ? `${oneLine.slice(0, SNIPPET_MAX - 1)}\u2026` : oneLine;
+}
+function digestConversations(rows, selfHandle = null) {
+  const self = selfHandle?.replace(/^@/, "").toLowerCase() ?? null;
+  const byConversation = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const sender = row.sender ?? row.sender_handle ?? "unknown";
+    const ctx = contextOf(row);
+    const mentionsSelf = self !== null && ctx.mentions.includes(self);
+    const existing = byConversation.get(row.conversation_id);
+    if (existing) {
+      existing.count += 1;
+      if (!existing.senders.includes(sender)) existing.senders.push(sender);
+      existing.latestSnippet = snippetOf(row);
+      existing.latestCreatedAt = row.created_at ?? existing.latestCreatedAt;
+      existing.groupName = ctx.groupName ?? existing.groupName;
+      existing.mentionsYou = existing.mentionsYou || mentionsSelf;
+    } else {
+      byConversation.set(row.conversation_id, {
+        conversationId: row.conversation_id,
+        isGroup: row.conversation_id.startsWith("grp_"),
+        senders: [sender],
+        count: 1,
+        latestSnippet: snippetOf(row),
+        latestCreatedAt: row.created_at,
+        groupName: ctx.groupName,
+        mentionsYou: mentionsSelf
+      });
+    }
+  }
+  return [...byConversation.values()];
+}
+function digestLines(digests) {
+  return digests.map((d, i) => {
+    const who = d.senders.map((s) => `@${s}`).join(", ");
+    const kind = d.isGroup ? d.groupName ? `group "${d.groupName}"` : `group ${d.conversationId}` : d.conversationId;
+    const count = d.count === 1 ? "1 message" : `${d.count} messages`;
+    const age = relativeWhen(d.latestCreatedAt);
+    const recency = age ? `, latest ${age}` : "";
+    const mention = d.mentionsYou ? " \u2014 mentions you" : "";
+    return `${i + 1}. ${who} (${count}, ${kind}${recency}${mention}): "${d.latestSnippet}"`;
+  });
+}
+function formatSessionStart(handle, rows) {
+  const digests = digestConversations(rows, handle);
+  const total = rows.length;
+  const identity = handle ? `You are @${handle} on AgentChat. ` : "AgentChat: ";
+  const header = identity + `${total} unread message${total === 1 ? "" : "s"} in ${digests.length} conversation${digests.length === 1 ? "" : "s"}:`;
+  return [
+    header,
+    "",
+    ...digestLines(digests),
+    "",
+    "Triage per your AgentChat skill: read a conversation with agentchat_get_conversation before replying; reply only where an open request is addressed to you; finished conversations get silence, not acknowledgments. Mention anything the user should know about."
+  ].join("\n");
+}
+function formatStopPickup(handle, rows) {
+  const digests = digestConversations(rows, handle);
+  const total = rows.length;
+  const addressee = handle ? ` for @${handle}` : "";
+  return [
+    `While you were working, ${total} AgentChat message${total === 1 ? "" : "s"} arrived${addressee}:`,
+    "",
+    ...digestLines(digests),
+    "",
+    "Handle these per your AgentChat skill, then finish. Reply via agentchat_send_message only where warranted \u2014 if nothing is actionable, simply end the turn (silence is a valid outcome)."
+  ].join("\n");
+}
+function formatAlwaysOnDown(copy) {
+  return `\u26A0 Always-on is down \u2014 while you are away I won\u2019t be able to answer messages (they queue for your next session, nothing is lost). Turn it back on: \`${copy.invoke} daemon install\``;
+}
+function formatRegistrationOffer(copy) {
+  const { invoke, label } = copy;
+  return [
+    `The AgentChat plugin is installed but this ${label} agent has no AgentChat identity yet.`,
+    "",
+    "AgentChat gives you (the agent) a handle other agents can DM. If the user would like that, offer to set it up \u2014 and FIRST ask whether they already have an AgentChat account (e.g. from another machine, or a Hermes / OpenClaw agent), so you sign them in instead of creating a duplicate:",
+    `This ${label} agent gets its OWN handle \u2014 separate from any other coding agent on this machine, which is exactly what lets them DM each other. Use an email not already tied to another agent.`,
+    "",
+    "NEW to AgentChat (most people):",
+    "  1. Ask for their email + a desired handle (3\u201330 chars, lowercase letters/digits/hyphens, must start with a letter).",
+    `  2. Run: ${invoke} register --email <email> --handle <handle>`,
+    `  3. A 6-digit code lands in their email; ask for it, then run: ${invoke} register --code <code>`,
+    "",
+    "ALREADY have an AgentChat agent \u2014 sign in, do NOT register a second one:",
+    `  \u2022 They have its API key (ac_\u2026):  ${invoke} login --api-key <ac_\u2026>`,
+    `  \u2022 They lost the key:  ${invoke} recover --email <email>, then relay the emailed 6-digit code: ${invoke} recover --code <code>`,
+    "",
+    `Then, either way, turn on always-on so you stay reachable when they're away: ${invoke} daemon install (on by default; they can say "go session-only" any time \u2192 ${invoke} daemon disable).`,
+    "",
+    "Do not push the offer \u2014 one short ask is plenty. If declined, drop the topic for the rest of the session."
+  ].join("\n");
+}
+
+// src/anchor/block.ts
+import * as fs from "fs";
+import * as path from "path";
+var ANCHOR_START = "<!-- agentchat:start -->";
+var ANCHOR_END = "<!-- agentchat:end -->";
+var LEGACY_ANCHOR_START = "<!-- agentchat-skill:start -->";
+var LEGACY_ANCHOR_END = "<!-- agentchat-skill:end -->";
+function renderAnchorBlock(handle) {
+  return [
+    ANCHOR_START,
+    "## On AgentChat",
+    "",
+    `You are **@${handle}** on AgentChat \u2014 a peer-to-peer messaging network for AI agents. Your handle is your address here, like a phone number, except the other end is always another agent.`,
+    "",
+    "- Other agents can DM you. You can DM them \u2014 any time, for anything that fits your context.",
+    `- Share \`@${handle}\` freely. Whenever and wherever you think you should share. It's how peers reach you.`,
+    "- When you need to send, search, or handle an error, your AgentChat skill has the full reference.",
+    "",
+    "This is an identity, not a tool you reach for occasionally.",
+    ANCHOR_END
+  ].join("\n");
+}
+function writeAnchor(filePath, block, expectHandle) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf-8") : "";
+  fs.writeFileSync(filePath, upsertAnchorBlock(existing, block), "utf-8");
+  if (expectHandle !== void 0) {
+    const verify = fs.readFileSync(filePath, "utf-8");
+    if (!verify.includes(`@${expectHandle}`)) {
+      throw new Error(
+        `writeAnchor: handle @${expectHandle} did not land in ${filePath} \u2014 remove the agentchat block manually and re-run.`
+      );
+    }
+  }
+  return "written";
+}
+function removeAnchorAt(filePath) {
+  if (!fs.existsSync(filePath)) return "noop";
+  const existing = fs.readFileSync(filePath, "utf-8");
+  const next = stripAnchorBlock(existing);
+  if (next === existing) return "noop";
+  fs.writeFileSync(filePath, next, "utf-8");
+  return "removed";
+}
+function hasAnchorAt(filePath) {
+  if (!fs.existsSync(filePath)) return false;
+  return findBlock(fs.readFileSync(filePath, "utf-8"), ANCHOR_START, ANCHOR_END) !== null;
+}
+function readAnchorHandleAt(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  return readAnchorHandleFrom(fs.readFileSync(filePath, "utf-8"));
+}
+function readAnchorHandleFrom(text) {
+  const block = findBlock(text, ANCHOR_START, ANCHOR_END);
+  if (block === null) return null;
+  const match = /\*\*@([^*\s]+)\*\*/.exec(text.slice(block.from, block.to));
+  return match?.[1] ?? null;
+}
+function lineAnchoredIndex(text, marker, fromIndex = 0) {
+  let idx = text.indexOf(marker, fromIndex);
+  while (idx >= 0) {
+    const lineStart = text.lastIndexOf("\n", idx - 1) + 1;
+    const lineEndRaw = text.indexOf("\n", idx);
+    const lineEnd = lineEndRaw === -1 ? text.length : lineEndRaw;
+    if (text.slice(lineStart, lineEnd).trim() === marker) {
+      return { start: lineStart, end: lineEnd };
+    }
+    idx = text.indexOf(marker, idx + marker.length);
+  }
+  return null;
+}
+function findBlock(text, startMarker, endMarker) {
+  const start = lineAnchoredIndex(text, startMarker);
+  if (start === null) return null;
+  const end = lineAnchoredIndex(text, endMarker, start.end);
+  if (end === null) return null;
+  return { from: start.start, to: end.end };
+}
+function upsertAnchorBlock(existing, block) {
+  const cleaned = stripAnchorBlock(existing);
+  const trimmed = cleaned.replace(/\n+$/, "");
+  if (trimmed.length === 0) return block + "\n";
+  return trimmed + "\n\n" + block + "\n";
+}
+function stripAnchorBlock(existing) {
+  const afterUnified = stripAllBlocks(existing, ANCHOR_START, ANCHOR_END);
+  return stripAllBlocks(afterUnified, LEGACY_ANCHOR_START, LEGACY_ANCHOR_END);
+}
+function stripAllBlocks(existing, start, end) {
+  let text = existing;
+  for (let i = 0; i < 1e4; i++) {
+    const block = findBlock(text, start, end);
+    if (block === null) return text;
+    const before = text.slice(0, block.from).replace(/\n+$/, "");
+    const after = text.slice(block.to).replace(/^\n+/, "");
+    if (before.length === 0 && after.length === 0) return "";
+    if (before.length === 0) text = after.endsWith("\n") ? after : after + "\n";
+    else if (after.length === 0) text = before + "\n";
+    else text = before + "\n\n" + after + (after.endsWith("\n") ? "" : "\n");
+  }
+  return text;
+}
+
+// src/hooks/engine.ts
+var SESSION_START_PEEK_LIMIT = 100;
+var STOP_PEEK_LIMIT = 50;
+var DEFAULT_MAX_CONTINUATIONS = 5;
+function hooksDisabled() {
+  return process.env["AGENTCHAT_HOOKS_ENABLED"] === "0";
+}
+function maxContinuations() {
+  const raw = process.env["AGENTCHAT_HOOK_MAX_CONTINUATIONS"];
+  if (raw === void 0) return DEFAULT_MAX_CONTINUATIONS;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 0 ? n : DEFAULT_MAX_CONTINUATIONS;
+}
+async function resolveHandle(cfg, cachedHandle) {
+  if (cachedHandle) return cachedHandle;
+  const me = await getMeLite(cfg);
+  return me?.handle ?? null;
+}
+function ackableRows(rows) {
+  const usable = rows.filter((r) => typeof r.delivery_id === "string" && r.delivery_id.length > 0);
+  if (usable.length < rows.length) {
+    log.warn(`${rows.length - usable.length} sync row(s) without delivery_id excluded from digest`);
+  }
+  return usable;
+}
+async function claimContiguousPrefix(cfg, rows, holder) {
+  const won = await Promise.all(rows.map((r) => claimReply(cfg, r.id, holder)));
+  const prefix = [];
+  for (let i = 0; i < rows.length; i++) {
+    if (!won[i]) break;
+    prefix.push(rows[i]);
+  }
+  if (prefix.length < rows.length) {
+    log.info(
+      `coexistence: daemon owns ${rows.length - prefix.length} row(s); surfacing ${prefix.length}`
+    );
+  }
+  return prefix;
+}
+async function sessionStart(ctx, input) {
+  const none = { context: null };
+  try {
+    if (hooksDisabled()) return none;
+    if (input.source === "compact") return none;
+    resetSession(ctx.home, input.sessionId);
+    const identity = resolveIdentity(ctx.home);
+    if (identity === null) {
+      if (shouldOfferRegistration(ctx.home)) {
+        recordRegistrationOffer(ctx.home);
+        return { context: formatRegistrationOffer(ctx.copy) };
+      }
+      return none;
+    }
+    const cfg = { apiKey: identity.apiKey, apiBase: identity.apiBase };
+    await markSessionActive(cfg);
+    const h = alwaysOnHealth(ctx.home);
+    const alert = h.wanted && !h.healthy ? formatAlwaysOnDown(ctx.copy) : null;
+    const peeked = ackableRows(await syncPeek(cfg, { limit: SESSION_START_PEEK_LIMIT }));
+    const rows = peeked.length > 0 ? await claimContiguousPrefix(cfg, peeked, `session:${input.sessionId}`) : [];
+    if (rows.length === 0) return { context: alert };
+    const handle = await resolveHandle(cfg, identity.handle);
+    const digest = formatSessionStart(handle, rows);
+    const context = alert !== null ? `${alert}
+
+${digest}` : digest;
+    const cursor = lastDeliveryId(rows);
+    if (cursor !== null) setPendingAck(ctx.home, input.sessionId, cursor);
+    return { context };
+  } catch (err) {
+    log.warn(`session-start hook degraded to no-op: ${String(err)}`);
+    return none;
+  }
+}
+async function userPrompt(ctx, input) {
+  try {
+    if (hooksDisabled()) return;
+    const identity = resolveIdentity(ctx.home);
+    if (identity === null) return;
+    const cursor = takePendingAck(ctx.home, input.sessionId);
+    if (cursor === null) return;
+    const cfg = { apiKey: identity.apiKey, apiBase: identity.apiBase };
+    try {
+      await syncAck(cfg, cursor);
+    } catch (err) {
+      setPendingAck(ctx.home, input.sessionId, cursor);
+      log.warn(`user-prompt ack failed (will retry next prompt): ${String(err)}`);
+    }
+  } catch (err) {
+    log.warn(`user-prompt hook degraded to no-op: ${String(err)}`);
+  }
+}
+async function stop(ctx, input) {
+  const none = { reason: null, commit: async () => {
+  } };
+  try {
+    if (hooksDisabled()) return none;
+    const identity = resolveIdentity(ctx.home);
+    if (identity === null) return none;
+    const cfg = { apiKey: identity.apiKey, apiBase: identity.apiBase };
+    await markSessionActive(cfg);
+    const cap = maxContinuations();
+    if (getContinuations(ctx.home, input.sessionId) >= cap) {
+      log.info(
+        `stop hook: continuation cap (${cap}) reached for ${input.sessionId}; leaving inbox queued`
+      );
+      return none;
+    }
+    const peeked = ackableRows(await syncPeek(cfg, { limit: STOP_PEEK_LIMIT }));
+    if (peeked.length === 0) return none;
+    const rows = await claimContiguousPrefix(cfg, peeked, `session:${input.sessionId}`);
+    if (rows.length === 0) return none;
+    recordContinuation(ctx.home, input.sessionId);
+    const handle = await resolveHandle(cfg, identity.handle);
+    const reason = formatStopPickup(handle, rows);
+    const cursor = lastDeliveryId(rows);
+    return {
+      reason,
+      commit: async () => {
+        if (cursor === null) return;
+        try {
+          await syncAck(cfg, cursor);
+        } catch (err) {
+          log.warn(`stop ack failed (messages stay queued): ${String(err)}`);
+        }
+      }
+    };
+  } catch (err) {
+    log.warn(`stop hook degraded to no-op: ${String(err)}`);
+    return none;
+  }
+}
+
+// src/hooks/hook-input.ts
+async function readHookInput(stream = process.stdin) {
+  let raw = "";
+  if (!stream.isTTY) {
+    try {
+      const chunks = [];
+      for await (const chunk of stream) {
+        chunks.push(Buffer.from(chunk));
+        if (Buffer.concat(chunks).length > 1e6) break;
+      }
+      raw = Buffer.concat(chunks).toString("utf-8");
+    } catch {
+      raw = "";
+    }
+  }
+  let parsed = {};
+  if (raw.trim().length > 0) {
+    try {
+      const value = JSON.parse(raw);
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        parsed = value;
+      }
+    } catch {
+      log.debug("hook stdin was not valid JSON; proceeding with defaults");
+    }
+  }
+  const sessionId = firstString(parsed, ["session_id", "sessionId", "thread_id", "conversation_id"]) ?? "unknown";
+  const source = firstString(parsed, ["source"]) ?? void 0;
+  return { sessionId, source };
+}
+function firstString(obj, keys) {
+  for (const key of keys) {
+    const value = obj[key];
+    if (typeof value === "string" && value.trim().length > 0) return value.trim();
+  }
+  return null;
+}
+
+// src/hooks/runners.ts
+function createHookRunners(context, dialect) {
+  return {
+    async runSessionStart() {
+      try {
+        const input = await readHookInput();
+        const { context: text } = await sessionStart(context(), input);
+        if (text !== null) dialect.printJson(dialect.sessionStartOutput(text));
+      } catch (err) {
+        log.warn(`session-start hook degraded to no-op: ${String(err)}`);
+      }
+    },
+    async runUserPrompt() {
+      try {
+        const input = await readHookInput();
+        await userPrompt(context(), input);
+      } catch (err) {
+        log.warn(`user-prompt hook degraded to no-op: ${String(err)}`);
+      }
+    },
+    async runStop() {
+      try {
+        const input = await readHookInput();
+        const { reason, commit } = await stop(context(), input);
+        if (reason === null) return;
+        dialect.printJson(dialect.stopOutput(reason));
+        await commit();
+      } catch (err) {
+        log.warn(`stop hook degraded to no-op: ${String(err)}`);
+      }
+    }
+  };
+}
+
+// src/identity/commands.ts
+import * as readline from "readline";
+import { AgentChatClient } from "agentchatme";
+
+// src/identity/host-profile.ts
+function anchorLabelOf(profile) {
+  if (profile.anchorLabel !== void 0) return profile.anchorLabel;
+  const file = profile.anchorFile();
+  const slash = Math.max(file.lastIndexOf("/"), file.lastIndexOf("\\"));
+  return slash >= 0 ? file.slice(slash + 1) : file;
+}
+
+// src/identity/commands.ts
+var HANDLE_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+function validHandle(handle) {
+  return handle.length >= 3 && handle.length <= 30 && HANDLE_PATTERN.test(handle);
+}
+async function prompt(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await new Promise((resolve2) => rl.question(question, resolve2));
+    return answer.trim();
+  } finally {
+    rl.close();
+  }
+}
+function describeApiError(err, invocation) {
+  const e = err ?? {};
+  const code = typeof e.code === "string" ? e.code : void 0;
+  const message = typeof e.message === "string" ? e.message : String(err);
+  switch (code) {
+    case "HANDLE_TAKEN":
+      return "That handle is already taken \u2014 pick another and re-run.";
+    case "EMAIL_TAKEN":
+      return `This email already has an active agent. Use \`${invocation} login\` with its key, or \`${invocation} recover --email <email>\` to re-key it.`;
+    case "EMAIL_EXHAUSTED":
+      return "This email has used its lifetime maximum of 3 registrations.";
+    case "INVALID_HANDLE":
+      return "The server rejected the handle (invalid or reserved word).";
+    case "INVALID_CODE":
+      return `Wrong or expired code. Re-check the 6 digits; after too many misses you must restart with \`${invocation} register\`.`;
+    case "EXPIRED":
+      return `This registration expired (codes last 10 minutes). Start over with \`${invocation} register\`.`;
+    default:
+      return code ? `${code}: ${message}` : message;
+  }
+}
+var RESTART_HINT = "Your messaging tools pick this up immediately \u2014 no restart needed. (If a send still says NOT_REGISTERED, you\u2019re on an older MCP; start a fresh session once to refresh it.)";
+function createIdentityCommands(profile) {
+  const invocation = () => profile.invocation();
+  const apiErr = (err) => describeApiError(err, invocation());
+  const LABEL = profile.label;
+  function writeOurAnchor(handle) {
+    const file = profile.anchorFile();
+    const label = anchorLabelOf(profile);
+    if (profile.isWired !== void 0 && !profile.isWired() && !hasAnchorAt(file)) return [];
+    try {
+      writeAnchor(file, profile.renderAnchor(handle), handle);
+      return [`  ${label}: @${handle} \u2192 ${file}`];
+    } catch (err) {
+      return [`  ${label}: FAILED \u2014 ${String(err)}`];
+    }
+  }
+  async function runRegister(opts) {
+    const home = profile.home();
+    const apiBase = opts.apiBase ?? process.env["AGENTCHAT_API_BASE"] ?? DEFAULT_API_BASE;
+    if (opts.code !== void 0) {
+      const code = opts.code.trim();
+      if (!/^\d{6}$/.test(code)) {
+        console.error("The code is the 6-digit number from the verification email.");
+        return 1;
+      }
+      const pending = readPending(home);
+      if (pending === null) {
+        console.error(
+          `No registration in progress. Start with: ${invocation()} register --email <email> --handle <handle>`
+        );
+        return 1;
+      }
+      if (pending.kind === "recover") {
+        console.error(
+          `The pending code belongs to an account RECOVERY \u2014 complete it with: ${invocation()} recover --code ${code}`
+        );
+        return 1;
+      }
+      const pendingHandle = pending.handle;
+      if (pendingHandle === void 0) {
+        clearPending(home);
+        console.error(`Pending registration was corrupt \u2014 start again with: ${invocation()} register`);
+        return 1;
+      }
+      try {
+        const result = await AgentChatClient.verify(pending.pending_id, code, {
+          baseUrl: pending.api_base ?? apiBase
+        });
+        writeCredentials(home, {
+          api_key: result.apiKey,
+          handle: pendingHandle,
+          ...pending.api_base ? { api_base: pending.api_base } : {},
+          created_at: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        clearPending(home);
+        console.log(
+          [
+            `Registered: @${pendingHandle} for ${LABEL}.`,
+            `API key stored at ${credentialsPath(home)} (never commit this file).`,
+            ...writeOurAnchor(pendingHandle),
+            "",
+            `This handle belongs to your ${LABEL} agent. Another coding agent on this machine is a separate peer with its own handle \u2014 you can DM each other.`,
+            `Other agents can DM you at @${pendingHandle}. Check \`${invocation()} status\` any time.`,
+            RESTART_HINT
+          ].join("\n")
+        );
+        return 0;
+      } catch (err) {
+        console.error(`Verification failed. ${apiErr(err)}`);
+        return 1;
+      }
+    }
+    if (resolveIdentity(home) !== null) {
+      console.error(
+        `${LABEL} already has an AgentChat identity (see \`${invocation()} status\`). Run \`${invocation()} logout\` first to replace it.`
+      );
+      return 1;
+    }
+    const inFlight = readPending(home);
+    if (inFlight?.kind === "recover") {
+      console.error(
+        `An account recovery is in progress \u2014 finish it with \`${invocation()} recover --code <code>\`, or discard it with \`${invocation()} logout\` before registering.`
+      );
+      return 1;
+    }
+    let email = opts.email?.trim().toLowerCase();
+    let handle = opts.handle?.trim().toLowerCase();
+    const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true;
+    if (!email) {
+      if (!interactive) {
+        console.error(`Missing --email. Usage: ${invocation()} register --email <email> --handle <handle>`);
+        return 1;
+      }
+      email = (await prompt("Email for verification codes: ")).toLowerCase();
+    }
+    if (!handle) {
+      if (!interactive) {
+        console.error(`Missing --handle. Usage: ${invocation()} register --email <email> --handle <handle>`);
+        return 1;
+      }
+      handle = (await prompt("Desired handle (3\u201330 chars, e.g. sanim-dev): ")).toLowerCase();
+    }
+    if (!email.includes("@")) {
+      console.error(`"${email}" does not look like an email address.`);
+      return 1;
+    }
+    if (!validHandle(handle)) {
+      console.error(
+        `Handle "@${handle}" is invalid. Rules: 3\u201330 characters, lowercase letters/digits/hyphens, must start with a letter, no trailing or doubled hyphens.`
+      );
+      return 1;
+    }
+    try {
+      const result = await AgentChatClient.register({
+        email,
+        handle,
+        ...opts.displayName ? { display_name: opts.displayName } : {},
+        ...opts.description ? { description: opts.description } : {},
+        baseUrl: apiBase
+      });
+      writePending(home, {
+        kind: "register",
+        pending_id: result.pending_id,
+        email,
+        handle,
+        ...apiBase !== DEFAULT_API_BASE ? { api_base: apiBase } : {},
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      console.log(
+        [
+          `Verification code sent to ${email} (valid ~10 minutes).`,
+          `Complete with: ${invocation()} register --code <6-digit-code>`
+        ].join("\n")
+      );
+      return 0;
+    } catch (err) {
+      console.error(`Registration failed. ${apiErr(err)}`);
+      return 1;
+    }
+  }
+  async function runLogin(opts) {
+    const home = profile.home();
+    const apiBase = opts.apiBase ?? process.env["AGENTCHAT_API_BASE"] ?? DEFAULT_API_BASE;
+    let apiKey = opts.apiKey?.trim();
+    if (!apiKey) {
+      if (process.stdin.isTTY !== true) {
+        console.error(`Missing --api-key. Usage: ${invocation()} login --api-key ac_live_\u2026`);
+        return 1;
+      }
+      apiKey = await prompt("AgentChat API key (ac_\u2026): ");
+    }
+    if (apiKey.length < 20) {
+      console.error("That does not look like an AgentChat API key (too short).");
+      return 1;
+    }
+    try {
+      const client = new AgentChatClient({ apiKey, baseUrl: apiBase });
+      const me = await client.getMe();
+      writeCredentials(home, {
+        api_key: apiKey,
+        handle: me.handle,
+        ...apiBase !== DEFAULT_API_BASE ? { api_base: apiBase } : {},
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      console.log([`Signed in as @${me.handle} for ${LABEL}.`, ...writeOurAnchor(me.handle), RESTART_HINT].join("\n"));
+      return 0;
+    } catch (err) {
+      console.error(`Login failed. ${apiErr(err)}`);
+      return 1;
+    }
+  }
+  async function runRecover(opts) {
+    const home = profile.home();
+    const apiBase = opts.apiBase ?? process.env["AGENTCHAT_API_BASE"] ?? DEFAULT_API_BASE;
+    if (opts.code !== void 0) {
+      const code = opts.code.trim();
+      if (!/^\d{6}$/.test(code)) {
+        console.error("The code is the 6-digit number from the recovery email.");
+        return 1;
+      }
+      const pending = readPending(home);
+      if (pending === null || pending.kind !== "recover") {
+        console.error(`No recovery in progress. Start with: ${invocation()} recover --email <email>`);
+        return 1;
+      }
+      try {
+        const result = await AgentChatClient.recoverVerify(pending.pending_id, code, {
+          baseUrl: pending.api_base ?? apiBase
+        });
+        writeCredentials(home, {
+          api_key: result.apiKey,
+          handle: result.handle,
+          ...pending.api_base ? { api_base: pending.api_base } : {},
+          created_at: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        clearPending(home);
+        console.log(
+          [
+            `Recovered: @${result.handle} for ${LABEL} \u2014 a fresh API key is stored (the old key is now revoked).`,
+            ...writeOurAnchor(result.handle),
+            RESTART_HINT
+          ].join("\n")
+        );
+        return 0;
+      } catch (err) {
+        console.error(`Recovery failed. ${apiErr(err)}`);
+        return 1;
+      }
+    }
+    let email = opts.email?.trim().toLowerCase();
+    if (!email) {
+      if (process.stdin.isTTY !== true) {
+        console.error(`Missing --email. Usage: ${invocation()} recover --email <email>`);
+        return 1;
+      }
+      email = (await prompt("Email the agent was registered with: ")).toLowerCase();
+    }
+    if (!email.includes("@")) {
+      console.error(`"${email}" does not look like an email address.`);
+      return 1;
+    }
+    try {
+      const result = await AgentChatClient.recover(email, { baseUrl: apiBase });
+      if (!result.pending_id) {
+        console.log("If an agent is registered with that email, a recovery code was sent to it.");
+        return 0;
+      }
+      writePending(home, {
+        kind: "recover",
+        pending_id: result.pending_id,
+        email,
+        ...apiBase !== DEFAULT_API_BASE ? { api_base: apiBase } : {},
+        created_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      console.log(
+        [
+          "Recovery code sent (valid ~10 minutes).",
+          `Complete with: ${invocation()} recover --code <6-digit-code>`,
+          "Note: completing recovery rotates the API key \u2014 anything using the old key stops working."
+        ].join("\n")
+      );
+      return 0;
+    } catch (err) {
+      console.error(`Recovery failed. ${apiErr(err)}`);
+      return 1;
+    }
+  }
+  async function runStatus(opts) {
+    const home = profile.home();
+    const anchorFile = profile.anchorFile();
+    const identity = resolveIdentity(home);
+    const pending = readPending(home);
+    if (identity === null) {
+      if (opts.json) {
+        console.log(
+          JSON.stringify({ configured: false, pending: pending !== null, pending_kind: pending?.kind ?? null })
+        );
+      } else if (pending?.kind === "recover") {
+        console.log(
+          `No identity yet, but an account recovery is waiting on its emailed code \u2014 finish with: ${invocation()} recover --code <code>`
+        );
+      } else if (pending !== null) {
+        console.log(
+          `No identity yet, but a registration for @${pending.handle ?? "?"} is waiting on its emailed code \u2014 finish with: ${invocation()} register --code <code>`
+        );
+      } else {
+        console.log(`No AgentChat identity for this ${LABEL} agent. Set one up with: ${invocation()} register`);
+      }
+      return 0;
+    }
+    try {
+      const client = new AgentChatClient({ apiKey: identity.apiKey, baseUrl: identity.apiBase });
+      const me = await client.getMe();
+      const rows = await syncPeek({ apiKey: identity.apiKey, apiBase: identity.apiBase }, { limit: 100 });
+      const unread = rows.length === 100 ? "100+" : String(rows.length);
+      if (opts.json) {
+        console.log(
+          JSON.stringify({
+            configured: true,
+            // Was hard-coded, and the Claude Code copy said 'codex'.
+            host: profile.id,
+            handle: me.handle,
+            status: me.status ?? "unknown",
+            unread: rows.length,
+            unread_capped: rows.length === 100,
+            key_source: identity.source,
+            api_base: identity.apiBase,
+            home,
+            anchor: hasAnchorAt(anchorFile)
+          })
+        );
+      } else {
+        console.log(
+          [
+            `@${me.handle} \u2014 ${me.status ?? "active"}  (${LABEL})`,
+            `Unread: ${unread} message(s) queued`,
+            `Key source: ${identity.source} (${identity.source === "file" ? credentialsPath(home) : "AGENTCHAT_API_KEY"})`,
+            `API: ${identity.apiBase}`,
+            `Anchor: ${hasAnchorAt(anchorFile) ? "yes" : "no"} (${anchorFile})`
+          ].join("\n")
+        );
+      }
+      return 0;
+    } catch (err) {
+      console.error(`Could not reach AgentChat: ${apiErr(err)}`);
+      return 1;
+    }
+  }
+  function runLogout() {
+    const home = profile.home();
+    const anchorFile = profile.anchorFile();
+    const reports = [];
+    let any = false;
+    if (clearCredentials(home)) {
+      any = true;
+      reports.push("  credentials deleted");
+    }
+    if (profile.removeWiring !== void 0) {
+      try {
+        const removed = profile.removeWiring();
+        if (removed.length > 0) reports.push(`  removed ${removed.join(", ")}`);
+      } catch {
+        reports.push(`  could not fully clean up the ${LABEL} wiring`);
+      }
+    }
+    if (removeAnchorAt(anchorFile) === "removed") {
+      reports.push(`  ${anchorLabelOf(profile)} anchor removed`);
+    }
+    console.log(
+      [
+        any ? `Signed out of ${LABEL}.` : "Nothing to sign out of.",
+        ...reports,
+        ...any ? [
+          "Any other coding agent on this machine is untouched \u2014 it is a separate AgentChat agent with its own handle.",
+          ...profile.logoutHints?.() ?? []
+        ] : []
+      ].join("\n")
+    );
+    return 0;
+  }
+  async function runDoctor(opts = {}) {
+    const home = profile.home();
+    const anchorFile = profile.anchorFile();
+    const checks = [];
+    checks.push({ name: "node", verdict: "PASS", detail: process.version });
+    checks.push({ name: "home", verdict: "PASS", detail: home });
+    const creds = readCredentials(home);
+    if (creds === null) {
+      checks.push({
+        name: "credentials",
+        verdict: "FAIL",
+        detail: `no identity at ${credentialsPath(home)} \u2014 run \`${invocation()} register\``
+      });
+    } else {
+      checks.push({ name: "credentials", verdict: "PASS", detail: `@${creds.handle}` });
+      const identity = resolveIdentity(home);
+      if (identity !== null) {
+        try {
+          const client = new AgentChatClient({ apiKey: identity.apiKey, baseUrl: identity.apiBase });
+          const started = Date.now();
+          const me = await client.getMe();
+          const verdict = (me.status ?? "active") === "active" ? "PASS" : "WARN";
+          checks.push({
+            name: "api-auth",
+            verdict,
+            detail: `@${me.handle} status=${me.status ?? "active"} (${Date.now() - started}ms)`
+          });
+          if (me.handle !== creds.handle) {
+            checks.push({
+              name: "handle-drift",
+              verdict: "WARN",
+              detail: `credentials say @${creds.handle} but the key authenticates as @${me.handle} \u2014 re-run \`${invocation()} login\``
+            });
+          }
+        } catch (err) {
+          checks.push({ name: "api-auth", verdict: "FAIL", detail: `getMe failed: ${String(err)}` });
+        }
+      }
+      const claimed = readAnchorHandleAt(anchorFile);
+      if (claimed === creds.handle) {
+        checks.push({ name: "anchor", verdict: "PASS", detail: `@${claimed} in ${anchorFile}` });
+      } else {
+        const why = claimed === null ? `no identity block in ${anchorFile}` : `${anchorFile} says @${claimed} but this agent is @${creds.handle}`;
+        if (opts.fix === true) {
+          const report = writeOurAnchor(creds.handle);
+          const failed = report.some((l) => l.includes("FAILED"));
+          checks.push({
+            name: "anchor",
+            verdict: failed ? "FAIL" : "PASS",
+            detail: failed ? `could not repair: ${report.join("; ")}` : `repaired \u2192 @${creds.handle}`
+          });
+        } else {
+          checks.push({
+            name: "anchor",
+            verdict: "WARN",
+            detail: `${why} \u2014 repair with \`${invocation()} doctor --fix\``
+          });
+        }
+      }
+    }
+    if (profile.extraDoctorChecks !== void 0) checks.push(...profile.extraDoctorChecks());
+    console.log(checks.map((c) => `${c.verdict.padEnd(4)} ${c.name}: ${c.detail}`).join("\n"));
+    return checks.some((c) => c.verdict === "FAIL") ? 1 : 0;
+  }
+  return { runRegister, runLogin, runRecover, runStatus, runLogout, runDoctor };
+}
+
+// src/daemon/service.ts
+import * as fs2 from "fs";
+import * as os from "os";
+import * as path2 from "path";
+import { spawnSync, spawn } from "child_process";
+function planForTest(opts) {
+  return plan(opts);
+}
+function plan(opts) {
+  const env = {};
+  if (process.env["PATH"]) env["PATH"] = process.env["PATH"];
+  for (const [k, v] of Object.entries(opts.env ?? {})) {
+    if (typeof v === "string" && v.length > 0) env[k] = v;
+  }
+  return {
+    label: opts.label,
+    node: process.execPath,
+    bin: path2.resolve(opts.entry),
+    home: path2.resolve(opts.home),
+    env
+  };
+}
+function run(cmd, args) {
+  const r = spawnSync(cmd, args, { encoding: "utf-8" });
+  return { ok: !r.error && r.status === 0, out: `${r.stdout ?? ""}${r.stderr ?? ""}`.trim() };
+}
+function registrationSkipped() {
+  const v = process.env["AGENTCHAT_SERVICE_DRY_RUN"];
+  return v !== void 0 && v !== "" && v !== "0";
+}
+function systemdUnitPath(label) {
+  return path2.join(os.homedir(), ".config", "systemd", "user", `${label}.service`);
+}
+function systemdUnit(p) {
+  const envLines = Object.entries(p.env).map(([k, v]) => `Environment=${k}=${v}`).join("\n");
+  return [
+    "[Unit]",
+    `Description=AgentChat always-on daemon (${p.label})`,
+    "After=network-online.target",
+    "Wants=network-online.target",
+    "",
+    "[Service]",
+    "Type=simple",
+    `ExecStart=${p.node} ${p.bin} --home ${p.home}`,
+    ...envLines ? [envLines] : [],
+    "Restart=on-failure",
+    "RestartSec=5",
+    "",
+    "[Install]",
+    "WantedBy=default.target",
+    ""
+  ].join("\n");
+}
+function installSystemd(p) {
+  const unitPath = systemdUnitPath(p.label);
+  fs2.mkdirSync(path2.dirname(unitPath), { recursive: true });
+  fs2.writeFileSync(unitPath, systemdUnit(p));
+  log.info(`wrote ${unitPath}`);
+  if (registrationSkipped()) return;
+  run("systemctl", ["--user", "daemon-reload"]);
+  const linger = run("loginctl", ["enable-linger", os.userInfo().username]);
+  if (!linger.ok) {
+    log.warn(`could not enable-linger (service won't survive logout until you run: sudo loginctl enable-linger ${os.userInfo().username})`);
+  }
+  const enabled = run("systemctl", ["--user", "enable", "--now", p.label]);
+  if (!enabled.ok) throw new Error(`systemctl enable failed: ${enabled.out}`);
+  log.info(`service ${p.label} enabled + started`);
+}
+function uninstallSystemd(label) {
+  run("systemctl", ["--user", "disable", "--now", label]);
+  const unitPath = systemdUnitPath(label);
+  if (fs2.existsSync(unitPath)) fs2.rmSync(unitPath);
+  run("systemctl", ["--user", "daemon-reload"]);
+  log.info(`service ${label} removed`);
+}
+function statusSystemd(label) {
+  const active = run("systemctl", ["--user", "is-active", label]).out || "unknown";
+  const enabled = run("systemctl", ["--user", "is-enabled", label]).out || "unknown";
+  return `systemd ${label}: ${active} (${enabled})`;
+}
+function launchdPlistPath(label) {
+  return path2.join(os.homedir(), "Library", "LaunchAgents", `${launchdLabel(label)}.plist`);
+}
+var launchdLabel = (label) => `me.agentchat.${label}`;
+function launchdPlist(p) {
+  const args = [p.node, p.bin, "--home", p.home];
+  const argXml = args.map((a) => `    <string>${a}</string>`).join("\n");
+  const envXml = Object.entries(p.env).map(([k, v]) => `    <key>${k}</key><string>${v}</string>`).join("\n");
+  const logPath = path2.join(p.home, "daemon.log");
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    '<plist version="1.0"><dict>',
+    `  <key>Label</key><string>${launchdLabel(p.label)}</string>`,
+    "  <key>ProgramArguments</key><array>",
+    argXml,
+    "  </array>",
+    ...envXml ? ["  <key>EnvironmentVariables</key><dict>", envXml, "  </dict>"] : [],
+    "  <key>RunAtLoad</key><true/>",
+    "  <key>KeepAlive</key><true/>",
+    `  <key>StandardErrorPath</key><string>${logPath}</string>`,
+    `  <key>StandardOutPath</key><string>${logPath}</string>`,
+    "</dict></plist>",
+    ""
+  ].join("\n");
+}
+function installLaunchd(p) {
+  const plistPath = launchdPlistPath(p.label);
+  fs2.mkdirSync(path2.dirname(plistPath), { recursive: true });
+  fs2.writeFileSync(plistPath, launchdPlist(p));
+  log.info(`wrote ${plistPath}`);
+  if (registrationSkipped()) return;
+  run("launchctl", ["unload", plistPath]);
+  const loaded = run("launchctl", ["load", "-w", plistPath]);
+  if (!loaded.ok) throw new Error(`launchctl load failed: ${loaded.out}`);
+  log.info(`service ${launchdLabel(p.label)} loaded + started`);
+}
+function uninstallLaunchd(label) {
+  const plistPath = launchdPlistPath(label);
+  run("launchctl", ["unload", "-w", plistPath]);
+  if (fs2.existsSync(plistPath)) fs2.rmSync(plistPath);
+  log.info(`service ${launchdLabel(label)} removed`);
+}
+function statusLaunchd(label) {
+  const r = run("launchctl", ["list", launchdLabel(label)]);
+  return `launchd ${launchdLabel(label)}: ${r.ok ? "loaded" : "not loaded"}`;
+}
+function isWslFromVersion(version) {
+  return /microsoft|wsl/i.test(version);
+}
+function isWsl() {
+  if (process.platform !== "linux") return false;
+  try {
+    return isWslFromVersion(fs2.readFileSync("/proc/version", "utf-8"));
+  } catch {
+    return false;
+  }
+}
+function winMode() {
+  if (process.platform === "win32") return "win32";
+  if (isWsl()) return "wsl";
+  return null;
+}
+function winMasterDir() {
+  return path2.join(os.homedir(), ".agentchat", "daemon");
+}
+function winStartupDir(mode) {
+  if (mode === "win32") {
+    return path2.join(os.homedir(), "AppData", "Roaming", "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
+  }
+  const appdata = run("cmd.exe", ["/c", "echo %APPDATA%"]).out.split(/\r?\n/).pop()?.trim() ?? "";
+  const base = run("wslpath", ["-u", appdata]).out.trim();
+  if (!base) throw new Error("could not locate the Windows Startup folder from WSL (is /mnt/c mounted?)");
+  return path2.join(base, "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
+}
+var vbsEscape = (s) => s.replace(/"/g, '""');
+var shQuote = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+function launcherVbs(command, env) {
+  const envLines = Object.entries(env).map(
+    ([k, v]) => `sh.Environment("Process").Item("${k}") = "${vbsEscape(v)}"`
+  );
+  return [
+    "' AgentChat always-on launcher \u2014 runs hidden, restarts on exit.",
+    'Set sh = CreateObject("WScript.Shell")',
+    ...envLines,
+    "Do",
+    `  sh.Run "${vbsEscape(command)}", 0, True`,
+    "  WScript.Sleep 5000",
+    "Loop"
+  ].join("\r\n") + "\r\n";
+}
+function winCommandNative(p) {
+  return `"${p.node}" "${p.bin}" --home "${p.home}"`;
+}
+function wslScriptContent(p) {
+  const exports = Object.entries(p.env).map(([k, v]) => `export ${k}=${shQuote(v)}`);
+  return ["#!/bin/bash", ...exports, `exec ${shQuote(p.node)} ${shQuote(p.bin)} --home ${shQuote(p.home)}`].join(
+    "\n"
+  ) + "\n";
+}
+function startDetached(cmd, args) {
+  if (process.env["AGENTCHATD_SERVICE_NO_START"] === "1") return;
+  try {
+    spawn(cmd, args, { detached: true, stdio: "ignore", windowsHide: true }).unref();
+  } catch (err) {
+    log.warn(`could not start the launcher now (it starts at next login): ${String(err)}`);
+  }
+}
+function winPathFromWsl(linuxPath) {
+  return run("wslpath", ["-w", linuxPath]).out.trim() || linuxPath;
+}
+function killLauncher(label, mode) {
+  const ps = `Get-CimInstance Win32_Process -Filter "Name='wscript.exe'" | Where-Object { $_.CommandLine -like '*${label}.vbs*' } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force }`;
+  run(mode === "win32" ? "powershell" : "powershell.exe", ["-NoProfile", "-Command", ps]);
+}
+function installWindows(p, mode) {
+  const master = winMasterDir();
+  fs2.mkdirSync(master, { recursive: true });
+  const masterVbs = path2.join(master, `${p.label}.vbs`);
+  if (mode === "win32") {
+    fs2.writeFileSync(masterVbs, launcherVbs(winCommandNative(p), p.env));
+  } else {
+    const scriptPath = path2.join(master, `${p.label}.sh`);
+    fs2.writeFileSync(scriptPath, wslScriptContent(p), { mode: 493 });
+    const distro = process.env["WSL_DISTRO_NAME"] ?? "";
+    if (!distro) throw new Error("WSL_DISTRO_NAME is not set \u2014 cannot target the right WSL distro");
+    fs2.writeFileSync(masterVbs, launcherVbs(`wsl.exe -d ${distro} -e bash "${scriptPath}"`, {}));
+  }
+  log.info(`wrote ${masterVbs}`);
+  enableWindows(p.label, mode);
+  log.info(`service ${p.label} installed (starts at login)`);
+}
+function enableWindows(label, mode) {
+  const masterVbs = path2.join(winMasterDir(), `${label}.vbs`);
+  if (!fs2.existsSync(masterVbs)) throw new Error(`no ${label} daemon installed \u2014 run install first`);
+  const startup = winStartupDir(mode);
+  fs2.mkdirSync(startup, { recursive: true });
+  const startupVbs = path2.join(startup, `${label}.vbs`);
+  fs2.copyFileSync(masterVbs, startupVbs);
+  if (registrationSkipped()) return;
+  if (mode === "win32") startDetached("wscript.exe", [startupVbs]);
+  else startDetached("cmd.exe", ["/c", "start", "", "/b", "wscript.exe", winPathFromWsl(startupVbs)]);
+}
+function disableWindows(label, mode) {
+  const startupVbs = path2.join(winStartupDir(mode), `${label}.vbs`);
+  if (fs2.existsSync(startupVbs)) fs2.rmSync(startupVbs);
+  killLauncher(label, mode);
+}
+function uninstallWindows(label, mode) {
+  try {
+    disableWindows(label, mode);
+  } catch {
+  }
+  for (const f of [`${label}.vbs`, `${label}.sh`]) {
+    const m = path2.join(winMasterDir(), f);
+    if (fs2.existsSync(m)) fs2.rmSync(m);
+  }
+}
+function statusWindows(label, mode) {
+  const installed = fs2.existsSync(path2.join(winMasterDir(), `${label}.vbs`));
+  let enabled = false;
+  try {
+    enabled = fs2.existsSync(path2.join(winStartupDir(mode), `${label}.vbs`));
+  } catch {
+  }
+  const host = mode === "wsl" ? "wsl" : "windows";
+  return `${host} ${label}: ${installed ? enabled ? "enabled" : "installed (disabled)" : "not installed"}`;
+}
+function installService(opts) {
+  const p = plan(opts);
+  if (!p.bin) throw new Error("no daemon entrypoint given (ServiceOpts.entry)");
+  const wm = winMode();
+  if (wm) return installWindows(p, wm);
+  if (process.platform === "linux") return installSystemd(p);
+  if (process.platform === "darwin") return installLaunchd(p);
+  throw new Error(`service install is not supported on ${process.platform} \u2014 run \`agentchatd start\` under your own supervisor`);
+}
+function uninstallService(opts) {
+  const label = opts.label;
+  const wm = winMode();
+  if (wm) return uninstallWindows(label, wm);
+  if (process.platform === "linux") return uninstallSystemd(label);
+  if (process.platform === "darwin") return uninstallLaunchd(label);
+  throw new Error(`service uninstall is not supported on ${process.platform}`);
+}
+function serviceStatus(opts) {
+  const label = opts.label;
+  const wm = winMode();
+  if (wm) return statusWindows(label, wm);
+  if (process.platform === "linux") return statusSystemd(label);
+  if (process.platform === "darwin") return statusLaunchd(label);
+  return `service management not supported on ${process.platform}`;
+}
+export {
+  ANCHOR_END,
+  ANCHOR_START,
+  DEFAULT_API_BASE,
+  HEARTBEAT_FILE,
+  WireError,
+  absoluteUtc,
+  acquireLeaderLock,
+  alwaysOnHealth,
+  alwaysOnWanted,
+  anchorLabelOf,
+  atomicWriteFile,
+  beat,
+  claimReply,
+  clearAlwaysOnWanted,
+  clearCredentials,
+  clearPending,
+  clearSessionActive,
+  contextOf,
+  createHookRunners,
+  createIdentityCommands,
+  credentialsPath,
+  formatAlwaysOnDown,
+  formatRegistrationOffer,
+  formatSessionStart,
+  formatStopPickup,
+  formatWhen,
+  getContinuations,
+  getMeLite,
+  hasAnchorAt,
+  hooksDisabled,
+  installService,
+  lastDeliveryId,
+  log,
+  markAlwaysOnWanted,
+  markSessionActive,
+  pendingPath,
+  planForTest,
+  readAnchorHandleAt,
+  readAnchorHandleFrom,
+  readCredentials,
+  readHookInput,
+  readJsonFile,
+  readPending,
+  readState,
+  recordContinuation,
+  recordRegistrationOffer,
+  relativeAge,
+  relativeWhen,
+  removeAnchorAt,
+  renderAnchorBlock,
+  resetSession,
+  resolveIdentity,
+  serviceStatus,
+  sessionStart,
+  setPendingAck,
+  shouldOfferRegistration,
+  statePath,
+  stop,
+  stripAnchorBlock,
+  syncAck,
+  syncPeek,
+  takePendingAck,
+  uninstallService,
+  upsertAnchorBlock,
+  userPrompt,
+  writeAnchor,
+  writeCredentials,
+  writePending,
+  writeState
+};
+//# sourceMappingURL=index.js.map