@integrity-labs/agt-cli 0.28.6 → 0.28.8

package/dist/mcp/direct-chat-channel.js

@@ -13971,9 +13971,49 @@ function buildImpersonationRefusal(toolName) {
 // src/channel-egress-tools.ts
 var DIRECT_CHAT_EGRESS_TOOLS = /* @__PURE__ */ new Set([
   "direct_chat.reply",
+  "direct_chat.consume",
   "channel_request_input"
 ]);
 
+// src/direct-chat-claim-tracker.ts
+var DirectChatClaimTracker = class {
+  bySession = /* @__PURE__ */ new Map();
+  /** Record that `messageId` was claimed for `sessionId` (idempotent). */
+  track(sessionId, messageId) {
+    let set = this.bySession.get(sessionId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.bySession.set(sessionId, set);
+    }
+    set.add(messageId);
+  }
+  /**
+   * The claimed-but-unconsumed message ids for a session, WITHOUT clearing them.
+   * Peek-then-clear-on-success (rather than drain-up-front) so a failed
+   * reply/consume POST doesn't lose the ids — they stay tracked for the retry.
+   */
+  peek(sessionId) {
+    return [...this.bySession.get(sessionId) ?? []];
+  }
+  /**
+   * Clear exactly the given ids for a session (call after a successful
+   * reply/consume). Only the ids actually sent are cleared, so any message
+   * claimed between peek and clear stays tracked for the next turn.
+   */
+  clear(sessionId, ids) {
+    const set = this.bySession.get(sessionId);
+    if (!set) return;
+    for (const id of ids) set.delete(id);
+    if (set.size === 0) this.bySession.delete(sessionId);
+  }
+  /** Total tracked message ids across all sessions (for bounding / diagnostics). */
+  get size() {
+    let n = 0;
+    for (const set of this.bySession.values()) n += set.size;
+    return n;
+  }
+};
+
 // src/mcp-spawn-lock.ts
 import {
   existsSync,
@@ -14044,12 +14084,52 @@ function readLockHolder(path) {
 }
 
 // src/direct-chat-channel.ts
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+import { watch, mkdirSync as mkdirSync2 } from "fs";
+
+// src/flags-cache-read.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { homedir } from "os";
 import { join as join2 } from "path";
+function defaultFlagsCachePath() {
+  return join2(homedir(), ".augmented", "flags-cache.json");
+}
+function envBoolean(raw) {
+  if (raw === void 0) return void 0;
+  const v = raw.trim().toLowerCase();
+  if (v === "") return void 0;
+  if (v === "1" || v === "true" || v === "yes" || v === "on") return true;
+  if (v === "0" || v === "false" || v === "no" || v === "off") return false;
+  return void 0;
+}
+function cachedBoolean(key, path) {
+  try {
+    if (!existsSync2(path)) return void 0;
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    if (!parsed || typeof parsed !== "object") return void 0;
+    const flags = parsed.flags;
+    if (!flags || typeof flags !== "object") return void 0;
+    const value = flags[key];
+    return typeof value === "boolean" ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveHostBooleanFlag(opts) {
+  const env = opts.env ?? process.env;
+  const envValue = envBoolean(env[opts.envVar]);
+  if (envValue !== void 0) return envValue;
+  const cached2 = cachedBoolean(opts.key, opts.cachePath ?? defaultFlagsCachePath());
+  if (cached2 !== void 0) return cached2;
+  return opts.defaultValue;
+}
+
+// src/direct-chat-channel.ts
 var AGT_HOST = process.env.AGT_HOST;
 var AGT_API_KEY = process.env.AGT_API_KEY;
 var AGT_AGENT_ID = process.env.AGT_AGENT_ID;
-var DIRECT_CHAT_AGENT_DIR = AGT_AGENT_ID ? join2(homedir(), ".augmented", AGT_AGENT_ID) : null;
+var DIRECT_CHAT_AGENT_DIR = AGT_AGENT_ID ? join3(homedir2(), ".augmented", AGT_AGENT_ID) : null;
 var inboundContextClient = createInboundContextClient({
   agtHost: AGT_HOST ?? null,
   agtApiKey: AGT_API_KEY ?? null,
@@ -14125,10 +14205,12 @@ var mcp = new Server(
       'Messages from the webapp Direct Chat arrive as <channel source="direct-chat" session_id="..." user="...">.',
       "Reply using the direct_chat.reply tool, passing the session_id from the tag.",
       "Always reply to every direct chat message \u2014 the user is waiting in the webapp.",
+      "In the rare case you deliberately handle a message without replying (e.g. an internal command), call direct_chat.consume with the session_id so it is not treated as undelivered and redelivered.",
       "Keep replies concise and helpful. You have full access to all your MCP tools."
     ].join(" ")
   }
 );
+var claimTracker = new DirectChatClaimTracker();
 mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
   tools: [
     {
@@ -14185,6 +14267,20 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
         required: ["session_id", "content"]
       }
+    },
+    {
+      name: "direct_chat.consume",
+      description: "Acknowledge direct-chat message(s) you handled WITHOUT sending a reply (e.g. a command that only updated state, or a message you deliberately ignored). Pass the session_id from the <channel> tag. If you send a direct_chat.reply you do NOT also need to consume \u2014 the reply already acknowledges the message. Without one of the two, a silently-handled message is treated as undelivered and may be redelivered.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          session_id: {
+            type: "string",
+            description: "Session ID (from the session_id attribute in the <channel> tag)"
+          }
+        },
+        required: ["session_id"]
+      }
     }
   ]
 }));
