@integrity-labs/agt-cli 0.15.8 → 0.15.9

package/mcp/slack-channel.js

@@ -13887,9 +13887,22 @@ var StdioServerTransport = class {
 };
 
 // src/slack-channel.ts
-import { readFileSync as readFileSync2, statSync, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, chmodSync } from "fs";
+import {
+  chmodSync,
+  createWriteStream,
+  existsSync,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  readdirSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  watch,
+  writeFileSync as writeFileSync2
+} from "fs";
 import { basename, join as join2, resolve as resolve2 } from "path";
 import { homedir as homedir2 } from "os";
+import { createHash, randomUUID } from "crypto";
 
 // src/slack-thread-store.ts
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -14158,6 +14171,239 @@ var THREAD_AUTO_FOLLOW = process.env.SLACK_THREAD_AUTO_FOLLOW ?? "off";
 var CHANNEL_RESPONSE_MODE = parseResponseMode(process.env.SLACK_CHANNEL_RESPONSE_MODE);
 var RESPONSE_TIMEOUT_MS = 3e5;
 var pendingMessages = /* @__PURE__ */ new Map();
+var SLACK_AGENT_DIR = AGENT_CODE_NAME ? join2(homedir2(), ".augmented", AGENT_CODE_NAME) : null;
+var SLACK_PENDING_INBOUND_DIR = SLACK_AGENT_DIR ? join2(SLACK_AGENT_DIR, "slack-pending-inbound") : null;
+var SLACK_RECOVERY_OUTBOX_DIR = SLACK_AGENT_DIR ? join2(SLACK_AGENT_DIR, "slack-recovery-outbox") : null;
+var SLACK_MAX_RECOVERY_ATTEMPTS = 3;
+function redactSlackId(id) {
+  if (!id) return "<none>";
+  return createHash("sha256").update(id).digest("hex").slice(0, 8);
+}
+function safeSlackMarkerName(channel, threadTs, messageTs) {
+  const safe = (s) => s.replace(/[^A-Za-z0-9_-]/g, "_");
+  return `${safe(channel)}__${safe(threadTs)}__${safe(messageTs)}.json`;
+}
+function slackPendingInboundPath(channel, threadTs, messageTs) {
+  if (!SLACK_PENDING_INBOUND_DIR) return null;
+  return join2(SLACK_PENDING_INBOUND_DIR, safeSlackMarkerName(channel, threadTs, messageTs));
+}
+function writeSlackPendingInboundMarker(channel, threadTs, messageTs) {
+  const path = slackPendingInboundPath(channel, threadTs, messageTs);
+  if (!path || !SLACK_PENDING_INBOUND_DIR) return;
+  const marker = {
+    channel,
+    thread_ts: threadTs,
+    message_ts: messageTs,
+    received_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    mkdirSync2(SLACK_PENDING_INBOUND_DIR, { recursive: true, mode: 448 });
+    writeFileSync2(path, JSON.stringify(marker), { mode: 384 });
+  } catch (err) {
+    process.stderr.write(
+      `slack-channel(${AGENT_CODE_NAME}): pending-inbound marker write failed: ${err.message}
+`
+    );
+  }
+}
+function clearSlackPendingInboundMarker(channel, threadTs, messageTs) {
+  const path = slackPendingInboundPath(channel, threadTs, messageTs);
+  if (!path) return;
+  try {
+    if (existsSync(path)) unlinkSync(path);
+  } catch {
+  }
+}
+function clearAllSlackPendingMarkersForThread(channel, threadTs) {
+  if (!SLACK_PENDING_INBOUND_DIR) return;
+  const safeChan = channel.replace(/[^A-Za-z0-9_-]/g, "_");
+  const safeThread = threadTs.replace(/[^A-Za-z0-9_-]/g, "_");
+  const prefix = `${safeChan}__${safeThread}__`;
+  try {
+    for (const f of readdirSync(SLACK_PENDING_INBOUND_DIR)) {
+      if (!f.startsWith(prefix) || !f.endsWith(".json")) continue;
+      try {
+        unlinkSync(join2(SLACK_PENDING_INBOUND_DIR, f));
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function slackNextRetryName(filename) {
+  const match = filename.match(/^(.*?)(?:\.retry-(\d+))?\.json$/);
+  if (!match) return null;
+  const base = match[1];
+  const prev = match[2] ? parseInt(match[2], 10) : 0;
+  const attempt = prev + 1;
+  if (attempt >= SLACK_MAX_RECOVERY_ATTEMPTS) {
+    return { next: `${base}.retry-${attempt}.poison.json`, attempt };
+  }
+  return { next: `${base}.retry-${attempt}.json`, attempt };
+}
+async function processSlackRecoveryOutboxFile(filename) {
+  if (!SLACK_RECOVERY_OUTBOX_DIR) return;
+  if (filename.endsWith(".poison.json") || filename.endsWith(".tmp")) return;
+  const fullPath = join2(SLACK_RECOVERY_OUTBOX_DIR, filename);
+  let payload;
+  try {
+    payload = JSON.parse(readFileSync2(fullPath, "utf-8"));
+  } catch (err) {
+    process.stderr.write(
+      `slack-channel(${AGENT_CODE_NAME}): recovery outbox parse failed (${filename}): ${err.message}
+`
+    );
+    try {
+      renameSync(fullPath, `${fullPath}.parse-error.poison`);
+    } catch {
+    }
+    return;
+  }
+  if (!payload.channel || !payload.text) {
+    process.stderr.write(
+      `slack-channel(${AGENT_CODE_NAME}): recovery outbox malformed (${filename}): missing channel or text
+`
+    );
+    try {
+      renameSync(fullPath, `${fullPath}.malformed.poison`);
+    } catch {
+    }
+    return;
+  }
+  const text = `[recovered reply] ${payload.text}`;
+  let sendSucceeded = false;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 15e3);
+  try {
+    const res = await fetch("https://slack.com/api/chat.postMessage", {
+      method: "POST",
+      signal: controller.signal,
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${BOT_TOKEN}` },
+      body: JSON.stringify({
+        channel: payload.channel,
+        text,
+        ...payload.thread_ts ? { thread_ts: payload.thread_ts } : {}
+      })
+    });
+    const data = await res.json();
+    if (data.ok) {
+      sendSucceeded = true;
+      process.stderr.write(
+        `slack-channel(${AGENT_CODE_NAME}): ghost-reply recovery sent (channel=${redactSlackId(payload.channel)} thread=${redactSlackId(payload.thread_ts)})
+`
+      );
+      if (payload.thread_ts) {
+        clearAllSlackPendingMarkersForThread(payload.channel, payload.thread_ts);
+      }
+    } else {
+      process.stderr.write(
+        `slack-channel(${AGENT_CODE_NAME}): ghost-reply recovery failed (channel=${redactSlackId(payload.channel)}): ${data.error ?? "unknown"}
+`
+      );
+    }
+  } catch (err) {
+    const msg = err.name === "AbortError" ? "timed out after 15s" : err.message;
+    process.stderr.write(
+      `slack-channel(${AGENT_CODE_NAME}): ghost-reply recovery error (channel=${redactSlackId(payload.channel)}): ${msg}
+`
+    );
+  } finally {
+    clearTimeout(timeoutId);
+  }
+  if (sendSucceeded) {
+    try {
+      unlinkSync(fullPath);
+    } catch {
+    }
+    return;
+  }
+  const next = slackNextRetryName(filename);
+  if (next) {
+    try {
+      renameSync(fullPath, join2(SLACK_RECOVERY_OUTBOX_DIR, next.next));
+      if (next.attempt >= SLACK_MAX_RECOVERY_ATTEMPTS) {
+        process.stderr.write(
+          `slack-channel(${AGENT_CODE_NAME}): ghost-reply recovery exhausted retries \u2014 moved to ${next.next}
+`
+        );
+      }
+    } catch {
+    }
+  }
+}
+function isFirstAttemptSlackOutboxFile(filename) {
+  if (!filename.endsWith(".json")) return false;
+  if (filename.includes(".retry-")) return false;
+  if (filename.endsWith(".poison.json") || filename.endsWith(".tmp")) return false;
+  if (filename.startsWith(".")) return false;
+  return true;
+}
+var SLACK_RETRY_SCAN_INTERVAL_MS = 6e4;
+var SLACK_RETRY_BACKOFF_BASE_MS = 6e4;
+function shouldRetrySlackNow(filename, mtimeMs) {
+  const match = filename.match(/\.retry-(\d+)\.json$/);
+  if (!match) return false;
+  const attempt = parseInt(match[1], 10);
+  return Date.now() - mtimeMs >= attempt * SLACK_RETRY_BACKOFF_BASE_MS;
+}
+function scanSlackRecoveryRetries() {
+  if (!SLACK_RECOVERY_OUTBOX_DIR) return;
+  let entries;
+  try {
+    entries = readdirSync(SLACK_RECOVERY_OUTBOX_DIR);
+  } catch {
+    return;
+  }
+  for (const f of entries) {
+    if (!f.endsWith(".json")) continue;
+    if (!f.includes(".retry-") || f.endsWith(".poison.json")) continue;
+    let mtimeMs;
+    try {
+      mtimeMs = statSync(join2(SLACK_RECOVERY_OUTBOX_DIR, f)).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (shouldRetrySlackNow(f, mtimeMs)) {
+      void processSlackRecoveryOutboxFile(f);
+    }
+  }
+}
+function startSlackRecoveryOutboxWatcher() {
+  if (!SLACK_RECOVERY_OUTBOX_DIR) return;
+  try {
+    mkdirSync2(SLACK_RECOVERY_OUTBOX_DIR, { recursive: true, mode: 448 });
+  } catch (err) {
+    process.stderr.write(
+      `slack-channel(${AGENT_CODE_NAME}): recovery outbox mkdir failed: ${err.message}
+`
+    );
+    return;
+  }
+  try {
+    for (const f of readdirSync(SLACK_RECOVERY_OUTBOX_DIR)) {
+      if (isFirstAttemptSlackOutboxFile(f)) void processSlackRecoveryOutboxFile(f);
+    }
+  } catch {
+  }
+  try {
+    const watcher = watch(SLACK_RECOVERY_OUTBOX_DIR, (event, filename) => {
+      if (event !== "rename" || !filename) return;
+      if (!isFirstAttemptSlackOutboxFile(filename)) return;
+      if (existsSync(join2(SLACK_RECOVERY_OUTBOX_DIR, filename))) {
+        void processSlackRecoveryOutboxFile(filename);
+      }
+    });
+    watcher.unref?.();
+  } catch (err) {
+    process.stderr.write(
+      `slack-channel(${AGENT_CODE_NAME}): recovery outbox watch failed: ${err.message}
+`
+    );
+  }
+  const retryTimer = setInterval(scanSlackRecoveryRetries, SLACK_RETRY_SCAN_INTERVAL_MS);
+  retryTimer.unref?.();
+}
+startSlackRecoveryOutboxWatcher();
 function trackPendingMessage(channel, threadTs, messageTs) {
   const key = `${channel}:${threadTs}:${messageTs}`;
   const timer = setTimeout(async () => {
@@ -14182,10 +14428,12 @@ function trackPendingMessage(channel, threadTs, messageTs) {
       });
     } catch {
     }
-    process.stderr.write(`slack-channel: Response timeout for message ${messageTs} in ${channel}
+    process.stderr.write(`slack-channel: Response timeout for message ${redactSlackId(messageTs)} in ${redactSlackId(channel)}
 `);
+    clearSlackPendingInboundMarker(channel, threadTs, messageTs);
   }, RESPONSE_TIMEOUT_MS);
   pendingMessages.set(key, timer);
+  writeSlackPendingInboundMarker(channel, threadTs, messageTs);
 }
 function clearPendingMessage(channel, threadTs) {
   for (const [key, timer] of pendingMessages) {
@@ -14194,6 +14442,90 @@ function clearPendingMessage(channel, threadTs) {
       pendingMessages.delete(key);
     }
   }
+  clearAllSlackPendingMarkersForThread(channel, threadTs);
+}
+var RESTART_FLAGS_DIR = join2(homedir2(), ".augmented", "restart-flags");
+function hashChannelId(id) {
+  return createHash("sha256").update(id).digest("hex").slice(0, 8);
+}
+async function postSlackMessage(body) {
+  try {
+    const res = await fetch("https://slack.com/api/chat.postMessage", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json; charset=utf-8",
+        Authorization: `Bearer ${BOT_TOKEN}`
+      },
+      body: JSON.stringify(body),
+      // Hard deadline so a hung Slack API can't stall the live Socket Mode
+      // event loop or the manager's restart ack path. Matches the timeout
+      // used elsewhere in this file for chat.postMessage.
+      signal: AbortSignal.timeout(SLACK_DOWNLOAD_TIMEOUT_MS)
+    });
+    return await res.json();
+  } catch (err) {
+    const isTimeout = err.name === "TimeoutError" || err.name === "AbortError";
+    return { ok: false, error: isTimeout ? "timeout" : err.message };
+  }
+}
+async function handleRestartCommand(opts) {
+  const codeName = AGENT_CODE_NAME ?? "unknown";
+  try {
+    if (!existsSync(RESTART_FLAGS_DIR)) {
+      mkdirSync2(RESTART_FLAGS_DIR, { recursive: true });
+    }
+    const flagPath = join2(RESTART_FLAGS_DIR, `${codeName}.flag`);
+    const flag = {
+      codeName,
+      source: "slack",
+      ts: Date.now(),
+      reply: {
+        channel: opts.channel,
+        ...opts.threadTs ? { thread_ts: opts.threadTs } : {},
+        message_ts: opts.ts
+      }
+    };
+    const tmpPath = `${flagPath}.${process.pid}.${randomUUID()}.tmp`;
+    writeFileSync2(tmpPath, JSON.stringify(flag) + "\n", "utf8");
+    renameSync(tmpPath, flagPath);
+    process.stderr.write(
+      `slack-channel(${codeName}): /restart queued from channel ${hashChannelId(opts.channel)}
+`
+    );
+    const ack = await postSlackMessage({
+      channel: opts.channel,
+      text: `\u23F3 Restart queued for \`${codeName}\`. The session will reconnect in a few seconds.`,
+      ...opts.threadTs ? { thread_ts: opts.threadTs } : {}
+    });
+    if (!ack.ok) {
+      process.stderr.write(
+        `slack-channel(${codeName}): /restart ack send failed: ${ack.error ?? "unknown"}
+`
+      );
+    }
+  } catch (err) {
+    process.stderr.write(
+      `slack-channel(${codeName}): /restart flag write failed: ${redactAugmentedPaths(err.message)}
+`
+    );
+    await postSlackMessage({
+      channel: opts.channel,
+      text: `\u274C Failed to queue restart for ${codeName}. Please try again in a few seconds.`,
+      ...opts.threadTs ? { thread_ts: opts.threadTs } : {}
+    });
+  }
+}
+async function denyUnauthorizedRestart(opts) {
+  const codeName = AGENT_CODE_NAME ?? "unknown";
+  process.stderr.write(
+    `slack-channel(${codeName}): /restart denied \u2014 sender not in SLACK_ALLOWED_USERS, channel ${hashChannelId(opts.channel)}
+`
+  );
+  await postSlackMessage({
+    channel: opts.channel,
+    text: `\u{1F6AB} \`/restart\` denied \u2014 your Slack user is not in the allowlist for \`${codeName}\`.`,
+    ...opts.threadTs ? { thread_ts: opts.threadTs } : {}
+  });
 }
 var trackedThreads = /* @__PURE__ */ new Map();
 var THREAD_STORE_PATH = resolveThreadStorePath();
@@ -14233,6 +14565,28 @@ if (!BOT_TOKEN || !APP_TOKEN) {
   );
   process.exit(1);
 }
+var slackStderrLogStream = null;
+if (AGENT_CODE_NAME) {
+  try {
+    const logDir = join2(homedir2(), ".augmented", AGENT_CODE_NAME);
+    mkdirSync2(logDir, { recursive: true });
+    slackStderrLogStream = createWriteStream(join2(logDir, "slack-channel-stderr.log"), {
+      flags: "a",
+      mode: 384
+    });
+    const origWrite = process.stderr.write.bind(process.stderr);
+    process.stderr.write = (chunk, ...rest) => {
+      try {
+        const buf = typeof chunk === "string" ? chunk : String(chunk);
+        const ts = (/* @__PURE__ */ new Date()).toISOString();
+        slackStderrLogStream?.write(`[${ts}] ${buf}${buf.endsWith("\n") ? "" : "\n"}`);
+      } catch {
+      }
+      return origWrite(chunk, ...rest);
+    };
+  } catch {
+  }
+}
 async function getBotUserId() {
   try {
     const res = await fetch("https://slack.com/api/auth.test", {
@@ -14268,16 +14622,17 @@ var mcp = new Server(
     // Attachments rules live near the top because they get chopped otherwise
     // and the agent silently loses attachment-handling guidance.
     instructions: [
-      'Messages from Slack arrive as <channel source="slack" user="<slack-id>" user_name="<display-name>" channel="..." thread_ts="...">.',
+      // Highest-priority lines first — Claude Code truncates this string at
+      // 2048 chars, so anything appended late silently disappears.
+      "CRITICAL: every response to a Slack <channel> tag MUST go through slack.reply. Text in your session WITHOUT a slack.reply call never reaches the user \u2014 the message dies inside the agent process.",
+      'Messages from Slack arrive as <channel source="slack" user="<slack-id>" user_name="<display-name>" channel="..." thread_ts="...">. Pass channel + thread_ts from the tag to slack.reply; always include thread_ts on threaded replies.',
       selfIdentityInstruction,
-      "Inbound attachments: the <channel> tag's `files` attribute is a JSON-serialised array \u2014 JSON.parse it before iterating. If a file entry has a `path`, the image is ALREADY DOWNLOADED locally \u2014 Read that path directly, do NOT call slack.download_attachment. That tool is only for entries with `file_id` but NO `path` (PDF, docx, csv, etc.): pass file_id + channel verbatim (never paraphrase), then Read the returned path. Single-image messages also get a top-level `image_path` convenience attribute; multi-image messages omit it. Never tell the user about internal file-handling failures that don't affect the answer.",
-      "Reply via slack.reply passing channel and thread_ts from the tag. Always include thread_ts on threaded replies so the response lands in the same thread.",
-      "Address users by user_name, never by raw user ID. In multi-participant threads the CURRENT speaker is the one on the latest <channel> tag \u2014 don't conflate with earlier participants.",
-      "Mentioned in a channel \u2192 respond in that thread. DM \u2192 respond directly.",
-      'auto_followed="true" messages are from threads you previously joined: reply only if you have something useful to add. Skip if the conversation moved on, the message is directed at someone else, or your input would not add value.',
-      "Reaction taxonomy (use slack.react sparingly \u2014 most messages need a reply, not a reaction): \u{1F440} = ack/working on it (already auto-added on inbound, do not duplicate); \u2705 = action completed successfully. NEVER react to signal failure \u2014 users misread emoji reactions and don't know why something failed. If an action failed, send a slack.reply with one sentence explaining what went wrong (no stack traces, no secrets) so the user understands.",
-      `When a message in a thread is not addressed to you (different @-mention, conversation between others, auto_followed catch-up): SILENTLY SKIP \u2014 no reaction, no reply, do nothing. Do NOT post a "this wasn't for me" message and do NOT add a failure reaction; either is misleading.`,
-      "To deliver a file, save it under your project dir and call slack.upload_file with path, channel, thread_ts."
+      "Inbound attachments: <channel> `files` is a JSON-serialised array \u2014 JSON.parse it. If an entry has `path`, the image is already downloaded \u2014 Read it directly, do NOT call slack.download_attachment. Use that tool only for entries with `file_id` but NO `path` (PDF, docx, csv): pass file_id + channel verbatim, then Read the returned path. Single-image messages also get a top-level `image_path`. Don't surface internal file-handling errors that don't affect the answer.",
+      "Address users by user_name, never by raw user ID. In multi-participant threads the CURRENT speaker is the one on the latest <channel> tag.",
+      'Mentioned in a channel \u2192 respond in that thread. DM \u2192 respond directly. auto_followed="true" \u2192 only reply if you have something useful to add.',
+      "Reaction taxonomy (use slack.react sparingly \u2014 prefer a reply): \u{1F440} = ack (already auto-added on inbound, do not duplicate); \u2705 = success. NEVER react to signal failure \u2014 users can't tell why something failed from an emoji. On failure, slack.reply with one sentence explaining what went wrong (no stack traces, no secrets).",
+      `When a thread message is NOT addressed to you (different @-mention, side conversation, auto_followed catch-up): SILENTLY SKIP \u2014 no reaction, no reply, no "this wasn't for me" message.`,
+      "To deliver a file: save under your project dir, call slack.upload_file with path + channel + thread_ts."
     ].join(" ")
   }
 );
@@ -14876,6 +15231,28 @@ async function connectSocketMode() {
       const isThreadReply = !!evt.thread_ts && evt.thread_ts !== evt.ts;
       const trackTs = evt.thread_ts ?? evt.ts ?? "";
       const threadKey = buildThreadKey(evt.channel, trackTs);
+      const rawText = evt.text ?? "";
+      const strippedText = rawText.replace(/^\s*<@[^>]+>\s*/, "").trim();
+      const isRestartCommand = strippedText === "/restart" || strippedText.startsWith("/restart ");
+      if (isRestartCommand) {
+        const senderAllowed = ALLOWED_USERS.size === 0 || evt.user != null && ALLOWED_USERS.has(evt.user);
+        if (!senderAllowed) {
+          await denyUnauthorizedRestart({
+            channel: evt.channel ?? "",
+            threadTs: evt.thread_ts
+          });
+          return;
+        }
+        await handleRestartCommand({
+          channel: evt.channel ?? "",
+          // Only carry thread_ts when the originating message was already
+          // threaded; a top-level command acks in-channel rather than
+          // synthesising a brand-new thread (CodeRabbit feedback).
+          threadTs: evt.thread_ts,
+          ts: evt.ts ?? ""
+        });
+        return;
+      }
       if (ALLOWED_USERS.size > 0 && evt.user && !ALLOWED_USERS.has(evt.user)) return;
       if (evt.type === "app_mention") {
         rememberThread(evt.channel, trackTs, "mentioned");