@treeseed/sdk 0.1.1 → 0.3.0

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.`);