@@ -14206,11 +14302,13 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
   }
   if (name === "direct_chat.reply") {
     const { session_id, content } = args;
+    const message_ids = claimTracker.peek(session_id);
     try {
       const res = await apiPost("/host/direct-chat/reply", {
         agent_id: AGT_AGENT_ID,
         session_id,
-        content
+        content,
+        message_ids
       });
       const data = await res.json();
       if (!res.ok || data.error) {
@@ -14219,6 +14317,7 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
           isError: true
         };
       }
+      claimTracker.clear(session_id, message_ids);
       return { content: [{ type: "text", text: "sent" }] };
     } catch (err) {
       return {
@@ -14227,9 +14326,80 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
       };
     }
   }
+  if (name === "direct_chat.consume") {
+    const { session_id } = args;
+    const message_ids = claimTracker.peek(session_id);
+    if (message_ids.length === 0) {
+      return { content: [{ type: "text", text: "nothing to consume" }] };
+    }
+    try {
+      const res = await apiPost("/host/direct-chat/consume", {
+        agent_id: AGT_AGENT_ID,
+        session_id,
+        message_ids
+      });
+      const data = await res.json();
+      if (!res.ok || data.error) {
+        return {
+          content: [{ type: "text", text: `Consume failed: ${data.error ?? res.statusText}` }],
+          isError: true
+        };
+      }
+      claimTracker.clear(session_id, message_ids);
+      return { content: [{ type: "text", text: "consumed" }] };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: `Failed: ${err.message}` }],
+        isError: true
+      };
+    }
+  }
   throw new Error(`Unknown tool: ${name}`);
 });
 await mcp.connect(new StdioServerTransport());
