sparkecoder 0.1.111 → 0.1.112

package/dist/index.js

@@ -826,9 +826,10 @@ function createDefaultConfig() {
 }
 function loadStoredAuthKey() {
   const locations = [
+    process.env.SPARKECODER_AUTH_KEY_PATH,
     join(process.cwd(), ".sparkecoder", AUTH_KEY_FILE),
     join(getAppDataDirectory(), AUTH_KEY_FILE)
-  ];
+  ].filter((p) => !!p);
   for (const keysPath of locations) {
     if (!existsSync(keysPath)) continue;
     try {
@@ -847,15 +848,44 @@ function saveAuthKey(authKey3, userId) {
     userId
   };
   const json = JSON.stringify(data, null, 2);
-  const appDir = ensureAppDataDirectory();
-  writeFileSync(join(appDir, AUTH_KEY_FILE), json, { mode: 384 });
+  const targets = [];
+  if (process.env.SPARKECODER_AUTH_KEY_PATH) {
+    targets.push({
+      label: "SPARKECODER_AUTH_KEY_PATH",
+      path: process.env.SPARKECODER_AUTH_KEY_PATH
+    });
+  }
   try {
-    const workspaceAuthDir = join(process.cwd(), ".sparkecoder");
-    if (!existsSync(workspaceAuthDir)) {
-      mkdirSync(workspaceAuthDir, { recursive: true });
+    const appDir = ensureAppDataDirectory();
+    targets.push({ label: "app-data", path: join(appDir, AUTH_KEY_FILE) });
+  } catch (err) {
+    console.warn(`[auth-key] could not ensure app data dir: ${err?.message ?? err}`);
+  }
+  targets.push({
+    label: "workspace",
+    path: join(process.cwd(), ".sparkecoder", AUTH_KEY_FILE)
+  });
+  const successes = [];
+  const failures = [];
+  for (const { label, path } of targets) {
+    try {
+      mkdirSync(dirname(path), { recursive: true });
+      writeFileSync(path, json, { mode: 384 });
+      successes.push(`${label}:${path}`);
+    } catch (err) {
+      failures.push({ label, path, error: err?.message ?? String(err) });
     }
-    writeFileSync(join(workspaceAuthDir, AUTH_KEY_FILE), json, { mode: 384 });
-  } catch {
+  }
+  if (successes.length === 0) {
+    const detail = failures.map((f) => `${f.label} (${f.path}): ${f.error}`).join("; ");
+    throw new Error(`Failed to persist auth-key.json to any location. ${detail}`);
+  }
+  if (failures.length > 0) {
+    console.warn(
+      `[auth-key] wrote to ${successes.length}/${targets.length} locations. Success: ${successes.join(", ")}. Failed: ${failures.map((f) => `${f.label} (${f.path}): ${f.error}`).join("; ")}`
+    );
+  } else if (process.env.SPARKECODER_VERBOSE_CONFIG) {
+    console.log(`[auth-key] saved to: ${successes.join(", ")}`);
   }
 }
 function getStoredAuthKeyInfo() {
@@ -8295,15 +8325,30 @@ var init_client3 = __esm({
 });
 
 // src/integrations/channels/slack.ts
+function threadKey(channel, threadTs) {
+  return `${channel}\u241F${threadTs}`;
+}
+function markThreadOwned(channel, threadTs) {
+  ownedThreads.add(threadKey(channel, threadTs));
+}
+function isThreadOwned(channel, threadTs) {
+  return ownedThreads.has(threadKey(channel, threadTs));
+}
 function stripMention(text) {
   return String(text || "").replace(/<@[^>]+>/g, "").trim();
 }
 function slackEventToInboundResult(event) {
   if (!event) return { event: null, dropReason: "empty_text" };
-  if (event.bot_id || event.subtype === "bot_message") return { event: null, dropReason: "bot_message" };
+  if (event.bot_id) return { event: null, dropReason: "bot_message" };
+  if (event.type === "message" && event.subtype && IGNORED_MESSAGE_SUBTYPES.has(event.subtype)) {
+    return { event: null, dropReason: "bot_message" };
+  }
   const isDm = event.type === "message" && event.channel_type === "im";
-  if (event.type !== "app_mention" && !isDm) return { event: null, dropReason: "unsupported_type" };
-  const text = stripMention(event.text);
+  const isThreadReply = event.type === "message" && !isDm && typeof event.thread_ts === "string" && event.thread_ts !== event.ts;
+  if (event.type !== "app_mention" && !isDm && !isThreadReply) {
+    return { event: null, dropReason: "unsupported_type" };
+  }
+  const text = event.type === "app_mention" ? stripMention(event.text) : (event.text ?? "").trim();
   if (!text) return { event: null, dropReason: "empty_text" };
   const policy = getSlackAllowlistPolicy();
   const userAllowlistActive = policy.allowedUsers.length > 0;
@@ -8338,11 +8383,12 @@ function slackEventToInboundResult(event) {
     }
   };
 }
-var slackChannel;
+var ownedThreads, slackChannel, IGNORED_MESSAGE_SUBTYPES;
 var init_slack = __esm({
   "src/integrations/channels/slack.ts"() {
     "use strict";
     init_client3();
+    ownedThreads = /* @__PURE__ */ new Set();
     slackChannel = {
       id: "slack",
       canSend: () => isSlackConfigured(),
@@ -8356,6 +8402,9 @@ var init_slack = __esm({
           threadTs: r.threadTs
         });
         if (!result.ok) throw new Error(`slack post failed: ${result.error}`);
+        if (r.slackChannel && r.threadTs) {
+          markThreadOwned(r.slackChannel, r.threadTs);
+        }
       },
       displayLabel(ref) {
         const r = ref;
@@ -8366,6 +8415,29 @@ var init_slack = __esm({
         return parts.join(" ");
       }
     };
+    IGNORED_MESSAGE_SUBTYPES = /* @__PURE__ */ new Set([
+      "bot_message",
+      "message_changed",
+      "message_deleted",
+      "channel_join",
+      "channel_leave",
+      "channel_topic",
+      "channel_purpose",
+      "channel_name",
+      "channel_archive",
+      "channel_unarchive",
+      "pinned_item",
+      "unpinned_item",
+      "thread_broadcast",
+      // also-broadcast-to-channel replies; the regular thread reply already fires
+      "message_replied",
+      // legacy parent-thread bump
+      "file_share",
+      // we'd handle these later; for now skip to avoid double-handling
+      "reply_broadcast",
+      "tombstone",
+      "huddle_thread"
+    ]);
   }
 });
 
@@ -10667,6 +10739,81 @@ var init_session_lock = __esm({
   }
 });
 
+// src/orchestrator/daemon.ts
+var daemon_exports = {};
+__export(daemon_exports, {
+  startOrchestratorDaemon: () => startOrchestratorDaemon,
+  subscribeToDaemonOutput: () => subscribeToDaemonOutput
+});
+function subscribeToDaemonOutput(sessionId, fn) {
+  let set = listeners.get(sessionId);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    listeners.set(sessionId, set);
+  }
+  set.add(fn);
+  return () => {
+    const s = listeners.get(sessionId);
+    if (!s) return;
+    s.delete(fn);
+    if (s.size === 0) listeners.delete(sessionId);
+  };
+}
+function broadcast(out) {
+  const set = listeners.get(out.sessionId);
+  if (!set) return;
+  for (const fn of set) {
+    try {
+      fn(out);
+    } catch (err) {
+      console.error("[daemon] listener threw:", err?.message || err);
+    }
+  }
+}
+function startOrchestratorDaemon() {
+  setFlushHandler(async (sessionId, events) => {
+    await runDaemonTurn(sessionId, events);
+  });
+}
+async function runDaemonTurn(sessionId, events) {
+  const startedAt = /* @__PURE__ */ new Date();
+  const session = await sessionQueries.getById(sessionId).catch(() => void 0);
+  if (!session) {
+    console.warn(`[daemon] flush for unknown session ${sessionId}; dropping ${events.length} event(s)`);
+    return;
+  }
+  const prompt = events.map((e) => e.content).join("\n\n");
+  let text = "";
+  let error;
+  await withSessionLock(sessionId, async () => {
+    try {
+      const agent = await Agent.create({ sessionId });
+      const result = await agent.stream({ prompt });
+      for await (const part of result.stream.fullStream) {
+        if (part.type === "text-delta") text += part.text || "";
+      }
+      await result.saveResponseMessages();
+    } catch (err) {
+      error = err?.message || String(err);
+      console.error(`[daemon] turn failed for ${sessionId}:`, error);
+    }
+  });
+  const finishedAt = /* @__PURE__ */ new Date();
+  const trimmed = text.trim();
+  broadcast({ sessionId, text: trimmed, triggeredBy: events, startedAt, finishedAt, error });
+}
+var listeners;
+var init_daemon = __esm({
+  "src/orchestrator/daemon.ts"() {
+    "use strict";
+    init_agent();
+    init_session_lock();
+    init_db();
+    init_inbox();
+    listeners = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/tasks/boot-recovery.ts
 var boot_recovery_exports = {};
 __export(boot_recovery_exports, {
@@ -10754,81 +10901,6 @@ var init_ensure_orchestrator = __esm({
   }
 });
 
-// src/orchestrator/daemon.ts
-var daemon_exports = {};
-__export(daemon_exports, {
-  startOrchestratorDaemon: () => startOrchestratorDaemon,
-  subscribeToDaemonOutput: () => subscribeToDaemonOutput
-});
-function subscribeToDaemonOutput(sessionId, fn) {
-  let set = listeners.get(sessionId);
-  if (!set) {
-    set = /* @__PURE__ */ new Set();
-    listeners.set(sessionId, set);
-  }
-  set.add(fn);
-  return () => {
-    const s = listeners.get(sessionId);
-    if (!s) return;
-    s.delete(fn);
-    if (s.size === 0) listeners.delete(sessionId);
-  };
-}
-function broadcast(out) {
-  const set = listeners.get(out.sessionId);
-  if (!set) return;
-  for (const fn of set) {
-    try {
-      fn(out);
-    } catch (err) {
-      console.error("[daemon] listener threw:", err?.message || err);
-    }
-  }
-}
-function startOrchestratorDaemon() {
-  setFlushHandler(async (sessionId, events) => {
-    await runDaemonTurn(sessionId, events);
-  });
-}
-async function runDaemonTurn(sessionId, events) {
-  const startedAt = /* @__PURE__ */ new Date();
-  const session = await sessionQueries.getById(sessionId).catch(() => void 0);
-  if (!session) {
-    console.warn(`[daemon] flush for unknown session ${sessionId}; dropping ${events.length} event(s)`);
-    return;
-  }
-  const prompt = events.map((e) => e.content).join("\n\n");
-  let text = "";
-  let error;
-  await withSessionLock(sessionId, async () => {
-    try {
-      const agent = await Agent.create({ sessionId });
-      const result = await agent.stream({ prompt });
-      for await (const part of result.stream.fullStream) {
-        if (part.type === "text-delta") text += part.text || "";
-      }
-      await result.saveResponseMessages();
-    } catch (err) {
-      error = err?.message || String(err);
-      console.error(`[daemon] turn failed for ${sessionId}:`, error);
-    }
-  });
-  const finishedAt = /* @__PURE__ */ new Date();
-  const trimmed = text.trim();
-  broadcast({ sessionId, text: trimmed, triggeredBy: events, startedAt, finishedAt, error });
-}
-var listeners;
-var init_daemon = __esm({
-  "src/orchestrator/daemon.ts"() {
-    "use strict";
-    init_agent();
-    init_session_lock();
-    init_db();
-    init_inbox();
-    listeners = /* @__PURE__ */ new Map();
-  }
-});
-
 // src/tasks/scheduler.ts
 var scheduler_exports = {};
 __export(scheduler_exports, {
@@ -10960,6 +11032,7 @@ function deriveAgentStatus(input) {
 
 // src/server/routes/sessions.ts
 init_pending_input();
+init_daemon();
 
 // src/server/devtools-store.ts
 var devtoolsContextStore = /* @__PURE__ */ new Map();
@@ -11102,6 +11175,63 @@ sessions2.post(
     }, 201);
   }
 );
+sessions2.get("/:id/updates", async (c) => {
+  const id = c.req.param("id");
+  const session = await sessionQueries.getById(id);
+  if (!session) return c.json({ error: "Session not found" }, 404);
+  const stream = new ReadableStream({
+    start(controller) {
+      const encoder = new TextEncoder();
+      const send = (data) => {
+        try {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+        } catch {
+        }
+      };
+      send({ type: "ready", sessionId: id });
+      const unsubscribe = subscribeToDaemonOutput(id, (output) => {
+        send({
+          type: "turn-complete",
+          sessionId: id,
+          finishedAt: output.finishedAt.toISOString(),
+          triggeredBy: output.triggeredBy.map((e) => e.content?.slice(0, 80)),
+          error: output.error ?? null
+        });
+      });
+      let cleaned = false;
+      const cleanup2 = () => {
+        if (cleaned) return;
+        cleaned = true;
+        clearInterval(keepalive);
+        unsubscribe();
+        try {
+          controller.close();
+        } catch {
+        }
+      };
+      const keepalive = setInterval(() => {
+        try {
+          controller.enqueue(encoder.encode(`: keepalive
+
+`));
+        } catch {
+          cleanup2();
+        }
+      }, 25e3);
+      c.req.raw.signal?.addEventListener("abort", cleanup2);
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no"
+    }
+  });
+});
 sessions2.get("/:id", async (c) => {
   const id = c.req.param("id");
   const session = await sessionQueries.getById(id);
@@ -13849,6 +13979,19 @@ function verifySlackSignature(opts) {
 init_client3();
 init_slack();
 init_inbox();
+var recentlyHandled = /* @__PURE__ */ new Map();
+var MAX_RECENT = 1e3;
+function alreadyHandled(channel, ts) {
+  if (!channel || !ts) return false;
+  const key2 = `${channel}\u241F${ts}`;
+  if (recentlyHandled.has(key2)) return true;
+  recentlyHandled.set(key2, Date.now());
+  if (recentlyHandled.size > MAX_RECENT) {
+    const oldest = recentlyHandled.keys().next().value;
+    if (oldest) recentlyHandled.delete(oldest);
+  }
+  return false;
+}
 var slack = new Hono6();
 slack.post("/events", async (c) => {
   const signingSecret = getSlackSigningSecret();
@@ -13874,8 +14017,26 @@ slack.post("/events", async (c) => {
     return c.json({ challenge: payload.challenge });
   }
   if (payload?.type === "event_callback" && payload?.event) {
-    const { event: inbound, dropReason } = slackEventToInboundResult(payload.event);
+    const ev = payload.event;
+    if (alreadyHandled(ev.channel, ev.ts)) {
+      return c.json({ ok: true });
+    }
+    const { event: inbound, dropReason } = slackEventToInboundResult(ev);
     if (inbound) {
+      const isThreadReply = ev.type === "message" && ev.channel_type !== "im" && typeof ev.thread_ts === "string" && ev.thread_ts !== ev.ts;
+      if (isThreadReply) {
+        const ours = isThreadOwned(ev.channel, ev.thread_ts) || await threadBelongsToUs(ev.channel, ev.thread_ts);
+        if (!ours) {
+          console.log(`[slack] dropping thread reply in unknown thread: channel=${ev.channel} thread=${ev.thread_ts}`);
+          return c.json({ ok: true });
+        }
+      }
+      if (ev.type === "app_mention" && ev.channel && (ev.thread_ts || ev.ts)) {
+        markThreadOwned(ev.channel, ev.thread_ts || ev.ts);
+      }
+      if (ev.type === "message" && ev.channel_type === "im" && ev.channel && (ev.thread_ts || ev.ts)) {
+        markThreadOwned(ev.channel, ev.thread_ts || ev.ts);
+      }
       const orchestratorId = await findOrCreateOrchestratorId();
       if (orchestratorId) {
         pushToInbox(orchestratorId, inbound);
@@ -13892,6 +14053,18 @@ slack.post("/events", async (c) => {
   }
   return c.json({ ok: true });
 });
+async function threadBelongsToUs(channel, threadTs) {
+  try {
+    const sessions3 = await sessionQueries.list(500, 0);
+    return sessions3.some((s) => {
+      const slack2 = s.config?.slack;
+      return slack2?.channel === channel && slack2?.threadTs === threadTs;
+    });
+  } catch (err) {
+    console.warn("[slack] threadBelongsToUs lookup failed:", err?.message ?? err);
+    return false;
+  }
+}
 async function findOrCreateOrchestratorId() {
   try {
     const all = await sessionQueries.list(500, 0);