playhead-cli 0.1.0 → 0.1.1

package/dist/mcp/bin.js

@@ -1548,6 +1548,27 @@ var init_schema = __esm({
   }
 });
 
+// src/shared/exit.ts
+var EXIT, FlowError, InfraError;
+var init_exit = __esm({
+  "src/shared/exit.ts"() {
+    "use strict";
+    EXIT = {
+      OK: 0,
+      FLOW: 1,
+      QUALITY: 2,
+      INFRA: 3,
+      USAGE: 4
+    };
+    FlowError = class extends Error {
+      exitCode = EXIT.FLOW;
+    };
+    InfraError = class extends Error {
+      exitCode = EXIT.INFRA;
+    };
+  }
+});
+
 // src/authoring/validate.ts
 var validate_exports = {};
 __export(validate_exports, {
@@ -1730,8 +1751,175 @@ var init_validate = __esm({
   }
 });
 
+// src/integrations/jira.ts
+var jira_exports = {};
+__export(jira_exports, {
+  addComment: () => addComment,
+  assertIssue: () => assertIssue,
+  attachFile: () => attachFile,
+  buildComment: () => buildComment,
+  collectEvidence: () => collectEvidence,
+  jiraConfigFromEnv: () => jiraConfigFromEnv,
+  reportToJira: () => reportToJira
+});
+import { readFile as readFile5, stat } from "fs/promises";
+import { join as join9, basename } from "path";
+import { existsSync as existsSync4 } from "fs";
+function jiraConfigFromEnv() {
+  const baseUrl = process.env.JIRA_BASE_URL;
+  const email = process.env.JIRA_EMAIL;
+  const token = process.env.JIRA_API_TOKEN;
+  if (!baseUrl || !email || !token) {
+    throw new InfraError(
+      "Jira is not configured \u2014 set JIRA_BASE_URL (https://yourorg.atlassian.net), JIRA_EMAIL, and JIRA_API_TOKEN (create one at id.atlassian.com \u2192 Security \u2192 API tokens)"
+    );
+  }
+  return { baseUrl: baseUrl.replace(/\/+$/, ""), email, token };
+}
+function authHeader(cfg) {
+  return `Basic ${Buffer.from(`${cfg.email}:${cfg.token}`).toString("base64")}`;
+}
+async function jiraFetch(cfg, path, init) {
+  const res = await fetch(`${cfg.baseUrl}${path}`, {
+    ...init,
+    headers: {
+      Authorization: authHeader(cfg),
+      Accept: "application/json",
+      ...init?.headers ?? {}
+    }
+  });
+  return res;
+}
+async function assertIssue(cfg, issueKey) {
+  const res = await jiraFetch(cfg, `/rest/api/3/issue/${encodeURIComponent(issueKey)}?fields=summary`);
+  if (res.status === 404) throw new InfraError(`Jira issue ${issueKey} not found on ${cfg.baseUrl}`);
+  if (res.status === 401 || res.status === 403) {
+    throw new InfraError(`Jira rejected the credentials for ${cfg.email} (HTTP ${res.status}) \u2014 check JIRA_API_TOKEN`);
+  }
+  if (!res.ok) throw new InfraError(`Jira issue lookup failed: HTTP ${res.status}`);
+  const body = await res.json();
+  return { key: body.key, summary: body.fields?.summary ?? "" };
+}
+async function attachFile(cfg, issueKey, filePath) {
+  const data = await readFile5(filePath);
+  const form = new FormData();
+  form.append("file", new Blob([new Uint8Array(data)]), basename(filePath));
+  const res = await jiraFetch(cfg, `/rest/api/3/issue/${encodeURIComponent(issueKey)}/attachments`, {
+    method: "POST",
+    headers: { "X-Atlassian-Token": "no-check" },
+    body: form
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new InfraError(`attaching ${basename(filePath)} failed: HTTP ${res.status} ${text.slice(0, 200)}`);
+  }
+  return basename(filePath);
+}
+async function addComment(cfg, issueKey, adfBody) {
+  const res = await jiraFetch(cfg, `/rest/api/3/issue/${encodeURIComponent(issueKey)}/comment`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ body: adfBody })
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new InfraError(`posting the comment failed: HTTP ${res.status} ${text.slice(0, 200)}`);
+  }
+}
+async function collectEvidence(outDir) {
+  const candidates = [
+    join9(outDir, "out.mp4"),
+    join9(outDir, "failure.mp4"),
+    join9(outDir, "verify", "verdict.json"),
+    join9(outDir, "verify", "contact-sheet.png"),
+    join9(outDir, "junit.xml"),
+    join9(outDir, "capture", "failure.json"),
+    join9(outDir, "capture", "console.json")
+  ];
+  const files = [];
+  for (const f of candidates) {
+    if (!existsSync4(f)) continue;
+    const s = await stat(f);
+    if (s.size > 95 * 1024 * 1024) {
+      log.warn(`skipping ${basename(f)} (${(s.size / 1e6).toFixed(0)}MB \u2014 larger than Jira's usual attachment ceiling)`);
+      continue;
+    }
+    files.push(f);
+  }
+  if (files.length === 0) {
+    throw new InfraError(`no Playhead artifacts found under ${outDir} \u2014 expected out.mp4/failure.mp4, verify/verdict.json, \u2026`);
+  }
+  let verdict;
+  const verdictPath = join9(outDir, "verify", "verdict.json");
+  if (existsSync4(verdictPath)) verdict = JSON.parse(await readFile5(verdictPath, "utf8"));
+  let failure;
+  const failurePath = join9(outDir, "capture", "failure.json");
+  if (existsSync4(failurePath)) failure = JSON.parse(await readFile5(failurePath, "utf8"));
+  const outcome = failure ? "flow-failed" : verdict?.verdict ?? "unknown";
+  return { outcome, ...verdict ? { verdict } : {}, ...failure ? { failure } : {}, files };
+}
+function buildComment(ev, attached) {
+  const text = (t, strong = false) => ({
+    type: "text",
+    text: t,
+    ...strong ? { marks: [{ type: "strong" }] } : {}
+  });
+  const para = (...content2) => ({ type: "paragraph", content: content2 });
+  const bullet = (items) => ({
+    type: "bulletList",
+    content: items.map((i) => ({ type: "listItem", content: [para(text(i))] }))
+  });
+  const content = [];
+  if (ev.outcome === "flow-failed" && ev.failure) {
+    content.push(para(text("Playhead: flow FAILED", true), text(` at step ${ev.failure.stepRef}`)));
+    content.push(para(text(ev.failure.message.split("\n")[0] ?? "")));
+    if (ev.failure.url) content.push(para(text(`Page at failure: ${ev.failure.url}`)));
+    content.push(para(text("The failure clip shows the flow up to the break \u2014 watch failure.mp4.")));
+  } else if (ev.verdict) {
+    const v = ev.verdict;
+    content.push(
+      para(text(`Playhead verdict: ${v.verdict === "publishable" ? "PUBLISHABLE \u2705" : "NOT PUBLISHABLE \u274C"}`, true))
+    );
+    content.push(
+      bullet(
+        v.checks.map((c) => `${c.status === "pass" ? "\u2713" : c.status === "fail" ? "\u2717" : "\xB7"} ${c.id}: ${c.details}`)
+      )
+    );
+    content.push(
+      para(
+        text(
+          `Provenance: playhead ${v.provenance.playheadVersion} \xB7 spec ${v.provenance.specHash.slice(0, 12)}\u2026 \xB7 captured ${v.provenance.capturedAt} \xB7 ${v.provenance.host}${v.signature ? " \xB7 signed" : " \xB7 unsigned"}`
+        )
+      )
+    );
+  } else {
+    content.push(para(text("Playhead render evidence attached.", true)));
+  }
+  content.push(para(text(`Attached: ${attached.join(", ")}`)));
+  return { type: "doc", version: 1, content };
+}
+async function reportToJira(issueKey, outDir, cfg = jiraConfigFromEnv()) {
+  const issue = await assertIssue(cfg, issueKey);
+  log.info(`reporting to ${issue.key} (\u201C${issue.summary}\u201D) on ${cfg.baseUrl}`);
+  const ev = await collectEvidence(outDir);
+  const attached = [];
+  for (const f of ev.files) {
+    attached.push(await attachFile(cfg, issueKey, f));
+    log.ok(`attached ${basename(f)}`);
+  }
+  await addComment(cfg, issueKey, buildComment(ev, attached));
+  log.ok(`verdict comment posted to ${issue.key}`);
+}
+var init_jira = __esm({
+  "src/integrations/jira.ts"() {
+    "use strict";
+    init_log();
+    init_exit();
+  }
+});
+
 // src/mcp/server.ts
