@treeseed/sdk 0.1.2 → 0.3.1

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

@@ -0,0 +1,21 @@
+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}".`);

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

@@ -0,0 +1,134 @@
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, chmodSync } from 'node:fs';
+import { basename, 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(/\.(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, 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) {
+    if (basename(filePath).startsWith('.ts-run-')) {
+        return;
+    }
+    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, 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' || extension === '.mjs')
+        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

@@ -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/treeseed-release-verify.js

@@ -0,0 +1,131 @@
+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 { agentPackageRoot, corePackageRoot, packageRoot, sdkPackageRoot } from '../operations/services/runtime-tools.js';
+const textExtensions = new Set(['.js', '.ts', '.mjs', '.cjs', '.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) && hasWorkspacePackageSource(agentPackageRoot)) {
+    run('npm', ['run', 'test:scaffold']);
+}
+else {
+    console.log('Skipping scaffold verification because local sdk/core/agent 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/treeseed-run-ts.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+import { build } from 'esbuild';
+import { readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const [, , entryArg, ...scriptArgs] = process.argv;
+
+if (!entryArg) {
+	console.error('Usage: node ./scripts/run-ts.mjs <entry.ts> [...args]');
+	process.exit(1);
+}
+
+const cwd = process.cwd();
+const entryPath = resolve(cwd, entryArg);
+const outfile = resolve(
+	dirname(entryPath),
+	`.ts-run-${Date.now()}-${Math.random().toString(36).slice(2)}.js`,
+);
+
+try {
+	await build({
+		entryPoints: [entryPath],
+		outfile,
+		bundle: true,
+		format: 'esm',
+		platform: 'node',
+		packages: 'external',
+		sourcemap: 'inline',
+		logLevel: 'silent',
+	});
+
+	const builtSource = readFileSync(outfile, 'utf8');
+	writeFileSync(
+		outfile,
+		builtSource.replace(/(['"`])(\.[^'"`\n]+)\.ts\1/g, '$1$2.js$1'),
+		'utf8',
+	);
+
+	process.argv = [process.argv[0] ?? 'node', entryPath, ...scriptArgs];
+	await import(pathToFileURL(outfile).href);
+} finally {
+	rmSync(outfile, { force: true });
+}

package/dist/scripts/validate-templates.js

@@ -0,0 +1,6 @@
+#!/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

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+import { existsSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const scriptRoot = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(scriptRoot, '..');
+const sourceRunner = resolve(packageRoot, 'scripts', 'run-ts.mjs');
+const sourceEntry = resolve(packageRoot, 'src', 'verification.ts');
+const publishedEntry = resolve(packageRoot, 'dist', 'verification.js');
+
+if (existsSync(sourceRunner) && existsSync(sourceEntry)) {
+	const result = spawnSync(process.execPath, [sourceRunner, sourceEntry], {
+		cwd: process.cwd(),
+		env: process.env,
+		stdio: 'inherit',
+	});
+	process.exit(result.status ?? 1);
+}
+
+if (existsSync(publishedEntry)) {
+	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

@@ -0,0 +1,39 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import {
+	createBranchPreviewDeployTarget,
+	createPersistentDeployTarget,
+	deployTargetLabel,
+	loadDeployState,
+} from '../dist/scripts/deploy-lib.js';
+import { renderDeployWorkflow } from '../dist/scripts/github-automation-lib.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 targets staging and main branches', () => {
+	const workflow = renderDeployWorkflow({ workingDirectory: '.' });
+	assert.match(workflow, /- staging/);
+	assert.match(workflow, /- main/);
+	assert.match(workflow, /--environment \$\{\{ github\.ref_name == 'main' && 'prod' \|\| 'staging' \}\}/);
+});
+
+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');
+});

package/dist/scripts/workspace-close.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { applyTreeseedEnvironmentToProcess } from '../operations/services/config-runtime.js';
+import { cleanupDestroyedState, createBranchPreviewDeployTarget, destroyCloudflareResources, loadDeployState, printDestroySummary, validateDestroyPrerequisites, } from '../operations/services/deploy.js';
+import { assertFeatureBranch, deleteLocalBranch, deleteRemoteBranch, mergeCurrentBranchIntoStaging, } from '../operations/services/git-workflow.js';
+import { loadCliDeployConfig } from '../operations/services/runtime-tools.js';
+import { runWorkspaceSavePreflight } from '../operations/services/save-deploy-preflight.js';
+const tenantRoot = process.cwd();
+const featureBranch = assertFeatureBranch(tenantRoot);
+const previewTarget = createBranchPreviewDeployTarget(featureBranch);
+const deployConfig = loadCliDeployConfig(tenantRoot);
+const previewState = loadDeployState(tenantRoot, deployConfig, { target: previewTarget });
+runWorkspaceSavePreflight({ cwd: tenantRoot });
+const repoDir = mergeCurrentBranchIntoStaging(tenantRoot, featureBranch);
+if (previewState.readiness?.initialized) {
+    applyTreeseedEnvironmentToProcess({ tenantRoot, scope: 'staging', override: true });
+    validateDestroyPrerequisites(tenantRoot, { requireRemote: true });
+    const result = destroyCloudflareResources(tenantRoot, { target: previewTarget });
+    printDestroySummary(result);
+}
+cleanupDestroyedState(tenantRoot, { target: previewTarget });
+deleteRemoteBranch(repoDir, featureBranch);
+deleteLocalBranch(repoDir, featureBranch);
+console.log('Treeseed close completed successfully.');
+console.log(`Merged ${featureBranch} into staging and removed branch artifacts.`);