@birdybeep/agent-core 0.0.1

package/dist/index.js

@@ -0,0 +1,1027 @@
+// src/adapter.ts
+var INTEGRATION_STATUSES = [
+  "installed",
+  "not_detected",
+  "needs_restart",
+  "needs_trust",
+  "error",
+  "revoked",
+  "unknown"
+];
+
+// src/api.ts
+import { z } from "zod";
+var ERROR_CODES = [
+  "validation_failed",
+  "unauthorized",
+  "forbidden",
+  "token_revoked",
+  "not_found",
+  "payload_too_large",
+  "rate_limited",
+  "quota_exceeded",
+  "internal_error"
+];
+var errorCodeSchema = z.enum(ERROR_CODES);
+var errorEnvelopeSchema = z.object({
+  error: z.object({
+    code: errorCodeSchema,
+    message: z.string(),
+    details: z.unknown().optional()
+  }),
+  requestId: z.string().optional()
+});
+var successEnvelopeSchema = (data) => z.object({ data });
+var ERROR_STATUS = {
+  validation_failed: 400,
+  unauthorized: 401,
+  forbidden: 403,
+  token_revoked: 403,
+  not_found: 404,
+  payload_too_large: 413,
+  rate_limited: 429,
+  quota_exceeded: 429,
+  internal_error: 500
+};
+
+// src/dedup.ts
+import { createHash } from "crypto";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { dirname, join as join2 } from "path";
+
+// src/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+function baseDir(kind) {
+  const home = homedir();
+  if (process.platform === "win32") {
+    const local = process.env["LOCALAPPDATA"];
+    return local && local.length > 0 ? local : join(home, "AppData", "Local");
+  }
+  if (process.platform === "darwin") {
+    return join(home, "Library", "Application Support");
+  }
+  const xdg = kind === "data" ? process.env["XDG_DATA_HOME"] : process.env["XDG_CONFIG_HOME"];
+  if (xdg && xdg.length > 0) return xdg;
+  return join(home, kind === "data" ? join(".local", "share") : ".config");
+}
+function birdyBeepDataDir() {
+  return join(baseDir("data"), "birdybeep");
+}
+function birdyBeepConfigDir() {
+  return join(baseDir("config"), "birdybeep");
+}
+
+// src/dedup.ts
+var DEFAULT_DEDUP_WINDOW_MS = 1e4;
+var APPROVAL_COLLAPSE_WINDOW_MS = 1e3;
+function isLedgerEntry(v) {
+  return typeof v === "object" && v !== null && typeof v["id"] === "string" && typeof v["ts"] === "number";
+}
+function contentHash(title, body) {
+  return createHash("sha256").update(`${title}
+${body}`).digest("hex").slice(0, 16);
+}
+function eventIdentity(event) {
+  return `${event.harness}:${event.source_session_id}:${event.event_type}:${contentHash(
+    event.title,
+    event.body
+  )}`;
+}
+function approvalCollapseIdentity(event) {
+  return `${event.harness}:${event.source_session_id}:approval_required:any`;
+}
+var RecentEventLedger = class {
+  path;
+  #windowMs;
+  #now;
+  constructor(options = {}) {
+    this.path = options.path ?? join2(birdyBeepDataDir(), "recent-events.json");
+    this.#windowMs = options.windowMs ?? DEFAULT_DEDUP_WINDOW_MS;
+    this.#now = options.now ?? (() => Date.now());
+  }
+  #read() {
+    if (!existsSync(this.path)) return [];
+    try {
+      const parsed = JSON.parse(readFileSync(this.path, "utf8"));
+      return Array.isArray(parsed) ? parsed.filter(isLedgerEntry) : [];
+    } catch {
+      return [];
+    }
+  }
+  #write(entries) {
+    const dir = dirname(this.path);
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    if (process.platform !== "win32") chmodSync(dir, 448);
+    const tmp = `${this.path}.tmp`;
+    writeFileSync(tmp, JSON.stringify(entries), { mode: 384 });
+    renameSync(tmp, this.path);
+    if (process.platform !== "win32") chmodSync(this.path, 384);
+  }
+  /**
+   * If `identity` was recorded within the window, return true (it's a duplicate —
+   * caller should skip). Otherwise record it (pruning expired entries) and return
+   * false. `windowMs` narrows the duplicate check for THIS identity (e.g. the short
+   * approval-collapse window) — pruning always uses the ledger's own (max) window so
+   * a narrower check never evicts entries other checks still need. Fail-open: any
+   * I/O error returns false (allow the send).
+   */
+  markAndCheck(identity, windowMs = this.#windowMs) {
+    try {
+      const now = this.#now();
+      const pruneCutoff = now - this.#windowMs;
+      const dupCutoff = now - Math.min(windowMs, this.#windowMs);
+      const fresh = this.#read().filter((e) => e.ts >= pruneCutoff);
+      if (fresh.some((e) => e.id === identity && e.ts >= dupCutoff)) return true;
+      fresh.push({ id: identity, ts: now });
+      this.#write(fresh);
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  clear() {
+    try {
+      if (existsSync(this.path)) rmSync(this.path, { force: true });
+    } catch {
+    }
+  }
+  /** Whether the ledger file has secure (0600) perms. True on Windows (ACL-based). */
+  isSecure() {
+    if (process.platform === "win32") return true;
+    try {
+      return (statSync(this.path).mode & 63) === 0;
+    } catch {
+      return true;
+    }
+  }
+};
+
+// src/event.ts
+import { z as z3 } from "zod";
+
+// src/primitives.ts
+import { z as z2 } from "zod";
+var BIRDYBEEP_EVENT_TYPES = [
+  "session_started",
+  "session_resumed",
+  "session_active",
+  "needs_input",
+  "approval_required",
+  "agent_idle",
+  "agent_completed",
+  "agent_failed",
+  "test_failed",
+  "tool_started",
+  "tool_finished",
+  "subagent_started",
+  "subagent_completed",
+  "custom",
+  // "test" (9fh): the `birdybeep test` diagnostic. Notifies by default server-side
+  // (unlike "custom", which the §10.5 matrix suppresses unconditionally) and is
+  // quota-exempt — the product's DEFAULT_NOTIFY/gauntlet carry the other half.
+  "test"
+];
+var AGENT_SESSION_STATUSES = [
+  "starting",
+  "running",
+  "waiting_for_input",
+  "waiting_for_approval",
+  "idle",
+  "completed",
+  "failed",
+  "unknown"
+];
+var HARNESS_IDS = ["claude_code", "codex", "opencode"];
+var eventTypeSchema = z2.enum(BIRDYBEEP_EVENT_TYPES);
+var sessionStatusSchema = z2.enum(AGENT_SESSION_STATUSES);
+var harnessSchema = z2.enum(HARNESS_IDS);
+var isoDateTimeSchema = z2.iso.datetime({ offset: true });
+var MAX_AGENT_EVENT_BYTES = 16 * 1024;
+function isWithinMaxAgentEventSize(body) {
+  const bytes = typeof body === "number" ? body : body.byteLength;
+  return bytes <= MAX_AGENT_EVENT_BYTES;
+}
+
+// src/event.ts
+var machineSchema = z3.object({
+  label: z3.string().min(1),
+  os: z3.string().min(1)
+});
+var workspaceSchema = z3.object({
+  cwd: z3.string().min(1),
+  repo_name: z3.string().optional(),
+  branch: z3.string().optional()
+});
+var eventMetadataSchema = z3.object({
+  tool: z3.string().optional(),
+  command_summary: z3.string().optional()
+}).catchall(z3.unknown());
+var birdyBeepAgentEventSchema = z3.object({
+  event_id: z3.string().min(1),
+  event_type: eventTypeSchema,
+  occurred_at: isoDateTimeSchema,
+  harness: harnessSchema,
+  harness_version: z3.string().optional(),
+  source_session_id: z3.string().min(1),
+  machine: machineSchema,
+  workspace: workspaceSchema,
+  status: sessionStatusSchema,
+  title: z3.string(),
+  body: z3.string(),
+  metadata: eventMetadataSchema.optional()
+});
+var agentEventsRequestSchema = birdyBeepAgentEventSchema;
+
+// src/fingerprint.ts
+import { createHash as createHash2 } from "crypto";
+import { cpus, hostname, networkInterfaces, totalmem } from "os";
+function primaryMac() {
+  const ifaces = networkInterfaces();
+  for (const list of Object.values(ifaces)) {
+    for (const entry of list ?? []) {
+      if (!entry.internal && entry.mac && entry.mac !== "00:00:00:00:00:00") return entry.mac;
+    }
+  }
+  return null;
+}
+function collectMachineSignals() {
+  return {
+    hostname: hostname(),
+    platform: process.platform,
+    arch: process.arch,
+    cpuModel: cpus()[0]?.model ?? "unknown",
+    totalmem: totalmem(),
+    mac: primaryMac()
+  };
+}
+function fingerprintFromSignals(signals) {
+  const material = [
+    signals.platform,
+    signals.arch,
+    signals.hostname,
+    signals.cpuModel,
+    String(signals.totalmem),
+    signals.mac ?? ""
+  ].join("\0");
+  return createHash2("sha256").update(material).digest("hex");
+}
+function getMachineFingerprintHash(signals = collectMachineSignals()) {
+  return fingerprintFromSignals(signals);
+}
+function getOS(platform = process.platform) {
+  switch (platform) {
+    case "darwin":
+      return "macos";
+    case "win32":
+      return "windows";
+    case "linux":
+      return "linux";
+    default:
+      return platform;
+  }
+}
+function getMachineLabel(rawHostname = hostname()) {
+  const label = rawHostname.replace(/\.local$/i, "").trim();
+  return label.length > 0 ? label : `${getOS()}-machine`;
+}
+function getMachineIdentity() {
+  return {
+    label: getMachineLabel(),
+    os: getOS(),
+    fingerprintHash: getMachineFingerprintHash()
+  };
+}
+
+// src/hook.ts
+async function runAgentHook(adapter, rawInput, options) {
+  let event;
+  try {
+    event = await adapter.normalizeEvent(rawInput);
+  } catch {
+    return { outcome: "skipped" };
+  }
+  const ledger = options.ledger ?? new RecentEventLedger();
+  const contentDup = ledger.markAndCheck(eventIdentity(event));
+  const approvalDup = event.event_type === "approval_required" && ledger.markAndCheck(approvalCollapseIdentity(event), APPROVAL_COLLAPSE_WINDOW_MS);
+  if (contentDup || approvalDup) {
+    return { outcome: "deduped", eventType: event.event_type };
+  }
+  const send = await options.sender.send(event);
+  return { outcome: send.outcome, eventType: event.event_type, send };
+}
+
+// src/integrations.ts
+import { z as z4 } from "zod";
+var integrationStatusSchema = z4.enum(INTEGRATION_STATUSES);
+var STATUS_REPORT_MAX_ITEMS = 16;
+var STATUS_REPORT_MAX_PAYLOAD_BYTES = 2048;
+var integrationStatusItemSchema = z4.object({
+  harness: harnessSchema,
+  status: integrationStatusSchema,
+  harness_version: z4.string().max(64).optional(),
+  adapter_version: z4.string().max(64).optional(),
+  last_status_payload: z4.unknown().optional().refine((v) => v === void 0 || JSON.stringify(v).length <= STATUS_REPORT_MAX_PAYLOAD_BYTES, {
+    message: "last_status_payload too large"
+  })
+});
+var integrationStatusReportSchema = z4.object({
+  integrations: z4.array(integrationStatusItemSchema).min(1).max(STATUS_REPORT_MAX_ITEMS)
+});
+var integrationStatusResponseSchema = z4.object({
+  integrations: z4.array(
+    z4.object({ harness: harnessSchema, status: integrationStatusSchema }).catchall(z4.unknown())
+  )
+});
+
+// src/normalize.ts
+import { createHash as createHash3, randomUUID } from "crypto";
+var TITLE_MAX_CHARS = 200;
+var BODY_MAX_CHARS = 2e3;
+var METADATA_VALUE_MAX_CHARS = 500;
+var METADATA_MAX_KEYS = 64;
+var METADATA_MAX_DEPTH = 4;
+var LABEL_MAX_CHARS = 120;
+var NormalizeError = class extends Error {
+  constructor(message, issues) {
+    super(message);
+    this.issues = issues;
+    this.name = "NormalizeError";
+  }
+  issues;
+};
+function isString(v) {
+  return typeof v === "string";
+}
+function asRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
+}
+function hashToken(value) {
+  return `h_${createHash3("sha256").update(value).digest("hex").slice(0, 16)}`;
+}
+var ABSOLUTE_PATH_RE = /(?:\/[A-Za-z0-9_.-]+){2,}|[A-Za-z]:(?:[\\/][A-Za-z0-9_. -]+)+/g;
+var SECRET_RES = [
+  /\bAKIA[0-9A-Z]{16}\b/g,
+  // AWS access key id
+  /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g,
+  // GitHub tokens
+  /\bsk-[A-Za-z0-9_-]{16,}\b/g,
+  // OpenAI-style keys
+  /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g,
+  // Slack tokens
+  /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g,
+  // JWT
+  /\b(?:bearer|token|secret|password|passwd|api[_-]?key)\b\s*[:=]\s*\S+/gi
+  // key=value secrets
+];
+function scrubAbsolutePaths(text) {
+  return text.replace(ABSOLUTE_PATH_RE, (match) => hashToken(match));
+}
+function redactSecrets(text) {
+  let out = text;
+  for (const re of SECRET_RES) out = out.replace(re, "[redacted]");
+  return out;
+}
+function truncate(text, max) {
+  return text.length <= max ? text : `${text.slice(0, Math.max(0, max - 1))}\u2026`;
+}
+function hashPath(path) {
+  return hashToken(path);
+}
+function cleanString(text, max) {
+  return truncate(redactSecrets(scrubAbsolutePaths(text)), max);
+}
+function sanitizeValue(value, depth) {
+  if (isString(value)) return cleanString(value, METADATA_VALUE_MAX_CHARS);
+  if (typeof value === "number" || typeof value === "boolean" || value === null) return value;
+  if (depth >= METADATA_MAX_DEPTH) return void 0;
+  if (Array.isArray(value)) {
+    return value.slice(0, METADATA_MAX_KEYS).map((v) => sanitizeValue(v, depth + 1));
+  }
+  if (typeof value === "object") {
+    const out = {};
+    let n = 0;
+    for (const [k, v] of Object.entries(value)) {
+      if (n >= METADATA_MAX_KEYS) break;
+      const cleaned = sanitizeValue(v, depth + 1);
+      if (cleaned !== void 0) {
+        out[cleanString(k, LABEL_MAX_CHARS)] = cleaned;
+        n++;
+      }
+    }
+    return out;
+  }
+  return void 0;
+}
+function serializedBytes(event) {
+  return Buffer.byteLength(JSON.stringify(event), "utf8");
+}
+function enforceSize(event) {
+  if (serializedBytes(event) <= MAX_AGENT_EVENT_BYTES) return event;
+  const steps = [
+    { ...event, metadata: void 0 },
+    { ...event, metadata: void 0, body: truncate(event.body, 256) },
+    {
+      ...event,
+      metadata: void 0,
+      body: truncate(event.body, 256),
+      title: truncate(event.title, 120)
+    }
+  ];
+  for (const candidate of steps) {
+    if (serializedBytes(candidate) <= MAX_AGENT_EVENT_BYTES) return candidate;
+  }
+  throw new NormalizeError("event exceeds max payload size even after shrinking");
+}
+function normalizeEvent(input, opts = {}) {
+  const rec = asRecord(input);
+  const ws = asRecord(rec["workspace"]);
+  const machine = asRecord(rec["machine"]);
+  const candidate = {
+    event_id: isString(rec["event_id"]) && rec["event_id"].length > 0 ? rec["event_id"] : opts.generateId?.() ?? `evt_local_${randomUUID()}`,
+    event_type: rec["event_type"],
+    occurred_at: isString(rec["occurred_at"]) && rec["occurred_at"].length > 0 ? rec["occurred_at"] : opts.now?.() ?? (/* @__PURE__ */ new Date()).toISOString(),
+    harness: rec["harness"],
+    // source_session_id is a key (§10.3) — keep it stable, but never let a raw path through.
+    source_session_id: isString(rec["source_session_id"]) ? scrubAbsolutePaths(rec["source_session_id"]) : rec["source_session_id"],
+    machine: {
+      label: isString(machine["label"]) ? cleanString(machine["label"], LABEL_MAX_CHARS) : machine["label"],
+      os: isString(machine["os"]) ? cleanString(machine["os"], LABEL_MAX_CHARS) : machine["os"]
+    },
+    workspace: {
+      // cwd is an absolute path → always hashed (§15: no absolute path leaves the machine).
+      cwd: isString(ws["cwd"]) ? hashPath(ws["cwd"]) : ws["cwd"]
+    },
+    status: rec["status"],
+    title: isString(rec["title"]) ? cleanString(rec["title"], TITLE_MAX_CHARS) : rec["title"],
+    body: isString(rec["body"]) ? cleanString(rec["body"], BODY_MAX_CHARS) : rec["body"]
+  };
+  if (isString(rec["harness_version"])) {
+    candidate["harness_version"] = cleanString(rec["harness_version"], LABEL_MAX_CHARS);
+  }
+  const wsOut = candidate["workspace"];
+  if (isString(ws["repo_name"])) wsOut["repo_name"] = cleanString(ws["repo_name"], LABEL_MAX_CHARS);
+  if (isString(ws["branch"])) wsOut["branch"] = cleanString(ws["branch"], LABEL_MAX_CHARS);
+  if (rec["metadata"] !== void 0) {
+    candidate["metadata"] = sanitizeValue(rec["metadata"], 0);
+  }
+  const parsed = birdyBeepAgentEventSchema.safeParse(candidate);
+  if (!parsed.success) {
+    throw new NormalizeError("normalized event failed schema validation", parsed.error.issues);
+  }
+  return enforceSize(parsed.data);
+}
+
+// src/pairing.ts
+import { z as z5 } from "zod";
+var pairStartRequestSchema = z5.object({
+  machine_label: z5.string().min(1),
+  os: z5.string().optional().catch(void 0),
+  cli_version: z5.string().optional().catch(void 0),
+  requested_scopes: z5.array(z5.string()).optional().catch(void 0)
+});
+var pairTokenRequestSchema = z5.object({
+  device_code: z5.string().min(1),
+  machine_fingerprint: z5.string().optional().catch(void 0)
+});
+var pairStartResponseSchema = z5.object({
+  device_code: z5.string(),
+  user_code: z5.string(),
+  qr_payload: z5.string(),
+  expires_at: isoDateTimeSchema
+});
+var pairTokenResponseSchema = z5.object({
+  machine_token: z5.string(),
+  machine_id: z5.string()
+});
+
+// src/queue.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import {
+  chmodSync as chmodSync2,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  readFileSync as readFileSync2,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  statSync as statSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { join as join3 } from "path";
+var QUEUE_RETENTION_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_DRAIN_MAX = 50;
+var CLAIM_RECLAIM_MS = 6e4;
+function isRecord(v) {
+  return typeof v === "object" && v !== null;
+}
+var LocalEventQueue = class {
+  dir;
+  #retentionMs;
+  #now;
+  constructor(options = {}) {
+    this.dir = options.dir ?? join3(birdyBeepDataDir(), "queue");
+    this.#retentionMs = options.retentionMs ?? QUEUE_RETENTION_MS;
+    this.#now = options.now ?? (() => Date.now());
+  }
+  /** Ensure the dir exists with 0700 perms; repair a too-permissive existing dir. */
+  #ensureDir() {
+    mkdirSync2(this.dir, { recursive: true, mode: 448 });
+    if (process.platform !== "win32") chmodSync2(this.dir, 448);
+  }
+  /** Park a normalized event on disk (atomic write, 0600). Never throws. */
+  enqueue(event) {
+    try {
+      this.#ensureDir();
+      const enqueuedAt = this.#now();
+      const name = `${enqueuedAt}-${randomUUID2()}.json`;
+      const finalPath = join3(this.dir, name);
+      const tmpPath = `${finalPath}.tmp`;
+      writeFileSync2(tmpPath, JSON.stringify({ enqueuedAt, event }), { mode: 384 });
+      renameSync2(tmpPath, finalPath);
+      if (process.platform !== "win32") chmodSync2(finalPath, 384);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Return orphaned `.claim` files (claims older than {@link CLAIM_RECLAIM_MS}) to the
+   * queue by renaming them back to their original `.json` name. The claim timestamp is
+   * embedded in the claim FILENAME (rename preserves mtime, so fs times would report
+   * the enqueue age, not the claim age — an active drain of an old entry must not be
+   * "reclaimed" out from under it). Racing reclaims are safe: rename losers ENOENT.
+   * Known window: a drainer SUSPENDED (not dead) >60s can resume after its claim was
+   * reclaimed and double-send — accepted, since 60s ≫ the 5s send budget (a claim that
+   * old almost always is a dead process) and the backend dedupe absorbs the repeat.
+   */
+  #reclaimOrphanedClaims(names) {
+    const cutoff = this.#now() - CLAIM_RECLAIM_MS;
+    for (const name of names) {
+      const m = /^(.+\.json)\.(\d+)-[0-9a-f-]+\.claim$/.exec(name);
+      if (!m || Number(m[2]) > cutoff) continue;
+      try {
+        renameSync2(join3(this.dir, name), join3(this.dir, m[1]));
+      } catch {
+      }
+    }
+  }
+  /** Read all non-expired entries (FIFO by enqueue time); prune expired/corrupt ones. */
+  #readFresh() {
+    if (!existsSync2(this.dir)) return { fresh: [], pruned: 0 };
+    if (process.platform !== "win32") {
+      try {
+        chmodSync2(this.dir, 448);
+      } catch {
+      }
+    }
+    let pruned = 0;
+    const fresh = [];
+    const cutoff = this.#now() - this.#retentionMs;
+    let names;
+    try {
+      names = readdirSync(this.dir);
+      this.#reclaimOrphanedClaims(names);
+      names = readdirSync(this.dir);
+    } catch {
+      return { fresh: [], pruned: 0 };
+    }
+    for (const name of names) {
+      if (!name.endsWith(".json")) continue;
+      const path = join3(this.dir, name);
+      try {
+        const parsed = JSON.parse(readFileSync2(path, "utf8"));
+        const enqueuedAt = isRecord(parsed) ? parsed["enqueuedAt"] : void 0;
+        const event = isRecord(parsed) ? parsed["event"] : void 0;
+        if (typeof enqueuedAt !== "number" || !isRecord(event)) {
+          rmSync2(path, { force: true });
+          pruned++;
+          continue;
+        }
+        if (enqueuedAt < cutoff) {
+          rmSync2(path, { force: true });
+          pruned++;
+          continue;
+        }
+        fresh.push({ path, enqueuedAt, event });
+      } catch {
+        try {
+          rmSync2(path, { force: true });
+        } catch {
+        }
+        pruned++;
+      }
+    }
+    fresh.sort((a, b) => a.enqueuedAt - b.enqueuedAt);
+    return { fresh, pruned };
+  }
+  /** Count of fresh (non-expired) queued events. Prunes expired entries as a side effect. */
+  size() {
+    return this.#readFresh().fresh.length;
+  }
+  /**
+   * Drain up to `max` fresh entries through `send`. Each entry is CLAIMED via an
+   * atomic rename before sending, so two concurrent drains never double-send the
+   * same event. delivered/drop remove the entry; retry keeps it for next time.
+   * Bounded + best-effort: never throws into the caller.
+   */
+  async drain(send, options = {}) {
+    const max = options.max ?? DEFAULT_DRAIN_MAX;
+    const result = { delivered: 0, dropped: 0, kept: 0, pruned: 0 };
+    let fresh;
+    try {
+      this.#ensureDir();
+      const read = this.#readFresh();
+      fresh = read.fresh;
+      result.pruned = read.pruned;
+    } catch {
+      return result;
+    }
+    for (const entry of fresh.slice(0, max)) {
+      if (options.stopWhen?.() === true) {
+        result.kept += 1;
+        continue;
+      }
+      const claim = `${entry.path}.${this.#now()}-${randomUUID2()}.claim`;
+      try {
+        renameSync2(entry.path, claim);
+      } catch {
+        continue;
+      }
+      let outcome;
+      try {
+        outcome = await send(entry.event);
+      } catch {
+        outcome = "retry";
+      }
+      if (outcome === "retry") {
+        try {
+          renameSync2(claim, entry.path);
+        } catch {
+        }
+        result.kept++;
+      } else {
+        try {
+          rmSync2(claim, { force: true });
+        } catch {
+        }
+        if (outcome === "delivered") result.delivered++;
+        else result.dropped++;
+      }
+    }
+    return result;
+  }
+  /** Remove every queued entry (used by `doctor` / debug tooling). Never throws. */
+  clear() {
+    if (!existsSync2(this.dir)) return 0;
+    let removed = 0;
+    try {
+      for (const name of readdirSync(this.dir)) {
+        try {
+          rmSync2(join3(this.dir, name), { force: true });
+          removed++;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return removed;
+  }
+  /** Whether the queue dir has secure (0700) perms. Returns true on Windows (ACL-based). */
+  isSecure() {
+    if (process.platform === "win32") return true;
+    try {
+      return (statSync2(this.dir).mode & 63) === 0;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/token-store.ts
+import { execFile } from "child_process";
+import {
+  chmodSync as chmodSync3,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync3,
+  renameSync as renameSync3,
+  rmSync as rmSync3,
+  statSync as statSync3,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { dirname as dirname2, join as join4 } from "path";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var SERVICE = "birdybeep";
+var ACCOUNT = "machine-token";
+var FileTokenStore = class {
+  kind = "file";
+  path;
+  constructor(options = {}) {
+    this.path = options.path ?? join4(birdyBeepDataDir(), "token");
+  }
+  // Sync internals, Promise-returning to satisfy the TokenStore interface.
+  get() {
+    if (!existsSync3(this.path)) return Promise.resolve(null);
+    this.#repairPerms();
+    const raw = readFileSync3(this.path, "utf8").trim();
+    return Promise.resolve(raw.length > 0 ? raw : null);
+  }
+  set(token) {
+    const dir = dirname2(this.path);
+    mkdirSync3(dir, { recursive: true, mode: 448 });
+    if (process.platform !== "win32") chmodSync3(dir, 448);
+    const tmp = `${this.path}.tmp`;
+    writeFileSync3(tmp, token, { mode: 384 });
+    renameSync3(tmp, this.path);
+    if (process.platform !== "win32") chmodSync3(this.path, 384);
+    return Promise.resolve();
+  }
+  clear() {
+    rmSync3(this.path, { force: true });
+    return Promise.resolve();
+  }
+  /** Repair a too-permissive token file (§15.1: strict perms). POSIX only. */
+  #repairPerms() {
+    if (process.platform === "win32") return;
+    try {
+      if ((statSync3(this.path).mode & 63) !== 0) chmodSync3(this.path, 384);
+    } catch {
+    }
+  }
+};
+var KeychainTokenStore = class {
+  kind = "keychain";
+  #backend;
+  constructor(backend) {
+    this.#backend = backend;
+  }
+  get() {
+    return this.#backend.get(SERVICE, ACCOUNT);
+  }
+  set(token) {
+    return this.#backend.set(SERVICE, ACCOUNT, token);
+  }
+  clear() {
+    return this.#backend.delete(SERVICE, ACCOUNT);
+  }
+};
+var unavailableKeychainBackend = {
+  available: false,
+  get: () => Promise.resolve(null),
+  set: () => Promise.reject(new Error("keychain unavailable")),
+  delete: () => Promise.resolve()
+};
+function macosKeychainBackend() {
+  return {
+    available: process.platform === "darwin",
+    async get(service, account) {
+      try {
+        const { stdout } = await execFileAsync("security", [
+          "find-generic-password",
+          "-s",
+          service,
+          "-a",
+          account,
+          "-w"
+        ]);
+        const value = stdout.replace(/\n$/, "");
+        return value.length > 0 ? value : null;
+      } catch {
+        return null;
+      }
+    },
+    async set(service, account, secret) {
+      await execFileAsync("security", [
+        "add-generic-password",
+        "-U",
+        "-s",
+        service,
+        "-a",
+        account,
+        "-w",
+        secret
+      ]);
+    },
+    async delete(service, account) {
+      try {
+        await execFileAsync("security", ["delete-generic-password", "-s", service, "-a", account]);
+      } catch {
+      }
+    }
+  };
+}
+function defaultKeychainBackend() {
+  if (process.platform === "darwin") return macosKeychainBackend();
+  return unavailableKeychainBackend;
+}
+function resolveTokenStore(options = {}) {
+  const backend = options.backend ?? defaultKeychainBackend();
+  if (backend.available) return new KeychainTokenStore(backend);
+  return new FileTokenStore(options.filePath !== void 0 ? { path: options.filePath } : {});
+}
+async function setToken(token, options = {}) {
+  const store = resolveTokenStore(options);
+  await store.set(token);
+  return store.kind;
+}
+async function getToken(options = {}) {
+  const backend = options.backend ?? defaultKeychainBackend();
+  if (backend.available) {
+    const fromKeychain = await new KeychainTokenStore(backend).get();
+    if (fromKeychain !== null) return fromKeychain;
+  }
+  const file = new FileTokenStore(options.filePath !== void 0 ? { path: options.filePath } : {});
+  return file.get();
+}
+async function clearToken(options = {}) {
+  const backend = options.backend ?? defaultKeychainBackend();
+  if (backend.available) await new KeychainTokenStore(backend).clear();
+  await new FileTokenStore(
+    options.filePath !== void 0 ? { path: options.filePath } : {}
+  ).clear();
+}
+
+// src/sender.ts
+var DEFAULT_SEND_TIMEOUT_MS = 3e3;
+var DEFAULT_TOTAL_BUDGET_MS = 5e3;
+var MIN_DRAIN_ATTEMPT_MS = 250;
+var AGENT_EVENTS_PATH = "/v1/agent-events";
+var EMPTY_DRAIN = { delivered: 0, dropped: 0, kept: 0, pruned: 0 };
+function classify(status, code) {
+  if (code === "rate_limited" || code === "internal_error") return "retry";
+  if (code !== void 0) return "drop";
+  if (status >= 500 || status === 429) return "retry";
+  return "drop";
+}
+function parseDecision(body) {
+  if (typeof body !== "object" || body === null) return void 0;
+  const decision = body["decision"];
+  return typeof decision === "string" ? decision : void 0;
+}
+function createSender(config) {
+  const baseUrl = config.baseUrl.replace(/\/$/, "");
+  const timeoutMs = config.timeoutMs ?? DEFAULT_SEND_TIMEOUT_MS;
+  const totalBudgetMs = config.totalBudgetMs ?? DEFAULT_TOTAL_BUDGET_MS;
+  const queue = config.queue ?? new LocalEventQueue();
+  const fetchImpl = config.fetchImpl ?? fetch;
+  const drainMax = config.drainMax ?? DEFAULT_DRAIN_MAX;
+  const clock = config.now ?? (() => Date.now());
+  async function attempt(event, token, attemptTimeoutMs = timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), attemptTimeoutMs);
+    try {
+      const res = await fetchImpl(`${baseUrl}${AGENT_EVENTS_PATH}`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+        body: JSON.stringify(event),
+        signal: controller.signal
+      });
+      if (res.status >= 200 && res.status < 300) {
+        const decision = parseDecision(await res.json().catch(() => void 0));
+        return { result: "delivered", status: res.status, decision };
+      }
+      let code;
+      try {
+        const body = await res.json();
+        const parsed = errorEnvelopeSchema.safeParse(body);
+        if (parsed.success) code = parsed.data.error.code;
+      } catch {
+      }
+      return { result: classify(res.status, code), status: res.status, code };
+    } catch {
+      return { result: "retry" };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  function drainQueue(token, deadline) {
+    return queue.drain(
+      (e) => {
+        const remaining = deadline - clock();
+        return attempt(e, token, Math.max(1, Math.min(timeoutMs, remaining))).then((a) => a.result);
+      },
+      { max: drainMax, stopWhen: () => deadline - clock() < MIN_DRAIN_ATTEMPT_MS }
+    );
+  }
+  return {
+    async send(event) {
+      const deadline = clock() + totalBudgetMs;
+      const token = await getToken(config.tokenOptions);
+      if (token === null) {
+        queue.enqueue(event);
+        return { outcome: "queued" };
+      }
+      const a = await attempt(event, token, Math.min(timeoutMs, totalBudgetMs));
+      let outcome;
+      if (a.result === "delivered") {
+        outcome = "delivered";
+      } else if (a.result === "retry") {
+        queue.enqueue(event);
+        outcome = "queued";
+      } else {
+        outcome = "dropped";
+      }
+      const drained = await drainQueue(token, deadline);
+      const result = { outcome, drained };
+      if (a.status !== void 0) result.status = a.status;
+      if (a.code !== void 0) result.code = a.code;
+      if (a.decision !== void 0) result.decision = a.decision;
+      return result;
+    },
+    async drainNow() {
+      const token = await getToken(config.tokenOptions);
+      if (token === null) return EMPTY_DRAIN;
+      return drainQueue(token, clock() + totalBudgetMs);
+    }
+  };
+}
+
+// src/index.ts
+var AGENT_CORE_VERSION = "0.0.0";
+export {
+  AGENT_CORE_VERSION,
+  AGENT_SESSION_STATUSES,
+  APPROVAL_COLLAPSE_WINDOW_MS,
+  BIRDYBEEP_EVENT_TYPES,
+  BODY_MAX_CHARS,
+  CLAIM_RECLAIM_MS,
+  DEFAULT_DEDUP_WINDOW_MS,
+  DEFAULT_DRAIN_MAX,
+  DEFAULT_SEND_TIMEOUT_MS,
+  DEFAULT_TOTAL_BUDGET_MS,
+  ERROR_CODES,
+  ERROR_STATUS,
+  FileTokenStore,
+  HARNESS_IDS,
+  INTEGRATION_STATUSES,
+  KeychainTokenStore,
+  LABEL_MAX_CHARS,
+  LocalEventQueue,
+  MAX_AGENT_EVENT_BYTES,
+  METADATA_MAX_DEPTH,
+  METADATA_MAX_KEYS,
+  METADATA_VALUE_MAX_CHARS,
+  NormalizeError,
+  QUEUE_RETENTION_MS,
+  RecentEventLedger,
+  STATUS_REPORT_MAX_ITEMS,
+  STATUS_REPORT_MAX_PAYLOAD_BYTES,
+  TITLE_MAX_CHARS,
+  agentEventsRequestSchema,
+  approvalCollapseIdentity,
+  birdyBeepAgentEventSchema,
+  birdyBeepConfigDir,
+  birdyBeepDataDir,
+  clearToken,
+  collectMachineSignals,
+  createSender,
+  defaultKeychainBackend,
+  errorCodeSchema,
+  errorEnvelopeSchema,
+  eventIdentity,
+  eventMetadataSchema,
+  eventTypeSchema,
+  fingerprintFromSignals,
+  getMachineFingerprintHash,
+  getMachineIdentity,
+  getMachineLabel,
+  getOS,
+  getToken,
+  harnessSchema,
+  hashPath,
+  integrationStatusItemSchema,
+  integrationStatusReportSchema,
+  integrationStatusResponseSchema,
+  integrationStatusSchema,
+  isWithinMaxAgentEventSize,
+  isoDateTimeSchema,
+  machineSchema,
+  macosKeychainBackend,
+  normalizeEvent,
+  pairStartRequestSchema,
+  pairStartResponseSchema,
+  pairTokenRequestSchema,
+  pairTokenResponseSchema,
+  redactSecrets,
+  resolveTokenStore,
+  runAgentHook,
+  scrubAbsolutePaths,
+  sessionStatusSchema,
+  setToken,
+  successEnvelopeSchema,
+  truncate,
+  unavailableKeychainBackend,
+  workspaceSchema
+};
+//# sourceMappingURL=index.js.map