-import { mkdtemp, writeFile as writeFile7, mkdir as mkdir5, readFile as readFile5 } from "fs/promises";
+import { mkdtemp, writeFile as writeFile7, mkdir as mkdir5, readFile as readFile6 } from "fs/promises";
 
 // src/shared/version.ts
 import { createRequire } from "module";
@@ -1740,7 +1928,7 @@ var PLAYHEAD_VERSION = createRequire(import.meta.url)("../../package.json").vers
 // src/mcp/server.ts
 init_explore();
 import { tmpdir } from "os";
-import { join as join9, resolve, isAbsolute } from "path";
+import { join as join10, resolve, isAbsolute } from "path";
 import { z as z2 } from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -2319,20 +2507,7 @@ function round1(n) {
 // src/capture/executor.ts
 init_geometry();
 init_log();
-
-// src/shared/exit.ts
-var EXIT = {
-  OK: 0,
-  FLOW: 1,
-  QUALITY: 2,
-  INFRA: 3,
-  USAGE: 4
-};
-var FlowError = class extends Error {
-  exitCode = EXIT.FLOW;
-};
-
-// src/capture/executor.ts
+init_exit();
 var SETTLE2 = { idleMs: 300, capMs: 5e3 };
 var TARGET_TIMEOUT_MS = 1e4;
 var EXPECT_TIMEOUT_MS = 1e4;
@@ -5598,7 +5773,7 @@ function buildServer() {
   const server = new McpServer(
     { name: "playhead", version: PLAYHEAD_VERSION },
     {
-      instructions: "Playhead turns a spec + a live web app into a verified walkthrough video. To make a demo: (1) call playhead_explore on the running app to get validated locators, (2) write a spec (or call playhead_author), (3) call playhead_render and read the verdict \u2014 fix the spec if it is not publishable. Every locator you use MUST come from an explore catalog."
+      instructions: "Playhead turns a spec + a live web app into a verified walkthrough video. To make a demo: (1) call playhead_explore on the running app to get validated locators, (2) write a spec (or call playhead_author), (3) call playhead_render and read the verdict \u2014 fix the spec if it is not publishable. Every locator you use MUST come from an explore catalog. To attach the result to a ticket, call playhead_jira with the same outDir after rendering."
     }
   );
   const dims = z2.string().regex(/^\d+x\d+$/).default("1280x720");
@@ -5643,7 +5818,7 @@ function buildServer() {
         maxSteps: 40,
         headless: true
       });
-      const yaml = await readFile5(path, "utf8");
+      const yaml = await readFile6(path, "utf8");
       return { content: [{ type: "text", text: `Wrote ${steps.length}-step spec to ${path}
 
 ${yaml}` }] };
@@ -5662,7 +5837,7 @@ ${yaml}` }] };
     },
     async ({ specPath, spec, live }) => {
       try {
-        const yaml = spec ?? await readFile5(resolve(specPath), "utf8");
+        const yaml = spec ?? await readFile6(resolve(specPath), "utf8");
         const parsed = parseSpec(yaml);
         const steps = parsed.scenes.reduce((n, s) => n + s.steps.length, 0);
         const header = `\u2713 Valid spec "${parsed.title}" \u2014 ${parsed.scenes.length} scenes, ${steps} steps.`;
@@ -5697,8 +5872,8 @@ ${formatValidateResult2(res)}` }],
       await mkdir5(out, { recursive: true });
       let parsedSpec;
       if (spec) {
-        const tmp = await mkdtemp(join9(tmpdir(), "playhead-spec-"));
-        const p = join9(tmp, "spec.yaml");
+        const tmp = await mkdtemp(join10(tmpdir(), "playhead-spec-"));
+        const p = join10(tmp, "spec.yaml");
         await writeFile7(p, spec);
         parsedSpec = parseSpec(spec);
       } else {
@@ -5714,6 +5889,35 @@ ${formatValidateResult2(res)}` }],
       };
     }
   );
+  server.registerTool(
+    "playhead_jira",
+    {
+      title: "Post render evidence to Jira",
+      description: "Attach a render's evidence to an EXISTING Jira issue and post a verdict comment \u2014 the video (or failure clip), verdict.json, contact sheet, JUnit, and console log, plus a comment carrying the per-check table (or the failing step + error for a flow failure). Run this AFTER playhead_render, pointing outDir at the same directory. Reports to existing issues only (never creates them). Requires JIRA_BASE_URL, JIRA_EMAIL, and JIRA_API_TOKEN in the environment \u2014 Playhead never handles a password.",
+      inputSchema: {
+        issueKey: z2.string().describe("the existing Jira issue key, e.g. PROJ-123"),
+        outDir: z2.string().default("playhead-out").describe("the render output directory (same one passed to playhead_render)")
+      }
+    },
+    async ({ issueKey, outDir }) => {
+      try {
+        const { reportToJira: reportToJira2, collectEvidence: collectEvidence2 } = await Promise.resolve().then(() => (init_jira(), jira_exports));
+        const out = resolve(outDir);
+        await reportToJira2(issueKey, out);
+        const ev = await collectEvidence2(out);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Posted to ${issueKey}: attached ${ev.files.length} artifact(s) [${ev.files.map((f) => f.split("/").pop()).join(", ")}] and a ${ev.outcome} verdict comment.`
+            }
+          ]
+        };
+      } catch (e) {
+        return { content: [{ type: "text", text: `\u2717 Jira report failed: ${e.message}` }], isError: true };
+      }
+    }
+  );
   return server;
 }
 function renderVerdictReport(verdict, videoPath, manifestPath) {