copilot-tap-extension 2.0.8 → 2.0.9

package/providers/templates/ci-review-provider.mjs

@@ -0,0 +1,46 @@
+import { connectProvider, push } from "./provider-utils.mjs";
+
+const tools = [
+  {
+    name: "ci_review_normalize_findings",
+    description: "Normalize structured code review findings into tap provider events.",
+    parameters: {
+      type: "object",
+      properties: {
+        findings: { type: "array" },
+        runUrl: { type: "string" },
+        repository: { type: "string" }
+      },
+      required: ["findings"]
+    }
+  }
+];
+
+connectProvider({
+  name: "ci-review-template",
+  tools,
+  onMessage(ws, msg) {
+    if (msg.type !== "tool.call" || msg.tool !== "ci_review_normalize_findings") {
+      return;
+    }
+    const args = msg.arguments ?? {};
+    for (const finding of args.findings ?? []) {
+      const priority = Number(finding.priority ?? 3);
+      push(ws, {
+        stream: "ci-review",
+        level: priority <= 1 ? "inject" : "surface",
+        event: {
+          type: "review.finding",
+          title: finding.title,
+          priority,
+          confidence: finding.confidence_score,
+          file: finding.code_location?.absolute_file_path,
+          line: finding.code_location?.line_range?.start,
+          runUrl: args.runUrl,
+          repository: args.repository
+        }
+      });
+    }
+    ws.send(JSON.stringify({ type: "tool.result", callId: msg.callId, result: { ok: true } }));
+  }
+});

package/providers/templates/detour-workflow-provider.mjs

@@ -0,0 +1,41 @@
+import { connectProvider, push } from "./provider-utils.mjs";
+
+const tools = [
+  {
+    name: "detour_emit_page_event",
+    description: "Normalize browser or Detour page events for tap streams.",
+    parameters: {
+      type: "object",
+      properties: {
+        url: { type: "string" },
+        eventType: { type: "string" },
+        message: { type: "string" },
+        severity: { type: "string" }
+      },
+      required: ["eventType", "message"]
+    }
+  }
+];
+
+connectProvider({
+  name: "detour-workflow-template",
+  tools,
+  onMessage(ws, msg) {
+    if (msg.type !== "tool.call" || msg.tool !== "detour_emit_page_event") {
+      return;
+    }
+    const args = msg.arguments ?? {};
+    const severity = String(args.severity ?? "info").toLowerCase();
+    push(ws, {
+      stream: "detour-browser",
+      level: /error|fatal|blocked/.test(severity) ? "inject" : "surface",
+      event: {
+        type: `browser.${args.eventType}`,
+        url: args.url ?? null,
+        severity,
+        message: args.message
+      }
+    });
+    ws.send(JSON.stringify({ type: "tool.result", callId: msg.callId, result: { ok: true } }));
+  }
+});

package/providers/templates/jira-github-provider.mjs

@@ -0,0 +1,42 @@
+import { connectProvider, push } from "./provider-utils.mjs";
+
+const tools = [
+  {
+    name: "jira_github_emit_issue",
+    description: "Emit a normalized Jira issue event for tap goals or orchestration.",
+    parameters: {
+      type: "object",
+      properties: {
+        issueKey: { type: "string" },
+        summary: { type: "string" },
+        description: { type: "string" },
+        label: { type: "string" },
+        prUrl: { type: "string" }
+      },
+      required: ["issueKey", "summary"]
+    }
+  }
+];
+
+connectProvider({
+  name: "jira-github-template",
+  tools,
+  onMessage(ws, msg) {
+    if (msg.type !== "tool.call" || msg.tool !== "jira_github_emit_issue") {
+      return;
+    }
+    const args = msg.arguments ?? {};
+    push(ws, {
+      stream: "jira-github",
+      level: "inject",
+      event: {
+        type: "jira.issue.ready",
+        issueKey: args.issueKey,
+        summary: args.summary,
+        label: args.label,
+        prUrl: args.prUrl ?? null
+      }
+    });
+    ws.send(JSON.stringify({ type: "tool.result", callId: msg.callId, result: { ok: true } }));
+  }
+});

package/providers/templates/provider-utils.mjs

@@ -0,0 +1,45 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import WebSocket from "ws";
+
+export function discoverTapToken() {
+  if (process.env.TAP_PROVIDER_TOKEN) {
+    return process.env.TAP_PROVIDER_TOKEN;
+  }
+  const copilotHome = process.env.COPILOT_HOME || path.join(os.homedir(), ".copilot");
+  return fs.readFileSync(path.join(copilotHome, "extensions", "tap", ".provider-token"), "utf8").trim();
+}
+
+export function connectProvider({ name, tools, session = "all", onMessage }) {
+  const token = discoverTapToken();
+  const ws = new WebSocket(process.env.TAP_PROVIDER_URL || "ws://127.0.0.1:9400");
+  ws.on("open", () => {
+    ws.send(JSON.stringify({ type: "auth", token }));
+  });
+  ws.on("message", (raw) => {
+    const msg = JSON.parse(String(raw));
+    if (msg.type === "sessions") {
+      ws.send(JSON.stringify({
+        type: "hello",
+        name,
+        protocolVersion: 2,
+        session,
+        tools
+      }));
+      return;
+    }
+    onMessage?.(ws, msg);
+  });
+  return ws;
+}
+
+export function push(ws, { stream, level = "surface", event, metadata = {} }) {
+  ws.send(JSON.stringify({
+    type: "push",
+    level,
+    stream,
+    event: typeof event === "string" ? event : JSON.stringify(event),
+    metadata
+  }));
+}

package/providers/templates/sast-triage-provider.mjs

@@ -0,0 +1,51 @@
+import { createHash } from "node:crypto";
+import { connectProvider, push } from "./provider-utils.mjs";
+
+function fingerprint(finding) {
+  return createHash("sha256")
+    .update([finding.cwe, finding.sink, finding.file, finding.line].filter(Boolean).join("|"))
+    .digest("hex")
+    .slice(0, 16);
+}
+
+const tools = [
+  {
+    name: "sast_emit_findings",
+    description: "Normalize SAST findings into stable, fingerprinted tap events.",
+    parameters: {
+      type: "object",
+      properties: {
+        findings: { type: "array" }
+      },
+      required: ["findings"]
+    }
+  }
+];
+
+connectProvider({
+  name: "sast-triage-template",
+  tools,
+  onMessage(ws, msg) {
+    if (msg.type !== "tool.call" || msg.tool !== "sast_emit_findings") {
+      return;
+    }
+    for (const finding of msg.arguments?.findings ?? []) {
+      const severity = String(finding.severity ?? "medium").toLowerCase();
+      push(ws, {
+        stream: "sast-triage",
+        level: /critical|high/.test(severity) ? "inject" : "surface",
+        event: {
+          type: "sast.finding",
+          fingerprint: fingerprint(finding),
+          severity,
+          cwe: finding.cwe,
+          file: finding.file,
+          line: finding.line,
+          sink: finding.sink,
+          exploitability: finding.exploitability ?? null
+        }
+      });
+    }
+    ws.send(JSON.stringify({ type: "tool.result", callId: msg.callId, result: { ok: true } }));
+  }
+});