@buildautomaton/cli 0.1.48 → 0.1.49

package/dist/index.js

@@ -22733,6 +22733,238 @@ var WebSocketMessageSchema = external_exports.object({
   error: external_exports.string().optional()
 });
 
+// ../types/src/integrations/link-detection/linear.ts
+function detectLinearLink(url2) {
+  const linearMatch = url2.match(
+    /https?:\/\/(?:app\.)?linear\.app\/([^/]+)\/issue\/([A-Z]+-\d+)/i
+  );
+  if (linearMatch) {
+    return {
+      url: url2,
+      integrationType: "linear",
+      resourceType: "work-item",
+      resourceId: linearMatch[2],
+      workspaceId: linearMatch[1]
+    };
+  }
+  return null;
+}
+
+// ../types/src/integrations/link-detection/github.ts
+function detectGitHubLink(url2) {
+  const githubIssueMatch = url2.match(
+    /https?:\/\/github\.com\/([^/]+)\/([^/]+)\/issues\/(\d+)/i
+  );
+  if (githubIssueMatch) {
+    return {
+      url: url2,
+      integrationType: "github",
+      resourceType: "issue",
+      resourceId: githubIssueMatch[3],
+      owner: githubIssueMatch[1],
+      repo: githubIssueMatch[2]
+    };
+  }
+  const githubPRMatch = url2.match(
+    /https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/i
+  );
+  if (githubPRMatch) {
+    return {
+      url: url2,
+      integrationType: "github",
+      resourceType: "pull-request",
+      resourceId: githubPRMatch[3],
+      owner: githubPRMatch[1],
+      repo: githubPRMatch[2]
+    };
+  }
+  return null;
+}
+
+// ../types/src/integrations/link-detection/jira.ts
+function detectJIRALink(url2) {
+  const jiraMatch = url2.match(
+    /https?:\/\/([^/]+)\.atlassian\.net\/(?:browse|jira\/software\/projects\/[^/]+\/issues)\/([A-Z]+-\d+)/i
+  );
+  if (jiraMatch) {
+    return {
+      url: url2,
+      integrationType: "jira",
+      resourceType: "issue",
+      resourceId: jiraMatch[2],
+      projectKey: jiraMatch[2].split("-")[0]
+    };
+  }
+  return null;
+}
+
+// ../types/src/integrations/link-detection/notion.ts
+function formatNotionPageId(hex) {
+  if (hex.length !== 32) return hex;
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+function detectNotionLink(url2) {
+  const standardMatch = url2.match(
+    /https?:\/\/(?:www\.)?notion\.(?:so|site)\/(?:[^/#?]+\/)?(?:[^/#?-]+-)?([a-f0-9]{32})/i
+  );
+  if (standardMatch) {
+    return {
+      url: url2,
+      integrationType: "notion",
+      resourceType: "page",
+      resourceId: formatNotionPageId(standardMatch[1])
+    };
+  }
+  const siteMatch = url2.match(
+    /https?:\/\/([^.]+)\.notion\.(?:so|site)\/(?:[^/#?-]+-)?([a-f0-9]{32})/i
+  );
+  if (siteMatch) {
+    return {
+      url: url2,
+      integrationType: "notion",
+      resourceType: "page",
+      resourceId: formatNotionPageId(siteMatch[2]),
+      notionWorkspaceId: siteMatch[1]
+    };
+  }
+  return null;
+}
+
+// ../types/src/integrations/link-detection/slack.ts
+function detectSlackLink(url2) {
+  const archiveThreadMatch = url2.match(
+    /https?:\/\/(?:([^./]+)\.)?slack\.com\/archives\/([A-Z0-9]+)\/p(\d+)(?:\?.*)?$/i
+  );
+  if (archiveThreadMatch) {
+    return {
+      url: url2,
+      integrationType: "slack",
+      resourceType: "thread",
+      resourceId: `${archiveThreadMatch[2]}-${archiveThreadMatch[3]}`,
+      isChannel: false
+    };
+  }
+  const appThreadMatch = url2.match(
+    /https?:\/\/app\.slack\.com\/client\/([^/]+)\/([A-Z0-9]+)\/thread\/[A-Z0-9]+-(\d+)/i
+  );
+  if (appThreadMatch) {
+    return {
+      url: url2,
+      integrationType: "slack",
+      resourceType: "thread",
+      resourceId: `${appThreadMatch[2]}-${appThreadMatch[3]}`,
+      isChannel: false
+    };
+  }
+  const channelOnlyMatch = url2.match(
+    /https?:\/\/(?:app\.)?(?:([^./]+)\.)?slack\.com\/archives\/([A-Z0-9]+)\/?(\?.*)?$/i
+  );
+  if (channelOnlyMatch && !url2.includes("/p")) {
+    return {
+      url: url2,
+      integrationType: "slack",
+      resourceType: "channel",
+      resourceId: channelOnlyMatch[2],
+      isChannel: true
+    };
+  }
+  return null;
+}
+
+// ../types/src/integrations/link-detection/zoom.ts
+function detectZoomLink(url2) {
+  try {
+    const u = new URL(url2);
+    const host = u.hostname.toLowerCase();
+    if (!host.endsWith("zoom.us") && !host.endsWith("zoom.com")) return null;
+    const pathParts = u.pathname.split("/").filter(Boolean);
+    if (pathParts.length >= 2 && (pathParts[0] === "j" || pathParts[0] === "s" || pathParts[0] === "my")) {
+      const meetingId = pathParts[1].replace(/\s/g, "");
+      if (meetingId.length >= 9) {
+        return {
+          url: url2,
+          integrationType: "zoom",
+          resourceType: "meeting",
+          resourceId: meetingId,
+          zoomMeetingId: meetingId
+        };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+
+// ../types/src/integrations/link-detection/asana.ts
+var ASANA_TASK_GID = /\d{10,}/;
+function parseAsanaTaskGid(segment) {
+  const trimmed2 = segment.trim();
+  if (!ASANA_TASK_GID.test(trimmed2)) return null;
+  return trimmed2;
+}
+function detectAsanaLink(url2) {
+  const v1ProjectMatch = url2.match(
+    /https?:\/\/app\.asana\.com\/1\/[^/]+\/project\/([^/?#]+)\/task\/([^/?#]+)/i
+  );
+  if (v1ProjectMatch) {
+    const taskGid = parseAsanaTaskGid(v1ProjectMatch[2]);
+    if (!taskGid) return null;
+    return {
+      url: url2,
+      integrationType: "asana",
+      resourceType: "task",
+      resourceId: taskGid,
+      asanaProjectGid: v1ProjectMatch[1]
+    };
+  }
+  const v1TaskMatch = url2.match(/https?:\/\/app\.asana\.com\/1\/[^/]+(?:\/[^/]+)*\/task\/([^/?#]+)/i);
+  if (v1TaskMatch) {
+    const taskGid = parseAsanaTaskGid(v1TaskMatch[1]);
+    if (!taskGid) return null;
+    return {
+      url: url2,
+      integrationType: "asana",
+      resourceType: "task",
+      resourceId: taskGid
+    };
+  }
+  const legacyMatch = url2.match(/https?:\/\/app\.asana\.com\/0\/([^/?#]+)\/([^/?#]+)/i);
+  if (legacyMatch) {
+    const projectGid = legacyMatch[1];
+    const taskGid = parseAsanaTaskGid(legacyMatch[2]);
+    if (!taskGid) return null;
+    if (projectGid === "inbox" || projectGid === "my_tasks") {
+      return null;
+    }
+    return {
+      url: url2,
+      integrationType: "asana",
+      resourceType: "task",
+      resourceId: taskGid,
+      asanaProjectGid: projectGid === "0" ? void 0 : projectGid
+    };
+  }
+  return null;
+}
+
+// ../types/src/integrations/link-detection/index.ts
+function detectIntegrationLink(url2) {
+  return detectLinearLink(url2) || detectGitHubLink(url2) || detectJIRALink(url2) || detectNotionLink(url2) || detectSlackLink(url2) || detectZoomLink(url2) || detectAsanaLink(url2);
+}
+function extractIntegrationLinks(text) {
+  const urlRegex = /https?:\/\/[^\s<>"{}|\\^`[\]]+/gi;
+  const urls = text.match(urlRegex) || [];
+  const links = [];
+  for (const url2 of urls) {
+    const detected = detectIntegrationLink(url2);
+    if (detected) links.push(detected);
+  }
+  return links;
+}
+function extractFetchableIntegrationLinks(text) {
+  return extractIntegrationLinks(text).filter((link) => !(link.integrationType === "slack" && link.isChannel));
+}
+
 // ../types/src/checkpoints.ts
 init_zod();
 var CheckpointKindSchema = external_exports.enum(["daily", "weekly", "overall"]);
@@ -23160,6 +23392,16 @@ var GitRepoMetaSchema = external_exports.object({
   updatedAt: external_exports.string()
 });
 
+// ../types/src/bridge-mcp-tool-display.ts
+var GET_INTEGRATION_CONTENT_TOOL = "get_integration_content";
+var LIST_PARENT_SESSION_PROMPTS_TOOL = "list_parent_session_prompts";
+var GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL = "get_parent_session_turn_transcript";
+var BRIDGE_MCP_TOOL_LABELS = {
+  [GET_INTEGRATION_CONTENT_TOOL]: "Fetch external ticket content",
+  [LIST_PARENT_SESSION_PROMPTS_TOOL]: "List parent session prompts",
+  [GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL]: "Read parent session transcript"
+};
+
 // ../types/src/claude-code-permission-mode.ts
 var CLAUDE_CODE_PERMISSION_MODES = [
   "default",
@@ -24469,7 +24711,7 @@ function installBridgeProcessResilience() {
 }
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.48".length > 0 ? "0.1.48" : "0.0.0-dev";
+var CLI_VERSION = "0.1.49".length > 0 ? "0.1.49" : "0.0.0-dev";
 
 // src/connection/heartbeat/constants.ts
 var BRIDGE_APP_HEARTBEAT_INTERVAL_MS = 1e4;
@@ -33129,7 +33371,15 @@ async function fetchInternalApiJson(params) {
   const token = params.getCloudAccessToken();
   if (!token) return { ok: false, error: "Missing cloud access token." };
   const url2 = `${internalApiBase(params.cloudApiBaseUrl)}${params.path}`;
-  const res = await fetch(url2, { headers: { Authorization: `Bearer ${token}` } });
+  const method = params.method ?? "GET";
+  const res = await fetch(url2, {
+    method,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      ...params.body != null ? { "Content-Type": "application/json" } : {}
+    },
+    ...params.body != null ? { body: JSON.stringify(params.body) } : {}
+  });
   if (!res.ok) {
     const t = await res.text().catch(() => "");
     return { ok: false, error: `${params.errorLabel} (${res.status}): ${t.slice(0, 200)}` };
@@ -33312,6 +33562,39 @@ async function enrichForkedSessionPromptForAgent(params) {
   return buildForkedSessionAgentPrompt(params.promptText, params.sessionId, parentSessionId);
 }
 
+// src/agents/acp/build-integration-content-agent-prompt-note.ts
+function buildIntegrationContentAgentPromptNote(sessionId) {
+  const sessionRef = sessionId.trim();
+  return [
+    "The user message includes link(s) to external integration resources (Linear, GitHub, Jira, Notion, Slack thread, Zoom, or Asana).",
+    "Use the get_integration_content MCP tool on the buildautomaton-bridge server to fetch the full content of each link.",
+    `When calling the tool, pass sessionId "${sessionRef}" and the URL as url.`,
+    "By default the tool links the fetched URL as this session external ticket when the session has none yet. Pass associateAsSessionTicket: false when fetching additional links for context only (after the primary ticket is linked, or when you do not want association).",
+    "If the tool reports unsupported_url, do not retry with the same URL. If it reports temporarily_unavailable, you may retry later."
+  ].join("\n");
+}
+function injectIntegrationContentAgentPromptNote(agentPrompt, sessionId) {
+  const note = buildIntegrationContentAgentPromptNote(sessionId);
+  const marker = "\nUser request:\n";
+  const idx = agentPrompt.indexOf(marker);
+  if (idx >= 0) {
+    return `${agentPrompt.slice(0, idx)}
+${note}${agentPrompt.slice(idx)}`;
+  }
+  return `${note}
+
+${agentPrompt.trim()}`;
+}
+
+// src/agents/acp/enrich-integration-content-prompt-for-agent.ts
+function enrichIntegrationContentPromptForAgent(params) {
+  if (!params.sessionId.trim()) return params.agentPromptText;
+  if (extractFetchableIntegrationLinks(params.originalPromptText).length === 0) {
+    return params.agentPromptText;
+  }
+  return injectIntegrationContentAgentPromptNote(params.agentPromptText, params.sessionId);
+}
+
 // src/agents/acp/send-prompt-to-agent.ts
 async function sendPromptToAgent(options) {
   const {
@@ -33342,6 +33625,13 @@ async function sendPromptToAgent(options) {
         getCloudAccessToken
       });
     }
+    if (sessionId) {
+      agentPromptText = enrichIntegrationContentPromptForAgent({
+        sessionId,
+        originalPromptText: promptText,
+        agentPromptText
+      });
+    }
     let sendOpts = {};
     if (attachments && attachments.length > 0) {
       if (!sessionId || !cloudApiBaseUrl || !getCloudAccessToken) {
@@ -39353,8 +39643,8 @@ async function callListParentSessionPromptsTool(ctx, cloud, childSessionId, pare
 }
 
 // src/mcp/tools/session-history/fork/tool-names.ts
-var LIST_PARENT_SESSION_PROMPTS_TOOL = "list_parent_session_prompts";
-var GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL = "get_parent_session_turn_transcript";
+var LIST_PARENT_SESSION_PROMPTS_TOOL2 = "list_parent_session_prompts";
+var GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL2 = "get_parent_session_turn_transcript";
 
 // src/mcp/tools/session-history/fork/call-fork-session-mcp-tool.ts
 async function callForkSessionMcpTool(ctx, cloud, name, args) {
@@ -39371,10 +39661,10 @@ async function callForkSessionMcpTool(ctx, cloud, name, args) {
     return mcpTextResult(parentResolved.error, true);
   }
   const parentSessionId = parentResolved.parentSessionId;
-  if (name === LIST_PARENT_SESSION_PROMPTS_TOOL) {
+  if (name === LIST_PARENT_SESSION_PROMPTS_TOOL2) {
     return callListParentSessionPromptsTool(ctx, cloud, childSessionId, parentSessionId);
   }
-  if (name === GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL) {
+  if (name === GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL2) {
     return callGetParentSessionTurnTranscriptTool(ctx, cloud, childSessionId, args);
   }
   return mcpTextResult(`Unknown fork session tool: ${name}`, true);
@@ -39387,7 +39677,7 @@ var SESSION_ID_SCHEMA = {
 };
 var FORK_SESSION_MCP_TOOL_DEFINITIONS = [
   {
-    name: LIST_PARENT_SESSION_PROMPTS_TOOL,
+    name: LIST_PARENT_SESSION_PROMPTS_TOOL2,
     description: "List user prompts (main turns) from the parent session a fork was created from. Requires sessionId. Returns an error if the session has no parent history (not a fork).",
     inputSchema: {
       type: "object",
@@ -39397,7 +39687,7 @@ var FORK_SESSION_MCP_TOOL_DEFINITIONS = [
     }
   },
   {
-    name: GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL,
+    name: GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL2,
     description: "Full transcript for one parent-session turn, including tool calls and agent messages. Requires sessionId and turnId. Returns an error if the session has no parent history (not a fork).",
     inputSchema: {
       type: "object",
@@ -39413,7 +39703,130 @@ var FORK_SESSION_MCP_TOOL_DEFINITIONS = [
 
 // src/mcp/tools/session-history/fork/is-fork-session-mcp-tool-name.ts
 function isForkSessionMcpToolName(name) {
-  return name === LIST_PARENT_SESSION_PROMPTS_TOOL || name === GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL;
+  return name === LIST_PARENT_SESSION_PROMPTS_TOOL2 || name === GET_PARENT_SESSION_TURN_TRANSCRIPT_TOOL2;
+}
+
+// src/mcp/tools/integration-content/tool-names.ts
+var GET_INTEGRATION_CONTENT_TOOL2 = "get_integration_content";
+
+// src/mcp/tools/integration-content/cloud/fetch-integration-content.ts
+async function fetchCloudIntegrationContent(params) {
+  return fetchInternalApiJson({
+    ...params,
+    path: `/internal/sessions/${encodeURIComponent(params.sessionId)}/integrations/content`,
+    errorLabel: "Integration content fetch failed",
+    method: "POST",
+    body: {
+      url: params.url,
+      associateAsSessionTicket: params.associateAsSessionTicket !== false
+    }
+  });
+}
+
+// src/mcp/tools/integration-content/format-integration-content-for-mcp.ts
+function formatIntegrationContentForMcp(result) {
+  if (!result.ok) {
+    const lines2 = [`status: ${result.code}`, `message: ${result.message}`];
+    if (result.integrationType) lines2.push(`integrationType: ${result.integrationType}`);
+    if (result.retryable) lines2.push("retryable: true");
+    lines2.push(...formatSessionTicketAssociationLines(result.sessionTicketAssociation));
+    return lines2.join("\n");
+  }
+  const lines = [
+    formatIntegrationContentBody(result.integrationType, result.content),
+    ...formatSessionTicketAssociationLines(result.sessionTicketAssociation)
+  ];
+  return lines.join("\n");
+}
+function formatSessionTicketAssociationLines(association) {
+  if (association.status === "associated") {
+    const title = association.externalTicket.displayTitle?.trim() || association.externalTicket.normalizedUrl;
+    return ["", "--- session ticket ---", "status: associated", `displayTitle: ${title}`];
+  }
+  if (association.status === "failed") {
+    return ["", "--- session ticket ---", "status: failed", `reason: ${association.reason}`];
+  }
+  return ["", "--- session ticket ---", `status: ${association.status}`, `reason: ${association.reason}`];
+}
+function formatIntegrationContentBody(integrationType, content) {
+  const lines = [
+    `integrationType: ${integrationType}`,
+    `title: ${content.title}`,
+    `url: ${content.url}`,
+    "",
+    "--- body ---",
+    content.body
+  ];
+  if (content.comments?.length) {
+    lines.push("", "--- comments ---");
+    for (const comment of content.comments) {
+      lines.push(`[${comment.createdAt}] ${comment.author}:`, comment.body, "");
+    }
+  }
+  const threadMessages = content.threadMessages;
+  if (threadMessages?.length) {
+    lines.push("", "--- thread messages ---");
+    for (const msg of threadMessages) {
+      lines.push(`[${msg.ts}] ${msg.displayName}: ${msg.text}`);
+    }
+  }
+  if (content.metadata && Object.keys(content.metadata).length > 0) {
+    lines.push("", "--- metadata ---", JSON.stringify(content.metadata, null, 2));
+  }
+  return lines.join("\n");
+}
+
+// src/mcp/tools/integration-content/call-integration-content-mcp-tool.ts
+async function callIntegrationContentMcpTool(ctx, cloud, name, args) {
+  if (name !== GET_INTEGRATION_CONTENT_TOOL2) {
+    return mcpTextResult(`Unknown integration content tool: ${name}`, true);
+  }
+  const sessionId = ctx.sessionId.trim();
+  if (!sessionId) return mcpTextResult("sessionId is required.", true);
+  const url2 = typeof args.url === "string" ? args.url.trim() : "";
+  if (!url2) return mcpTextResult("url is required.", true);
+  const associateAsSessionTicket = args.associateAsSessionTicket !== false;
+  const fetched = await fetchCloudIntegrationContent({
+    sessionId,
+    url: url2,
+    associateAsSessionTicket,
+    cloudApiBaseUrl: cloud.cloudApiBaseUrl,
+    getCloudAccessToken: cloud.getCloudAccessToken
+  });
+  if (!fetched.ok) return mcpTextResult(fetched.error, true);
+  const text = formatIntegrationContentForMcp(fetched.data);
+  const isError = !fetched.data.ok;
+  return mcpTextResult(text, isError);
+}
+
+// src/mcp/tools/integration-content/tool-definitions.ts
+var SESSION_ID_SCHEMA2 = {
+  type: "string",
+  description: "Id of the current session. Required on every tool call so the workspace integration credentials can be resolved."
+};
+var INTEGRATION_CONTENT_MCP_TOOL_DEFINITIONS = [
+  {
+    name: GET_INTEGRATION_CONTENT_TOOL2,
+    description: "Fetch the full content of a supported external integration link (Linear, GitHub, Jira, Notion, Slack thread, Zoom meeting, Asana). Requires sessionId and url. By default, links the URL as this session external ticket when the session has none yet. Pass associateAsSessionTicket: false to fetch content only (e.g. additional context links). Returns an error when the URL is unsupported, the integration is not connected, or content is temporarily unavailable (retry may succeed).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        sessionId: SESSION_ID_SCHEMA2,
+        url: { type: "string", description: "External integration URL to fetch" },
+        associateAsSessionTicket: {
+          type: "boolean",
+          description: "Defaults to true. When true and the session has no linked external ticket yet, links this URL as the session external ticket. Pass false when fetching additional links for context only."
+        }
+      },
+      required: ["sessionId", "url"],
+      additionalProperties: false
+    }
+  }
+];
+
+// src/mcp/tools/integration-content/index.ts
+function isIntegrationContentMcpToolName(name) {
+  return name === GET_INTEGRATION_CONTENT_TOOL2;
 }
 
 // src/mcp/bridge-mcp-tools.ts
@@ -39426,7 +39839,7 @@ function requireCloud(shared) {
 function createBridgeMcpToolRegistry(shared) {
   const cloud = requireCloud(shared);
   return {
-    listTools: async () => [...FORK_SESSION_MCP_TOOL_DEFINITIONS],
+    listTools: async () => [...FORK_SESSION_MCP_TOOL_DEFINITIONS, ...INTEGRATION_CONTENT_MCP_TOOL_DEFINITIONS],
     callTool: async (name, args) => {
       if (isForkSessionMcpToolName(name)) {
         if (!cloud) {
@@ -39444,6 +39857,22 @@ function createBridgeMcpToolRegistry(shared) {
         }
         return callForkSessionMcpTool({ ...shared, sessionId }, cloud, name, args);
       }
+      if (isIntegrationContentMcpToolName(name)) {
+        if (!cloud) {
+          return {
+            content: [{ type: "text", text: "Bridge MCP tools require cloud API credentials." }],
+            isError: true
+          };
+        }
+        const sessionId = typeof args.sessionId === "string" ? args.sessionId.trim() : "";
+        if (!sessionId) {
+          return {
+            content: [{ type: "text", text: "sessionId is required." }],
+            isError: true
+          };
+        }
+        return callIntegrationContentMcpTool({ ...shared, sessionId }, cloud, name, args);
+      }
       throw new Error(`Unknown bridge MCP tool: ${name}`);
     }
   };