@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/scripts/test-cloudflare-local.js

@@ -1,209 +0,0 @@
-import assert from 'node:assert/strict';
-import { mkdirSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { setTimeout as delay } from 'node:timers/promises';
-import { prepareCloudflareLocalRuntime, spawnProcess, startWranglerDev } from '../operations/services/local-dev.js';
-import { fixtureRoot, fixtureWranglerConfig } from '../operations/services/runtime-paths.js';
-const TEST_PORT = 8791;
-const BASE_URL = `http://127.0.0.1:${TEST_PORT}`;
-const RUN_ID = `${Date.now()}-${process.pid}`;
-const ipSeed = Date.now() + process.pid;
-const TEST_IP = `198.51.${(ipSeed >>> 8) % 250}.${ipSeed % 250}`;
-const TEST_EMAIL = `integration-subscriber-${RUN_ID}@localhost.test`;
-const PERSIST_TO = resolve(process.cwd(), '.local', 'cloudflare-integration', RUN_ID);
-const workerLogs = [];
-mkdirSync(PERSIST_TO, { recursive: true });
-function captureLogs(stream, label) {
-    if (!stream) {
-        return;
-    }
-    stream.setEncoding('utf8');
-    stream.on('data', (chunk) => {
-        workerLogs.push(`[${label}] ${chunk}`);
-        if (workerLogs.length > 40) {
-            workerLogs.shift();
-        }
-    });
-}
-function readBody(message) {
-    return new Promise((resolve) => {
-        let body = '';
-        message.setEncoding('utf8');
-        message.on('data', (chunk) => {
-            body += chunk;
-        });
-        message.on('end', () => resolve(body));
-    });
-}
-function extractSetCookie(response) {
-    if (typeof response.headers.getSetCookie === 'function') {
-        return response.headers.getSetCookie();
-    }
-    const cookie = response.headers.get('set-cookie');
-    return cookie ? [cookie] : [];
-}
-async function waitForWorker(worker) {
-    for (let attempt = 0; attempt < 60; attempt += 1) {
-        if (worker.exitCode !== null) {
-            throw new Error(`Wrangler exited before the worker became ready (exit ${worker.exitCode}).\n${workerLogs.join('')}`);
-        }
-        try {
-            const response = await fetch(`${BASE_URL}/api/form/submit?formType=subscribe`, {
-                signal: AbortSignal.timeout(5000),
-                headers: {
-                    'x-forwarded-for': TEST_IP,
-                },
-            });
-            if (response.ok) {
-                return;
-            }
-        }
-        catch {
-            // Keep polling until the local worker is ready.
-        }
-        await delay(1000);
-    }
-    throw new Error(`Timed out waiting for local Wrangler dev to start.\n${workerLogs.join('')}`);
-}
-async function issueToken() {
-    const response = await fetch(`${BASE_URL}/api/form/submit?formType=subscribe`, {
-        signal: AbortSignal.timeout(10000),
-        headers: {
-            'x-forwarded-for': TEST_IP,
-        },
-    });
-    assert.equal(response.status, 200, 'token endpoint should return HTTP 200');
-    const payload = await response.json();
-    const cookies = extractSetCookie(response);
-    assert.equal(payload.ok, true, 'token payload should be ok');
-    assert.ok(payload.formToken, 'token endpoint should return a form token');
-    assert.ok(payload.sessionId, 'token endpoint should return a session id');
-    assert.ok(cookies.length > 0, 'token endpoint should set a session cookie');
-    return {
-        formToken: payload.formToken,
-        sessionId: payload.sessionId,
-        cookieHeader: cookies.map((cookie) => cookie.split(';', 1)[0]).join('; '),
-    };
-}
-async function submitSubscribeForm({ formToken, sessionId, cookieHeader }, email = TEST_EMAIL) {
-    const form = new FormData();
-    form.set('formType', 'subscribe');
-    form.set('name', 'Integration Test');
-    form.set('email', email);
-    form.set('formToken', formToken);
-    form.set('formSession', sessionId);
-    form.set('redirectTo', '/');
-    return fetch(`${BASE_URL}/api/form/submit`, {
-        method: 'POST',
-        redirect: 'manual',
-        signal: AbortSignal.timeout(10000),
-        headers: {
-            cookie: cookieHeader,
-            origin: BASE_URL,
-            referer: `${BASE_URL}/`,
-            'x-forwarded-for': TEST_IP,
-        },
-        body: form,
-    });
-}
-async function querySubscribers() {
-    const query = `SELECT email, created_at FROM subscribers WHERE email = '${TEST_EMAIL}'`;
-    const child = spawnProcess('wrangler', [
-        'd1',
-        'execute',
-        'docs-site-data',
-        '--local',
-        '--config',
-        fixtureWranglerConfig,
-        '--persist-to',
-        PERSIST_TO,
-        '--json',
-        '--command',
-        query,
-    ], { stdio: ['ignore', 'pipe', 'inherit'], cwd: fixtureRoot });
-    const stdout = await readBody(child.stdout);
-    const exitCode = await new Promise((resolve) => {
-        child.on('exit', resolve);
-    });
-    assert.equal(exitCode, 0, 'local D1 query should succeed');
-    const parsed = JSON.parse(stdout);
-    const results = Array.isArray(parsed) ? parsed : [parsed];
-    const rows = results.flatMap((entry) => entry.results ?? []);
-    return rows;
-}
-async function main() {
-    prepareCloudflareLocalRuntime({
-        persistTo: PERSIST_TO,
-        envOverrides: {
-            TREESEED_LOCAL_DEV_MODE: 'cloudflare',
-            TREESEED_FORMS_LOCAL_BYPASS_CLOUDFLARE_GUARDS: 'false',
-            TREESEED_SMTP_HOST: '127.0.0.1',
-            TREESEED_SMTP_PORT: '1025',
-        },
-    });
-    const worker = startWranglerDev(['--port', String(TEST_PORT), '--persist-to', PERSIST_TO], {
-        stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    captureLogs(worker.stdout, 'stdout');
-    captureLogs(worker.stderr, 'stderr');
-    const teardown = async () => {
-        if (worker.exitCode === null && !worker.killed) {
-            worker.kill('SIGTERM');
-            await Promise.race([
-                new Promise((resolve) => worker.once('exit', resolve)),
-                delay(5000),
-            ]);
-            if (worker.exitCode === null && !worker.killed) {
-                worker.kill('SIGKILL');
-                await Promise.race([
-                    new Promise((resolve) => worker.once('exit', resolve)),
-                    delay(5000),
-                ]);
-            }
-        }
-    };
-    process.on('SIGINT', async () => {
-        await teardown();
-        process.exit(130);
-    });
-    process.on('SIGTERM', async () => {
-        await teardown();
-        process.exit(143);
-    });
-    let shouldQuerySubscribers = false;
-    try {
-        await waitForWorker(worker);
-        const firstToken = await issueToken();
-        const firstResponse = await submitSubscribeForm(firstToken);
-        assert.equal(firstResponse.status, 303, 'subscribe submit should redirect');
-        assert.match(firstResponse.headers.get('location') ?? '', /\/\?formStatus=success&formCode=success#site-subscribe$/, 'subscribe success redirect should include success markers');
-        shouldQuerySubscribers = true;
-        const replayResponse = await submitSubscribeForm(firstToken);
-        assert.equal(replayResponse.status, 303, 'replayed submit should still redirect');
-        assert.match(replayResponse.headers.get('location') ?? '', /\/\?formStatus=error&formCode=token_replayed#site-subscribe$/, 'replayed token should be rejected by KV-backed nonce storage');
-        for (let attempt = 0; attempt < 2; attempt += 1) {
-            const token = await issueToken();
-            const response = await submitSubscribeForm(token);
-            assert.equal(response.status, 303, 'pre-limit submissions should redirect');
-            assert.match(response.headers.get('location') ?? '', /\/\?formStatus=success&formCode=success#site-subscribe$/, 'pre-limit submissions should succeed');
-        }
-        const limitedToken = await issueToken();
-        const limitedResponse = await submitSubscribeForm(limitedToken);
-        assert.equal(limitedResponse.status, 303, 'rate-limited submit should redirect');
-        assert.match(limitedResponse.headers.get('location') ?? '', /\/\?formStatus=error&formCode=rate_limited#site-subscribe$/, 'local KV-backed rate limiting should reject the fourth submission');
-    }
-    finally {
-        await teardown();
-    }
-    if (shouldQuerySubscribers) {
-        const rows = await querySubscribers();
-        assert.equal(rows.length, 1, 'subscriber should be written to local D1');
-        assert.equal(rows[0].email, TEST_EMAIL, 'subscriber email should match the submitted address');
-        assert.equal(rows[0].status, 'active', 'subscriber should be active');
-        assert.equal(rows[0].source, 'footer', 'subscriber source should be tracked');
-    }
-}
-main().catch((error) => {
-    console.error(error);
-    process.exit(1);
-});

package/dist/scripts/test-scaffold.js

@@ -1,300 +0,0 @@
-#!/usr/bin/env node
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { corePackageRoot, packageRoot, packageScriptPath, sdkPackageRoot } from '../operations/services/runtime-tools.js';
-import { listTemplateProducts, validateTemplateProduct } from '../operations/services/template-registry.js';
-import { TREESEED_DEFAULT_STARTER_TEMPLATE_ID } from '../sdk-types.js';
-const npmCacheDir = process.env.TREESEED_SCAFFOLD_NPM_CACHE_DIR
-    ? resolve(process.env.TREESEED_SCAFFOLD_NPM_CACHE_DIR)
-    : resolve(tmpdir(), 'treeseed-npm-cache');
-const packageJson = JSON.parse(readFileSync(resolve(corePackageRoot, 'package.json'), 'utf8'));
-const sdkPackageJson = JSON.parse(readFileSync(resolve(sdkPackageRoot, 'package.json'), 'utf8'));
-const cliPackageJson = JSON.parse(readFileSync(resolve(packageRoot, 'package.json'), 'utf8'));
-const workspaceTarballs = (() => {
-    try {
-        return JSON.parse(process.env.TREESEED_WORKSPACE_TARBALLS ?? '{}');
-    }
-    catch {
-        return {};
-    }
-})();
-const externalCoreTarball = process.env.TREESEED_SCAFFOLD_CORE_TARBALL
-    ? resolve(process.env.TREESEED_SCAFFOLD_CORE_TARBALL)
-    : typeof workspaceTarballs['@treeseed/core'] === 'string'
-        ? resolve(workspaceTarballs['@treeseed/core'])
-        : null;
-const externalSdkTarball = process.env.TREESEED_SCAFFOLD_SDK_TARBALL
-    ? resolve(process.env.TREESEED_SCAFFOLD_SDK_TARBALL)
-    : typeof workspaceTarballs['@treeseed/sdk'] === 'string'
-        ? resolve(workspaceTarballs['@treeseed/sdk'])
-        : null;
-const externalCliTarball = process.env.TREESEED_SCAFFOLD_CLI_TARBALL
-    ? resolve(process.env.TREESEED_SCAFFOLD_CLI_TARBALL)
-    : typeof workspaceTarballs['@treeseed/cli'] === 'string'
-        ? resolve(workspaceTarballs['@treeseed/cli'])
-        : null;
-const reusesExternalTarballs = Boolean(externalCoreTarball || externalSdkTarball || externalCliTarball);
-const scaffoldChecks = new Set((process.env.TREESEED_SCAFFOLD_CHECKS ?? 'build,deploy')
-    .split(',')
-    .map((value) => value.trim())
-    .filter(Boolean));
-const timings = [];
-const resetScaffoldCache = process.env.TREESEED_SCAFFOLD_RESET_CACHE === '1';
-const scaffoldTempRoot = resolve(process.env.TREESEED_SCAFFOLD_TEMP_ROOT ?? resolve(packageRoot, '.local', 'tmp'));
-mkdirSync(scaffoldTempRoot, { recursive: true });
-function logStep(message) {
-    console.log(`[treeseed:test-scaffold] ${message}`);
-}
-function withTiming(label, action) {
-    const startedAt = Date.now();
-    logStep(`${label} started`);
-    try {
-        const result = action();
-        if (result && typeof result.then === 'function') {
-            return result.then((resolved) => {
-                const durationMs = Date.now() - startedAt;
-                timings.push({ label, durationMs, status: 'completed' });
-                logStep(`${label} completed in ${(durationMs / 1000).toFixed(1)}s`);
-                return resolved;
-            }).catch((error) => {
-                const durationMs = Date.now() - startedAt;
-                timings.push({ label, durationMs, status: 'failed' });
-                logStep(`${label} failed in ${(durationMs / 1000).toFixed(1)}s`);
-                throw error;
-            });
-        }
-        const durationMs = Date.now() - startedAt;
-        timings.push({ label, durationMs, status: 'completed' });
-        logStep(`${label} completed in ${(durationMs / 1000).toFixed(1)}s`);
-        return result;
-    }
-    catch (error) {
-        const durationMs = Date.now() - startedAt;
-        timings.push({ label, durationMs, status: 'failed' });
-        logStep(`${label} failed in ${(durationMs / 1000).toFixed(1)}s`);
-        throw error;
-    }
-}
-function printSummary() {
-    if (timings.length === 0) {
-        return;
-    }
-    console.log('[treeseed:test-scaffold] Stage summary');
-    for (const entry of timings) {
-        console.log(`[treeseed:test-scaffold] ${entry.status === 'completed' ? 'ok  ' : 'fail'} ${entry.label} (${(entry.durationMs / 1000).toFixed(1)}s)`);
-    }
-}
-function resetNpmCache() {
-    rmSync(npmCacheDir, { recursive: true, force: true });
-}
-function runStep(command, args, { cwd = packageRoot, env = {}, capture = false } = {}) {
-    const result = spawnSync(command, args, {
-        cwd,
-        env: { ...process.env, ...env },
-        stdio: capture ? 'pipe' : 'inherit',
-        encoding: 'utf8',
-    });
-    if (result.status !== 0) {
-        const message = capture ? (result.stderr?.trim() || result.stdout?.trim() || `${command} ${args.join(' ')} failed`) : `${command} ${args.join(' ')} failed`;
-        throw new Error(message);
-    }
-    return result;
-}
-function createTempSiteRoot() {
-    return mkdtempSync(join(scaffoldTempRoot, 'treeseed-scaffold-'));
-}
-function rewriteScaffoldDependency(siteRoot, tarballPath, cliTarballPath) {
-    const packageJsonPath = resolve(siteRoot, 'package.json');
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-    packageJson.dependencies = packageJson.dependencies ?? {};
-    packageJson.dependencies['@treeseed/core'] = tarballPath;
-    packageJson.dependencies['@treeseed/cli'] = cliTarballPath;
-    writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, 'utf8');
-}
-function installManualPackageTarball(siteRoot, tarballPath, packageName) {
-    const extractRoot = mkdtempSync(join(scaffoldTempRoot, 'treeseed-scaffold-package-'));
-    try {
-        runStep('tar', ['-xzf', tarballPath, '-C', extractRoot]);
-        const scopeRoot = resolve(siteRoot, 'node_modules', '@treeseed');
-        mkdirSync(scopeRoot, { recursive: true });
-        cpSync(resolve(extractRoot, 'package'), resolve(scopeRoot, packageName.split('/')[1]), { recursive: true });
-    }
-    finally {
-        rmSync(extractRoot, { recursive: true, force: true });
-    }
-}
-function linkWorkspacePackage(siteRoot, packageName, sourceRoot) {
-    const scopeRoot = resolve(siteRoot, 'node_modules', '@treeseed');
-    mkdirSync(scopeRoot, { recursive: true });
-    symlinkSync(sourceRoot, resolve(scopeRoot, packageName.split('/')[1]), 'dir');
-}
-function resolveSharedNodeModulesRoot() {
-    let current = packageRoot;
-    while (true) {
-        const candidate = resolve(current, 'node_modules');
-        if (existsSync(candidate)) {
-            return candidate;
-        }
-        const parent = resolve(current, '..');
-        if (parent === current) {
-            break;
-        }
-        current = parent;
-    }
-    throw new Error(`Unable to locate a shared node_modules directory for ${packageRoot}.`);
-}
-function mirrorSharedNodeModules(siteRoot) {
-    const sharedNodeModules = resolveSharedNodeModulesRoot();
-    for (const entry of readdirSync(sharedNodeModules, { withFileTypes: true })) {
-        if (entry.name === '.bin' || entry.name === '@treeseed' || entry.name === '@astrojs') {
-            continue;
-        }
-        const sourcePath = resolve(sharedNodeModules, entry.name);
-        const targetPath = resolve(siteRoot, 'node_modules', entry.name);
-        mkdirSync(dirname(targetPath), { recursive: true });
-        if (entry.name === 'astro') {
-            cpSync(sourcePath, targetPath, { recursive: true });
-            continue;
-        }
-        symlinkSync(sourcePath, targetPath, 'dir');
-    }
-    const sharedAstroScope = resolve(sharedNodeModules, '@astrojs');
-    const targetAstroScope = resolve(siteRoot, 'node_modules', '@astrojs');
-    mkdirSync(targetAstroScope, { recursive: true });
-    for (const packageName of ['cloudflare', 'mdx', 'sitemap', 'starlight']) {
-        cpSync(resolve(sharedAstroScope, packageName), resolve(targetAstroScope, packageName), { recursive: true });
-    }
-}
-function linkTreeseedBins(siteRoot) {
-    const binRoot = resolve(siteRoot, 'node_modules', '.bin');
-    mkdirSync(binRoot, { recursive: true });
-    for (const [name, relativeTarget] of [
-        ['treeseed', '../@treeseed/cli/dist/cli/main.js'],
-        ['treeseed-agents', '../@treeseed/agent/dist/agents/cli.js'],
-        ['treeseed-agent-service', '../@treeseed/agent/dist/scripts/treeseed-agent-service.js'],
-    ]) {
-        symlinkSync(relativeTarget, resolve(binRoot, name));
-    }
-}
-function createTarball(root, pkg) {
-    return withTiming(`${pkg.name} build+pack`, () => {
-        if (typeof pkg.scripts?.['build:dist'] === 'string') {
-            runStep('npm', ['run', 'build:dist'], { cwd: root });
-        }
-        const output = runStep('npm', ['pack', '--silent', '--ignore-scripts', '--cache', npmCacheDir], {
-            cwd: root,
-            capture: true,
-            env: {
-                npm_config_cache: npmCacheDir,
-                NPM_CONFIG_CACHE: npmCacheDir,
-            },
-        });
-        const filename = output.stdout
-            .split('\n')
-            .map((line) => line.trim())
-            .filter(Boolean)
-            .at(-1)
-            || `${pkg.name.replace(/^@/, '').replaceAll('/', '-')}-${pkg.version}.tgz`;
-        return resolve(root, filename);
-    });
-}
-async function scaffoldSite(siteRoot) {
-    for (const definition of await listTemplateProducts({ writeWarning: (message) => console.warn(message) })) {
-        await validateTemplateProduct(definition, { writeWarning: (message) => console.warn(message) });
-    }
-    runStep(process.execPath, [packageScriptPath('scaffold-site'), siteRoot, '--template', TREESEED_DEFAULT_STARTER_TEMPLATE_ID, '--name', 'Smoke Site', '--site-url', 'https://smoke.example.com', '--contact-email', 'hello@example.com']);
-}
-function installScaffold(siteRoot, { coreTarballPath, sdkTarballPath, cliTarballPath }) {
-    if (coreTarballPath && sdkTarballPath && cliTarballPath) {
-        linkWorkspacePackage(siteRoot, sdkPackageJson.name, sdkPackageRoot);
-        linkWorkspacePackage(siteRoot, packageJson.name, corePackageRoot);
-        linkWorkspacePackage(siteRoot, cliPackageJson.name, packageRoot);
-        mirrorSharedNodeModules(siteRoot);
-        linkTreeseedBins(siteRoot);
-        return;
-    }
-    runStep('npm', ['install', '--cache', npmCacheDir, '--prefer-offline', '--no-audit', '--no-fund'], {
-        cwd: siteRoot,
-        env: {
-            npm_config_cache: npmCacheDir,
-            NPM_CONFIG_CACHE: npmCacheDir,
-            npm_config_prefer_offline: 'true',
-            npm_config_audit: 'false',
-            npm_config_fund: 'false',
-        },
-    });
-}
-function runScaffoldChecks(siteRoot) {
-    if (scaffoldChecks.has('build')) {
-        withTiming('scaffold build', () => {
-            runStep('npm', ['run', 'build'], { cwd: siteRoot });
-        });
-    }
-    if (scaffoldChecks.has('deploy')) {
-        withTiming('scaffold deploy plan', () => {
-            runStep('npm', ['run', 'deploy', '--', '--plan'], { cwd: siteRoot });
-        });
-    }
-}
-const siteRoot = createTempSiteRoot();
-let tarballPath = externalCoreTarball;
-let sdkTarballPath = externalSdkTarball;
-let cliTarballPath = externalCliTarball;
-try {
-    if (!reusesExternalTarballs && resetScaffoldCache) {
-        logStep(`resetting npm cache at ${npmCacheDir}`);
-        resetNpmCache();
-    }
-    if (!sdkTarballPath) {
-        logStep('building and packing @treeseed/sdk');
-        sdkTarballPath = createTarball(sdkPackageRoot, sdkPackageJson);
-    }
-    else {
-        logStep(`reusing provided @treeseed/sdk tarball: ${sdkTarballPath}`);
-    }
-    if (!tarballPath) {
-        logStep('building and packing @treeseed/core');
-        tarballPath = createTarball(corePackageRoot, packageJson);
-    }
-    else {
-        logStep(`reusing provided @treeseed/core tarball: ${tarballPath}`);
-    }
-    if (!cliTarballPath) {
-        logStep('building and packing @treeseed/cli');
-        cliTarballPath = createTarball(packageRoot, cliPackageJson);
-    }
-    else {
-        logStep(`reusing provided @treeseed/cli tarball: ${cliTarballPath}`);
-    }
-    logStep(`scaffolding temporary tenant at ${siteRoot}`);
-    await withTiming('scaffold tenant generation', async () => {
-        await scaffoldSite(siteRoot);
-    });
-    rewriteScaffoldDependency(siteRoot, tarballPath, cliTarballPath);
-    logStep(`installing scaffolded tenant dependencies with checks: ${[...scaffoldChecks].join(', ') || 'none'}`);
-    await withTiming('scaffold dependency install', async () => {
-        installScaffold(siteRoot, {
-            coreTarballPath: tarballPath,
-            sdkTarballPath,
-            cliTarballPath,
-        });
-    });
-    logStep('running scaffold smoke checks');
-    runScaffoldChecks(siteRoot);
-    console.log(`Scaffold smoke test passed in ${dirname(siteRoot) ? siteRoot : '.'}`);
-}
-finally {
-    printSummary();
-    rmSync(siteRoot, { recursive: true, force: true });
-    if (sdkTarballPath && !externalSdkTarball) {
-        rmSync(sdkTarballPath, { force: true });
-    }
-    if (tarballPath && !externalCoreTarball) {
-        rmSync(tarballPath, { force: true });
-    }
-    if (!reusesExternalTarballs && resetScaffoldCache) {
-        resetNpmCache();
-    }
-}

package/dist/scripts/test-smoke.js

@@ -1,137 +0,0 @@
-import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
-import { mkdtempSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { packageRoot } from './package-tools.js';
-const npmCacheDir = resolve(tmpdir(), 'treeseed-npm-cache');
-function run(command, args, cwd = packageRoot, capture = false, extraEnv = {}) {
-    const result = spawnSync(command, args, {
-        cwd,
-        stdio: capture ? 'pipe' : 'inherit',
-        encoding: 'utf8',
-        env: {
-            ...process.env,
-            ...extraEnv,
-            npm_config_cache: npmCacheDir,
-            NPM_CONFIG_CACHE: npmCacheDir,
-        },
-    });
-    if (result.status !== 0) {
-        throw new Error(result.stderr?.trim() || result.stdout?.trim() || `${command} ${args.join(' ')} failed`);
-    }
-    return (result.stdout ?? '').trim();
-}
-function resolveNodeModulesRoot() {
-    let current = packageRoot;
-    while (true) {
-        const candidate = resolve(current, 'node_modules');
-        try {
-            readdirSync(candidate);
-            return candidate;
-        }
-        catch {
-        }
-        const parent = resolve(current, '..');
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    throw new Error(`Unable to locate node_modules for ${packageRoot}.`);
-}
-function mirrorDependencies(tempRoot) {
-    const sharedNodeModules = resolveNodeModulesRoot();
-    for (const entry of readdirSync(sharedNodeModules, { withFileTypes: true })) {
-        if (entry.name === '.bin') {
-            continue;
-        }
-        if (entry.name === '@treeseed') {
-            const sourceScopeRoot = resolve(sharedNodeModules, entry.name);
-            const targetScopeRoot = resolve(tempRoot, 'node_modules', entry.name);
-            mkdirSync(targetScopeRoot, { recursive: true });
-            for (const scopedEntry of readdirSync(sourceScopeRoot, { withFileTypes: true })) {
-                if (scopedEntry.name === 'sdk') {
-                    continue;
-                }
-                const targetPath = resolve(targetScopeRoot, scopedEntry.name);
-                symlinkSync(resolve(sourceScopeRoot, scopedEntry.name), targetPath, scopedEntry.isDirectory() ? 'dir' : 'file');
-            }
-            continue;
-        }
-        const targetPath = resolve(tempRoot, 'node_modules', entry.name);
-        mkdirSync(dirname(targetPath), { recursive: true });
-        symlinkSync(resolve(sharedNodeModules, entry.name), targetPath, 'dir');
-    }
-}
-function resolveInstalledSdkRoot(installRoot) {
-    const directRoot = resolve(installRoot, 'node_modules', '@treeseed', 'sdk');
-    const nestedRoot = resolve(directRoot, 'package');
-    if (existsSync(resolve(directRoot, 'package.json'))) {
-        return directRoot;
-    }
-    if (existsSync(resolve(nestedRoot, 'package.json'))) {
-        return nestedRoot;
-    }
-    throw new Error('Unable to locate installed SDK package root in smoke test.');
-}
-function loadPackedSdkPackageJson(installRoot) {
-    return JSON.parse(readFileSync(resolve(resolveInstalledSdkRoot(installRoot), 'package.json'), 'utf8'));
-}
-function wireSdkBin(installRoot) {
-    const packageJson = loadPackedSdkPackageJson(installRoot);
-    const relativeBinPath = packageJson.bin?.['treeseed-sdk-verify'];
-    if (!relativeBinPath) {
-        throw new Error('Packed SDK is missing treeseed-sdk-verify bin metadata.');
-    }
-    const binRoot = resolve(installRoot, 'node_modules', '.bin');
-    const target = resolve(resolveInstalledSdkRoot(installRoot), relativeBinPath);
-    const linkPath = resolve(binRoot, 'treeseed-sdk-verify');
-    mkdirSync(binRoot, { recursive: true });
-    symlinkSync(target, linkPath);
-    chmodSync(target, 0o755);
-    return linkPath;
-}
-const stageRoot = mkdtempSync(join(tmpdir(), 'treeseed-sdk-smoke-'));
-const packRoot = resolve(stageRoot, 'pack');
-const extractRoot = resolve(stageRoot, 'extract');
-const installRoot = resolve(stageRoot, 'install');
-try {
-    mkdirSync(packRoot, { recursive: true });
-    mkdirSync(extractRoot, { recursive: true });
-    const packOutput = run('npm', ['pack', '--ignore-scripts', '--cache', npmCacheDir, '--pack-destination', packRoot], packageRoot, true);
-    const filename = packOutput
-        .split('\n')
-        .map((line) => line.trim())
-        .filter(Boolean)
-        .at(-1)
-        ?? readdirSync(packRoot, { withFileTypes: true })
-            .filter((entry) => entry.isFile() && entry.name.endsWith('.tgz'))
-            .map((entry) => entry.name)
-            .sort((left, right) => left.localeCompare(right, undefined, { numeric: true, sensitivity: 'base' }))
-            .at(-1);
-    if (!filename) {
-        throw new Error('Unable to determine packed SDK tarball name.');
-    }
-    const tarballPath = resolve(packRoot, filename);
-    run('tar', ['-xzf', tarballPath, '-C', extractRoot]);
-    mkdirSync(resolve(installRoot, 'node_modules', '@treeseed'), { recursive: true });
-    run('cp', ['-R', resolve(extractRoot, 'package'), resolve(installRoot, 'node_modules', '@treeseed', 'sdk')]);
-    mirrorDependencies(installRoot);
-    const verifyBin = wireSdkBin(installRoot);
-    writeFileSync(resolve(installRoot, 'package.json'), `${JSON.stringify({
-        name: 'treeseed-sdk-smoke',
-        private: true,
-        type: 'module',
-        scripts: {
-            'verify:direct': 'tsx -e "console.log(\'treeseed-sdk-smoke-verify\')"',
-            'verify:local': 'tsx -e "process.env.TREESEED_VERIFY_DRIVER=\'direct\'; console.log(\'treeseed-sdk-smoke-verify-local\')"',
-            'verify:action': 'tsx -e "process.env.TREESEED_VERIFY_DRIVER=\'act\'; console.log(\'treeseed-sdk-smoke-verify-action\')"',
-        },
-    }, null, 2)}\n`, 'utf8');
-    run(process.execPath, ['--input-type=module', '-e', 'await import("@treeseed/sdk/verification");'], installRoot);
-    run(verifyBin, [], installRoot, false, { TREESEED_VERIFY_DRIVER: 'direct' });
-    console.log('SDK packed-install smoke passed.');
-}
-finally {
-    rmSync(stageRoot, { recursive: true, force: true });
-}

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

@@ -1,21 +0,0 @@
-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+$/.test(tagName)) {
-    console.error(`Release tag "${tagName}" must use plain semver format "x.y.z".`);
-    process.exit(1);
-}
-const taggedVersion = tagName;
-if (taggedVersion !== packageVersion) {
-    console.error(`Release tag version "${taggedVersion}" does not match @treeseed/cli version "${packageVersion}".`);
-    process.exit(1);
-}
-console.log(`Release tag "${tagName}" matches @treeseed/cli version "${packageVersion}".`);