@wipcomputer/memory-crystal 0.7.29 → 0.7.32

package/dist/pair.js

@@ -1,75 +0,0 @@
-import {
-  RELAY_KEY_PATH,
-  decodePairingString,
-  encodePairingString,
-  generateRelayKey,
-  loadRelayKey
-} from "./chunk-KCQUXVYT.js";
-import "./chunk-EXEZZADG.js";
-
-// src/pair.ts
-import { existsSync, writeFileSync, mkdirSync, chmodSync } from "fs";
-import { dirname } from "path";
-import qrcode from "qrcode-terminal";
-function generateQR(text) {
-  return new Promise((resolve) => {
-    qrcode.generate(text, { small: true }, (code) => {
-      resolve(code);
-    });
-  });
-}
-function saveKey(key) {
-  const dir = dirname(RELAY_KEY_PATH);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-  writeFileSync(RELAY_KEY_PATH, key.toString("base64") + "\n", { mode: 384 });
-  try {
-    chmodSync(RELAY_KEY_PATH, 384);
-  } catch {
-  }
-}
-async function pairShow() {
-  let key;
-  try {
-    key = loadRelayKey();
-    console.log("Relay key found.\n");
-  } catch {
-    console.log("No relay key found. Generating one...");
-    key = generateRelayKey();
-    saveKey(key);
-    console.log(`Key saved to ${RELAY_KEY_PATH}
-`);
-  }
-  const pairingString = encodePairingString(key);
-  console.log("Scan this QR code from your other device:\n");
-  const qr = await generateQR(pairingString);
-  console.log(qr);
-  console.log("Or copy this pairing code:\n");
-  console.log(`  ${pairingString}
-`);
-  console.log("On the other device, run:");
-  console.log(`  crystal pair --code ${pairingString}
-`);
-}
-function pairReceive(code) {
-  const key = decodePairingString(code);
-  if (existsSync(RELAY_KEY_PATH)) {
-    try {
-      const existing = loadRelayKey();
-      if (existing.equals(key)) {
-        console.log("This device already has the same key. Nothing to do.");
-        return;
-      }
-      console.log("Replacing existing relay key with new key from pairing code.");
-    } catch {
-    }
-  }
-  saveKey(key);
-  console.log(`Key received and saved to ${RELAY_KEY_PATH}`);
-  console.log("Relay encryption is now active on this device.");
-}
-export {
-  pairReceive,
-  pairShow
-};

package/dist/poller.d.ts

@@ -1 +0,0 @@
-#!/usr/bin/env node

package/dist/poller.js

@@ -1,634 +0,0 @@
-#!/usr/bin/env node
-import {
-  ensureStaging,
-  isNewAgent,
-  markReady
-} from "./chunk-ZCQYHTNU.js";
-import {
-  generateSessionSummary,
-  writeSummaryFile
-} from "./chunk-Y72C7F6O.js";
-import {
-  pushFileSync
-} from "./chunk-3G3SFYYI.js";
-import {
-  Crystal,
-  resolveConfig
-} from "./chunk-FBQWSDPC.js";
-import {
-  decryptJSON,
-  encryptJSON,
-  loadRelayKey
-} from "./chunk-KCQUXVYT.js";
-import {
-  ensureLdm,
-  resolveStatePath,
-  stateWritePath
-} from "./chunk-EXEZZADG.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);
-  });
-}