@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/operations/services/release-proof-planner.js

@@ -1,195 +0,0 @@
-import { createHash } from "node:crypto";
-import { existsSync, readFileSync } from "node:fs";
-import { basename, resolve } from "node:path";
-import { discoverTreeseedPackageAdapters } from "./package-adapters.js";
-import { classifyTreeseedGitMode, runTreeseedGitText } from "./git-runner.js";
-import {
-  computeProofInputHash
-} from "./release-proof.js";
-import { findReusableProof, readProofLedger } from "./release-proof-ledger.js";
-function runGit(args, cwd) {
-  try {
-    return runTreeseedGitText(args, {
-      cwd,
-      mode: classifyTreeseedGitMode(args),
-      timeoutMs: 12e4,
-      maxBuffer: 1024 * 1024 * 8
-    }).trim();
-  } catch {
-    return null;
-  }
-}
-function fileSha256(filePath) {
-  if (!existsSync(filePath)) return null;
-  return createHash("sha256").update(readFileSync(filePath)).digest("hex");
-}
-function repositoryFor(adapter) {
-  const repository = adapter.metadata.repository;
-  if (typeof repository === "string" && repository.trim()) return repository.trim();
-  if (repository && typeof repository === "object" && !Array.isArray(repository)) {
-    const url = repository.url;
-    if (typeof url === "string") {
-      return url.replace(/^git\+/u, "").replace(/^ssh:\/\/git@github\.com[:/]/u, "").replace(/^git@github\.com:/u, "").replace(/^https:\/\/github\.com\//u, "").replace(/\.git$/u, "").replace(/\/$/u, "");
-    }
-  }
-  return null;
-}
-function hostedWorkflowForPackage(adapter) {
-  const configured = adapter.metadata.hostedVerifyWorkflow;
-  if (typeof configured === "string" && configured.trim()) return configured.trim().replace(/^\.github\/workflows\//u, "");
-  const workflowCheck = adapter.releaseChecks.find((check) => check.kind === "github-workflow");
-  if (workflowCheck?.detail) return basename(workflowCheck.detail);
-  if (adapter.id === "treedx" || adapter.kind === "beam-elixir-rust") return "release-gate.yml";
-  return "verify.yml";
-}
-function commandForPackage(adapter, driver) {
-  const command = commandSpecForPackage(adapter, driver);
-  return command ? [command.command, ...command.args].join(" ") : null;
-}
-function commandSpecForPackage(adapter, driver) {
-  if (driver === "act") return adapter.verifyCommands.local ? {
-    ...adapter.verifyCommands.local,
-    label: "verify:action",
-    command: "npm",
-    args: ["run", "verify:action"]
-  } : null;
-  if (driver !== "local") return null;
-  return adapter.verifyCommands.release ?? adapter.verifyCommands.local ?? adapter.verifyCommands.fast;
-}
-function subjectForPackage(adapter) {
-  return {
-    kind: "package",
-    id: `package:${adapter.id}`,
-    name: adapter.id,
-    repoPath: adapter.dir,
-    repository: repositoryFor(adapter),
-    branch: runGit(["branch", "--show-current"], adapter.dir),
-    headSha: runGit(["rev-parse", "HEAD"], adapter.dir)
-  };
-}
-function internalDependencyHeadShas(adapter, adaptersByName) {
-  const packageJsonPath = resolve(adapter.dir, "package.json");
-  if (!existsSync(packageJsonPath)) return {};
-  const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-  const sections = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
-  const heads = {};
-  for (const section of sections) {
-    const entries = parsed[section] && typeof parsed[section] === "object" && !Array.isArray(parsed[section]) ? parsed[section] : {};
-    for (const name of Object.keys(entries)) {
-      const dependency = adaptersByName.get(name);
-      if (!dependency) continue;
-      heads[name] = runGit(["rev-parse", "HEAD"], dependency.dir);
-    }
-  }
-  return heads;
-}
-function proofInputForPackage(root, adapter, driver, dependencyProofIds, adaptersByName) {
-  const workflow = hostedWorkflowForPackage(adapter);
-  const dockerfile = adapter.artifacts.find((artifact) => artifact.dockerfile)?.dockerfile;
-  const sourceHashes = {
-    head: runGit(["rev-parse", "HEAD"], adapter.dir),
-    ...Object.fromEntries(Object.entries(internalDependencyHeadShas(adapter, adaptersByName)).map(([name, sha]) => [`dependency:${name}`, sha]))
-  };
-  const baseInputs = {
-    topologyHash: computeProofInputHash({
-      packageId: adapter.id,
-      kind: adapter.kind,
-      workflow,
-      command: commandForPackage(adapter, driver),
-      artifacts: adapter.artifacts,
-      dependencyProofIds
-    }),
-    packageJsonHash: fileSha256(resolve(adapter.dir, "package.json")),
-    lockfileHash: adapter.kind === "node-typescript" ? fileSha256(resolve(adapter.dir, "package-lock.json")) : fileSha256(resolve(adapter.dir, "Cargo.lock")) ?? fileSha256(resolve(adapter.dir, "mix.lock")),
-    manifestHash: fileSha256(adapter.manifestPath ?? resolve(adapter.dir, "treeseed.package.yaml")),
-    workflowHash: fileSha256(resolve(adapter.dir, ".github", "workflows", workflow)),
-    dockerfileHash: dockerfile ? fileSha256(resolve(adapter.dir, dockerfile)) : null,
-    sourceHashes,
-    dependencyProofIds
-  };
-  return {
-    subject: subjectForPackage(adapter),
-    driver,
-    inputs: {
-      ...baseInputs,
-      inputHash: computeProofInputHash({
-        root,
-        subject: subjectForPackage(adapter),
-        driver,
-        ...baseInputs
-      })
-    }
-  };
-}
-function selectAdapters(root, subject) {
-  const adapters = discoverTreeseedPackageAdapters(root);
-  if (!subject) return adapters;
-  const normalized = subject.replace(/^package:/u, "");
-  return adapters.filter((adapter) => adapter.id === normalized || adapter.name === normalized || `package:${adapter.id}` === subject);
-}
-function buildTreeseedProofPlan(input) {
-  const target = input.target ?? "staging";
-  const driver = input.driver ?? "github-hosted";
-  const subjects = [];
-  const proofIds = /* @__PURE__ */ new Map();
-  const selectedAdapters = selectAdapters(input.root, input.subject);
-  const adaptersByName = new Map(discoverTreeseedPackageAdapters(input.root).flatMap((adapter) => [[adapter.id, adapter], [adapter.name, adapter]]));
-  for (const adapter of selectedAdapters) {
-    const dependencyProofIds = [];
-    const proofInput = proofInputForPackage(input.root, adapter, driver, dependencyProofIds, adaptersByName);
-    const reusableProof = findReusableProof(input.root, proofInput);
-    if (reusableProof) proofIds.set(adapter.id, reusableProof.proofId);
-    const workflow = driver === "github-hosted" ? hostedWorkflowForPackage(adapter) : null;
-    const command = driver === "github-hosted" ? null : commandForPackage(adapter, driver);
-    const commandSpec = driver === "github-hosted" ? null : commandSpecForPackage(adapter, driver);
-    subjects.push({
-      ...proofInput,
-      workflow,
-      command,
-      commandSpec,
-      authority: driver === "github-hosted" ? "authoritative" : "advisory",
-      reusableProof,
-      rerunReasons: reusableProof ? [] : ["No reusable passed proof record matches this subject, driver, and input hash."]
-    });
-  }
-  return {
-    target,
-    driver,
-    subjects,
-    summary: {
-      subjects: subjects.length,
-      reusable: subjects.filter((subject) => subject.reusableProof).length,
-      pending: subjects.filter((subject) => !subject.reusableProof).length
-    }
-  };
-}
-function summarizeTreeseedProofLedger(root) {
-  const records = readProofLedger(root);
-  const failures = records.filter((record) => record.status === "failed" || record.status === "blocked");
-  const latest = records[0] ?? null;
-  const slowest = [...records].filter((record) => typeof record.durationMs === "number").sort((left, right) => (right.durationMs ?? 0) - (left.durationMs ?? 0)).slice(0, 10).map((record) => ({
-    subject: record.subject.id,
-    driver: record.driver,
-    durationMs: record.durationMs,
-    status: record.status,
-    reason: record.invalidationReasons[0] ?? (record.reusable ? "Proof record is reusable." : "Proof record is not reusable.")
-  }));
-  return {
-    records,
-    latest,
-    failures,
-    slowest,
-    summary: {
-      records: records.length,
-      passed: records.filter((record) => record.status === "passed").length,
-      failed: failures.length,
-      pending: records.filter((record) => record.status === "pending").length,
-      reusable: records.filter((record) => record.reusable).length
-    }
-  };
-}
-export {
-  buildTreeseedProofPlan,
-  hostedWorkflowForPackage,
-  summarizeTreeseedProofLedger
-};

package/dist/operations/services/release-proof-runner.d.ts

@@ -1,16 +0,0 @@
-import { type TreeseedProofDriver, type TreeseedProofRecord } from './release-proof.js';
-import { type TreeseedProofPlan, type TreeseedProofTarget } from './release-proof-planner.js';
-export type TreeseedProofRunResult = {
-    plan: TreeseedProofPlan;
-    records: TreeseedProofRecord[];
-    reused: TreeseedProofRecord[];
-    failures: TreeseedProofRecord[];
-    ok: boolean;
-};
-export declare function runTreeseedProof(input: {
-    root: string;
-    target?: TreeseedProofTarget;
-    driver?: TreeseedProofDriver;
-    subject?: string | null;
-    write?: (line: string, stream?: 'stdout' | 'stderr') => void;
-}): Promise<TreeseedProofRunResult>;

package/dist/operations/services/release-proof-runner.js

@@ -1,169 +0,0 @@
-import {
-  createProofRecord
-} from "./release-proof.js";
-import { spawnSync } from "node:child_process";
-import { maybeResolveGitHubRepositorySlug } from "./github-automation.js";
-import { writeProofRecord } from "./release-proof-ledger.js";
-import { buildTreeseedProofPlan } from "./release-proof-planner.js";
-import { inspectGitHubActionsVerification } from "./github-actions-verification.js";
-function workflowRecordFromInspection(input) {
-  const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
-  return createProofRecord({
-    subject: input.subject.subject,
-    inputs: input.subject.inputs,
-    driver: input.subject.driver,
-    status: input.status,
-    startedAt: input.startedAt,
-    finishedAt,
-    reusable: input.status === "passed",
-    invalidationReasons: input.status === "passed" ? [] : [input.workflow?.message ?? "Hosted GitHub workflow did not pass."],
-    result: input.workflow && input.subject.subject.repository ? {
-      workflow: {
-        repository: input.subject.subject.repository,
-        workflow: input.workflow.workflow,
-        runId: input.workflow.runId,
-        url: input.workflow.url,
-        conclusion: input.workflow.conclusion,
-        failedJobs: input.workflow.failedJobs.map((job) => ({
-          id: job.id,
-          name: job.name,
-          url: job.url,
-          failedSteps: job.failedSteps.map((step) => step.name),
-          ...job.logExcerpt ? { logExcerpt: job.logExcerpt } : {}
-        }))
-      }
-    } : {}
-  });
-}
-async function runHostedProof(root, subject) {
-  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  if (!subject.subject.repository && maybeResolveGitHubRepositorySlug(subject.subject.repoPath) == null) {
-    return createProofRecord({
-      subject: subject.subject,
-      inputs: subject.inputs,
-      driver: subject.driver,
-      status: "skipped",
-      startedAt,
-      reusable: false,
-      invalidationReasons: ["Proof subject is not backed by a GitHub repository in this local test workspace."]
-    });
-  }
-  if (!subject.subject.repository || !subject.subject.branch || !subject.subject.headSha || !subject.workflow) {
-    return createProofRecord({
-      subject: subject.subject,
-      inputs: subject.inputs,
-      driver: subject.driver,
-      status: "blocked",
-      startedAt,
-      reusable: false,
-      invalidationReasons: ["Repository, branch, head SHA, or workflow is unavailable for hosted proof."]
-    });
-  }
-  const report = await inspectGitHubActionsVerification([{
-    name: subject.subject.name,
-    repoPath: subject.subject.repoPath,
-    repository: subject.subject.repository,
-    branch: subject.subject.branch,
-    headSha: subject.subject.headSha,
-    workflows: [subject.workflow],
-    kind: subject.subject.kind === "root" ? "root" : "package",
-    missingIsFailure: true
-  }], {
-    includeLogs: true,
-    logLines: 120
-  });
-  const workflow = report.repositories[0]?.workflows[0] ?? null;
-  const status = workflow?.state === "success" ? "passed" : workflow?.state === "pending" ? "pending" : "failed";
-  return workflowRecordFromInspection({ root, subject, workflow, startedAt, status });
-}
-function advisorySkippedProof(subject) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  return createProofRecord({
-    subject: subject.subject,
-    inputs: subject.inputs,
-    driver: subject.driver,
-    status: "skipped",
-    startedAt: now,
-    finishedAt: now,
-    reusable: false,
-    invalidationReasons: [
-      subject.driver === "act" ? "Local action simulation is advisory and cannot satisfy authoritative hosted proof." : "Only github-hosted proof execution is enabled for this proof runner slice."
-    ],
-    result: subject.command ? {
-      command: { command: subject.command, cwd: subject.subject.repoPath, exitCode: null }
-    } : {}
-  });
-}
-function runLocalProof(subject) {
-  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  if (!subject.commandSpec) {
-    return createProofRecord({
-      subject: subject.subject,
-      inputs: subject.inputs,
-      driver: subject.driver,
-      status: "blocked",
-      startedAt,
-      reusable: false,
-      invalidationReasons: ["No local proof command is declared for this subject."]
-    });
-  }
-  const result = spawnSync(subject.commandSpec.command, subject.commandSpec.args, {
-    cwd: subject.commandSpec.cwd || subject.subject.repoPath,
-    env: {
-      ...process.env,
-      TREESEED_VERIFY_DRIVER: "direct",
-      TMPDIR: process.env.TMPDIR ?? "/tmp"
-    },
-    stdio: "inherit",
-    shell: false
-  });
-  const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const exitCode = typeof result.status === "number" ? result.status : null;
-  const errorMessage = result.error instanceof Error ? result.error.message : null;
-  return createProofRecord({
-    subject: subject.subject,
-    inputs: subject.inputs,
-    driver: subject.driver,
-    status: exitCode === 0 ? "passed" : "failed",
-    startedAt,
-    finishedAt,
-    reusable: exitCode === 0,
-    invalidationReasons: exitCode === 0 ? [] : [`Local proof command failed${errorMessage ? `: ${errorMessage}` : exitCode == null ? "." : ` with exit code ${exitCode}.`}`],
-    result: {
-      command: {
-        command: [subject.commandSpec.command, ...subject.commandSpec.args].join(" "),
-        cwd: subject.commandSpec.cwd || subject.subject.repoPath,
-        exitCode
-      }
-    }
-  });
-}
-async function runTreeseedProof(input) {
-  const plan = buildTreeseedProofPlan(input);
-  const records = [];
-  const reused = [];
-  for (const subject of plan.subjects) {
-    if (subject.reusableProof) {
-      reused.push(subject.reusableProof);
-      continue;
-    }
-    input.write?.(`[proof] Proving ${subject.subject.id} with ${subject.driver}${subject.workflow ? ` (${subject.workflow})` : ""}.`);
-    const record = subject.driver === "github-hosted" ? await runHostedProof(input.root, subject) : subject.driver === "local" ? runLocalProof(subject) : advisorySkippedProof(subject);
-    writeProofRecord(input.root, record);
-    records.push(record);
-    if (record.status === "failed" || record.status === "blocked") {
-      break;
-    }
-  }
-  const failures = [...records, ...reused].filter((record) => record.status === "failed" || record.status === "blocked" || record.driver === "github-hosted" && record.status === "pending");
-  return {
-    plan,
-    records,
-    reused,
-    failures,
-    ok: failures.length === 0 && records.every((record) => record.status === "passed" || record.status === "skipped")
-  };
-}
-export {
-  runTreeseedProof
-};

package/dist/operations/services/release-proof.d.ts

@@ -1,81 +0,0 @@
-export type TreeseedProofSubjectKind = 'package' | 'root' | 'hosted-app' | 'provider-resource' | 'workflow' | 'scene';
-export type TreeseedProofStatus = 'passed' | 'failed' | 'pending' | 'blocked' | 'skipped';
-export type TreeseedProofDriver = 'local' | 'act' | 'github-hosted' | 'railway-live' | 'cloudflare-live' | 'reconcile-live';
-export type TreeseedProofSubject = {
-    kind: TreeseedProofSubjectKind;
-    id: string;
-    name: string;
-    repoPath: string;
-    repository: string | null;
-    branch: string | null;
-    headSha: string | null;
-};
-export type TreeseedProofInputs = {
-    inputHash: string;
-    topologyHash: string;
-    packageJsonHash?: string | null;
-    lockfileHash?: string | null;
-    manifestHash?: string | null;
-    workflowHash?: string | null;
-    dockerfileHash?: string | null;
-    sourceHashes?: Record<string, string | null>;
-    dependencyProofIds: string[];
-};
-export type TreeseedProofRecord = {
-    schemaVersion: 1;
-    proofId: string;
-    subject: TreeseedProofSubject;
-    inputs: TreeseedProofInputs;
-    driver: TreeseedProofDriver;
-    status: TreeseedProofStatus;
-    startedAt: string;
-    finishedAt: string | null;
-    durationMs: number | null;
-    result: {
-        workflow?: {
-            repository: string;
-            workflow: string;
-            runId: number | null;
-            url: string | null;
-            conclusion: string | null;
-            failedJobs: Array<{
-                id: number;
-                name: string;
-                url: string | null;
-                failedSteps: string[];
-                logExcerpt?: string | null;
-            }>;
-        };
-        command?: {
-            command: string;
-            cwd: string;
-            exitCode: number | null;
-        };
-        liveVerification?: Record<string, unknown>;
-    };
-    reusable: boolean;
-    invalidationReasons: string[];
-};
-export type TreeseedProofInput = {
-    subject: TreeseedProofSubject;
-    inputs: Omit<TreeseedProofInputs, 'inputHash'> & {
-        inputHash?: string;
-    };
-    driver: TreeseedProofDriver;
-};
-export declare function sha256(value: string): string;
-export declare function computeProofInputHash(input: TreeseedProofInput | Record<string, unknown>): string;
-export declare function proofIdFor(input: TreeseedProofInput): string;
-export declare function createProofRecord(input: {
-    subject: TreeseedProofSubject;
-    inputs: Omit<TreeseedProofInputs, 'inputHash'> & {
-        inputHash?: string;
-    };
-    driver: TreeseedProofDriver;
-    status: TreeseedProofStatus;
-    startedAt: string;
-    finishedAt?: string | null;
-    result?: TreeseedProofRecord['result'];
-    reusable?: boolean;
-    invalidationReasons?: string[];
-}): TreeseedProofRecord;

package/dist/operations/services/release-proof.js

@@ -1,79 +0,0 @@
-import { createHash } from "node:crypto";
-function stableJson(value) {
-  if (Array.isArray(value)) {
-    return `[${value.map((entry) => stableJson(entry)).join(",")}]`;
-  }
-  if (value && typeof value === "object") {
-    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
-  }
-  return JSON.stringify(value);
-}
-function sha256(value) {
-  return createHash("sha256").update(value).digest("hex");
-}
-function computeProofInputHash(input) {
-  return sha256(stableJson(input));
-}
-function proofIdFor(input) {
-  return sha256(stableJson({
-    subject: input.subject,
-    inputs: {
-      ...input.inputs,
-      dependencyProofIds: [...input.inputs.dependencyProofIds].sort()
-    },
-    driver: input.driver
-  }));
-}
-function createProofRecord(input) {
-  const normalizedInput = {
-    subject: input.subject,
-    driver: input.driver,
-    inputs: {
-      ...input.inputs,
-      dependencyProofIds: [...input.inputs.dependencyProofIds].sort(),
-      inputHash: input.inputs.inputHash ?? ""
-    }
-  };
-  const inputHash = input.inputs.inputHash || computeProofInputHash({
-    subject: input.subject,
-    driver: input.driver,
-    inputs: {
-      ...input.inputs,
-      dependencyProofIds: [...input.inputs.dependencyProofIds].sort(),
-      inputHash: void 0
-    }
-  });
-  const finishedAt = input.finishedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-  const startedMs = Date.parse(input.startedAt);
-  const finishedMs = finishedAt ? Date.parse(finishedAt) : NaN;
-  return {
-    schemaVersion: 1,
-    proofId: proofIdFor({
-      ...normalizedInput,
-      inputs: {
-        ...normalizedInput.inputs,
-        inputHash
-      }
-    }),
-    subject: input.subject,
-    inputs: {
-      ...input.inputs,
-      inputHash,
-      dependencyProofIds: [...input.inputs.dependencyProofIds].sort()
-    },
-    driver: input.driver,
-    status: input.status,
-    startedAt: input.startedAt,
-    finishedAt,
-    durationMs: Number.isFinite(startedMs) && Number.isFinite(finishedMs) ? Math.max(0, finishedMs - startedMs) : null,
-    result: input.result ?? {},
-    reusable: input.reusable ?? input.status === "passed",
-    invalidationReasons: input.invalidationReasons ?? []
-  };
-}
-export {
-  computeProofInputHash,
-  createProofRecord,
-  proofIdFor,
-  sha256
-};