@integrity-labs/agt-cli 0.23.1 → 0.24.0

package/dist/mcp/index.js

@@ -22293,6 +22293,77 @@ async function registerForwardedApiTools() {
   }
   return { registered, skipped };
 }
+server.tool(
+  "projects.list",
+  "List artefacts (websites, slide decks, mockups) this agent has previously published. Call this BEFORE re-publishing to find and modify existing work instead of creating duplicates.",
+  {
+    publisher: external_exports.string().optional().describe('Filter by publisher (e.g. "here-now")'),
+    kind: external_exports.enum(["mockup", "deck", "site", "app", "other"]).optional().describe("Filter by artefact kind"),
+    limit: external_exports.number().int().min(1).max(100).optional().describe("Maximum projects to return (default 50, max 100)")
+  },
+  async (params) => {
+    const data = await apiPost("/host/my-published-projects", {
+      agent_id: AGT_AGENT_ID,
+      publisher: params.publisher,
+      kind: params.kind,
+      limit: params.limit
+    });
+    if (!data.projects.length) {
+      return { content: [{ type: "text", text: "No published projects yet." }] };
+    }
+    const lines = data.projects.map((p) => {
+      const title = p.title ?? "(untitled)";
+      const expires = p.expires_at ? ` expires ${p.expires_at}` : "";
+      return `- [${p.kind}] ${title} \u2014 ${p.live_url} (id: ${p.id}, ${p.mode}, published ${p.published_at}${expires})`;
+    });
+    return { content: [{ type: "text", text: lines.join("\n") }] };
+  }
+);
+server.tool(
+  "projects.get",
+  "Fetch metadata for a single published project. Returns the project record without the source HTML \u2014 call projects.get_source_chunk to retrieve the HTML in chunks when you need to modify it.",
+  {
+    project_id: external_exports.string().uuid().describe("The project id returned by projects.list")
+  },
+  async (params) => {
+    const data = await apiPost(`/host/published-project/${encodeURIComponent(params.project_id)}`, {
+      agent_id: AGT_AGENT_ID
+    });
+    const p = data.project;
+    const header = [
+      `Project: ${p.title ?? "(untitled)"} [${p.kind}]`,
+      `Publisher: ${p.publisher} (${p.mode})`,
+      `Live URL: ${p.live_url}`,
+      p.claim_url ? `Claim URL: ${p.claim_url}` : null,
+      `Published: ${p.published_at}`,
+      p.expires_at ? `Expires: ${p.expires_at}` : null,
+      `Last modified: ${p.last_modified_at}`,
+      p.has_source_html ? `Source HTML: ${p.source_html_length} bytes (call projects.get_source_chunk to fetch)` : "(source HTML not preserved for this project)"
+    ].filter((s) => s !== null).join("\n");
+    return { content: [{ type: "text", text: header }] };
+  }
+);
+server.tool(
+  "projects.get_source_chunk",
+  "Fetch a chunk of source HTML for a published project. Use this to assemble the HTML for modification when projects.get reports a non-zero source_html_length.",
+  {
+    project_id: external_exports.string().uuid().describe("The project id returned by projects.list"),
+    offset: external_exports.number().int().min(0).describe("Byte offset into the source HTML to start from"),
+    limit: external_exports.number().int().min(1).max(65536).optional().describe("Max bytes to return (default 32KB, max 64KB)")
+  },
+  async (params) => {
+    const data = await apiPost(`/host/published-project/${encodeURIComponent(params.project_id)}/source-chunk`, {
+      agent_id: AGT_AGENT_ID,
+      offset: params.offset,
+      limit: params.limit
+    });
+    const trailer = data.end_of_content ? "\n\n---\n(end of source)" : `
+
+---
+(more \u2014 next offset: ${data.offset + data.length}, total: ${data.total_length} bytes)`;
+    return { content: [{ type: "text", text: data.chunk + trailer }] };
+  }
+);
 async function main() {
   try {
     const result = await registerForwardedApiTools();

package/dist/mcp/slack-channel.js

@@ -14890,21 +14890,16 @@ var StdioServerTransport = class {
 // src/slack-channel.ts
 import {
   chmodSync,
-  closeSync,
   createWriteStream,
   existsSync,
-  fsyncSync,
-  ftruncateSync,
   mkdirSync as mkdirSync2,
-  openSync,
   readFileSync as readFileSync2,
   readdirSync,
   renameSync,
-  statSync as statSync2,
+  statSync,
   unlinkSync,
   watch,
-  writeFileSync as writeFileSync2,
-  writeSync
+  writeFileSync as writeFileSync2
 } from "fs";
 import { basename, join as join2, resolve as resolve2 } from "path";
 import { homedir as homedir2 } from "os";
@@ -15503,40 +15498,6 @@ function createSlackBotUserIdClient(args) {
   };
 }
 
-// src/pending-reminder-schedule.ts
-import { statSync } from "fs";
-var REMINDER_SCHEDULE_MS = [5, 10, 20].map((m) => m * 6e4);
-var MAX_REMINDERS = REMINDER_SCHEDULE_MS.length;
-var RESPONSE_TIMEOUT_MS = REMINDER_SCHEDULE_MS[0];
-function nextReminderFireAtMs(receivedAtMs, currentReminderCount) {
-  const safeCount = Number.isFinite(currentReminderCount) ? Math.max(0, Math.trunc(currentReminderCount)) : 0;
-  let elapsed = 0;
-  for (let i = 0; i <= safeCount && i < MAX_REMINDERS; i++) {
-    elapsed += REMINDER_SCHEDULE_MS[i];
-  }
-  return receivedAtMs + elapsed;
-}
-function reminderText(reminderIndex, cancelCommandAvailable) {
-  switch (reminderIndex) {
-    case 0:
-      return "Heads-up \u2014 I'm still on it. This one's taking more than the usual minute.";
-    case 1:
-      return "Still working. Going deeper than expected; back when I have something useful.";
-    case 2:
-    default:
-      return cancelCommandAvailable ? "I'm 30+ min in on this. Type `/cancel` to abort, or ping me if it's urgent and I'll re-scope." : "I'm 30+ min in on this. If the answer's urgent, ping me and I'll pause to triage. Otherwise I'll keep going.";
-  }
-}
-function agentTurnEndedSinceInbound(lastStopAtPath, receivedAtMs, deps = { statSync }) {
-  if (!lastStopAtPath) return false;
-  try {
-    const stat = deps.statSync(lastStopAtPath);
-    return stat.mtimeMs > receivedAtMs;
-  } catch {
-    return false;
-  }
-}
-
 // src/slack-channel.ts
 var BOT_TOKEN = process.env.SLACK_BOT_TOKEN;
 var APP_TOKEN = process.env.SLACK_APP_TOKEN;
@@ -15581,12 +15542,9 @@ var SLACK_PEER_CLASSIFIER_CONFIG = {
   peers: parsePeersEnv(process.env.SLACK_PEERS, process.env.SLACK_PEERS_GATE),
   peer_disabled_mode: SLACK_PEER_DISABLED_MODE
 };
-var pendingMessages = /* @__PURE__ */ new Map();
-var CANCEL_COMMAND_AVAILABLE = false;
 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 LAST_STOP_AT_PATH = SLACK_AGENT_DIR ? join2(SLACK_AGENT_DIR, "last-stop-at") : null;
 var SLACK_MAX_RECOVERY_ATTEMPTS = 3;
 function redactSlackId(id) {
   if (!id) return "<none>";
@@ -15619,57 +15577,6 @@ function writeSlackPendingInboundMarker(channel, threadTs, messageTs) {
     );
   }
 }
-function updateSlackPendingInboundMarker(marker) {
-  const path = slackPendingInboundPath(marker.channel, marker.thread_ts, marker.message_ts);
-  if (!path) return false;
-  let fd;
-  try {
-    fd = openSync(path, "r+");
-  } catch (err) {
-    const code = err.code;
-    if (code === "ENOENT") return false;
-    process.stderr.write(
-      `slack-channel(${AGENT_CODE_NAME}): pending-inbound marker open-for-update failed: ${err.message}
-`
-    );
-    return false;
-  }
-  try {
-    const payload = Buffer.from(JSON.stringify(marker));
-    ftruncateSync(fd, 0);
-    writeSync(fd, payload, 0, payload.length, 0);
-    fsyncSync(fd);
-    return true;
-  } catch (err) {
-    process.stderr.write(
-      `slack-channel(${AGENT_CODE_NAME}): pending-inbound marker write failed: ${err.message}
-`
-    );
-    return false;
-  } finally {
-    try {
-      closeSync(fd);
-    } catch {
-    }
-  }
-}
-function readSlackPendingInboundMarker(channel, threadTs, messageTs) {
-  const path = slackPendingInboundPath(channel, threadTs, messageTs);
-  if (!path || !existsSync(path)) return null;
-  try {
-    return JSON.parse(readFileSync2(path, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-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, "_");
@@ -15816,7 +15723,7 @@ function scanSlackRecoveryRetries() {
     if (!f.includes(".retry-") || f.endsWith(".poison.json")) continue;
     let mtimeMs;
     try {
-      mtimeMs = statSync2(join2(SLACK_RECOVERY_OUTBOX_DIR, f)).mtimeMs;
+      mtimeMs = statSync(join2(SLACK_RECOVERY_OUTBOX_DIR, f)).mtimeMs;
     } catch {
       continue;
     }
@@ -15861,105 +15768,11 @@ function startSlackRecoveryOutboxWatcher() {
   retryTimer.unref?.();
 }
 startSlackRecoveryOutboxWatcher();
-var SLACK_REMINDER_FETCH_TIMEOUT_MS = 1e4;
-async function slackFetchWithTimeout(url, body) {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), SLACK_REMINDER_FETCH_TIMEOUT_MS);
-  try {
-    await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", Authorization: `Bearer ${BOT_TOKEN}` },
-      body: JSON.stringify(body),
-      signal: controller.signal
-    });
-  } finally {
-    clearTimeout(timeoutId);
-  }
-}
-async function fireSlackResponseTimeout(channel, threadTs, messageTs) {
-  const marker = readSlackPendingInboundMarker(channel, threadTs, messageTs);
-  if (!marker) {
-    return;
-  }
-  const receivedAtMs = Date.parse(marker.received_at);
-  if (Number.isFinite(receivedAtMs) && agentTurnEndedSinceInbound(LAST_STOP_AT_PATH, receivedAtMs)) {
-    process.stderr.write(
-      `slack-channel(${AGENT_CODE_NAME}): suppressing reminder for ${redactSlackId(messageTs)} in ${redactSlackId(channel)} \u2014 turn ended after inbound at ${marker.received_at}; clearing marker
-`
-    );
-    const key2 = `${channel}:${threadTs}:${messageTs}`;
-    const existing = pendingMessages.get(key2);
-    if (existing) {
-      clearTimeout(existing);
-      pendingMessages.delete(key2);
-    }
-    clearSlackPendingInboundMarker(channel, threadTs, messageTs);
-    return;
-  }
-  const reminderIndex = marker.reminder_count ?? 0;
-  if (reminderIndex >= MAX_REMINDERS) {
-    return;
-  }
-  try {
-    await slackFetchWithTimeout("https://slack.com/api/chat.postMessage", {
-      channel,
-      thread_ts: threadTs,
-      text: reminderText(reminderIndex, CANCEL_COMMAND_AVAILABLE)
-    });
-  } catch {
-  }
-  if (reminderIndex === 1) {
-    try {
-      await slackFetchWithTimeout("https://slack.com/api/reactions.remove", {
-        channel,
-        timestamp: messageTs,
-        name: "eyes"
-      });
-    } catch {
-    }
-    try {
-      await slackFetchWithTimeout("https://slack.com/api/reactions.add", {
-        channel,
-        timestamp: messageTs,
-        name: "hourglass_flowing_sand"
-      });
-    } catch {
-    }
-  }
-  const nextCount = reminderIndex + 1;
-  const persisted = updateSlackPendingInboundMarker({ ...marker, reminder_count: nextCount });
-  if (!persisted) {
-    process.stderr.write(
-      `slack-channel(${AGENT_CODE_NAME}): reminder ${nextCount}/${MAX_REMINDERS} posted but marker cleared mid-fire (agent replied) \u2014 not arming next timer
-`
-    );
-    return;
-  }
-  process.stderr.write(
-    `slack-channel(${AGENT_CODE_NAME}): reminder ${nextCount}/${MAX_REMINDERS} posted for message ${redactSlackId(messageTs)} in ${redactSlackId(channel)} (marker left pending)
-`
-  );
-  if (nextCount < MAX_REMINDERS) {
-    armSlackPendingTimer(channel, threadTs, messageTs, REMINDER_SCHEDULE_MS[nextCount]);
-  }
-}
-function armSlackPendingTimer(channel, threadTs, messageTs, durationMs) {
-  const key2 = `${channel}:${threadTs}:${messageTs}`;
-  const existing = pendingMessages.get(key2);
-  if (existing) clearTimeout(existing);
-  const timer = setTimeout(() => {
-    pendingMessages.delete(key2);
-    void fireSlackResponseTimeout(channel, threadTs, messageTs);
-  }, Math.max(0, durationMs));
-  timer.unref?.();
-  pendingMessages.set(key2, timer);
-}
+var STALE_MARKER_MS = 24 * 60 * 60 * 1e3;
 function trackPendingMessage(channel, threadTs, messageTs) {
   writeSlackPendingInboundMarker(channel, threadTs, messageTs);
-  armSlackPendingTimer(channel, threadTs, messageTs, RESPONSE_TIMEOUT_MS);
 }
-var STALE_MARKER_MS = 24 * 60 * 60 * 1e3;
-function rearmSlackPendingTimersFromDisk() {
+function sweepSlackStaleMarkersOnBoot() {
   if (!SLACK_PENDING_INBOUND_DIR) return;
   if (!existsSync(SLACK_PENDING_INBOUND_DIR)) return;
   let filenames;
@@ -15967,16 +15780,13 @@ function rearmSlackPendingTimersFromDisk() {
     filenames = readdirSync(SLACK_PENDING_INBOUND_DIR);
   } catch (err) {
     process.stderr.write(
-      `slack-channel(${AGENT_CODE_NAME}): rearm readdir failed: ${err.message}
+      `slack-channel(${AGENT_CODE_NAME}): stale-marker readdir failed: ${err.message}
 `
     );
     return;
   }
   const now = Date.now();
-  let armed = 0;
-  let firedNow = 0;
   let cleared = 0;
-  let exhausted = 0;
   for (const filename of filenames) {
     if (!filename.endsWith(".json")) continue;
     if (filename.endsWith(".tmp")) continue;
@@ -15986,25 +15796,18 @@ function rearmSlackPendingTimersFromDisk() {
       marker = JSON.parse(readFileSync2(fullPath, "utf-8"));
     } catch (err) {
       process.stderr.write(
-        `slack-channel(${AGENT_CODE_NAME}): rearm parse failed for ${filename}: ${err.message}
+        `slack-channel(${AGENT_CODE_NAME}): stale-marker parse failed for ${redactSlackId(filename)}: ${err.message}
 `
       );
       try {
         unlinkSync(fullPath);
       } catch {
       }
+      cleared++;
       continue;
     }
     const { channel, thread_ts, message_ts, received_at } = marker;
     if (!channel || !thread_ts || !message_ts || !received_at) {
-      try {
-        unlinkSync(fullPath);
-      } catch {
-      }
-      continue;
-    }
-    const receivedAtMs = Date.parse(received_at);
-    if (!Number.isFinite(receivedAtMs)) {
       try {
         unlinkSync(fullPath);
       } catch {
@@ -16012,49 +15815,24 @@ function rearmSlackPendingTimersFromDisk() {
       cleared++;
       continue;
     }
-    if (now - receivedAtMs > STALE_MARKER_MS) {
-      process.stderr.write(
-        `slack-channel(${AGENT_CODE_NAME}): rearm skipping stale marker channel=${redactSlackId(channel)} message=${redactSlackId(message_ts)}
-`
-      );
+    const receivedAtMs = Date.parse(received_at);
+    if (!Number.isFinite(receivedAtMs) || receivedAtMs > now || now - receivedAtMs > STALE_MARKER_MS) {
       try {
         unlinkSync(fullPath);
       } catch {
       }
       cleared++;
-      continue;
-    }
-    const reminderCount = marker.reminder_count ?? 0;
-    if (reminderCount >= MAX_REMINDERS) {
-      exhausted++;
-      continue;
-    }
-    const nextFireAt = nextReminderFireAtMs(receivedAtMs, reminderCount);
-    const remainingMs = nextFireAt - now;
-    if (remainingMs <= 0) {
-      pendingMessages.delete(`${channel}:${thread_ts}:${message_ts}`);
-      void fireSlackResponseTimeout(channel, thread_ts, message_ts);
-      firedNow++;
-    } else {
-      armSlackPendingTimer(channel, thread_ts, message_ts, remainingMs);
-      armed++;
     }
   }
-  if (armed > 0 || firedNow > 0 || cleared > 0 || exhausted > 0) {
+  if (cleared > 0) {
     process.stderr.write(
-      `slack-channel(${AGENT_CODE_NAME}): rearm summary armed=${armed} fired_now=${firedNow} stale_cleared=${cleared} reminders_exhausted=${exhausted}
+      `slack-channel(${AGENT_CODE_NAME}): stale-marker sweep cleared=${cleared}
 `
     );
   }
 }
-rearmSlackPendingTimersFromDisk();
+sweepSlackStaleMarkersOnBoot();
 function clearPendingMessage(channel, threadTs) {
-  for (const [key2, timer] of pendingMessages) {
-    if (key2.startsWith(`${channel}:${threadTs}:`)) {
-      clearTimeout(timer);
-      pendingMessages.delete(key2);
-    }
-  }
   clearAllSlackPendingMarkersForThread(channel, threadTs);
 }
 function noteThreadActivity(channel, threadTs) {
@@ -16064,16 +15842,24 @@ function noteThreadActivity(channel, threadTs) {
 function noteThreadActivityByMessageTs(channel, messageTs) {
   if (!channel || !messageTs) return;
   clearPendingMessage(channel, messageTs);
-  const suffix = `:${messageTs}`;
-  for (const [key2, timer] of pendingMessages) {
-    if (!key2.startsWith(`${channel}:`)) continue;
-    if (!key2.endsWith(suffix)) continue;
-    clearTimeout(timer);
-    pendingMessages.delete(key2);
-    const parts = key2.split(":");
-    if (parts.length >= 3) {
-      const threadTs = parts[1];
-      clearSlackPendingInboundMarker(channel, threadTs, messageTs);
+  if (!SLACK_PENDING_INBOUND_DIR) return;
+  if (!existsSync(SLACK_PENDING_INBOUND_DIR)) return;
+  let filenames;
+  try {
+    filenames = readdirSync(SLACK_PENDING_INBOUND_DIR);
+  } catch {
+    return;
+  }
+  const safeChannel = channel.replace(/[^A-Za-z0-9_-]/g, "_");
+  const safeMessageTs = messageTs.replace(/[^A-Za-z0-9_-]/g, "_");
+  const channelPrefix = `${safeChannel}__`;
+  const messageSuffix = `__${safeMessageTs}.json`;
+  for (const filename of filenames) {
+    if (!filename.startsWith(channelPrefix)) continue;
+    if (!filename.endsWith(messageSuffix)) continue;
+    try {
+      unlinkSync(join2(SLACK_PENDING_INBOUND_DIR, filename));
+    } catch {
     }
   }
 }
@@ -17028,7 +16814,7 @@ ${formatted}` : "Thread is empty or not found."
     let bytes;
     let size;
     try {
-      const stat = statSync2(resolvedPath);
+      const stat = statSync(resolvedPath);
       if (!stat.isFile()) {
         return {
           content: [{ type: "text", text: `Upload refused: ${resolvedPath} is not a regular file.` }],