@treeseed/sdk 0.1.2 → 0.3.1

package/dist/scripts/tenant-check.js

@@ -0,0 +1,7 @@
+import { resolveAstroBin, createProductionBuildEnv, packageScriptPath, runNodeBinary, runNodeScript } from '../operations/services/runtime-tools.js';
+runNodeScript(packageScriptPath('patch-starlight-content-path'), [], { cwd: process.cwd() });
+runNodeScript(packageScriptPath('aggregate-book'), [], { cwd: process.cwd() });
+runNodeBinary(resolveAstroBin(), ['check'], {
+    cwd: process.cwd(),
+    env: createProductionBuildEnv(),
+});

package/dist/scripts/tenant-d1-migrate-local.js

@@ -0,0 +1,11 @@
+import { resolve } from 'node:path';
+import { runLocalD1Migrations } from '../operations/services/d1-migration.js';
+import { ensureGeneratedWranglerConfig } from '../operations/services/deploy.js';
+const tenantRoot = process.cwd();
+const migrationsRoot = resolve(tenantRoot, 'migrations');
+const { wranglerPath: wranglerConfig } = ensureGeneratedWranglerConfig(tenantRoot);
+runLocalD1Migrations({
+    cwd: tenantRoot,
+    wranglerConfig,
+    migrationsRoot,
+});

