infraweaver 0.1.0

package/src/commands/mcp.ts

@@ -0,0 +1,126 @@
+import { existsSync, statSync } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+import arg from "arg";
+import { PRODUCT_SLUG } from "#app/brand";
+import { startLocalMcpServer } from "#app/mcp/localServer";
+import { setLogSink } from "#app/utils/log";
+
+const SEVERITIES = ["critical", "high", "medium", "low", "info"] as const;
+type SeverityFlag = (typeof SEVERITIES)[number];
+
+const SCAN_SCOPES = ["full", "diff"] as const;
+type ScanScopeFlag = (typeof SCAN_SCOPES)[number];
+
+function isSeverity(value: string): value is SeverityFlag {
+  return (SEVERITIES as readonly string[]).includes(value);
+}
+
+function isScanScope(value: string): value is ScanScopeFlag {
+  return (SCAN_SCOPES as readonly string[]).includes(value);
+}
+
+interface McpCliParams {
+  args: string[];
+  prog: string;
+  showHelp?: boolean;
+}
+
+function printMcpUsage(params: { stream: typeof console.log; prog: string }): void {
+  params.stream(`usage: ${params.prog} mcp [options]\n`);
+  params.stream(`start the local MCP server (stdio) exposing ${PRODUCT_SLUG}'s read-only`);
+  params.stream("terraform tools — scan, validate, verify, plan, version currency,");
+  params.stream("modules, provider schema, roots — to MCP clients like Claude Code,");
+  params.stream("Cursor, or Windsurf. example registration:");
+  params.stream(`  claude mcp add ${PRODUCT_SLUG} -- npx -y ${PRODUCT_SLUG} mcp`);
+  params.stream("");
+  params.stream("options:");
+  params.stream("  --cwd <dir>                   workspace to operate on (default: current dir)");
+  params.stream(`  --severity-threshold <sev>    minimum severity (${SEVERITIES.join("|")})`);
+  params.stream("  --scan-scope <scope>          full (default) or diff (vs base branch)");
+  params.stream("  --iac-languages <list>        Assess scope: auto (default) | terraform | comma list");
+  params.stream("  --module-catalogue <list>     approved modules to prefer (comma/newline-sep)");
+  params.stream("  -h, --help                    show help");
+}
+
+function parseMcpArgs(args: string[]) {
+  return arg(
+    {
+      "--help": Boolean,
+      "--cwd": String,
+      "--severity-threshold": String,
+      "--scan-scope": String,
+      "--iac-languages": String,
+      "--module-catalogue": String,
+      "-h": "--help",
+    },
+    { argv: args },
+  );
+}
+
+export async function runMcpCli(params: McpCliParams): Promise<void> {
+  if (params.showHelp) {
+    printMcpUsage({ stream: console.log, prog: params.prog });
+    return;
+  }
+
+  let parsed: ReturnType<typeof parseMcpArgs>;
+  try {
+    parsed = parseMcpArgs(params.args);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`${message}\n`);
+    printMcpUsage({ stream: console.error, prog: params.prog });
+    process.exit(1);
+  }
+
+  if (parsed["--help"]) {
+    printMcpUsage({ stream: console.log, prog: params.prog });
+    return;
+  }
+
+  if (parsed._.length > 0) {
+    console.error(`unexpected positional arguments for mcp: ${parsed._.join(" ")}\n`);
+    printMcpUsage({ stream: console.error, prog: params.prog });
+    process.exit(1);
+  }
+
+  const rawCwd = parsed["--cwd"];
+  let cwd = process.cwd();
+  if (rawCwd) {
+    cwd = isAbsolute(rawCwd) ? rawCwd : resolve(process.cwd(), rawCwd);
+  }
+  if (!existsSync(cwd) || !statSync(cwd).isDirectory()) {
+    console.error(`--cwd is not a directory: ${cwd}`);
+    process.exit(1);
+  }
+
+  const severityRaw = parsed["--severity-threshold"];
+  if (severityRaw !== undefined && !isSeverity(severityRaw)) {
+    console.error(
+      `invalid --severity-threshold: ${severityRaw} (expected ${SEVERITIES.join("|")})`,
+    );
+    process.exit(1);
+  }
+  const scopeRaw = parsed["--scan-scope"];
+  if (scopeRaw !== undefined && !isScanScope(scopeRaw)) {
+    console.error(`invalid --scan-scope: ${scopeRaw} (expected ${SCAN_SCOPES.join("|")})`);
+    process.exit(1);
+  }
+
+  // stdout is the JSON-RPC channel from here on — every diagnostic goes to stderr.
+  setLogSink("stderr");
+
+  const server = await startLocalMcpServer({
+    cwd,
+    severityThreshold: severityRaw,
+    scanScope: scopeRaw,
+    iacLanguages: parsed["--iac-languages"],
+    moduleCatalogue: parsed["--module-catalogue"],
+  });
+
+  const shutdown = (): void => {
+    void server.stop().finally(() => process.exit(0));
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}