+var processedIds = /* @__PURE__ */ new Set();
+async function pollForMessages() {
+  try {
+    const res = await apiPost("/host/direct-chat/poll", {
+      agent_id: AGT_AGENT_ID
+    });
+    if (!res.ok) return;
+    const data = await res.json();
+    for (const msg of data.messages ?? []) {
+      if (processedIds.has(msg.id)) continue;
+      processedIds.add(msg.id);
+      if (processedIds.size > 500) {
+        const ids = [...processedIds];
+        for (let i = 0; i < 250; i++) processedIds.delete(ids[i]);
+      }
+      claimTracker.track(msg.session_id, msg.id);
+      await mcp.notification({
+        method: "notifications/claude/channel",
+        params: {
+          content: msg.content,
+          meta: {
+            session_id: msg.session_id,
+            user: "webapp",
+            source: "direct-chat"
+          }
+        }
+      });
+      inboundContextClient?.recordInbound({
+        sourceIntegration: "direct-chat",
+        sourceExternalId: msg.session_id
+      });
+      process.stderr.write(
+        `direct-chat-channel: Injected message ${msg.id} (session=${msg.session_id})
+`
+      );
+    }
+  } catch (err) {
+    process.stderr.write(
+      `direct-chat-channel: Poll error: ${err.message}
+`
+    );
+  }
+}
 var acquiredLockPath = null;
 {
   const lockResult = acquireMcpSpawnLock({
@@ -14246,16 +14416,71 @@ var acquiredLockPath = null;
     acquiredLockPath = lockResult.path;
   }
 }
-process.stderr.write(
-  `direct-chat-channel: Started (agent=${AGT_AGENT_ID}, polling=disabled \u2014 using Realtime)
+var DOORBELL_ENABLED = resolveHostBooleanFlag({
+  key: "direct-chat-doorbell",
+  envVar: "AGT_DIRECT_CHAT_DOORBELL_ENABLED",
+  defaultValue: false
+});
+var DOORBELL_FILE = "direct-chat-doorbell";
+var SAFETY_NET_POLL_MS = 3e4;
+var pollInFlight = false;
+async function pollOnce() {
+  if (pollInFlight) return;
+  pollInFlight = true;
+  try {
+    await pollForMessages();
+  } finally {
+    pollInFlight = false;
+  }
+}
+var doorbellWatcher = null;
+var safetyNetTimer = null;
+if (DOORBELL_ENABLED && DIRECT_CHAT_AGENT_DIR) {
+  try {
+    mkdirSync2(DIRECT_CHAT_AGENT_DIR, { recursive: true });
+  } catch {
+  }
+  let debounce = null;
+  try {
+    doorbellWatcher = watch(DIRECT_CHAT_AGENT_DIR, (_event, filename) => {
+      if (filename !== DOORBELL_FILE) return;
+      if (debounce) clearTimeout(debounce);
+      debounce = setTimeout(() => {
+        void pollOnce();
+      }, 50);
+    });
+  } catch (err) {
+    process.stderr.write(
+      `direct-chat-channel: doorbell watch failed (${err.message}) \u2014 relying on safety-net poll
 `
-);
+    );
+  }
+  safetyNetTimer = setInterval(() => {
+    void pollOnce();
+  }, SAFETY_NET_POLL_MS);
+  safetyNetTimer.unref?.();
+  void pollOnce();
+  process.stderr.write(
+    `direct-chat-channel: Started (agent=${AGT_AGENT_ID}, delivery=doorbell+pull \u2014 watching ${DOORBELL_FILE}, safety-net ${SAFETY_NET_POLL_MS}ms)
+`
+  );
+} else {
+  process.stderr.write(
+    `direct-chat-channel: Started (agent=${AGT_AGENT_ID}, polling=disabled \u2014 using Realtime)
+`
+  );
+}
 var isShuttingDown = false;
 function shutdown(reason) {
   if (isShuttingDown) return;
   isShuttingDown = true;
   process.stderr.write(`direct-chat-channel: ${reason} \u2014 exiting
 `);
+  try {
+    doorbellWatcher?.close();
+  } catch {
+  }
+  if (safetyNetTimer) clearInterval(safetyNetTimer);
   try {
     releaseMcpSpawnLock(acquiredLockPath);
   } catch {

package/dist/{persistent-session-DSG4HI4R.js → persistent-session-S6H3P6WD.js}

@@ -23,8 +23,8 @@ import {
   stopPersistentSession,
   takeZombieDetection,
   writePersistentClaudeWrapper
-} from "./chunk-LIB6VTH3.js";
-import "./chunk-NS4G4HHD.js";
+} from "./chunk-QG553V7F.js";
+import "./chunk-CHUL4CPY.js";
 import "./chunk-XWVM4KPK.js";
 export {
   SEND_KEYS_ENTER_DELAY_MS,
@@ -52,4 +52,4 @@ export {
   takeZombieDetection,
   writePersistentClaudeWrapper
 };
-//# sourceMappingURL=persistent-session-DSG4HI4R.js.map
+//# sourceMappingURL=persistent-session-S6H3P6WD.js.map

package/dist/{responsiveness-probe-53KDTOUT.js → responsiveness-probe-6BLLBJB4.js}

@@ -1,7 +1,7 @@
 import {
   paneLogPath
-} from "./chunk-LIB6VTH3.js";
-import "./chunk-NS4G4HHD.js";
+} from "./chunk-QG553V7F.js";
+import "./chunk-CHUL4CPY.js";
 import "./chunk-XWVM4KPK.js";
 
 // src/lib/responsiveness-probe.ts
@@ -248,4 +248,4 @@ export {
   parkPendingInbound,
   readAndResetChannelDeflections
 };
-//# sourceMappingURL=responsiveness-probe-53KDTOUT.js.map
+//# sourceMappingURL=responsiveness-probe-6BLLBJB4.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@integrity-labs/agt-cli",
-  "version": "0.28.6",
+  "version": "0.28.8",
   "description": "Augmented Team CLI — agent provisioning and management",
   "type": "module",
   "engines": {