@integrity-labs/agt-cli 0.19.21 → 0.19.23

package/mcp/slack-channel.js

@@ -6801,24 +6801,7 @@ var require_dist = __commonJS({
   }
 });
 
-// src/slack-block-kit-runtime.ts
-var slack_block_kit_runtime_exports = {};
-__export(slack_block_kit_runtime_exports, {
-  buildAskUserBlocks: () => buildAskUserBlocks,
-  buildRatingActionsBlock: () => buildRatingActionsBlock,
-  createPendingInteraction: () => createPendingInteraction,
-  decodeActionId: () => decodeActionId,
-  defaultRatingLabels: () => defaultRatingLabels,
-  encodeActionId: () => encodeActionId,
-  generateOptionToken: () => generateOptionToken,
-  ratingValuesForScale: () => ratingValuesForScale,
-  recordSlackDelivery: () => recordSlackDelivery,
-  resolveInteractive: () => resolveInteractive,
-  updatePendingInteractionMessageTs: () => updatePendingInteractionMessageTs,
-  validateAskUserOptions: () => validateAskUserOptions,
-  validateSlackBlocks: () => validateSlackBlocks,
-  waitForResolution: () => waitForResolution
-});
+// src/ask-user-runtime.ts
 async function getAuthToken(cfg) {
   if (auth.token && Date.now() < auth.expiresAtEpochMs) return auth.token;
   const res = await fetch(`${cfg.apiHost}/host/exchange`, {
@@ -6872,13 +6855,17 @@ async function createPendingInteraction(cfg, input) {
   }
 }
 async function updatePendingInteractionMessageTs(cfg, callbackId, messageTs) {
-  const res = await apiCall(cfg, "PATCH", `/host/pending-interactions/${encodeURIComponent(callbackId)}`, {
-    agent_id: cfg.agentId,
-    message_ts: messageTs
-  });
+  const res = await apiCall(
+    cfg,
+    "PATCH",
+    `/host/pending-interactions/${encodeURIComponent(callbackId)}`,
+    { agent_id: cfg.agentId, message_ts: messageTs }
+  );
   if (!res.ok) {
     const body = await res.text().catch(() => "");
-    throw new Error(`updatePendingInteractionMessageTs failed (${res.status}): ${body.slice(0, 200)}`);
+    throw new Error(
+      `updatePendingInteractionMessageTs failed (${res.status}): ${body.slice(0, 200)}`
+    );
   }
 }
 async function waitForResolution(cfg, callbackId, opts) {
@@ -6929,6 +6916,80 @@ function generateOptionToken() {
   const out = Buffer.from(bytes).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
   return out;
 }
+function validateAskUserOptions(options, limits = DEFAULT_ASK_USER_LIMITS) {
+  const errors = [];
+  if (!Array.isArray(options)) {
+    return { ok: false, errors: [{ path: "options", message: "must be an array" }] };
+  }
+  if (options.length === 0) {
+    errors.push({ path: "options", message: "must contain at least one option" });
+  }
+  if (options.length > limits.maxOptions) {
+    errors.push({
+      path: "options",
+      message: `max ${limits.maxOptions} options`
+    });
+  }
+  const seenLabels = /* @__PURE__ */ new Set();
+  const seenValues = /* @__PURE__ */ new Set();
+  options.forEach((opt, i) => {
+    const o = opt;
+    const path = `options[${i}]`;
+    if (typeof o?.label !== "string" || o.label.length === 0) {
+      errors.push({ path: `${path}.label`, message: "required string" });
+    } else {
+      if (o.label.length > limits.maxLabelChars) {
+        errors.push({ path: `${path}.label`, message: `max ${limits.maxLabelChars} chars` });
+      }
+      if (seenLabels.has(o.label)) errors.push({ path: `${path}.label`, message: "duplicate label" });
+      seenLabels.add(o.label);
+    }
+    if (typeof o?.value !== "string" || o.value.length === 0) {
+      errors.push({ path: `${path}.value`, message: "required string" });
+    } else {
+      if (o.value.length > limits.maxValueChars) {
+        errors.push({ path: `${path}.value`, message: `max ${limits.maxValueChars} chars` });
+      }
+      if (seenValues.has(o.value)) errors.push({ path: `${path}.value`, message: "duplicate value" });
+      seenValues.add(o.value);
+    }
+  });
+  return { ok: errors.length === 0, errors };
+}
+var auth, API_FETCH_TIMEOUT_MS, DEFAULT_ASK_USER_LIMITS;
+var init_ask_user_runtime = __esm({
+  "src/ask-user-runtime.ts"() {
+    "use strict";
+    auth = { token: null, expiresAtEpochMs: 0 };
+    API_FETCH_TIMEOUT_MS = 1e4;
+    DEFAULT_ASK_USER_LIMITS = {
+      maxOptions: 5,
+      maxLabelChars: 75,
+      maxValueChars: 2e3
+    };
+  }
+});
+
+// src/slack-block-kit-runtime.ts
+var slack_block_kit_runtime_exports = {};
+__export(slack_block_kit_runtime_exports, {
+  DEFAULT_ASK_USER_LIMITS: () => DEFAULT_ASK_USER_LIMITS,
+  apiCall: () => apiCall,
+  buildAskUserBlocks: () => buildAskUserBlocks,
+  buildRatingActionsBlock: () => buildRatingActionsBlock,
+  createPendingInteraction: () => createPendingInteraction,
+  decodeActionId: () => decodeActionId,
+  defaultRatingLabels: () => defaultRatingLabels,
+  encodeActionId: () => encodeActionId,
+  generateOptionToken: () => generateOptionToken,
+  ratingValuesForScale: () => ratingValuesForScale,
+  recordSlackDelivery: () => recordSlackDelivery,
+  resolveInteractive: () => resolveInteractive,
+  updatePendingInteractionMessageTs: () => updatePendingInteractionMessageTs,
+  validateAskUserOptions: () => validateAskUserOptions,
+  validateSlackBlocks: () => validateSlackBlocks,
+  waitForResolution: () => waitForResolution
+});
 function validateSlackBlocks(blocks) {
   const errors = [];
   const cap = 10;
@@ -6949,161 +7010,121 @@ function validateSlackBlocks(blocks) {
     const path = `blocks[${i}]`;
     const type = block?.type;
     if (typeof type !== "string") {
-      push(path, "block.type is required");
+      push(path, "`type` is required and must be a string");
       continue;
     }
     if (!SUPPORTED_BLOCK_TYPES.includes(type)) {
-      push(path, `block type '${type}' is not supported. Use one of: ${SUPPORTED_BLOCK_TYPES.join(", ")}`);
+      push(path, `unsupported block type "${type}" \u2014 supported: ${SUPPORTED_BLOCK_TYPES.join(", ")}`);
       continue;
     }
-    if (typeof block.block_id === "string" && block.block_id.length > SLACK_LIMITS.identifierChars) {
+    if ("block_id" in block && typeof block.block_id === "string" && block.block_id.length > SLACK_LIMITS.identifierChars) {
       push(`${path}.block_id`, `max ${SLACK_LIMITS.identifierChars} chars`);
     }
-    switch (type) {
-      case "header":
-        validateHeaderBlock(block, path, push);
-        break;
-      case "section":
-        validateSectionBlock(block, path, push);
-        break;
-      case "context":
-        validateContextBlock(block, path, push);
-        break;
-      case "actions":
-        validateActionsBlock(block, path, push);
-        break;
-    }
+    if (type === "header") validateHeaderBlock(block, path, push);
+    else if (type === "section") validateSectionBlock(block, path, push);
+    else if (type === "context") validateContextBlock(block, path, push);
+    else if (type === "actions") validateActionsBlock(block, path, push);
   }
   return { ok: errors.length === 0, errors };
 }
 function validateHeaderBlock(b, path, push) {
   const text = b.text;
-  if (!text || text.type !== "plain_text" || typeof text.text !== "string") {
-    push(`${path}.text`, "header.text must be { type: 'plain_text', text: string }");
+  if (!text) {
+    push(`${path}.text`, "header requires a text object");
     return;
   }
-  if (text.text.length > SLACK_LIMITS.headerTextChars) {
-    push(`${path}.text.text`, `max ${SLACK_LIMITS.headerTextChars} chars`);
-  }
+  validateTextObject(text, `${path}.text`, SLACK_LIMITS.headerTextChars, ["plain_text"], push);
 }
 function validateSectionBlock(b, path, push) {
-  const hasText = "text" in b;
-  const hasFields = "fields" in b;
-  if (!hasText && !hasFields) {
-    push(path, "section block requires text or fields");
+  const text = b.text;
+  const fields = b.fields;
+  if (!text && !fields) {
+    push(path, "section must have at least one of `text` or `fields`");
     return;
   }
-  if (hasText) validateTextObject(b.text, `${path}.text`, push, SLACK_LIMITS.sectionTextChars);
-  if (hasFields) {
-    if (!Array.isArray(b.fields)) {
-      push(`${path}.fields`, "must be an array");
-      return;
-    }
-    if (b.fields.length > SLACK_LIMITS.sectionFields) {
-      push(`${path}.fields`, `max ${SLACK_LIMITS.sectionFields} fields (got ${b.fields.length})`);
+  if (text) {
+    validateTextObject(text, `${path}.text`, SLACK_LIMITS.sectionTextChars, ["plain_text", "mrkdwn"], push);
+  }
+  if (fields) {
+    if (!Array.isArray(fields)) {
+      push(`${path}.fields`, "`fields` must be an array");
+    } else if (fields.length > SLACK_LIMITS.sectionFields) {
+      push(`${path}.fields`, `max ${SLACK_LIMITS.sectionFields} fields`);
+    } else {
+      fields.forEach((f, i) => {
+        validateTextObject(f, `${path}.fields[${i}]`, SLACK_LIMITS.sectionFieldChars, ["plain_text", "mrkdwn"], push);
+      });
     }
-    b.fields.forEach(
-      (f, i) => validateTextObject(f, `${path}.fields[${i}]`, push, SLACK_LIMITS.sectionFieldChars)
-    );
   }
 }
 function validateContextBlock(b, path, push) {
-  if (!Array.isArray(b.elements) || b.elements.length === 0) {
-    push(`${path}.elements`, "context block requires non-empty elements array");
+  const elements = b.elements;
+  if (!Array.isArray(elements) || elements.length === 0) {
+    push(`${path}.elements`, "context requires non-empty `elements` array");
     return;
   }
-  b.elements.forEach(
-    (el, i) => validateTextObject(el, `${path}.elements[${i}]`, push, SLACK_LIMITS.sectionFieldChars)
-  );
+  elements.forEach((el, i) => {
+    validateTextObject(el, `${path}.elements[${i}]`, SLACK_LIMITS.sectionTextChars, ["plain_text", "mrkdwn"], push);
+  });
 }
 function validateActionsBlock(b, path, push) {
-  if (!Array.isArray(b.elements) || b.elements.length === 0) {
-    push(`${path}.elements`, "actions block requires non-empty elements array");
+  const elements = b.elements;
+  if (!Array.isArray(elements) || elements.length === 0) {
+    push(`${path}.elements`, "actions requires non-empty `elements` array");
     return;
   }
-  if (b.elements.length > SLACK_LIMITS.actionElements) {
-    push(`${path}.elements`, `max ${SLACK_LIMITS.actionElements} action elements (got ${b.elements.length})`);
+  if (elements.length > SLACK_LIMITS.actionElements) {
+    push(`${path}.elements`, `max ${SLACK_LIMITS.actionElements} elements`);
   }
-  b.elements.forEach((el, i) => {
-    const elPath = `${path}.elements[${i}]`;
-    const e = el;
-    if (typeof e?.type !== "string") {
-      push(elPath, "element.type is required");
+  elements.forEach((el, i) => {
+    const type = el?.type;
+    if (typeof type !== "string") {
+      push(`${path}.elements[${i}]`, "each element must have a `type`");
       return;
     }
-    if (!SUPPORTED_ACTION_ELEMENTS.includes(e.type)) {
-      push(elPath, `element type '${e.type}' is not supported. Use one of: ${SUPPORTED_ACTION_ELEMENTS.join(", ")}`);
+    if (!SUPPORTED_ACTION_ELEMENTS.includes(type)) {
+      push(`${path}.elements[${i}]`, `unsupported action element "${type}" \u2014 supported: ${SUPPORTED_ACTION_ELEMENTS.join(", ")}`);
       return;
     }
-    if (typeof e.action_id !== "string" || e.action_id.length === 0) {
-      push(`${elPath}.action_id`, "required");
-    } else if (e.action_id.length > SLACK_LIMITS.identifierChars) {
-      push(`${elPath}.action_id`, `max ${SLACK_LIMITS.identifierChars} chars`);
-    }
-    if (e.type === "button") {
-      const t = e.text;
-      if (!t || t.type !== "plain_text" || typeof t.text !== "string") {
-        push(`${elPath}.text`, "button.text must be { type: 'plain_text', text: string }");
-      } else if (t.text.length > SLACK_LIMITS.buttonLabelChars) {
-        push(`${elPath}.text.text`, `max ${SLACK_LIMITS.buttonLabelChars} chars`);
+    if (type === "button") {
+      const text = el.text;
+      if (!text) {
+        push(`${path}.elements[${i}].text`, "button requires a text object");
+      } else {
+        validateTextObject(text, `${path}.elements[${i}].text`, SLACK_LIMITS.buttonLabelChars, ["plain_text"], push);
+      }
+      const actionId = el.action_id;
+      if (typeof actionId !== "string" || actionId.length === 0) {
+        push(`${path}.elements[${i}].action_id`, "button requires a non-empty `action_id`");
+      } else if (actionId.length > SLACK_LIMITS.identifierChars) {
+        push(`${path}.elements[${i}].action_id`, `max ${SLACK_LIMITS.identifierChars} chars`);
+      }
+      const value = el.value;
+      if (value !== void 0) {
+        if (typeof value !== "string") {
+          push(`${path}.elements[${i}].value`, "`value` must be a string");
+        } else if (value.length > SLACK_LIMITS.optionValueChars) {
+          push(`${path}.elements[${i}].value`, `max ${SLACK_LIMITS.optionValueChars} chars`);
+        }
       }
     }
   });
 }
-function validateTextObject(obj, path, push, maxChars) {
-  if (!obj || typeof obj !== "object") {
-    push(path, "must be a text object");
+function validateTextObject(text, path, maxChars, allowedTypes, push) {
+  if (!text || typeof text !== "object") {
+    push(path, "must be an object with `type` and `text`");
     return;
   }
-  if (obj.type !== "plain_text" && obj.type !== "mrkdwn") {
-    push(`${path}.type`, "must be 'plain_text' or 'mrkdwn'");
-    return;
-  }
-  if (typeof obj.text !== "string") {
-    push(`${path}.text`, "must be a string");
-    return;
+  const t = text;
+  if (typeof t.type !== "string" || !allowedTypes.includes(t.type)) {
+    push(`${path}.type`, `must be one of: ${allowedTypes.join(", ")}`);
   }
-  if (obj.text.length > maxChars) {
-    push(`${path}.text`, `max ${maxChars} chars (got ${obj.text.length})`);
+  if (typeof t.text !== "string" || t.text.length === 0) {
+    push(`${path}.text`, "required non-empty string");
+  } else if (t.text.length > maxChars) {
+    push(`${path}.text`, `max ${maxChars} chars`);
   }
 }
-function validateAskUserOptions(options) {
-  const errors = [];
-  if (!Array.isArray(options)) {
-    return { ok: false, errors: [{ path: "options", message: "must be an array" }] };
-  }
-  if (options.length === 0) {
-    errors.push({ path: "options", message: "must contain at least one option" });
-  }
-  if (options.length > SLACK_LIMITS.actionElements) {
-    errors.push({ path: "options", message: `max ${SLACK_LIMITS.actionElements} options (one Slack actions block)` });
-  }
-  const seenLabels = /* @__PURE__ */ new Set();
-  const seenValues = /* @__PURE__ */ new Set();
-  options.forEach((opt, i) => {
-    const o = opt;
-    const path = `options[${i}]`;
-    if (typeof o?.label !== "string" || o.label.length === 0) {
-      errors.push({ path: `${path}.label`, message: "required string" });
-    } else {
-      if (o.label.length > SLACK_LIMITS.buttonLabelChars) {
-        errors.push({ path: `${path}.label`, message: `max ${SLACK_LIMITS.buttonLabelChars} chars` });
-      }
-      if (seenLabels.has(o.label)) errors.push({ path: `${path}.label`, message: "duplicate label" });
-      seenLabels.add(o.label);
-    }
-    if (typeof o?.value !== "string" || o.value.length === 0) {
-      errors.push({ path: `${path}.value`, message: "required string" });
-    } else {
-      if (o.value.length > SLACK_LIMITS.optionValueChars) {
-        errors.push({ path: `${path}.value`, message: `max ${SLACK_LIMITS.optionValueChars} chars` });
-      }
-      if (seenValues.has(o.value)) errors.push({ path: `${path}.value`, message: "duplicate value" });
-      seenValues.add(o.value);
-    }
-  });
-  return { ok: errors.length === 0, errors };
-}
 function encodeActionId(callbackId, token) {
   return `aug:${callbackId}:${token}`;
 }
@@ -7174,12 +7195,12 @@ async function recordSlackDelivery(cfg, input) {
     throw new Error(`recordSlackDelivery failed (${res.status}): ${body.slice(0, 200)}`);
   }
 }
-var auth, API_FETCH_TIMEOUT_MS, SLACK_LIMITS, SUPPORTED_BLOCK_TYPES, SUPPORTED_ACTION_ELEMENTS, ACTION_ID_RE;
+var SLACK_LIMITS, SUPPORTED_BLOCK_TYPES, SUPPORTED_ACTION_ELEMENTS, ACTION_ID_RE;
 var init_slack_block_kit_runtime = __esm({
   "src/slack-block-kit-runtime.ts"() {
     "use strict";
-    auth = { token: null, expiresAtEpochMs: 0 };
-    API_FETCH_TIMEOUT_MS = 1e4;
+    init_ask_user_runtime();
+    init_ask_user_runtime();
     SLACK_LIMITS = {
       blocksPerMessage: 50,
       sectionTextChars: 3e3,
@@ -14930,6 +14951,81 @@ function createCrossTeamPeerAuditClient(args) {
   };
 }
 
+// src/slack-bot-user-id-client.ts
+var REQUEST_TIMEOUT_MS2 = 1e4;
+function createSlackBotUserIdClient(args) {
+  if (!args.agtHost || !args.agtApiKey || !args.agentId) return null;
+  const fetchImpl = args.fetchImpl ?? fetch;
+  const log = args.log ?? (() => {
+  });
+  const base = args.agtHost.replace(/\/+$/, "");
+  const agentId = args.agentId;
+  const apiKey = args.agtApiKey;
+  let reportedFor = null;
+  let cachedToken = null;
+  let cachedTokenExpiresAt = 0;
+  async function getToken() {
+    if (cachedToken && Date.now() < cachedTokenExpiresAt) return cachedToken;
+    const resp = await fetchImpl(`${base}/host/exchange`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ host_key: apiKey }),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
+    });
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "");
+      throw new Error(`/host/exchange failed (${resp.status}): ${body.slice(0, 200)}`);
+    }
+    const data = await resp.json();
+    cachedToken = data.token;
+    cachedTokenExpiresAt = data.expires_at ? new Date(data.expires_at).getTime() - 12e4 : Date.now() + 55 * 6e4;
+    return cachedToken;
+  }
+  async function postOnce(botUserId2) {
+    const token = await getToken();
+    return fetchImpl(`${base}/host/slack-bot-user-id`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ agent_id: agentId, bot_user_id: botUserId2 }),
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
+    });
+  }
+  async function emitAsync(botUserId2) {
+    try {
+      let resp = await postOnce(botUserId2);
+      if (resp.status === 401) {
+        cachedToken = null;
+        cachedTokenExpiresAt = 0;
+        resp = await postOnce(botUserId2);
+      }
+      if (!resp.ok) {
+        const body = await resp.text().catch(() => "");
+        log(
+          `slack-bot-user-id: POST failed (${resp.status}) user=${botUserId2}: ${body.slice(0, 200)}`
+        );
+        return false;
+      }
+      return true;
+    } catch (err) {
+      log(`slack-bot-user-id: emit threw user=${botUserId2}: ${err.message}`);
+      return false;
+    }
+  }
+  return {
+    report(botUserId2) {
+      if (reportedFor === botUserId2) return;
+      const snapshot = botUserId2;
+      reportedFor = snapshot;
+      void emitAsync(botUserId2).then((ok) => {
+        if (ok) return;
+        if (reportedFor === snapshot) {
+          reportedFor = null;
+        }
+      });
+    }
+  };
+}
+
 // src/slack-channel.ts
 var BOT_TOKEN = process.env.SLACK_BOT_TOKEN;
 var APP_TOKEN = process.env.SLACK_APP_TOKEN;
@@ -15658,6 +15754,14 @@ var botUserId = await resolveBotUserIdOrThrow();
 var botUserIdForLog = `${botUserId.slice(0, 2)}***${botUserId.slice(-2)}`;
 process.stderr.write(`slack-channel: Bot user ID resolved (${botUserIdForLog})
 `);
+var slackBotUserIdClient = createSlackBotUserIdClient({
+  agtHost: AGT_HOST,
+  agtApiKey: AGT_API_KEY,
+  agentId: AGT_AGENT_ID,
+  log: (line) => process.stderr.write(`slack-channel: ${line}
+`)
+});
+slackBotUserIdClient?.report(botUserId);
 var selfIdentityInstruction = `Your own Slack user_id is ${botUserId}. Treat <@${botUserId}> mentions as directed at you, even inside auto_followed threads.`;
 var mcp = new Server(
   { name: "slack", version: "0.1.0" },
@@ -16372,6 +16476,9 @@ function askUserToolAvailable() {
 function interactiveHostAvailable() {
   return blockKitToolsAvailable() && Boolean(AGT_HOST && AGT_API_KEY && AGT_AGENT_ID);
 }
+function forwardingHostAvailable() {
+  return Boolean(AGT_HOST && AGT_API_KEY && AGT_AGENT_ID);
+}
 async function postSlackMessageWithTs(payload) {
   try {
     const res = await fetch("https://slack.com/api/chat.postMessage", {
@@ -16856,9 +16963,9 @@ async function connectSocketMode() {
         return;
       }
       if (msg.type === "interactive" && msg.payload?.type === "block_actions") {
-        if (!interactiveHostAvailable()) {
+        if (!forwardingHostAvailable()) {
           process.stderr.write(
-            `slack-channel(${AGENT_CODE_NAME}): block_actions received but Block Kit + host MCP wiring missing \u2014 dropping
+            `slack-channel(${AGENT_CODE_NAME}): block_actions received but host MCP wiring missing (AGT_HOST/AGT_API_KEY/AGT_AGENT_ID) \u2014 dropping
 `
           );
           return;

package/package.json

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