@wipcomputer/memory-crystal 0.7.32 → 0.7.34-alpha.1

package/dist/poller.js

@@ -0,0 +1,634 @@
+#!/usr/bin/env node
+import {
+  ensureStaging,
+  isNewAgent,
+  markReady
+} from "./chunk-5I7GMRDN.js";
+import {
+  generateSessionSummary,
+  writeSummaryFile
+} from "./chunk-Y72C7F6O.js";
+import {
+  pushFileSync
+} from "./chunk-CGIDSAJB.js";
+import {
+  Crystal,
+  resolveConfig
+} from "./chunk-2GBYLMEF.js";
+import {
+  decryptJSON,
+  encryptJSON,
+  loadRelayKey
+} from "./chunk-D3MACYZ4.js";
+import {
+  ensureLdm,
+  resolveStatePath,
+  stateWritePath
+} from "./chunk-DFQ72B7M.js";
+
+// src/poller.ts
+import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { createDecipheriv } from "crypto";
+var RELAY_URL = process.env.CRYSTAL_RELAY_URL || "";
+var RELAY_TOKEN = process.env.CRYSTAL_RELAY_TOKEN || "";
+var POLLER_STATE_PATH = resolveStatePath("relay-poller-state.json");
+function loadState() {
+  try {
+    if (existsSync(POLLER_STATE_PATH)) {
+      const raw = JSON.parse(readFileSync(POLLER_STATE_PATH, "utf-8"));
+      return {
+        lastPoll: raw.lastPoll ?? null,
+        totalIngested: raw.totalIngested ?? 0,
+        totalChatgptIngested: raw.totalChatgptIngested ?? 0,
+        totalAttachments: raw.totalAttachments ?? 0,
+        lastMirrorPush: raw.lastMirrorPush ?? null,
+        lastDeltaChunkId: raw.lastDeltaChunkId ?? 0
+      };
+    }
+  } catch {
+  }
+  return { lastPoll: null, totalIngested: 0, totalChatgptIngested: 0, totalAttachments: 0, lastMirrorPush: null, lastDeltaChunkId: 0 };
+}
+function saveState(state) {
+  const writePath = stateWritePath("relay-poller-state.json");
+  writeFileSync(writePath, JSON.stringify(state, null, 2));
+}
+async function pollConversations(crystal, relayKey) {
+  let ingested = 0;
+  let errors = 0;
+  const listResp = await fetch(`${RELAY_URL}/pickup/conversations`, {
+    headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+  });
+  if (!listResp.ok) {
+    throw new Error(`Relay list failed: ${listResp.status} ${await listResp.text()}`);
+  }
+  const listData = await listResp.json();
+  if (listData.count === 0) return { ingested: 0, errors: 0 };
+  process.stderr.write(`[relay-poller] conversations: ${listData.count} blob(s) waiting
+`);
+  for (const blob of listData.blobs) {
+    try {
+      const blobResp = await fetch(`${RELAY_URL}/pickup/conversations/${blob.id}`, {
+        headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+      });
+      if (!blobResp.ok) {
+        process.stderr.write(`[relay-poller] failed to fetch blob ${blob.id}: ${blobResp.status}
+`);
+        errors++;
+        continue;
+      }
+      const encryptedText = await blobResp.text();
+      const encrypted = JSON.parse(encryptedText);
+      let drop;
+      try {
+        drop = decryptJSON(encrypted, relayKey);
+      } catch (err) {
+        process.stderr.write(`[relay-poller] blob ${blob.id} failed verification: ${err.message} ... DISCARDED
+`);
+        await fetch(`${RELAY_URL}/confirm/conversations/${blob.id}`, {
+          method: "DELETE",
+          headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+        });
+        errors++;
+        continue;
+      }
+      if (isNewAgent(drop.agent_id)) {
+        process.stderr.write(`[relay-poller] new agent "${drop.agent_id}" detected, routing to staging
+`);
+        const staging = ensureStaging(drop.agent_id);
+        const jsonlPath = join(staging.transcripts, `relay-${blob.id}.jsonl`);
+        const jsonlLines = drop.messages.map((m) => JSON.stringify(m)).join("\n") + "\n";
+        writeFileSync(jsonlPath, jsonlLines);
+        markReady(drop.agent_id);
+        await fetch(`${RELAY_URL}/confirm/conversations/${blob.id}`, {
+          method: "DELETE",
+          headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+        });
+        process.stderr.write(`[relay-poller] staged ${drop.messages.length} messages for ${drop.agent_id}
+`);
+        continue;
+      }
+      const maxSingleChunkChars = 2e3 * 4;
+      const chunks = [];
+      for (const msg of drop.messages) {
+        if (msg.text.length <= maxSingleChunkChars) {
+          chunks.push({
+            text: msg.text,
+            role: msg.role,
+            source_type: "conversation",
+            source_id: `cc:${msg.sessionId}`,
+            agent_id: drop.agent_id,
+            token_count: Math.ceil(msg.text.length / 4),
+            created_at: msg.timestamp
+          });
+        } else {
+          for (const ct of crystal.chunkText(msg.text)) {
+            chunks.push({
+              text: ct,
+              role: msg.role,
+              source_type: "conversation",
+              source_id: `cc:${msg.sessionId}`,
+              agent_id: drop.agent_id,
+              token_count: Math.ceil(ct.length / 4),
+              created_at: msg.timestamp
+            });
+          }
+        }
+      }
+      const count = await crystal.ingest(chunks);
+      ingested += count;
+      await fetch(`${RELAY_URL}/confirm/conversations/${blob.id}`, {
+        method: "DELETE",
+        headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+      });
+      process.stderr.write(`[relay-poller] blob ${blob.id}: ${count} chunks ingested from ${drop.agent_id}
+`);
+      try {
+        const remotePaths = ensureLdm(drop.agent_id);
+        const jsonlPath = join(remotePaths.transcripts, `relay-${blob.id}.jsonl`);
+        const jsonlLines = drop.messages.map((m) => JSON.stringify(m)).join("\n") + "\n";
+        writeFileSync(jsonlPath, jsonlLines);
+        const summaryMsgs = drop.messages.map((m) => ({
+          role: m.role,
+          text: m.text,
+          timestamp: m.timestamp,
+          sessionId: m.sessionId
+        }));
+        const summary = await generateSessionSummary(summaryMsgs);
+        const sessionId = drop.messages[0]?.sessionId || "unknown";
+        writeSummaryFile(remotePaths.sessions, summary, drop.agent_id, sessionId);
+        appendDailyBreadcrumb(drop.agent_id, drop.messages.find((m) => m.role === "user")?.text || "");
+      } catch (fileErr) {
+        process.stderr.write(`[relay-poller] file tree write failed (non-fatal): ${fileErr.message}
+`);
+      }
+    } catch (err) {
+      process.stderr.write(`[relay-poller] error processing blob ${blob.id}: ${err.message}
+`);
+      errors++;
+    }
+  }
+  try {
+    await pollCommands();
+  } catch (err) {
+    process.stderr.write(`[relay-poller] commands poll failed (non-fatal): ${err.message}
+`);
+  }
+  return { ingested, errors };
+}
+async function pollChatgpt(crystal, relayKey) {
+  let ingested = 0;
+  let attachments = 0;
+  let errors = 0;
+  const listResp = await fetch(`${RELAY_URL}/pickup/chatgpt`, {
+    headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+  });
+  if (!listResp.ok) {
+    process.stderr.write(`[relay-poller] chatgpt list failed: ${listResp.status}
+`);
+    return { ingested: 0, attachments: 0, errors: 1 };
+  }
+  const listData = await listResp.json();
+  if (listData.count > 0) {
+    process.stderr.write(`[relay-poller] chatgpt: ${listData.count} drop(s) waiting
+`);
+  }
+  for (const blob of listData.blobs) {
+    try {
+      const blobResp = await fetch(`${RELAY_URL}/pickup/chatgpt/${blob.id}`, {
+        headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+      });
+      if (!blobResp.ok) {
+        process.stderr.write(`[relay-poller] chatgpt: failed to fetch ${blob.id}: ${blobResp.status}
+`);
+        errors++;
+        continue;
+      }
+      const encryptedText = await blobResp.text();
+      const encrypted = JSON.parse(encryptedText);
+      let drop;
+      try {
+        drop = decryptJSON(encrypted, relayKey);
+      } catch (err) {
+        process.stderr.write(`[relay-poller] chatgpt: ${blob.id} failed verification: ${err.message} ... DISCARDED
+`);
+        await confirmBlob("chatgpt", blob.id);
+        errors++;
+        continue;
+      }
+      switch (drop.type) {
+        case "conversation": {
+          const data = drop.data;
+          const result = await ingestConversationDrop(crystal, drop, data);
+          ingested += result;
+          break;
+        }
+        case "remember": {
+          const data = drop.data;
+          await crystal.remember(data.text, data.category);
+          ingested++;
+          process.stderr.write(`[relay-poller] chatgpt: remembered "${data.text.slice(0, 60)}..." (${data.category}) from ${drop.agent_id}
+`);
+          break;
+        }
+        case "forget": {
+          const data = drop.data;
+          const ok = crystal.forget(data.memory_id);
+          process.stderr.write(`[relay-poller] chatgpt: forget memory #${data.memory_id} from ${drop.agent_id}: ${ok ? "done" : "not found"}
+`);
+          break;
+        }
+        case "attachment": {
+          const data = drop.data;
+          const result = await fetchAndSaveAttachment(data, drop.agent_id, relayKey);
+          if (result) attachments++;
+          break;
+        }
+        default:
+          process.stderr.write(`[relay-poller] chatgpt: unknown drop type "${drop.type}" ... skipping
+`);
+      }
+      await confirmBlob("chatgpt", blob.id);
+    } catch (err) {
+      process.stderr.write(`[relay-poller] chatgpt: error processing ${blob.id}: ${err.message}
+`);
+      errors++;
+    }
+  }
+  const attResp = await fetch(`${RELAY_URL}/pickup/chatgpt-attachments`, {
+    headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+  });
+  if (attResp.ok) {
+    const attData = await attResp.json();
+    if (attData.count > 0) {
+      process.stderr.write(`[relay-poller] chatgpt-attachments: ${attData.count} blob(s) (cleaned up after metadata processing)
+`);
+    }
+  }
+  return { ingested, attachments, errors };
+}
+async function ingestConversationDrop(crystal, drop, data) {
+  const maxSingleChunkChars = 2e3 * 4;
+  const chunks = [];
+  const sessionTag = data.session_id ? `cloud:${data.session_id}` : `cloud:${drop.timestamp.slice(0, 10)}`;
+  const text = data.content;
+  if (text.length <= maxSingleChunkChars) {
+    chunks.push({
+      text,
+      role: data.role,
+      source_type: "conversation",
+      source_id: sessionTag,
+      agent_id: drop.agent_id,
+      token_count: Math.ceil(text.length / 4),
+      created_at: drop.timestamp
+    });
+  } else {
+    for (const ct of crystal.chunkText(text)) {
+      chunks.push({
+        text: ct,
+        role: data.role,
+        source_type: "conversation",
+        source_id: sessionTag,
+        agent_id: drop.agent_id,
+        token_count: Math.ceil(ct.length / 4),
+        created_at: drop.timestamp
+      });
+    }
+  }
+  if (data.tool_calls?.length) {
+    for (const tc of data.tool_calls) {
+      const toolText = `[Tool: ${tc.tool_name}] Args: ${tc.arguments}${tc.result ? `
+Result: ${tc.result}` : ""}`;
+      chunks.push({
+        text: toolText,
+        role: "assistant",
+        source_type: "tool_call",
+        source_id: sessionTag,
+        agent_id: drop.agent_id,
+        token_count: Math.ceil(toolText.length / 4),
+        created_at: drop.timestamp
+      });
+    }
+  }
+  const count = await crystal.ingest(chunks);
+  try {
+    const remotePaths = ensureLdm(drop.agent_id);
+    const jsonlPath = join(remotePaths.transcripts, `cloud-${drop.timestamp.replace(/[:.]/g, "-")}.jsonl`);
+    const line = JSON.stringify({
+      type: "conversation",
+      agent_id: drop.agent_id,
+      timestamp: drop.timestamp,
+      role: data.role,
+      content: data.content,
+      session_id: data.session_id,
+      turn_index: data.turn_index,
+      model: data.model,
+      tool_calls: data.tool_calls,
+      raw_json: data.raw_json
+    });
+    appendFileSync(jsonlPath, line + "\n");
+    appendDailyBreadcrumb(drop.agent_id, data.role === "user" ? data.content : `[${data.model || "assistant"}] ${data.content.slice(0, 80)}`);
+  } catch (fileErr) {
+    process.stderr.write(`[relay-poller] chatgpt file tree write failed (non-fatal): ${fileErr.message}
+`);
+  }
+  if (count > 0) {
+    process.stderr.write(`[relay-poller] chatgpt: ${count} chunk(s) from ${drop.agent_id} (${data.role}, turn ${data.turn_index ?? "?"})
+`);
+  }
+  return count;
+}
+async function fetchAndSaveAttachment(data, agentId, relayKey) {
+  try {
+    const blobId = data.r2_key.split("/").pop();
+    if (!blobId) {
+      process.stderr.write(`[relay-poller] chatgpt: invalid attachment r2_key: ${data.r2_key}
+`);
+      return false;
+    }
+    const blobResp = await fetch(`${RELAY_URL}/pickup/chatgpt-attachments/${blobId}`, {
+      headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+    });
+    if (!blobResp.ok) {
+      process.stderr.write(`[relay-poller] chatgpt: failed to fetch attachment ${blobId}: ${blobResp.status}
+`);
+      return false;
+    }
+    const encryptedText = await blobResp.text();
+    const encryptedPayload = JSON.parse(encryptedText);
+    const nonce = Buffer.from(encryptedPayload.nonce, "base64");
+    const encryptedData = Buffer.from(encryptedPayload.data, "base64");
+    const ciphertext = encryptedData.subarray(0, encryptedData.length - 16);
+    const tag = encryptedData.subarray(encryptedData.length - 16);
+    const decipher = createDecipheriv("aes-256-gcm", relayKey, nonce);
+    decipher.setAuthTag(tag);
+    const decryptedBuf = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+    const remotePaths = ensureLdm(agentId);
+    const attachmentsDir = join(remotePaths.agentRoot, "memory", "attachments");
+    if (!existsSync(attachmentsDir)) mkdirSync(attachmentsDir, { recursive: true });
+    const safeFilename = data.filename.replace(/[^a-zA-Z0-9._-]/g, "_");
+    const filePath = join(attachmentsDir, `${blobId}-${safeFilename}`);
+    writeFileSync(filePath, decryptedBuf);
+    const metaPath = filePath + ".meta.json";
+    writeFileSync(metaPath, JSON.stringify({
+      filename: data.filename,
+      mime_type: data.mime_type,
+      size_bytes: data.size_bytes,
+      source: data.source,
+      surface: data.surface,
+      context: data.context,
+      session_id: data.session_id,
+      agent_id: agentId,
+      saved_at: (/* @__PURE__ */ new Date()).toISOString()
+    }, null, 2));
+    await confirmBlob("chatgpt-attachments", blobId);
+    process.stderr.write(`[relay-poller] chatgpt: saved attachment ${data.filename} (${data.mime_type}, ${(data.size_bytes / 1024).toFixed(1)}KB) from ${agentId}
+`);
+    return true;
+  } catch (err) {
+    process.stderr.write(`[relay-poller] chatgpt: attachment save failed: ${err.message}
+`);
+    return false;
+  }
+}
+async function confirmBlob(channel, id) {
+  await fetch(`${RELAY_URL}/confirm/${channel}/${id}`, {
+    method: "DELETE",
+    headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+  });
+}
+function appendDailyBreadcrumb(agentId, text) {
+  try {
+    const remotePaths = ensureLdm(agentId);
+    const now = /* @__PURE__ */ new Date();
+    const dateStr = now.toISOString().slice(0, 10);
+    const dailyPath = join(remotePaths.daily, `${dateStr}.md`);
+    if (!existsSync(dailyPath)) {
+      writeFileSync(dailyPath, `# ${dateStr} - ${agentId} Daily Log (via relay)
+
+`);
+    }
+    if (text) {
+      const snippet = text.slice(0, 120).replace(/\n/g, " ").trim();
+      appendFileSync(dailyPath, `- **${now.toISOString().slice(11, 16)}** [relay] ${snippet}
+`);
+    }
+  } catch {
+  }
+}
+async function pollOnce() {
+  if (!RELAY_URL || !RELAY_TOKEN) {
+    throw new Error("CRYSTAL_RELAY_URL and CRYSTAL_RELAY_TOKEN must be set");
+  }
+  const relayKey = loadRelayKey();
+  const config = resolveConfig();
+  const crystal = new Crystal(config);
+  await crystal.init();
+  const conv = await pollConversations(crystal, relayKey);
+  const chatgpt = await pollChatgpt(crystal, relayKey);
+  return {
+    ingested: conv.ingested + chatgpt.ingested,
+    errors: conv.errors + chatgpt.errors,
+    chatgptIngested: chatgpt.ingested,
+    chatgptAttachments: chatgpt.attachments
+  };
+}
+async function pollCommands() {
+  const relayKey = loadRelayKey();
+  const listResp = await fetch(`${RELAY_URL}/pickup/commands`, {
+    headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+  });
+  if (!listResp.ok) return;
+  const listData = await listResp.json();
+  if (listData.count === 0) return;
+  process.stderr.write(`[relay-poller] ${listData.count} command(s) waiting
+`);
+  for (const blob of listData.blobs) {
+    try {
+      const blobResp = await fetch(`${RELAY_URL}/pickup/commands/${blob.id}`, {
+        headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+      });
+      if (!blobResp.ok) continue;
+      const encryptedText = await blobResp.text();
+      const encrypted = JSON.parse(encryptedText);
+      let cmd;
+      try {
+        cmd = decryptJSON(encrypted, relayKey);
+      } catch {
+        await fetch(`${RELAY_URL}/confirm/commands/${blob.id}`, {
+          method: "DELETE",
+          headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+        });
+        continue;
+      }
+      const gatewayPort = process.env.CRYSTAL_SERVE_PORT || "18790";
+      try {
+        const resp = await fetch(`http://127.0.0.1:${gatewayPort}/process`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            action: cmd.action || "dream-weave",
+            agent_id: cmd.agent_id,
+            mode: cmd.mode
+          })
+        });
+        if (resp.ok) {
+          process.stderr.write(`[relay-poller] delivered command: ${cmd.action} for ${cmd.agent_id}
+`);
+        } else {
+          process.stderr.write(`[relay-poller] gateway rejected command: ${resp.status}
+`);
+        }
+      } catch (err) {
+        process.stderr.write(`[relay-poller] gateway not available (non-fatal): ${err.message}
+`);
+      }
+      await fetch(`${RELAY_URL}/confirm/commands/${blob.id}`, {
+        method: "DELETE",
+        headers: { "Authorization": `Bearer ${RELAY_TOKEN}` }
+      });
+    } catch (err) {
+      process.stderr.write(`[relay-poller] command processing error: ${err.message}
+`);
+    }
+  }
+}
+async function pushDelta(force) {
+  if (!RELAY_URL || !RELAY_TOKEN) {
+    throw new Error("CRYSTAL_RELAY_URL and CRYSTAL_RELAY_TOKEN must be set");
+  }
+  const relayKey = loadRelayKey();
+  const config = resolveConfig();
+  const crystal = new Crystal(config);
+  await crystal.init();
+  const state = loadState();
+  const sinceId = force ? 0 : state.lastDeltaChunkId || 0;
+  const maxId = crystal.getMaxChunkId();
+  if (maxId <= sinceId) {
+    process.stderr.write(`[relay-poller] no new chunks since ID ${sinceId}
+`);
+    return;
+  }
+  const chunks = crystal.exportChunksSince(sinceId);
+  if (chunks.length === 0) {
+    process.stderr.write(`[relay-poller] no new chunks to push
+`);
+    return;
+  }
+  const deltaPayload = {
+    version: Crystal.DELTA_VERSION,
+    sinceId,
+    maxId,
+    chunkCount: chunks.length,
+    pushedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    chunks
+  };
+  const encrypted = encryptJSON(deltaPayload, relayKey);
+  const resp = await fetch(`${RELAY_URL}/drop/mirror`, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${RELAY_TOKEN}`,
+      "Content-Type": "application/octet-stream"
+    },
+    body: JSON.stringify(encrypted)
+  });
+  if (!resp.ok) {
+    throw new Error(`Delta push failed: ${resp.status} ${await resp.text()}`);
+  }
+  state.lastDeltaChunkId = maxId;
+  state.lastMirrorPush = (/* @__PURE__ */ new Date()).toISOString();
+  saveState(state);
+  const payloadSize = JSON.stringify(encrypted).length;
+  process.stderr.write(
+    `[relay-poller] delta pushed: ${chunks.length} chunks (ID ${sinceId + 1}..${maxId}), ${(payloadSize / 1024).toFixed(1)}KB
+`
+  );
+}
+var args = process.argv.slice(2);
+if (args.includes("--status")) {
+  const state = loadState();
+  const mode = RELAY_URL && RELAY_TOKEN ? "configured" : "not configured";
+  console.log(`Relay poller status:`);
+  console.log(`  Relay URL:         ${RELAY_URL || "(not set)"}`);
+  console.log(`  Mode:              ${mode}`);
+  console.log(`  Last poll:         ${state.lastPoll || "never"}`);
+  console.log(`  Total ingested:    ${state.totalIngested} (conversations)`);
+  console.log(`  ChatGPT ingested:  ${state.totalChatgptIngested} (cloud MCP)`);
+  console.log(`  Attachments saved: ${state.totalAttachments}`);
+  console.log(`  Last delta:        ${state.lastMirrorPush || "never"}`);
+  console.log(`  Delta watermark:   chunk ID ${state.lastDeltaChunkId || 0}`);
+  process.exit(0);
+}
+if (args.includes("--push-mirror") || args.includes("--push-delta")) {
+  const full = args.includes("--full");
+  pushDelta(full).then(() => {
+    process.exit(0);
+  }).catch((err) => {
+    process.stderr.write(`[relay-poller] mirror push error: ${err.message}
+`);
+    process.exit(1);
+  });
+} else if (args.includes("--watch")) {
+  const POLL_INTERVAL = 2 * 60 * 1e3;
+  async function loop() {
+    process.stderr.write(`[relay-poller] watching (every ${POLL_INTERVAL / 1e3}s)...
+`);
+    while (true) {
+      try {
+        const result = await pollOnce();
+        const state = loadState();
+        state.lastPoll = (/* @__PURE__ */ new Date()).toISOString();
+        state.totalIngested += result.ingested;
+        state.totalChatgptIngested += result.chatgptIngested;
+        state.totalAttachments += result.chatgptAttachments;
+        saveState(state);
+        const totalNew = result.ingested + result.chatgptAttachments;
+        if (totalNew > 0) {
+          process.stderr.write(`[relay-poller] poll complete: ${result.ingested} ingested, ${result.chatgptAttachments} attachments, ${result.errors} errors
+`);
+          try {
+            await pushDelta();
+          } catch (deltaErr) {
+            process.stderr.write(`[relay-poller] delta push failed (non-fatal): ${deltaErr.message}
+`);
+          }
+        }
+        try {
+          const { manifest, files } = await pushFileSync();
+          if (files > 0) {
+            process.stderr.write(`[relay-poller] file sync pushed: ${files} files
+`);
+          }
+        } catch (fileSyncErr) {
+          process.stderr.write(`[relay-poller] file sync failed (non-fatal): ${fileSyncErr.message}
+`);
+        }
+      } catch (err) {
+        process.stderr.write(`[relay-poller] poll error: ${err.message}
+`);
+      }
+      await new Promise((r) => setTimeout(r, POLL_INTERVAL));
+    }
+  }
+  loop();
+} else {
+  pollOnce().then((result) => {
+    const state = loadState();
+    state.lastPoll = (/* @__PURE__ */ new Date()).toISOString();
+    state.totalIngested += result.ingested;
+    state.totalChatgptIngested += result.chatgptIngested;
+    state.totalAttachments += result.chatgptAttachments;
+    saveState(state);
+    const totalNew = result.ingested + result.chatgptAttachments;
+    if (totalNew > 0) {
+      process.stderr.write(`[relay-poller] ${result.ingested} chunks ingested, ${result.chatgptAttachments} attachments, ${result.errors} errors
+`);
+    }
+    process.exit(result.errors > 0 ? 1 : 0);
+  }).catch((err) => {
+    process.stderr.write(`[relay-poller] error: ${err.message}
+`);
+    process.exit(1);
+  });
+}

package/dist/role.d.ts

@@ -0,0 +1,24 @@
+type CrystalRole = 'core' | 'node';
+interface RoleState {
+    role: CrystalRole;
+    override: boolean;
+    relayUrl?: string;
+    agentId: string;
+    setAt: string;
+}
+interface RoleInfo {
+    role: CrystalRole;
+    source: 'state-file' | 'auto-detected';
+    relayUrl: string | null;
+    relayToken: boolean;
+    relayKeyExists: boolean;
+    agentId: string;
+    hasLocalEmbeddings: boolean;
+    hasLocalDb: boolean;
+}
+declare function loadRoleState(): RoleState | null;
+declare function detectRole(): RoleInfo;
+declare function promoteToCore(): void;
+declare function demoteToNode(relayUrl?: string): void;
+
+export { type CrystalRole, type RoleInfo, type RoleState, demoteToNode, detectRole, loadRoleState, promoteToCore };

package/dist/role.js

@@ -0,0 +1,13 @@
+import {
+  demoteToNode,
+  detectRole,
+  loadRoleState,
+  promoteToCore
+} from "./chunk-437F27T6.js";
+import "./chunk-DFQ72B7M.js";
+export {
+  demoteToNode,
+  detectRole,
+  loadRoleState,
+  promoteToCore
+};