@treeseed/sdk 0.4.9 → 0.4.11

package/dist/platform/utils/site-config-schema.js

@@ -166,6 +166,108 @@ function parseTheme(value, path) {
 	};
 }
 
+function parseAccessRoles(value, path) {
+	const record = optionalRecord(value, path);
+	if (!record) {
+		return {};
+	}
+
+	return Object.fromEntries(
+		Object.entries(record).map(([roleId, rawRole]) => {
+			const parsedRole = expectRecord(rawRole, `${path}.${roleId}`);
+			return [
+				roleId,
+				{
+					grants: stringArray(parsedRole.grants, `${path}.${roleId}.grants`),
+				},
+			];
+		}),
+	);
+}
+
+function parseAccessPolicies(value, path) {
+	const record = optionalRecord(value, path);
+	if (!record) {
+		return {};
+	}
+
+	return Object.fromEntries(
+		Object.entries(record).map(([policyId, rawPolicy]) => {
+			const parsedPolicy = expectRecord(rawPolicy, `${path}.${policyId}`);
+			return [
+				policyId,
+				{
+					audience: optionalString(parsedPolicy.audience, `${path}.${policyId}.audience`),
+					entitlement: optionalString(parsedPolicy.entitlement, `${path}.${policyId}.entitlement`),
+					offer: optionalString(parsedPolicy.offer, `${path}.${policyId}.offer`),
+					visibility: optionalString(parsedPolicy.visibility, `${path}.${policyId}.visibility`),
+				},
+			];
+		}),
+	);
+}
+
+function parseAccessDefaults(value, path) {
+	const record = optionalRecord(value, path);
+	if (!record) {
+		return { models: {} };
+	}
+
+	const models = optionalRecord(record.models, `${path}.models`) ?? {};
+	return {
+		models: Object.fromEntries(
+			Object.entries(models).map(([modelId, rawSurfaces]) => {
+				const parsedSurfaces = expectRecord(rawSurfaces, `${path}.models.${modelId}`);
+				return [
+					modelId,
+					Object.fromEntries(
+						Object.entries(parsedSurfaces).map(([surfaceId, rawPolicy]) => [
+							surfaceId,
+							expectString(rawPolicy, `${path}.models.${modelId}.${surfaceId}`),
+						]),
+					),
+				];
+			}),
+		),
+	};
+}
+
+function parseAccessBootstrap(value, path) {
+	const record = optionalRecord(value, path);
+	if (!record) {
+		return {};
+	}
+
+	const owners = optionalRecord(record.owners, `${path}.owners`);
+	return {
+		owners: owners
+			? {
+				emails: stringArray(owners.emails, `${path}.owners.emails`),
+				roles: stringArray(owners.roles, `${path}.owners.roles`),
+			}
+			: undefined,
+	};
+}
+
+function parseAccess(value, path) {
+	const record = optionalRecord(value, path);
+	if (!record) {
+		return {
+			roles: {},
+			policies: {},
+			defaults: { models: {} },
+			bootstrap: {},
+		};
+	}
+
+	return {
+		roles: parseAccessRoles(record.roles, `${path}.roles`),
+		policies: parseAccessPolicies(record.policies, `${path}.policies`),
+		defaults: parseAccessDefaults(record.defaults, `${path}.defaults`),
+		bootstrap: parseAccessBootstrap(record.bootstrap, `${path}.bootstrap`),
+	};
+}
+
 /** @type {TreeseedFieldAliasRegistry} */
 const siteFieldAliases = {
 	siteUrl: { key: 'siteUrl', aliases: ['site_url'] },
@@ -228,6 +330,7 @@ export function parseSiteConfig(source) {
 		emailNotificationFieldAliases,
 		expectRecord(site.emailNotifications, 'site.emailNotifications'),
 	);
+	const access = parseAccess(parsed.access, 'access');
 
 	return {
 		site: {
@@ -317,5 +420,6 @@ export function parseSiteConfig(source) {
 				},
 			},
 		},
+		access,
 	};
 }

package/dist/plugin-default.d.ts

@@ -14,6 +14,8 @@ declare const _default: {
         };
         deploy: string[];
         content: {
+            runtime: string[];
+            publish: string[];
             docs: string[];
         };
         site: string[];