package/src/commands/verifyEvidence.ts

@@ -0,0 +1,100 @@
+/**
+ * `infraweaver verify-evidence <bundle> <sig> <pubkey>` — offline verification of
+ * a signed compliance artefact (the evidence bundle or the CycloneDX VEX).
+ *
+ * Checks the detached Ed25519 signature (`<bundle>.sig`, base64) over the
+ * bundle's EXACT bytes against the SPKI public-key PEM. No network, no private
+ * key, no GitHub context — an auditor can run it anywhere. Exit 0 = signature
+ * OK; exit 1 = verification failed / unreadable input.
+ */
+import { readFileSync } from "node:fs";
+import { EVIDENCE_FILE, PRODUCT_NAME } from "#app/brand";
+import { publicKeyFingerprint, verifyBytes } from "#app/mcp/terraform/signing";
+
+interface VerifyEvidenceCliParams {
+  args: string[];
+  prog: string;
+  showHelp?: boolean;
+}
+
+function printUsage(params: {
+  stream: typeof console.log;
+  prog: string;
+}): void {
+  params.stream(
+    `usage: ${params.prog} verify-evidence <bundle> <sig> <pubkey>\n`,
+  );
+  params.stream(
+    `verify a ${PRODUCT_NAME} compliance artefact's detached Ed25519 signature:`,
+  );
+  params.stream(
+    `  <bundle>   the signed file (e.g. compliance/${EVIDENCE_FILE})`,
+  );
+  params.stream(
+    "  <sig>      the detached signature beside it (base64, e.g. …-evidence.json.sig)",
+  );
+  params.stream(
+    "  <pubkey>   the signer's public key (SPKI PEM — also embedded in the bundle's",
+  );
+  params.stream("             `signature.public_key` metadata)");
+  params.stream("");
+  params.stream(
+    "exits 0 when the signature verifies over the bundle's exact bytes, 1 otherwise.",
+  );
+}
+
+function readFileOrExit(path: string, what: string): Buffer {
+  try {
+    return readFileSync(path);
+  } catch (e) {
+    console.error(
+      `could not read the ${what} at ${path}: ${e instanceof Error ? e.message : String(e)}`,
+    );
+    process.exit(1);
+  }
+}
+
+export async function runVerifyEvidenceCli(
+  params: VerifyEvidenceCliParams,
+): Promise<void> {
+  if (
+    params.showHelp ||
+    params.args.includes("--help") ||
+    params.args.includes("-h")
+  ) {
+    printUsage({ stream: console.log, prog: params.prog });
+    return;
+  }
+  const positional = params.args.filter((a) => !a.startsWith("-"));
+  if (positional.length !== 3) {
+    console.error(`expected exactly 3 arguments, got ${positional.length}\n`);
+    printUsage({ stream: console.error, prog: params.prog });
+    process.exit(1);
+  }
+  const [bundlePath, sigPath, pubkeyPath] = positional as [
+    string,
+    string,
+    string,
+  ];
+  const bundle = readFileOrExit(bundlePath, "bundle");
+  const sig = readFileOrExit(sigPath, "signature").toString("utf8");
+  const pubkey = readFileOrExit(pubkeyPath, "public key").toString("utf8");
+
+  if (verifyBytes(bundle, sig, pubkey)) {
+    let fingerprint = "";
+    try {
+      fingerprint = ` (key sha256:${publicKeyFingerprint(pubkey)})`;
+    } catch {
+      /* verified above, so the key parsed — fingerprint is best-effort display */
+    }
+    console.log(
+      `signature OK — ${bundlePath} verifies under the supplied Ed25519 key${fingerprint}`,
+    );
+    return;
+  }
+  console.error(
+    `signature verification FAILED — ${bundlePath} does not verify under ${pubkeyPath} ` +
+      "(the file was modified, the signature belongs to different bytes, or the key is wrong)",
+  );
+  process.exit(1);
+}

