@treeseed/agent 0.1.2

package/dist/agents/testing/e2e-harness.js

@@ -0,0 +1,435 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { access, cp, mkdtemp, mkdir, readFile, readdir, rm, symlink, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { createRequire } from "node:module";
+import ts from "typescript";
+import { MemoryAgentDatabase } from "../d1-store.js";
+import { resolveModelDefinition } from "../model-registry.js";
+import { runFromRecord } from "../stores/run-store.js";
+import { serializeFrontmatterDocument } from "../frontmatter.js";
+const execFileAsync = promisify(execFile);
+const require2 = createRequire(import.meta.url);
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function resolveDocsRoot() {
+  if (process.env.TREESEED_AGENT_FIXTURE_ROOT) {
+    return path.resolve(process.env.TREESEED_AGENT_FIXTURE_ROOT);
+  }
+  const cwd = process.cwd();
+  const corePackageRoot = path.resolve(path.dirname(require2.resolve("@treeseed/core")), "..");
+  const candidates = [];
+  let current = cwd;
+  while (true) {
+    candidates.push(
+      path.resolve(current, ".fixtures", "treeseed-fixtures", "sites", "working-site"),
+      path.resolve(current, "fixture"),
+      path.resolve(current, "fixtures", "sites", "working-site")
+    );
+    const parent = path.resolve(current, "..");
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  candidates.push(
+    path.resolve(corePackageRoot, ".fixtures", "treeseed-fixtures", "sites", "working-site"),
+    path.resolve(corePackageRoot, "fixture")
+  );
+  for (const candidate of candidates) {
+    if (existsSync(path.join(candidate, "src", "manifest.yaml"))) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    `Unable to resolve an agent smoke fixture root. Checked: ${candidates.join(", ")}`
+  );
+}
+async function resolveWranglerBin() {
+  if (process.env.TREESEED_AGENT_WRANGLER_BIN) {
+    return path.resolve(process.env.TREESEED_AGENT_WRANGLER_BIN);
+  }
+  try {
+    const wranglerPackageRoot = path.resolve(path.dirname(require2.resolve("wrangler/package.json")));
+    const packageJson = JSON.parse(await readFile(path.join(wranglerPackageRoot, "package.json"), "utf8"));
+    const relativeBin = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.wrangler;
+    if (!relativeBin) {
+      throw new Error("Unable to resolve wrangler binary path from package.json.");
+    }
+    return path.resolve(wranglerPackageRoot, relativeBin);
+  } catch {
+    const packageLocal = path.resolve(resolveDocsRoot(), "node_modules", ".bin", "wrangler");
+    await access(packageLocal);
+    return packageLocal;
+  }
+}
+async function runCommand(command, args, cwd) {
+  await execFileAsync(command, args, {
+    cwd,
+    env: process.env,
+    maxBuffer: 10 * 1024 * 1024
+  });
+}
+async function walkFiles(root) {
+  const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
+  const nested = await Promise.all(
+    entries.map(async (entry) => {
+      const fullPath = path.join(root, entry.name);
+      if (entry.isDirectory()) {
+        return walkFiles(fullPath);
+      }
+      return [fullPath];
+    })
+  );
+  return nested.flat();
+}
+async function patchFixtureAgentSpecs(repoRoot) {
+  const updates = /* @__PURE__ */ new Map([
+    ["architecture-agent.mdx", "    operations: [pick, update, create]"],
+    ["engineer-agent.mdx", "    operations: [pick, update, create]"],
+    ["releaser-agent.mdx", "    operations: [pick, update, get, create]"],
+    ["researcher-agent.mdx", "    operations: [pick, update, create]"],
+    ["reviewer-agent.mdx", "    operations: [pick, update, get, create]"]
+  ]);
+  for (const [filename, permissionLine] of updates) {
+    const filePath = path.join(repoRoot, "src", "content", "agents", filename);
+    const source = await readFile(filePath, "utf8").catch(() => null);
+    if (!source) {
+      continue;
+    }
+    const next = source.replace(
+      /(\n  - model: message\n)    operations: \[[^\]]+\]/,
+      `$1${permissionLine}`
+    );
+    if (next !== source) {
+      await writeFile(filePath, next, "utf8");
+    }
+  }
+}
+async function transpileFixtureAgentHandlers(repoRoot) {
+  const agentsRoot = path.join(repoRoot, "src", "agents");
+  const agentFiles = (await readdir(agentsRoot, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isFile() && entry.name.endsWith(".ts")).map((entry) => entry.name);
+  for (const filename of agentFiles) {
+    const sourcePath = path.join(agentsRoot, filename);
+    const outputPath = path.join(agentsRoot, filename.replace(/\.ts$/u, ".js"));
+    const source = await readFile(sourcePath, "utf8");
+    const transformed = ts.transpileModule(source, {
+      compilerOptions: {
+        module: ts.ModuleKind.ESNext,
+        target: ts.ScriptTarget.ES2022
+      }
+    }).outputText.replace(/(['"`])(\.[^'"`\n]+)\.ts\1/g, "$1$2.js$1");
+    await writeFile(outputPath, transformed, "utf8");
+  }
+}
+async function migrateDatabase(repoRoot, persistTo) {
+  const wrangler = await resolveWranglerBin();
+  for (const migration of [
+    "0001_subscribers.sql",
+    "0002_agent_runtime.sql",
+    "0003_agent_run_trace.sql"
+  ]) {
+    await runCommand(
+      wrangler,
+      [
+        "d1",
+        "execute",
+        "karyon-docs-site-data",
+        "--local",
+        "--persist-to",
+        persistTo,
+        "--file",
+        path.join(repoRoot, "migrations", migration)
+      ],
+      repoRoot
+    );
+  }
+}
+async function initializeSandboxRepo(repoRoot) {
+  await runCommand("git", ["init", "-b", "main"], repoRoot);
+  await runCommand("git", ["config", "user.email", "agents-e2e@example.test"], repoRoot);
+  await runCommand("git", ["config", "user.name", "Agents E2E"], repoRoot);
+  await runCommand("git", ["add", "."], repoRoot);
+  await runCommand("git", ["commit", "-m", "test: baseline sandbox"], repoRoot);
+}
+function createObjectiveDocument(slug, date) {
+  return serializeFrontmatterDocument(
+    {
+      title: `Objective ${slug}`,
+      description: `Objective ${slug} description`,
+      date,
+      status: "planned",
+      tags: ["agent", "e2e"],
+      summary: `Summary for ${slug}`,
+      draft: false,
+      timeHorizon: "near-term",
+      motivation: `Motivation for ${slug}`,
+      primaryContributor: "planner-agent",
+      relatedQuestions: [],
+      relatedBooks: []
+    },
+    `# Objective ${slug}
+`
+  );
+}
+function createQuestionDocument(slug, date, relatedObjectives = []) {
+  return serializeFrontmatterDocument(
+    {
+      title: `Question ${slug}`,
+      description: `Question ${slug} description`,
+      date,
+      status: "planned",
+      tags: ["agent", "e2e"],
+      summary: `Summary for ${slug}`,
+      draft: false,
+      questionType: "implementation",
+      motivation: `Motivation for ${slug}`,
+      primaryContributor: "planner-agent",
+      relatedObjectives,
+      relatedBooks: []
+    },
+    `# Question ${slug}
+`
+  );
+}
+function createKnowledgeDocument(slug, title) {
+  return serializeFrontmatterDocument(
+    {
+      title,
+      slug,
+      updated: nowIso(),
+      tags: ["agent", "e2e"]
+    },
+    `# ${title}
+`
+  );
+}
+async function createAgentTestRuntime(options) {
+  const rootDir = await mkdtemp(path.join(os.tmpdir(), "karyon-agents-e2e-"));
+  const repoRoot = path.join(rootDir, "docs");
+  const persistTo = path.join(rootDir, ".wrangler-state");
+  const docsRoot = resolveDocsRoot();
+  const previousContentRoot = process.env.TREESEED_AGENT_CONTENT_ROOT;
+  const previousExecutionMode = process.env.TREESEED_AGENT_EXECUTION_PROVIDER;
+  const previousTenantRoot = process.env.TREESEED_TENANT_ROOT;
+  const previousCwd = process.cwd();
+  const sharedNodeModules = path.join(previousCwd, "node_modules");
+  await cp(docsRoot, repoRoot, {
+    recursive: true,
+    filter(source) {
+      const relativePath = path.relative(docsRoot, source);
+      if (!relativePath) {
+        return true;
+      }
+      return ![
+        ".wrangler",
+        ".agent-worktrees",
+        "node_modules",
+        "dist",
+        ".astro",
+        "coverage"
+      ].some((prefix) => relativePath === prefix || relativePath.startsWith(`${prefix}${path.sep}`));
+    }
+  });
+  if (existsSync(sharedNodeModules)) {
+    await symlink(sharedNodeModules, path.join(repoRoot, "node_modules"), "dir");
+  }
+  await transpileFixtureAgentHandlers(repoRoot);
+  await patchFixtureAgentSpecs(repoRoot);
+  process.env.TREESEED_AGENT_CONTENT_ROOT = path.join(repoRoot, "src", "content");
+  process.env.TREESEED_AGENT_EXECUTION_PROVIDER = options?.executionMode ?? "stub";
+  process.env.TREESEED_TENANT_ROOT = repoRoot;
+  process.chdir(repoRoot);
+  await mkdir(persistTo, { recursive: true });
+  await initializeSandboxRepo(repoRoot);
+  const [{ AgentKernel }, { AgentSdk }] = await Promise.all([
+    import("../kernel/agent-kernel.js"),
+    import("../sdk.js")
+  ]);
+  const sdk = options?.databaseMode === "local-d1" ? (await migrateDatabase(repoRoot, persistTo), AgentSdk.createLocal({
+    repoRoot,
+    databaseName: "karyon-docs-site-data",
+    persistTo
+  })) : new AgentSdk({
+    repoRoot,
+    database: new MemoryAgentDatabase()
+  });
+  const kernel = new AgentKernel(sdk, repoRoot, {
+    execution: options?.execution,
+    mutations: options?.mutations
+  });
+  async function writeSeedFile(relativePath, source, message) {
+    const filePath = path.join(repoRoot, relativePath);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, source, "utf8");
+    await runCommand("git", ["add", relativePath], repoRoot);
+    await runCommand("git", ["commit", "-m", message], repoRoot);
+  }
+  return {
+    rootDir,
+    repoRoot,
+    persistTo,
+    sdk,
+    kernel,
+    async seedObjectives(entries) {
+      for (const entry of entries) {
+        await writeSeedFile(
+          path.join("src", "content", "objectives", `${entry.slug}.mdx`),
+          createObjectiveDocument(entry.slug, entry.date ?? "2099-01-01T00:00:00.000Z"),
+          `test(seed): objective ${entry.slug}`
+        );
+      }
+    },
+    async seedQuestions(entries) {
+      for (const entry of entries) {
+        await writeSeedFile(
+          path.join("src", "content", "questions", `${entry.slug}.mdx`),
+          createQuestionDocument(
+            entry.slug,
+            entry.date ?? "2099-01-01T00:00:00.000Z",
+            entry.relatedObjectives ?? []
+          ),
+          `test(seed): question ${entry.slug}`
+        );
+      }
+    },
+    async seedKnowledge(entries) {
+      for (const entry of entries) {
+        await writeSeedFile(
+          path.join("src", "content", "knowledge", `${entry.slug}.md`),
+          createKnowledgeDocument(entry.slug, entry.title ?? `Knowledge ${entry.slug}`),
+          `test(seed): knowledge ${entry.slug}`
+        );
+      }
+    },
+    async seedMessages(entries) {
+      const messages = [];
+      for (const entry of entries) {
+        const created = await sdk.createMessage({
+          ...entry,
+          actor: "agents-e2e"
+        });
+        messages.push(created.payload);
+      }
+      return messages;
+    },
+    async clearModelContent(model) {
+      const definition = resolveModelDefinition(model);
+      if (!definition.contentDir) {
+        throw new Error(`Model ${model} is not content-backed.`);
+      }
+      const relativeContentDir = path.relative(repoRoot, definition.contentDir);
+      await rm(definition.contentDir, { recursive: true, force: true });
+      await mkdir(definition.contentDir, { recursive: true });
+      await runCommand("git", ["add", "-A", relativeContentDir], repoRoot);
+      await runCommand("git", ["commit", "-m", `test(seed): clear ${model}`], repoRoot);
+    },
+    runAgent(slug) {
+      return kernel.runAgent(slug);
+    },
+    runCycle() {
+      return kernel.runCycle();
+    },
+    async readMessages() {
+      const response = await sdk.search({
+        model: "message",
+        sort: [{ field: "created_at", direction: "asc" }],
+        limit: 100
+      });
+      return response.payload;
+    },
+    async readRunLogs() {
+      const database = sdk.database;
+      if (database.inspectRuns) {
+        return database.inspectRuns().map((row) => runFromRecord(row));
+      }
+      const rows = database.db ? await database.db.prepare(`
+					SELECT
+						record_key AS run_id,
+						lookup_key AS agent_slug,
+						status,
+						json_extract(payload_json, '$.triggerSource') AS trigger_source,
+						json_extract(payload_json, '$.handlerKind') AS handler_kind,
+						json_extract(payload_json, '$.triggerKind') AS trigger_kind,
+						json_extract(payload_json, '$.selectedItemKey') AS selected_item_key,
+						json_extract(payload_json, '$.selectedMessageId') AS selected_message_id,
+						json_extract(payload_json, '$.claimedMessageId') AS claimed_message_id,
+						json_extract(payload_json, '$.branchName') AS branch_name,
+						secondary_key AS commit_sha,
+						json_extract(payload_json, '$.prUrl') AS pr_url,
+						json_extract(payload_json, '$.summary') AS summary,
+						json_extract(payload_json, '$.error') AS error,
+						json_extract(payload_json, '$.errorCategory') AS error_category,
+						json_extract(payload_json, '$.changedPaths') AS changed_paths,
+						created_at AS started_at,
+						json_extract(payload_json, '$.finishedAt') AS finished_at
+					FROM runtime_records
+					WHERE record_type = 'agent_run'
+					ORDER BY created_at ASC
+				`).all() : { results: [] };
+      return rows.results.map((row) => runFromRecord(row));
+    },
+    async readContentLeases() {
+      const database = sdk.database;
+      if (database.inspectLeases) {
+        return database.inspectLeases();
+      }
+      if (!database.db) {
+        return [];
+      }
+      const rows = await database.db.prepare("SELECT * FROM lease_state ORDER BY item_key ASC").all();
+      return rows.results;
+    },
+    async readSandboxArtifacts() {
+      const worktreeRoot = path.join(repoRoot, ".agent-worktrees");
+      const files = (await walkFiles(worktreeRoot)).filter((entry) => entry.includes(`${path.sep}.agent-artifacts${path.sep}`));
+      return Promise.all(
+        files.map(async (filePath) => ({
+          path: filePath,
+          content: await readFile(filePath, "utf8")
+        }))
+      );
+    },
+    async claimMessage(messageTypes, workerId = "agents-e2e-claimer") {
+      const claimed = await sdk.claimMessage({
+        workerId,
+        messageTypes,
+        leaseSeconds: 300
+      });
+      return claimed.payload;
+    },
+    async claimObjectiveLease(itemKey, workerId = "agents-e2e-lease-holder") {
+      return sdk.database.tryClaimContentLease({
+        model: "objective",
+        itemKey,
+        claimedBy: workerId,
+        leaseSeconds: 300
+      });
+    },
+    async cleanup() {
+      if (previousContentRoot === void 0) {
+        delete process.env.TREESEED_AGENT_CONTENT_ROOT;
+      } else {
+        process.env.TREESEED_AGENT_CONTENT_ROOT = previousContentRoot;
+      }
+      if (previousExecutionMode === void 0) {
+        delete process.env.TREESEED_AGENT_EXECUTION_PROVIDER;
+      } else {
+        process.env.TREESEED_AGENT_EXECUTION_PROVIDER = previousExecutionMode;
+      }
+      if (previousTenantRoot === void 0) {
+        delete process.env.TREESEED_TENANT_ROOT;
+      } else {
+        process.env.TREESEED_TENANT_ROOT = previousTenantRoot;
+      }
+      process.chdir(previousCwd);
+      await rm(rootDir, { recursive: true, force: true });
+    }
+  };
+}
+export {
+  createAgentTestRuntime
+};

package/dist/agents/wrangler-d1.js

@@ -0,0 +1 @@
+export * from "@treeseed/sdk/wrangler-d1";

package/dist/index.js

@@ -0,0 +1,9 @@
+import { AgentKernel } from "./agents/kernel/agent-kernel.js";
+import { runTreeseedAgentCli } from "./agents/cli.js";
+import { resolveAgentHandler, listRegisteredAgentHandlers } from "./agents/registry.js";
+export {
+  AgentKernel,
+  listRegisteredAgentHandlers,
+  resolveAgentHandler,
+  runTreeseedAgentCli
+};

package/dist/scripts/assert-release-tag-version.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/assert-release-tag-version.js

@@ -0,0 +1,20 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const packageRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const packageJson = JSON.parse(readFileSync(resolve(packageRoot, 'package.json'), 'utf8'));
+const packageVersion = packageJson.version;
+const tagName = process.argv[2] || process.env.GITHUB_REF_NAME;
+if (!tagName) {
+    console.error('Release tag validation requires a tag name argument or GITHUB_REF_NAME.');
+    process.exit(1);
+}
+if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(tagName)) {
+    console.error(`Release tag "${tagName}" must be a plain semver tag like "${packageVersion}".`);
+    process.exit(1);
+}
+if (tagName !== packageVersion) {
+    console.error(`Release tag "${tagName}" does not match @treeseed/agent version "${packageVersion}".`);
+    process.exit(1);
+}
+console.log(`Release tag "${tagName}" matches @treeseed/agent version "${packageVersion}".`);

package/dist/scripts/build-dist.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/build-dist.js

@@ -0,0 +1,98 @@
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, chmodSync } from 'node:fs';
+import { dirname, extname, join, relative, resolve } from 'node:path';
+import { build } from 'esbuild';
+import ts from 'typescript';
+import { packageRoot } from './package-tools.js';
+const srcRoot = resolve(packageRoot, 'src');
+const scriptsRoot = resolve(packageRoot, 'scripts');
+const distRoot = resolve(packageRoot, 'dist');
+const COPY_EXTENSIONS = new Set(['.d.js', '.json', '.md']);
+function walkFiles(root) {
+    const files = [];
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        const fullPath = join(root, entry.name);
+        if (entry.isDirectory())
+            files.push(...walkFiles(fullPath));
+        else
+            files.push(fullPath);
+    }
+    return files;
+}
+function ensureDir(filePath) {
+    mkdirSync(dirname(filePath), { recursive: true });
+}
+function rewriteRuntimeSpecifiers(contents) {
+    return contents
+        .replace(/(['"`])(\.[^'"`\n]+)\.(mjs|ts)\1/g, '$1$2.js$1')
+        .replace(/(['"`])\.\.\/src\//g, '$1../');
+}
+async function compileModule(filePath, sourceRoot, outputRoot) {
+    const relativePath = relative(sourceRoot, filePath);
+    const outputFile = resolve(outputRoot, relativePath.replace(/\.(mjs|ts)$/u, '.js'));
+    ensureDir(outputFile);
+    await build({
+        entryPoints: [filePath],
+        outfile: outputFile,
+        platform: 'node',
+        format: 'esm',
+        bundle: false,
+        logLevel: 'silent',
+    });
+    const builtSource = readFileSync(outputFile, 'utf8');
+    writeFileSync(outputFile, rewriteRuntimeSpecifiers(builtSource), 'utf8');
+}
+function copyAsset(filePath, sourceRoot, outputRoot) {
+    const outputFile = resolve(outputRoot, relative(sourceRoot, filePath));
+    ensureDir(outputFile);
+    copyFileSync(filePath, outputFile);
+    if (outputFile.endsWith('.d.js')) {
+        writeFileSync(outputFile, rewriteRuntimeSpecifiers(readFileSync(outputFile, 'utf8')), 'utf8');
+    }
+}
+function transpileScript(filePath) {
+    const source = readFileSync(filePath, 'utf8');
+    const relativePath = relative(scriptsRoot, filePath);
+    const outputFile = resolve(distRoot, 'scripts', relativePath.replace(/\.(mjs|ts)$/u, '.js'));
+    const transformed = extname(filePath) === '.ts'
+        ? ts.transpileModule(source, {
+            compilerOptions: { module: ts.ModuleKind.ESNext, target: ts.ScriptTarget.ES2022 },
+        }).outputText
+        : source;
+    ensureDir(outputFile);
+    writeFileSync(outputFile, rewriteRuntimeSpecifiers(transformed), 'utf8');
+    chmodSync(outputFile, 0o755);
+}
+function emitDeclarations() {
+    const configPath = ts.findConfigFile(packageRoot, ts.sys.fileExists, 'tsconfig.json');
+    if (!configPath)
+        throw new Error('Unable to locate tsconfig.json for declaration build.');
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, packageRoot);
+    const program = ts.createProgram({
+        rootNames: parsed.fileNames,
+        options: { ...parsed.options, declaration: true, emitDeclarationOnly: true, declarationDir: distRoot, noEmit: false },
+    });
+    const result = program.emit();
+    if (result.emitSkipped)
+        throw new Error('Declaration build failed.');
+}
+rmSync(distRoot, { recursive: true, force: true });
+for (const filePath of walkFiles(srcRoot)) {
+    const extension = extname(filePath);
+    if (extension === '.ts')
+        await compileModule(filePath, srcRoot, distRoot);
+    else if (COPY_EXTENSIONS.has(extension))
+        copyAsset(filePath, srcRoot, distRoot);
+}
+for (const filePath of walkFiles(scriptsRoot)) {
+    const extension = extname(filePath);
+    if (extension === '.ts' || extension === '.ts')
+        transpileScript(filePath);
+}
+emitDeclarations();
+if (existsSync(resolve(packageRoot, 'README.md'))) {
+    copyFileSync(resolve(packageRoot, 'README.md'), resolve(distRoot, '..', 'README.md'));
+}
+if (existsSync(resolve(packageRoot, 'Dockerfile'))) {
+    copyFileSync(resolve(packageRoot, 'Dockerfile'), resolve(distRoot, '..', 'Dockerfile'));
+}

package/dist/scripts/package-tools.d.ts

@@ -0,0 +1 @@
+export declare const packageRoot: string;

package/dist/scripts/package-tools.js

@@ -0,0 +1,7 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const scriptRoot = dirname(fileURLToPath(import.meta.url));
+const packageCandidate = resolve(scriptRoot, '..');
+export const packageRoot = packageCandidate.endsWith('/dist')
+    ? resolve(packageCandidate, '..')
+    : packageCandidate;

package/dist/scripts/publish-package.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/publish-package.js

@@ -0,0 +1,19 @@
+import { spawnSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const packageRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const extraArgs = process.argv.slice(2);
+const npmArgs = ['publish', '.', '--access', 'public'];
+if (process.env.GITHUB_ACTIONS === 'true')
+    npmArgs.push('--provenance');
+npmArgs.push(...extraArgs);
+const result = spawnSync('npm', npmArgs, {
+    cwd: packageRoot,
+    stdio: 'inherit',
+    env: process.env,
+});
+if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+}
+process.exit(result.status ?? 1);

package/dist/scripts/release-verify.d.ts

@@ -0,0 +1 @@
+export {};