@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/scripts/treeseed-build-dist.js

@@ -1,131 +0,0 @@
-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 templateCatalogSourceRoot = resolve(srcRoot, 'template-catalog');
-const COPY_EXTENSIONS = new Set(['.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, outputFile = null) {
-    let rewritten = contents
-        .replace(/(['"`])(\.[^'"`\n]+)\.(mjs|ts)\1/g, '$1$2.js$1')
-        .replace(/(['"`])\.\.\/src\//g, '$1../');
-    if (!outputFile || outputFile.includes(`${resolve(distRoot, 'scripts')}`)) {
-        return rewritten;
-    }
-    rewritten = rewritten.replace(/(['"`])((?:\.\.\/)+scripts\/([^'"`\n]+))\1/g, (_match, quote, _specifier, scriptPath) => {
-        const targetPath = resolve(distRoot, 'scripts', scriptPath);
-        let relativeSpecifier = relative(dirname(outputFile), targetPath).replaceAll('\\', '/');
-        if (!relativeSpecifier.startsWith('.')) {
-            relativeSpecifier = `./${relativeSpecifier}`;
-        }
-        return `${quote}${relativeSpecifier}${quote}`;
-    });
-    return rewritten;
-}
-function isTypeScriptSource(filePath) {
-    return filePath.endsWith('.ts') && !filePath.endsWith('.d.js');
-}
-async function compileModule(filePath, sourceRoot, outputRoot) {
-    const relativePath = relative(sourceRoot, filePath);
-    const outputFile = resolve(outputRoot, relativePath.replace(/\.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, outputFile), '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 copyAssetTree(sourceRoot, outputRoot) {
-    for (const filePath of walkFiles(sourceRoot)) {
-        copyAsset(filePath, sourceRoot, outputRoot);
-    }
-}
-function transpileScript(filePath) {
-    const source = readFileSync(filePath, 'utf8');
-    const relativePath = relative(scriptsRoot, filePath);
-    const outputFile = resolve(distRoot, 'scripts', relativePath.replace(/\.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, outputFile), 'utf8');
-    chmodSync(outputFile, 0o755);
-}
-function emitDeclarations() {
-    const rootNames = walkFiles(srcRoot).filter(isTypeScriptSource);
-    const program = ts.createProgram({
-        rootNames,
-        options: {
-            allowImportingTsExtensions: true,
-            target: ts.ScriptTarget.ES2022,
-            module: ts.ModuleKind.ESNext,
-            moduleResolution: ts.ModuleResolutionKind.Bundler,
-            strict: true,
-            types: ['node'],
-            declaration: true,
-            emitDeclarationOnly: true,
-            declarationDir: distRoot,
-            rootDir: srcRoot,
-            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)) {
-    if (filePath.startsWith(`${templateCatalogSourceRoot}/`)) {
-        continue;
-    }
-    const extension = extname(filePath);
-    if (isTypeScriptSource(filePath))
-        await compileModule(filePath, srcRoot, distRoot);
-    else if (COPY_EXTENSIONS.has(extension))
-        copyAsset(filePath, srcRoot, distRoot);
-}
-if (existsSync(templateCatalogSourceRoot)) {
-    copyAssetTree(templateCatalogSourceRoot, resolve(distRoot, 'template-catalog'));
-}
-for (const filePath of walkFiles(scriptsRoot)) {
-    const extension = extname(filePath);
-    if (extension === '.ts')
-        transpileScript(filePath);
-}
-emitDeclarations();
-if (existsSync(resolve(packageRoot, 'README.md'))) {
-    copyFileSync(resolve(packageRoot, 'README.md'), resolve(distRoot, '..', 'README.md'));
-}

package/dist/scripts/treeseed-publish-package.js

@@ -1,19 +0,0 @@
-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/treeseed-release-verify.js

@@ -1,131 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
-import { mkdtempSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, extname, join, resolve } from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { corePackageRoot, packageRoot, sdkPackageRoot } from '../operations/services/runtime-tools.js';
-const textExtensions = new Set(['.js', '.ts', '.d.js', '.json', '.md']);
-const forbiddenPatterns = [
-    /['"`]workspace:[^'"`\n]+['"`]/,
-    /['"`](?:\.\.\/|\.\/)[^'"`\n]*src\/[^'"`\n]*\.(?:[cm]?js|ts|tsx|json|astro|css)['"`]/,
-    /['"`][^'"`\n]*\/packages\/[^'"`\n]*\/src\/[^'"`\n]*['"`]/,
-];
-function run(command, args, cwd = packageRoot, capture = false) {
-    const result = spawnSync(command, args, {
-        cwd,
-        stdio: capture ? 'pipe' : 'inherit',
-        encoding: 'utf8',
-        env: process.env,
-    });
-    if (result.status !== 0) {
-        throw new Error(result.stderr?.trim() || result.stdout?.trim() || `${command} ${args.join(' ')} failed`);
-    }
-    return (result.stdout ?? '').trim();
-}
-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));
-            continue;
-        }
-        files.push(fullPath);
-    }
-    return files;
-}
-function scanDirectory(root) {
-    for (const filePath of walkFiles(root)) {
-        if (!textExtensions.has(extname(filePath)))
-            continue;
-        const source = readFileSync(filePath, 'utf8');
-        for (const pattern of forbiddenPatterns) {
-            if (pattern.test(source)) {
-                throw new Error(`${filePath} contains forbidden publish reference matching ${pattern}.`);
-            }
-        }
-    }
-}
-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 === 'cli') {
-                    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, entry.isDirectory() ? 'dir' : 'file');
-    }
-}
-function pack(root, fallbackName) {
-    const output = run('npm', ['pack', '--silent', '--ignore-scripts'], root, true);
-    const filename = output
-        .split('\n')
-        .map((line) => line.trim())
-        .filter(Boolean)
-        .at(-1) ?? fallbackName;
-    return resolve(root, filename);
-}
-function installPackagedPackage(extractRoot, tempRoot, tarballPath, folderName) {
-    mkdirSync(resolve(tempRoot, 'node_modules', '@treeseed'), { recursive: true });
-    run('tar', ['-xzf', tarballPath, '-C', extractRoot]);
-    run('cp', ['-R', resolve(extractRoot, 'package'), resolve(tempRoot, 'node_modules', '@treeseed', folderName)]);
-    rmSync(resolve(extractRoot, 'package'), { recursive: true, force: true });
-}
-function hasWorkspacePackageSource(root) {
-    return root !== packageRoot && existsSync(resolve(root, 'scripts'));
-}
-run('npm', ['run', 'build']);
-scanDirectory(resolve(packageRoot, 'dist'));
-run('npm', ['test']);
-if (hasWorkspacePackageSource(sdkPackageRoot) && hasWorkspacePackageSource(corePackageRoot)) {
-    run('npm', ['run', 'test:scaffold']);
-}
-else {
-    console.log('Skipping scaffold verification because local sdk/core package sources are not available.');
-}
-const stageRoot = mkdtempSync(join(tmpdir(), 'treeseed-cli-release-'));
-const extractRoot = resolve(stageRoot, 'extract');
-const installRoot = resolve(stageRoot, 'install');
-try {
-    mkdirSync(extractRoot, { recursive: true });
-    const cliTarball = pack(packageRoot, 'treeseed-cli.tgz');
-    mirrorDependencies(installRoot);
-    installPackagedPackage(extractRoot, installRoot, cliTarball, 'cli');
-    writeFileSync(resolve(installRoot, 'package.json'), `${JSON.stringify({ name: 'treeseed-cli-smoke', private: true, type: 'module' }, null, 2)}\n`, 'utf8');
-    run(process.execPath, ['node_modules/@treeseed/cli/dist/cli/main.js', '--help'], installRoot);
-    console.log('CLI packed-install bin smoke passed.');
-}
-finally {
-    rmSync(stageRoot, { recursive: true, force: true });
-}

package/dist/scripts/validate-templates.js

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-import { validateAllTemplateDefinitions } from '../operations/services/template-registry.js';
-const definitions = await validateAllTemplateDefinitions({
-    writeWarning: (message) => console.warn(message),
-});
-console.log(`Validated ${definitions.length} template definition${definitions.length === 1 ? '' : 's'}.`);

package/dist/scripts/verify-driver.js

@@ -1,45 +0,0 @@
-#!/usr/bin/env node
-import { existsSync } from 'node:fs';
-import { spawnSync } from 'node:child_process';
-import { dirname, resolve } from 'node:path';
-import { tmpdir } from 'node:os';
-import { fileURLToPath } from 'node:url';
-const scriptRoot = dirname(fileURLToPath(import.meta.url));
-const packageRoot = resolve(scriptRoot, '..');
-const sourceEntry = resolve(packageRoot, 'src', 'verification.ts');
-const publishedEntry = resolve(packageRoot, 'dist', 'verification.js');
-const entrypointCheckOnly = process.env.TREESEED_VERIFY_ENTRYPOINT_CHECK === 'true';
-function withShortTempEnv() {
-    if (process.platform === 'win32') {
-        return process.env;
-    }
-    const env = { ...process.env };
-    const shortTemp = tmpdir();
-    for (const key of ['TMPDIR', 'TMP', 'TEMP']) {
-        const value = env[key];
-        if (value && value.length > shortTemp.length) {
-            env[key] = shortTemp;
-        }
-    }
-    return env;
-}
-if (existsSync(sourceEntry)) {
-    if (entrypointCheckOnly) {
-        process.exit(0);
-    }
-    const result = spawnSync('tsx', [sourceEntry], {
-        cwd: process.cwd(),
-        env: withShortTempEnv(),
-        stdio: 'inherit',
-    });
-    process.exit(result.status ?? 1);
-}
-if (existsSync(publishedEntry)) {
-    if (entrypointCheckOnly) {
-        process.exit(0);
-    }
-    const { runTreeseedVerifyDriver } = await import('../dist/verification.js');
-    process.exit(runTreeseedVerifyDriver({ packageRoot: process.cwd() }));
-}
-process.stderr.write(`Unable to locate Treeseed SDK verification runtime from ${packageRoot}.\n`);
-process.exit(1);

package/dist/scripts/workflow-commands.test.js

@@ -1,31 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { createBranchPreviewDeployTarget, createPersistentDeployTarget, deployTargetLabel, loadDeployState, } from '../dist/scripts/deploy-lib.js';
-import { renderDeployWebWorkflow } from '../dist/operations/services/github-automation.js';
-import { incrementVersion } from '../dist/scripts/workspace-save-lib.js';
-import { makeTenantRoot } from './cli-test-fixtures.js';
-test('persistent and branch targets produce distinct labels', () => {
-    assert.equal(deployTargetLabel(createPersistentDeployTarget('staging')), 'staging');
-    assert.equal(deployTargetLabel(createBranchPreviewDeployTarget('feature/one')), 'branch:feature/one');
-});
-test('branch preview state derives branch-specific worker names', () => {
-    const tenantRoot = makeTenantRoot();
-    const deployConfig = {
-        cloudflare: { accountId: 'fixture-cloudflare-account-id', workerName: 'treeseed-working-site' },
-    };
-    const state = loadDeployState(tenantRoot, deployConfig, { target: createBranchPreviewDeployTarget('feature/preview') });
-    assert.match(state.workerName, /^treeseed-working-site-feature-preview/);
-    assert.equal(state.previewEnabled, true);
-});
-test('deploy workflow exposes final web actions only', () => {
-    const webWorkflow = renderDeployWebWorkflow({ workingDirectory: '.' });
-    assert.match(webWorkflow, /default: deploy_web/);
-    assert.match(webWorkflow, /- publish_content/);
-    assert.doesNotMatch(webWorkflow, /RAILWAY_API_TOKEN/);
-    assert.doesNotMatch(webWorkflow, /deploy_processing/);
-});
-test('version bump utility supports major, minor, and patch', () => {
-    assert.equal(incrementVersion('1.2.3', 'patch'), '1.2.4');
-    assert.equal(incrementVersion('1.2.3', 'minor'), '1.3.0');
-    assert.equal(incrementVersion('1.2.3', 'major'), '2.0.0');
-});