package/src/entry.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+import { runInfraweaverCli } from "#app/runCli";
+
+runInfraweaverCli({
+  cliArgs: ["gha"],
+});

package/src/entryPost.ts

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+//
+// GitHub Actions `post:` entry point. Runs after the main step regardless of
+// exit status (cancellation, timeout, unhandled error) — that's the contract
+// we need for credential persistence: if OpenCode refreshed the Codex
+// auth.json during the run, the refreshed token must land back in Infraweaver
+// even when the main step died unexpectedly.
+//
+// THIS IS WHY `CODEX_AUTH_JSON` HAS TO LIVE IN INFRAWEAVER'S OWN SECRET STORE,
+// NOT IN GITHUB ACTIONS SECRETS. The refresh chain rotates on every use; this
+// hook PUTs the rotated chain back to Infraweaver Postgres so the next run starts
+// from a fresh token. GH Actions secrets are read-only at runtime — there is
+// no API to write them back from inside a job — so a token stashed there
+// silently goes stale on the first refresh and the next run fails. See
+// wiki/codex-auth.md.
+//
+// Today's only job: detect a Codex auth refresh by diffing the on-disk
+// auth.json against the original refresh token (saved to GH Actions state
+// by src/agents/opencode.ts), convert OpenCode's auth shape
+// back to Codex CLI shape, and PUT it to /api/runtime/secret.
+//
+// Silent no-op when the main step didn't materialize Codex auth (no state
+// saved). Best-effort: failures are logged but never throw — the workflow
+// is already done, and a missed refresh write-back means the user re-runs
+// `infraweaver auth codex` next time the chain breaks.
+//
+// Imports here MUST stay stdlib-only — GHA runs this file directly from the
+// checked-out action repo, which has no node_modules for sha-pinned consumers.
+
+import { existsSync, readFileSync } from "node:fs";
+import { PRODUCT_NAME } from "#app/brand";
+import { cloudFetch } from "#app/utils/cloudFetchCore";
+import { detectCodexRefresh } from "#app/utils/codexRefreshDetect";
+import * as core from "#app/utils/ghaCore";
+
+async function main(): Promise<void> {
+  const raw = core.getState("codex_writeback");
+  if (!raw) {
+    core.info("codex post-hook: no writeback state — skipping");
+    return;
+  }
+
+  let state: { apiToken: string; authPath: string; originalRefresh: string };
+  try {
+    state = JSON.parse(raw) as typeof state;
+  } catch (err) {
+    core.warning(`codex post-hook: malformed writeback state — ${err}`);
+    return;
+  }
+  if (!state.apiToken || !state.authPath || !state.originalRefresh) {
+    core.warning("codex post-hook: incomplete writeback state — skipping");
+    return;
+  }
+
+  if (!existsSync(state.authPath)) {
+    core.info(
+      `codex post-hook: ${state.authPath} not found — nothing to write back`,
+    );
+    return;
+  }
+
+  let authFileContent: string;
+  try {
+    authFileContent = readFileSync(state.authPath, "utf8");
+  } catch (err) {
+    core.warning(`codex post-hook: cannot read ${state.authPath} — ${err}`);
+    return;
+  }
+
+  const refreshedCodexJson = detectCodexRefresh({
+    authFileContent,
+    originalRefresh: state.originalRefresh,
+  });
+  if (!refreshedCodexJson) {
+    core.info("codex post-hook: refresh chain unchanged — no writeback needed");
+    return;
+  }
+
+  try {
+    const response = await cloudFetch({
+      path: "/api/runtime/secret",
+      method: "PUT",
+      headers: {
+        authorization: `Bearer ${state.apiToken}`,
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        name: "CODEX_AUTH_JSON",
+        value: refreshedCodexJson,
+      }),
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      core.warning(
+        `codex post-hook: writeback returned ${response.status}: ${body}`,
+      );
+      return;
+    }
+    core.info(
+      `codex post-hook: refreshed CODEX_AUTH_JSON persisted to ${PRODUCT_NAME}`,
+    );
+  } catch (err) {
+    core.warning(`codex post-hook: writeback failed — ${err}`);
+  }
+}
+
+main().catch((err) => {
+  core.warning(`codex post-hook: unexpected error — ${err}`);
+});