package/dist/plugin-default.js

@@ -24,6 +24,8 @@ var plugin_default_default = defineTreeseedPlugin({
     },
     deploy: ["cloudflare"],
     content: {
+      runtime: ["filesystem", "team_scoped_r2_overlay"],
+      publish: ["filesystem", "team_scoped_r2_overlay"],
       docs: ["default"]
     },
     site: ["default"]

package/dist/scripts/check-build-warnings.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+const args = process.argv.slice(2);
+const allowlisted = [];
+const files = [];
+
+for (let index = 0; index < args.length; index += 1) {
+	const arg = args[index];
+	if (arg === '--allow') {
+		const pattern = args[index + 1];
+		if (!pattern) {
+			throw new Error('Missing value for --allow.');
+		}
+		allowlisted.push(new RegExp(pattern));
+		index += 1;
+		continue;
+	}
+	files.push(arg);
+}
+
+if (files.length === 0) {
+	throw new Error('Usage: node check-build-warnings.mjs <log-file> [<log-file> ...] [--allow <regex>]');
+}
+
+const warningLines = [];
+for (const file of files) {
+	const contents = readFileSync(resolve(process.cwd(), file), 'utf8');
+	for (const line of contents.split(/\r?\n/u)) {
+		if (!line.includes('[WARN]')) {
+			continue;
+		}
+		if (allowlisted.some((pattern) => pattern.test(line))) {
+			continue;
+		}
+		warningLines.push(line);
+	}
+}
+
+if (warningLines.length > 0) {
+	console.error('Unexpected build warnings detected:');
+	for (const line of warningLines) {
+		console.error(`- ${line}`);
+	}
+	process.exit(1);
+}
+
+console.log('No unexpected build warnings detected.');

package/dist/scripts/config-treeseed.js

@@ -74,6 +74,13 @@ try {
         console.log(`Machine key: ${keyPath}`);
         console.log(`Updated values: ${applyResult.updated.length}`);
         console.log(`Initialized environments: ${result.initialized.length}`);
+        for (const scope of scopes) {
+            const readiness = result.readinessByScope?.[scope];
+            if (!readiness)
+                continue;
+            const status = readiness.deployable ? 'deployable' : readiness.provisioned ? 'provisioned' : readiness.configured ? 'configured' : 'pending';
+            console.log(`Readiness (${scope}): ${status}`);
+        }
         if (result.synced.github) {
             console.log(`GitHub sync: ${result.synced.github.secrets.length} secrets, ${result.synced.github.variables.length} variables (${result.synced.github.repository})`);
         }

package/dist/scripts/tenant-workflow-action.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { resolveScope, runProjectPlatformAction, } from '../operations/services/project-platform.js';
+const tenantRoot = process.cwd();
+function parseArgs(argv) {
+    const parsed = {
+        action: 'deploy_code',
+        environment: null,
+        projectId: null,
+        previewId: null,
+        dryRun: false,
+    };
+    const rest = [...argv];
+    while (rest.length) {
+        const current = rest.shift();
+        if (!current)
+            continue;
+        if (current === '--action') {
+            parsed.action = (rest.shift() ?? parsed.action);
+            continue;
+        }
+        if (current.startsWith('--action=')) {
+            parsed.action = (current.split('=', 2)[1] ?? parsed.action);
+            continue;
+        }
+        if (current === '--environment') {
+            parsed.environment = rest.shift() ?? null;
+            continue;
+        }
+        if (current.startsWith('--environment=')) {
+            parsed.environment = current.split('=', 2)[1] ?? null;
+            continue;
+        }
+        if (current === '--project-id') {
+            parsed.projectId = rest.shift() ?? null;
+            continue;
+        }
+        if (current.startsWith('--project-id=')) {
+            parsed.projectId = current.split('=', 2)[1] ?? null;
+            continue;
+        }
+        if (current === '--preview-id') {
+            parsed.previewId = rest.shift() ?? null;
+            continue;
+        }
+        if (current.startsWith('--preview-id=')) {
+            parsed.previewId = current.split('=', 2)[1] ?? null;
+            continue;
+        }
+        if (current === '--dry-run') {
+            parsed.dryRun = true;
+            continue;
+        }
+        throw new Error(`Unknown workflow action argument: ${current}`);
+    }
+    return parsed;
+}
+async function main() {
+    const options = parseArgs(process.argv.slice(2));
+    const scope = resolveScope(options.environment);
+    const result = await runProjectPlatformAction(options.action, {
+        tenantRoot,
+        scope,
+        projectId: options.projectId ?? process.env.TREESEED_PROJECT_ID ?? null,
+        previewId: options.previewId,
+        dryRun: options.dryRun,
+    });
+    if (result !== undefined) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    }
+}
+await main();

package/dist/scripts/workspace-command-e2e.js

@@ -549,7 +549,6 @@ async function runLocalSuite() {
         try {
             return runCommand('save-no-changes', process.execPath, [packageScriptPath('treeseed'), 'save', 'test: no-op save'], {
                 cwd: clonedWorkspace.workingRoot,
-                allowedExitCodes: [1],
                 env: cacheEnv(),
             });
         }
@@ -643,7 +642,6 @@ async function runStagingSuite() {
             return runCommand('staging-save-no-op', 'npm', ['run', 'save', '--', 'test: staging no-op save'], {
                 cwd: staging.workingRoot,
                 env: cacheEnv(createWranglerCommandEnv()),
-                allowedExitCodes: [1],
                 timeoutMs: 180000,
             });
         });

package/dist/scripts/workspace-save.js

@@ -1,11 +1,8 @@
 #!/usr/bin/env node
-import { writeFileSync, mkdirSync } from 'node:fs';
+import { mkdirSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
-import { applyTreeseedEnvironmentToProcess } from '../operations/services/config-runtime.js';
-import { collectMergeConflictReport, currentBranch, formatMergeConflictReport, hasMeaningfulChanges, originRemoteUrl, repoRoot, } from '../operations/services/workspace-save.js';
-import { remoteBranchExists, STAGING_BRANCH, PRODUCTION_BRANCH } from '../operations/services/git-workflow.js';
-import { run, workspaceRoot } from '../operations/services/workspace-tools.js';
-import { runWorkspaceSavePreflight } from '../operations/services/save-deploy-preflight.js';
+import { TreeseedWorkflowError, TreeseedWorkflowSdk } from '../workflow.js';
+import { formatWorkspaceSaveFailureReport, formatWorkspaceSaveSuccessReport, parseWorkspaceSaveScriptArgs, } from '../operations/services/workspace-save-script.js';
 function writeSaveReport(payload) {
     const target = process.env.TREESEED_SAVE_REPORT_PATH;
     if (!target) {
@@ -15,110 +12,53 @@ function writeSaveReport(payload) {
     mkdirSync(dirname(filePath), { recursive: true });
     writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
 }
-function parseArgs(argv) {
-    const parsed = {
-        hotfix: false,
-        messageParts: [],
-    };
-    for (const current of argv) {
-        if (current === '--hotfix') {
-            parsed.hotfix = true;
-            continue;
-        }
-        parsed.messageParts.push(current);
-    }
-    return {
-        hotfix: parsed.hotfix,
-        message: parsed.messageParts.join(' ').trim(),
-    };
-}
-const options = parseArgs(process.argv.slice(2));
-const message = options.message;
-const root = workspaceRoot();
-const gitRoot = repoRoot(root);
-const branch = currentBranch(gitRoot);
-const scope = branch === STAGING_BRANCH ? 'staging' : branch === PRODUCTION_BRANCH ? 'prod' : 'local';
-applyTreeseedEnvironmentToProcess({ tenantRoot: root, scope, override: true });
-if (!message) {
-    writeSaveReport({ ok: false, kind: 'usage', message: 'Treeseed save requires a commit message.' });
-    console.error('Treeseed save requires a commit message. Usage: treeseed save <message>');
-    process.exit(1);
-}
-if (!branch) {
-    writeSaveReport({ ok: false, kind: 'missing_branch', message: 'Treeseed save requires an active git branch.' });
-    console.error('Treeseed save requires an active git branch.');
-    process.exit(1);
-}
-if (branch === PRODUCTION_BRANCH && !options.hotfix) {
-    writeSaveReport({
-        ok: false,
-        kind: 'protected_branch',
-        branch,
-        message: 'Treeseed save is blocked on main. Use `treeseed release` for normal production promotion or `treeseed save --hotfix` for an explicit hotfix.',
-    });
-    console.error('Treeseed save is blocked on main. Use `treeseed release` for normal production promotion or `treeseed save --hotfix` for an explicit hotfix.');
-    process.exit(1);
-}
-try {
-    originRemoteUrl(gitRoot);
-}
-catch {
-    writeSaveReport({ ok: false, kind: 'missing_origin', message: 'Treeseed save requires an origin remote.' });
-    console.error('Treeseed save requires an origin remote.');
-    process.exit(1);
-}
-try {
-    runWorkspaceSavePreflight({ cwd: root });
-}
-catch (error) {
-    const kind = error?.kind ?? 'preflight_failed';
-    writeSaveReport({
-        ok: false,
-        kind,
-        message: error instanceof Error ? error.message : String(error),
-    });
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exit(error?.exitCode ?? 1);
-}
-if (!hasMeaningfulChanges(gitRoot)) {
-    writeSaveReport({ ok: false, kind: 'no_changes', message: 'Treeseed save found no meaningful repository changes to commit.' });
-    console.error('Treeseed save found no meaningful repository changes to commit.');
-    process.exit(1);
-}
-run('git', ['add', '-A'], { cwd: gitRoot });
-run('git', ['commit', '-m', message], { cwd: gitRoot });
-try {
-    if (remoteBranchExists(gitRoot, branch)) {
-        run('git', ['pull', '--rebase', 'origin', branch], { cwd: gitRoot });
-        run('git', ['push', 'origin', branch], { cwd: gitRoot });
+function printSaveSummary(payload) {
+    const commitSha = typeof payload.commitSha === 'string' ? payload.commitSha : '';
+    const previewStatus = typeof payload.previewAction?.status === 'string'
+        ? String(payload.previewAction.status)
+        : 'skipped';
+    if (payload.noChanges === true) {
+        console.log('Treeseed save found no new changes and confirmed branch sync.');
     }
     else {
-        run('git', ['push', '-u', 'origin', branch], { cwd: gitRoot });
+        console.log('Treeseed save completed successfully.');
+    }
+    if (typeof payload.branch === 'string') {
+        console.log(`Branch: ${payload.branch}`);
+    }
+    if (typeof payload.scope === 'string') {
+        console.log(`Environment scope: ${payload.scope}`);
     }
+    if (commitSha) {
+        console.log(`Commit: ${commitSha.slice(0, 12)}`);
+    }
+    console.log(`Preview action: ${previewStatus}`);
 }
-catch (error) {
-    const report = collectMergeConflictReport(gitRoot);
-    writeSaveReport({
-        ok: false,
-        kind: 'merge_conflict',
-        branch,
-        report,
-        formatted: formatMergeConflictReport(report, gitRoot, branch),
+async function main() {
+    const options = parseWorkspaceSaveScriptArgs(process.argv.slice(2));
+    const workflow = new TreeseedWorkflowSdk({
+        cwd: process.cwd(),
+        env: process.env,
     });
-    console.error(formatMergeConflictReport(report, gitRoot, branch));
-    process.exit(12);
+    try {
+        const result = await workflow.save({
+            message: options.message,
+            hotfix: options.hotfix,
+        });
+        const payload = result.payload;
+        writeSaveReport(formatWorkspaceSaveSuccessReport(result));
+        printSaveSummary(payload);
+    }
+    catch (error) {
+        if (error instanceof TreeseedWorkflowError) {
+            writeSaveReport(formatWorkspaceSaveFailureReport(error));
+            console.error(error.message);
+            process.exit(error.exitCode ?? 1);
+        }
+        const report = formatWorkspaceSaveFailureReport(error);
+        console.error(report.message);
+        writeSaveReport(report);
+        process.exit(1);
+    }
 }
-const summary = {
-    ok: true,
-    kind: 'success',
-    message,
-    branch,
-    scope,
-    hotfix: options.hotfix,
-    root,
-    repositoryRoot: gitRoot,
-};
-writeSaveReport(summary);
-console.log('Treeseed save completed successfully.');
-console.log(`Branch: ${branch}`);
-console.log(`Environment scope: ${scope}`);
+await main();