package/dist/scripts/tenant-deploy.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { applyTreeseedEnvironmentToProcess } from '../operations/services/config-runtime.js';
+import { assertDeploymentInitialized, createBranchPreviewDeployTarget, createPersistentDeployTarget, deployTargetLabel, ensureGeneratedWranglerConfig, finalizeDeploymentState, runRemoteD1Migrations, } from '../operations/services/deploy.js';
+import { currentManagedBranch, PRODUCTION_BRANCH, STAGING_BRANCH } from '../operations/services/git-workflow.js';
+import { packageScriptPath, resolveWranglerBin } from '../operations/services/runtime-tools.js';
+import { runTenantDeployPreflight } from '../operations/services/save-deploy-preflight.js';
+const tenantRoot = process.cwd();
+const args = process.argv.slice(2);
+function writeDeployReport(payload) {
+    const target = process.env.TREESEED_DEPLOY_REPORT_PATH;
+    if (!target) {
+        return;
+    }
+    const filePath = resolve(target);
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+}
+function parseArgs(argv) {
+    const parsed = {
+        dryRun: false,
+        only: null,
+        name: null,
+        environment: null,
+        targetBranch: null,
+    };
+    const rest = [...argv];
+    while (rest.length) {
+        const current = rest.shift();
+        if (!current)
+            continue;
+        if (current === '--dry-run') {
+            parsed.dryRun = true;
+            continue;
+        }
+        if (current === '--only') {
+            parsed.only = rest.shift() ?? null;
+            continue;
+        }
+        if (current === '--name') {
+            parsed.name = rest.shift() ?? null;
+            continue;
+        }
+        if (current === '--environment') {
+            parsed.environment = rest.shift() ?? null;
+            continue;
+        }
+        if (current.startsWith('--environment=')) {
+            parsed.environment = current.split('=', 2)[1] ?? null;
+            continue;
+        }
+        if (current === '--target-branch') {
+            parsed.targetBranch = rest.shift() ?? null;
+            continue;
+        }
+        if (current.startsWith('--target-branch=')) {
+            parsed.targetBranch = current.split('=', 2)[1] ?? null;
+            continue;
+        }
+        throw new Error(`Unknown deploy argument: ${current}`);
+    }
+    return parsed;
+}
+function inferEnvironmentFromBranch() {
+    const branch = currentManagedBranch(tenantRoot);
+    if (branch === STAGING_BRANCH) {
+        return 'staging';
+    }
+    if (branch === PRODUCTION_BRANCH) {
+        return 'prod';
+    }
+    return null;
+}
+function resolveTarget(options) {
+    if (options.targetBranch) {
+        return {
+            target: createBranchPreviewDeployTarget(options.targetBranch),
+            scope: 'staging',
+        };
+    }
+    const environment = options.environment ?? (process.env.CI ? inferEnvironmentFromBranch() : null);
+    if (!environment) {
+        throw new Error('Treeseed deploy requires `--environment local|staging|prod` outside CI.');
+    }
+    return {
+        target: createPersistentDeployTarget(environment),
+        scope: environment,
+    };
+}
+function runNodeScript(scriptPath, scriptArgs = [], env = {}) {
+    const result = spawnSync(process.execPath, [scriptPath, ...scriptArgs], {
+        stdio: 'inherit',
+        cwd: tenantRoot,
+        env: { ...process.env, ...env },
+    });
+    if (result.status !== 0) {
+        process.exit(result.status ?? 1);
+    }
+}
+function runWranglerDeploy(configPath) {
+    const result = spawnSync(process.execPath, [resolveWranglerBin(), 'deploy', '--config', configPath], {
+        stdio: 'inherit',
+        cwd: tenantRoot,
+        env: { ...process.env },
+    });
+    if (result.status !== 0) {
+        process.exit(result.status ?? 1);
+    }
+}
+async function main() {
+    const options = parseArgs(args);
+    const { target, scope } = resolveTarget(options);
+    applyTreeseedEnvironmentToProcess({ tenantRoot, scope, override: true });
+    const allowedSteps = new Set(['migrate', 'build', 'publish']);
+    if (options.only && !allowedSteps.has(options.only)) {
+        throw new Error(`Unsupported deploy step "${options.only}". Expected one of ${[...allowedSteps].join(', ')}.`);
+    }
+    const shouldRun = (step) => !options.only || options.only === step;
+    if (options.name) {
+        console.log(`Deploy target label: ${options.name}`);
+    }
+    if (scope === 'local') {
+        runTenantDeployPreflight({ cwd: tenantRoot, scope: 'local' });
+        runNodeScript(packageScriptPath('tenant-build'));
+        writeDeployReport({ ok: true, kind: 'success', scope, dryRun: options.dryRun, target: deployTargetLabel(target) });
+        console.log('Treeseed local deploy completed as a build-only publish target.');
+        return;
+    }
+    try {
+        assertDeploymentInitialized(tenantRoot, { target });
+        runTenantDeployPreflight({ cwd: tenantRoot, scope });
+    }
+    catch (error) {
+        writeDeployReport({
+            ok: false,
+            kind: 'preflight_failed',
+            target: deployTargetLabel(target),
+            message: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+    const { wranglerPath } = ensureGeneratedWranglerConfig(tenantRoot, { target });
+    if (shouldRun('migrate')) {
+        const result = runRemoteD1Migrations(tenantRoot, { dryRun: options.dryRun, target });
+        console.log(`${options.dryRun ? 'Planned' : 'Applied'} remote migrations for ${result.databaseName}.`);
+    }
+    if (shouldRun('build')) {
+        if (options.dryRun) {
+            console.log('Dry run: skipped tenant build.');
+        }
+        else {
+            runNodeScript(packageScriptPath('tenant-build'));
+        }
+    }
+    if (shouldRun('publish')) {
+        if (options.dryRun) {
+            console.log(`Dry run: would deploy ${deployTargetLabel(target)} with generated Wrangler config at ${resolve(wranglerPath)}.`);
+        }
+        else {
+            runWranglerDeploy(wranglerPath);
+            finalizeDeploymentState(tenantRoot, { target });
+        }
+    }
+    writeDeployReport({
+        ok: true,
+        kind: 'success',
+        dryRun: options.dryRun,
+        only: options.only,
+        target: deployTargetLabel(target),
+    });
+}
+try {
+    await main();
+}
+catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+}

package/dist/scripts/tenant-destroy.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { applyTreeseedEnvironmentToProcess, assertTreeseedCommandEnvironment } from '../operations/services/config-runtime.js';
+import { cleanupDestroyedState, createPersistentDeployTarget, destroyCloudflareResources, loadDeployState, printDestroySummary, validateDestroyPrerequisites, } from '../operations/services/deploy.js';
+import { deriveCloudflareWorkerName } from '../platform/deploy/config.js';
+const tenantRoot = process.cwd();
+function parseArgs(argv) {
+    const parsed = {
+        dryRun: false,
+        force: false,
+        skipConfirmation: false,
+        confirm: null,
+        removeBuildArtifacts: false,
+        environment: null,
+    };
+    const rest = [...argv];
+    while (rest.length) {
+        const current = rest.shift();
+        if (!current)
+            continue;
+        if (current === '--dry-run') {
+            parsed.dryRun = true;
+            continue;
+        }
+        if (current === '--force') {
+            parsed.force = true;
+            continue;
+        }
+        if (current === '--skip-confirmation') {
+            parsed.skipConfirmation = true;
+            continue;
+        }
+        if (current === '--confirm') {
+            parsed.confirm = rest.shift() ?? null;
+            continue;
+        }
+        if (current === '--remove-build-artifacts') {
+            parsed.removeBuildArtifacts = true;
+            continue;
+        }
+        if (current === '--environment') {
+            parsed.environment = rest.shift() ?? null;
+            continue;
+        }
+        if (current.startsWith('--environment=')) {
+            parsed.environment = current.split('=', 2)[1] ?? null;
+            continue;
+        }
+        throw new Error(`Unknown destroy argument: ${current}`);
+    }
+    return parsed;
+}
+function getExpectedConfirmation(deployConfig) {
+    return deployConfig.slug;
+}
+function printDangerMessage(deployConfig, state, expectedConfirmation) {
+    console.error('DANGER: treeseed destroy will permanently delete this site and its Cloudflare resources.');
+    console.error(`  Site: ${deployConfig.name}`);
+    console.error(`  Slug: ${deployConfig.slug}`);
+    console.error(`  Worker: ${state.workerName ?? deriveCloudflareWorkerName(deployConfig)}`);
+    console.error(`  D1: ${state.d1Databases.SITE_DATA_DB.databaseName}`);
+    console.error(`  KV FORM_GUARD_KV: ${state.kvNamespaces.FORM_GUARD_KV.name}`);
+    console.error(`  KV SESSION: ${state.kvNamespaces.SESSION.name}`);
+    console.error('  This action is irreversible.');
+    console.error(`  To continue, type exactly: ${expectedConfirmation}`);
+}
+async function readConfirmation(expectedConfirmation) {
+    const rl = readline.createInterface({ input, output });
+    try {
+        return (await rl.question('Confirmation: ')).trim() === expectedConfirmation;
+    }
+    finally {
+        rl.close();
+    }
+}
+const options = parseArgs(process.argv.slice(2));
+const scope = options.environment ?? 'prod';
+const target = createPersistentDeployTarget(scope);
+applyTreeseedEnvironmentToProcess({ tenantRoot, scope, override: true });
+assertTreeseedCommandEnvironment({ tenantRoot, scope, purpose: 'destroy' });
+const deployConfig = validateDestroyPrerequisites(tenantRoot, { requireRemote: !options.dryRun });
+const state = loadDeployState(tenantRoot, deployConfig, { target });
+const expectedConfirmation = getExpectedConfirmation(deployConfig);
+if (!options.skipConfirmation) {
+    printDangerMessage(deployConfig, state, expectedConfirmation);
+    const confirmed = options.confirm !== null ? options.confirm === expectedConfirmation : await readConfirmation(expectedConfirmation);
+    if (!confirmed) {
+        console.error('Destroy aborted: confirmation text did not match.');
+        process.exit(1);
+    }
+}
+const result = destroyCloudflareResources(tenantRoot, {
+    dryRun: options.dryRun,
+    force: options.force,
+    target,
+});
+printDestroySummary(result);
+if (options.dryRun) {
+    console.log('Dry run: no remote resources were deleted.');
+    process.exit(0);
+}
+cleanupDestroyedState(tenantRoot, { target, removeBuildArtifacts: options.removeBuildArtifacts });
+console.log('Treeseed destroy completed and local deployment state was removed.');

package/dist/scripts/tenant-dev.js

@@ -0,0 +1,171 @@
+import { spawnSync } from 'node:child_process';
+import { corePackageRoot, packageScriptPath, spawnNodeBinary, resolveWranglerBin } from '../operations/services/runtime-tools.js';
+import { applyTreeseedEnvironmentToProcess, assertTreeseedCommandEnvironment } from '../operations/services/config-runtime.js';
+import { ensureGeneratedWranglerConfig } from '../operations/services/deploy.js';
+import { loadTreeseedDeployConfig } from '../platform/deploy/config.js';
+import { createTenantWatchEntries, isEditablePackageWorkspace, startPollingWatch, stopManagedProcess, writeDevReloadStamp, workspaceSdkRoot, } from '../operations/services/watch-dev.js';
+const tenantRoot = process.cwd();
+const cliArgs = process.argv.slice(2);
+const watchMode = cliArgs.includes('--watch');
+const wranglerArgs = cliArgs.filter((arg) => arg !== '--watch');
+let wranglerChild = null;
+let stopWatching = null;
+let isStoppingForRebuild = false;
+let shuttingDown = false;
+function shouldEnsureMailpit() {
+    if (process.env.TREESEED_DEV_FORCE_MAILPIT === '1') {
+        return true;
+    }
+    return loadTreeseedDeployConfig().smtp?.enabled === true;
+}
+function runStep(command, args, { cwd = tenantRoot, env = {}, fatal = true } = {}) {
+    const result = spawnSync(command, args, {
+        stdio: 'inherit',
+        cwd,
+        env: { ...process.env, ...env },
+    });
+    if (result.status !== 0 && fatal) {
+        process.exit(result.status ?? 1);
+    }
+    return result.status === 0;
+}
+function runNodeScript(scriptPath, args = [], options = {}) {
+    return runStep(process.execPath, [scriptPath, ...args], options);
+}
+function runTenantBuildCycle({ includePackageBuild = false, includeSdkBuild = false, fatal = true } = {}) {
+    const envOverrides = ['TREESEED_LOCAL_DEV_MODE=cloudflare'];
+    if (watchMode) {
+        envOverrides.push('TREESEED_PUBLIC_DEV_WATCH_RELOAD=true');
+    }
+    if (includeSdkBuild && isEditablePackageWorkspace()) {
+        const sdkRoot = workspaceSdkRoot();
+        if (sdkRoot) {
+            const sdkBuilt = runStep('npm', ['run', 'build:dist'], {
+                cwd: sdkRoot,
+                fatal,
+            });
+            if (!sdkBuilt) {
+                return false;
+            }
+        }
+    }
+    if (includePackageBuild && isEditablePackageWorkspace()) {
+        const distBuilt = runStep('npm', ['run', 'build:dist'], {
+            cwd: corePackageRoot,
+            fatal,
+        });
+        if (!distBuilt) {
+            return false;
+        }
+    }
+    const buildScripts = [
+        ['patch-starlight-content-path', []],
+        ['aggregate-book', []],
+        ['sync-dev-vars', envOverrides],
+        ['tenant-d1-migrate-local', []],
+    ];
+    if (shouldEnsureMailpit()) {
+        buildScripts.splice(2, 0, ['ensure-mailpit', []]);
+    }
+    for (const [scriptName, args] of buildScripts) {
+        const ok = runNodeScript(packageScriptPath(scriptName), args, { fatal });
+        if (!ok) {
+            return false;
+        }
+    }
+    ensureGeneratedWranglerConfig(tenantRoot);
+    if (watchMode) {
+        writeDevReloadStamp(tenantRoot);
+    }
+    const built = runNodeScript(packageScriptPath('tenant-build'), [], {
+        fatal,
+        env: watchMode ? { TREESEED_PUBLIC_DEV_WATCH_RELOAD: 'true' } : {},
+    });
+    if (!built) {
+        return false;
+    }
+    return true;
+}
+function startWrangler() {
+    const { wranglerPath } = ensureGeneratedWranglerConfig(tenantRoot);
+    const child = spawnNodeBinary(resolveWranglerBin(), ['dev', '--local', '--config', wranglerPath, ...wranglerArgs], {
+        cwd: tenantRoot,
+        env: watchMode ? { TREESEED_PUBLIC_DEV_WATCH_RELOAD: 'true' } : {},
+        detached: process.platform !== 'win32',
+    });
+    wranglerChild = child;
+    child.on('exit', (code, signal) => {
+        if (child !== wranglerChild) {
+            return;
+        }
+        wranglerChild = null;
+        if (isStoppingForRebuild || shuttingDown) {
+            return;
+        }
+        if (stopWatching) {
+            stopWatching();
+        }
+        if (signal) {
+            process.kill(process.pid, signal);
+            return;
+        }
+        process.exit(code ?? 0);
+    });
+}
+async function restartWranglerAfterBuild() {
+    if (wranglerChild) {
+        isStoppingForRebuild = true;
+        await stopManagedProcess(wranglerChild);
+        isStoppingForRebuild = false;
+    }
+    if (!shuttingDown) {
+        startWrangler();
+    }
+}
+async function shutdownAndExit(code = 0) {
+    shuttingDown = true;
+    if (stopWatching) {
+        stopWatching();
+    }
+    await stopManagedProcess(wranglerChild);
+    process.exit(code);
+}
+process.on('SIGINT', () => {
+    void shutdownAndExit(130);
+});
+process.on('SIGTERM', () => {
+    void shutdownAndExit(143);
+});
+process.env.TREESEED_LOCAL_DEV_MODE = process.env.TREESEED_LOCAL_DEV_MODE ?? 'cloudflare';
+applyTreeseedEnvironmentToProcess({ tenantRoot, scope: 'local', override: true });
+assertTreeseedCommandEnvironment({ tenantRoot, scope: 'local', purpose: 'dev' });
+runTenantBuildCycle({
+    includeSdkBuild: isEditablePackageWorkspace(),
+    includePackageBuild: isEditablePackageWorkspace(),
+    fatal: true,
+});
+startWrangler();
+if (watchMode) {
+    console.log('Starting unified Wrangler watch mode. Changes will rebuild the app and refresh the browser.');
+    stopWatching = startPollingWatch({
+        watchEntries: createTenantWatchEntries(tenantRoot),
+        onChange: async ({ changedPaths, packageChanged, sdkChanged }) => {
+            console.log(`Detected ${changedPaths.length} change${changedPaths.length === 1 ? '' : 's'}; rebuilding ${sdkChanged ? 'sdk, core, and tenant' : packageChanged ? 'core and tenant' : 'tenant'} output...`);
+            isStoppingForRebuild = true;
+            await stopManagedProcess(wranglerChild);
+            isStoppingForRebuild = false;
+            const ok = runTenantBuildCycle({
+                includeSdkBuild: sdkChanged,
+                includePackageBuild: packageChanged || sdkChanged,
+                fatal: false,
+            });
+            if (ok) {
+                startWrangler();
+                console.log('Rebuild complete. Wrangler restarted with the updated output.');
+            }
+            else {
+                console.error('Rebuild failed. Wrangler remains stopped until the next successful save.');
+            }
+        },
+    });
+}

package/dist/scripts/tenant-lint.js

@@ -0,0 +1,4 @@
+import { packageScriptPath, runNodeScript } from '../operations/services/runtime-tools.js';
+runNodeScript(packageScriptPath('cleanup-markdown'), ['--check'], {
+    cwd: process.cwd(),
+});

package/dist/scripts/tenant-test.js

@@ -0,0 +1,4 @@
+import { packageScriptPath, runNodeScript } from '../operations/services/runtime-tools.js';
+runNodeScript(packageScriptPath('tenant-check'), [], {
+    cwd: process.cwd(),
+});