package/src/external.ts

@@ -0,0 +1,308 @@
+/**
+ * ⚠️ LIMITED IMPORTS - this file is imported by Next.js and must avoid pulling in backend code.
+ * All shared constants, types, and data used by both the Next.js app and the action runtime live here.
+ * Other files in action/ re-export from this file for backward compatibility.
+ */
+
+import type { PullRequest } from "@octokit/webhooks-types";
+
+// mcp name constant
+export const infraweaverMcpName = "infraweaver";
+
+/** @see {@link file://./agents/shared.ts} Agent interface that uses this type */
+export type AgentId = "claude" | "opencode";
+
+/**
+ * format a tool name the way each agent's MCP client presents it to the model.
+ * claude code: mcp__infraweaver__select_mode
+ * opencode:    infraweaver_select_mode
+ */
+export function formatMcpToolRef(agentId: AgentId, toolName: string): string {
+  switch (agentId) {
+    case "claude":
+      return `mcp__${infraweaverMcpName}__${toolName}`;
+    case "opencode":
+      return `${infraweaverMcpName}_${toolName}`;
+    default:
+      return agentId satisfies never;
+  }
+}
+
+// model alias registry lives in models.ts — re-exported here for shared access
+export type { ModelAlias, ModelProvider, ProviderConfig } from "#app/models";
+export {
+  DEFAULT_PROXY_MODEL,
+  getAutoSelectHintModel,
+  getModelEnvVars,
+  getModelManagedCredentials,
+  getModelProvider,
+  getProviderDisplayName,
+  modelAliases,
+  parseModel,
+  providers,
+  resolveCliModel,
+  resolveDisplayAlias,
+  resolveModelSlug,
+  resolveOpenRouterModel,
+} from "#app/models";
+
+// tool permission types shared with server dispatch
+export type ToolPermission = "disabled" | "enabled";
+export type ShellPermission = "disabled" | "restricted" | "enabled";
+export type PushPermission = "disabled" | "restricted" | "enabled";
+
+// workflow yml permissions for GITHUB_TOKEN
+export type WorkflowPermissionValue = "read" | "write" | "none";
+export type WorkflowIdTokenPermissionValue = "write" | "none";
+
+export interface WorkflowPermissions {
+  actions?: WorkflowPermissionValue;
+  attestations?: WorkflowPermissionValue;
+  checks?: WorkflowPermissionValue;
+  contents?: WorkflowPermissionValue;
+  deployments?: WorkflowPermissionValue;
+  discussions?: WorkflowPermissionValue;
+  "id-token"?: WorkflowIdTokenPermissionValue;
+  issues?: WorkflowPermissionValue;
+  models?: WorkflowPermissionValue;
+  packages?: WorkflowPermissionValue;
+  pages?: WorkflowPermissionValue;
+  "pull-requests"?: WorkflowPermissionValue;
+  "repository-projects"?: WorkflowPermissionValue;
+  "security-events"?: WorkflowPermissionValue;
+  statuses?: WorkflowPermissionValue;
+}
+
+// permission level for the author who triggered the event
+// matches GitHub's permission levels: admin > write > maintain > triage > read > none
+export type AuthorPermission =
+  | "admin"
+  | "maintain"
+  | "write"
+  | "triage"
+  | "read"
+  | "none";
+
+// base interface for common payload event fields
+interface BasePayloadEvent {
+  issue_number?: number;
+  is_pr?: boolean;
+  branch?: string;
+  /** title of the issue/PR (or contextual title for comments) */
+  title?: string;
+  /** primary content for this trigger (issue body, PR body, comment body, review body, etc.) */
+  body?: string | null;
+  comment_id?: number;
+  review_id?: number;
+  review_state?: string;
+  /** GraphQL review-thread context (shape owned by the backend producer; not read in-action) */
+  thread?: unknown;
+  pull_request?: PullRequest;
+  check_suite?: {
+    id: number;
+    head_sha: string;
+    head_branch: string | null;
+    status: string | null;
+    conclusion: string | null;
+    url: string;
+  };
+  comment_ids?: number[] | "all";
+  /** permission level of the user who triggered this event */
+  authorPermission?: AuthorPermission;
+  /** when true, runs silently without progress comments (e.g., auto-labeling) */
+  silent?: boolean;
+  [key: string]: unknown;
+}
+
+interface PullRequestOpenedEvent extends BasePayloadEvent {
+  trigger: "pull_request_opened";
+  issue_number: number;
+  is_pr: true;
+  title: string;
+  body: string | null;
+  branch: string;
+}
+
+interface PullRequestReadyForReviewEvent extends BasePayloadEvent {
+  trigger: "pull_request_ready_for_review";
+  issue_number: number;
+  is_pr: true;
+  title: string;
+  body: string | null;
+  branch: string;
+}
+
+interface PullRequestReviewRequestedEvent extends BasePayloadEvent {
+  trigger: "pull_request_review_requested";
+  issue_number: number;
+  is_pr: true;
+  title: string;
+  body: string | null;
+  branch: string;
+}
+
+interface PullRequestReviewSubmittedEvent extends BasePayloadEvent {
+  trigger: "pull_request_review_submitted";
+  issue_number: number;
+  is_pr: true;
+  review_id: number;
+  /** review body is the primary content */
+  body: string | null;
+  review_state: string;
+  branch: string;
+}
+
+interface PullRequestReviewCommentCreatedEvent extends BasePayloadEvent {
+  trigger: "pull_request_review_comment_created";
+  issue_number: number;
+  is_pr: true;
+  title: string;
+  comment_id: number;
+  /** comment body is the primary content (null if already in prompt) */
+  body: string | null;
+  thread?: unknown;
+  branch: string;
+}
+
+interface IssuesOpenedEvent extends BasePayloadEvent {
+  trigger: "issues_opened";
+  issue_number: number;
+  title: string;
+  body: string | null;
+}
+
+interface IssuesAssignedEvent extends BasePayloadEvent {
+  trigger: "issues_assigned";
+  issue_number: number;
+  title: string;
+  body: string | null;
+}
+
+interface IssuesLabeledEvent extends BasePayloadEvent {
+  trigger: "issues_labeled";
+  issue_number: number;
+  title: string;
+  body: string | null;
+}
+
+interface IssueCommentCreatedEvent extends BasePayloadEvent {
+  trigger: "issue_comment_created";
+  comment_id: number;
+  /** distinguishes this from PR review comments (which use pull_request_review_comment_created) */
+  comment_type: "issue";
+  /** comment body is the primary content (null if already in prompt) */
+  body: string | null;
+  issue_number: number;
+  // PR-specific fields (only present when is_pr is true)
+  is_pr?: true;
+  branch?: string;
+  title?: string;
+}
+
+interface CheckSuiteCompletedEvent extends BasePayloadEvent {
+  trigger: "check_suite_completed";
+  issue_number: number;
+  is_pr: true;
+  title: string;
+  body: string | null;
+  pull_request: PullRequest;
+  branch: string;
+  check_suite: {
+    id: number;
+    head_sha: string;
+    head_branch: string | null;
+    status: string | null;
+    conclusion: string | null;
+    url: string;
+  };
+}
+
+interface WorkflowDispatchEvent extends BasePayloadEvent {
+  trigger: "workflow_dispatch";
+}
+
+interface FixReviewEvent extends BasePayloadEvent {
+  trigger: "fix_review";
+  issue_number: number;
+  is_pr: true;
+  review_id: number;
+  /** when true, only address comments the triggerer approved with 👍 (vs all comments) */
+  approved_only?: boolean | undefined;
+}
+
+interface ImplementPlanEvent extends BasePayloadEvent {
+  trigger: "implement_plan";
+  issue_number: number;
+  plan_comment_id: number;
+  /** plan content is the primary content (null if already in prompt) */
+  body: string | null;
+}
+
+interface PullRequestSynchronizeEvent extends BasePayloadEvent {
+  trigger: "pull_request_synchronize";
+  issue_number: number;
+  is_pr: true;
+  title: string;
+  body: string | null;
+  branch: string;
+  /** SHA before the push -- used to compute incremental range-diff between PR versions */
+  before_sha: string;
+}
+
+interface UnknownEvent extends BasePayloadEvent {
+  trigger: "unknown";
+}
+
+// discriminated union for payload event based on trigger
+// note: all events use issue_number for consistency (PRs are issues in GitHub's API)
+export type PayloadEvent =
+  | PullRequestOpenedEvent
+  | PullRequestReadyForReviewEvent
+  | PullRequestSynchronizeEvent
+  | PullRequestReviewRequestedEvent
+  | PullRequestReviewSubmittedEvent
+  | PullRequestReviewCommentCreatedEvent
+  | IssuesOpenedEvent
+  | IssuesAssignedEvent
+  | IssuesLabeledEvent
+  | IssueCommentCreatedEvent
+  | CheckSuiteCompletedEvent
+  | WorkflowDispatchEvent
+  | FixReviewEvent
+  | ImplementPlanEvent
+  | UnknownEvent;
+
+// writeable payload type for building payloads
+export interface WriteablePayload {
+  "~infraweaver": true;
+  /** semantic version of the payload to ensure compatibility */
+  version: string;
+  /** provider/model slug (e.g. "anthropic/claude-opus") */
+  model?: string | undefined;
+  /** the user's actual request (body if @infraweaver tagged) */
+  prompt: string;
+  /** github username of the human who triggered this workflow run */
+  triggerer?: string | undefined;
+  /** event-level instructions for this trigger type (flag-expanded server-side) */
+  eventInstructions?: string | undefined;
+  /**
+   * system-injected note about prior superseded runs (e.g. when the
+   * triggering @infraweaver comment is edited). rendered alongside the user's
+   * prompt rather than via eventInstructions so it survives user-prompt
+   * precedence.
+   */
+  previousRunsNote?: string | undefined;
+  /** event data from webhook payload - discriminated union based on trigger field */
+  event: PayloadEvent;
+  /** timeout for agent run (e.g., "10m", "1h30m") - defaults to "1h" */
+  timeout?: string | undefined;
+  /** working directory for the agent */
+  cwd?: string | undefined;
+  /** pre-created progress comment (ID + type) for updating status */
+  progressComment?: { id: string; type: "issue" | "review" } | undefined;
+  /** when true, seed the PR summary tmpfile + persist edits at run end */
+  generateSummary?: boolean | undefined;
+}
+
+// immutable payload type for agent execution
+export type Payload = Readonly<WriteablePayload>;