@treeseed/sdk 0.13.0-rc.2 → 0.13.0-rc.21

package/dist/scripts/maintenance/cleanup-markdown.js

@@ -1,377 +0,0 @@
-import fsSync from 'node:fs';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import process from 'node:process';
-import { fileURLToPath } from 'node:url';
-import { unified } from 'unified';
-import remarkFrontmatter from 'remark-frontmatter';
-import remarkGfm from 'remark-gfm';
-import remarkMath from 'remark-math';
-import remarkMdx from 'remark-mdx';
-import remarkParse from 'remark-parse';
-import remarkStringify from 'remark-stringify';
-const __filename = fileURLToPath(import.meta.url);
-const DEFAULT_TARGETS = ['src/content/knowledge', 'src/content/pages', 'src/content/notes'];
-const MARKDOWN_EXTENSIONS = new Set(['.md', '.mdx']);
-export async function normalizeMarkdown(source, options = {}) {
-    const normalizedSource = source.replace(/\r\n?/g, '\n');
-    const { frontmatter, body } = splitFrontmatter(normalizedSource);
-    const preprocessed = preprocessMarkdownBody(body);
-    const isMdxFile = (options.filePath ?? '').toLowerCase().endsWith('.mdx');
-    const processor = unified().use(remarkParse).use(remarkFrontmatter, ['yaml']).use(remarkGfm).use(remarkMath);
-    if (isMdxFile) {
-        processor.use(remarkMdx);
-    }
-    processor.use(remarkStringify, {
-        bullet: '-',
-        closeAtx: false,
-        fences: true,
-        incrementListMarker: true,
-        listItemIndent: 'one',
-        resourceLink: true,
-        rule: '*',
-        ruleRepetition: 3,
-        ruleSpaces: false,
-        setext: false,
-        tightDefinitions: true,
-    });
-    const rendered = postprocessMarkdown(String(await processor.process({ path: options.filePath ?? 'document.md', value: preprocessed }))).trimEnd();
-    const segments = [];
-    if (frontmatter) {
-        segments.push(frontmatter.trimEnd());
-    }
-    if (rendered) {
-        segments.push(rendered);
-    }
-    return `${segments.join('\n\n')}\n`;
-}
-export async function collectMarkdownTargets(inputPaths, cwd = process.cwd()) {
-    const requested = inputPaths.length > 0 ? inputPaths : DEFAULT_TARGETS;
-    const resolved = requested.map((target) => resolveTargetPath(target, cwd));
-    const files = [];
-    for (const target of resolved) {
-        const stats = await safeStat(target);
-        if (!stats) {
-            continue;
-        }
-        if (stats.isFile()) {
-            if (isMarkdownFile(target)) {
-                files.push(target);
-            }
-            continue;
-        }
-        files.push(...(await collectMarkdownFiles(target)));
-    }
-    return [...new Set(files)].sort((left, right) => left.localeCompare(right, undefined, { numeric: true, sensitivity: 'base' }));
-}
-async function collectMarkdownFiles(rootPath) {
-    const entries = await fs.readdir(rootPath, { withFileTypes: true });
-    const files = [];
-    for (const entry of entries) {
-        const fullPath = path.join(rootPath, entry.name);
-        if (entry.isDirectory()) {
-            files.push(...(await collectMarkdownFiles(fullPath)));
-            continue;
-        }
-        if (entry.isFile() && isMarkdownFile(fullPath)) {
-            files.push(fullPath);
-        }
-    }
-    return files;
-}
-function isMarkdownFile(filePath) {
-    return MARKDOWN_EXTENSIONS.has(path.extname(filePath).toLowerCase());
-}
-async function safeStat(targetPath) {
-    try {
-        return await fs.stat(targetPath);
-    }
-    catch {
-        return null;
-    }
-}
-function resolveTargetPath(target, cwd) {
-    const directPath = path.resolve(cwd, target);
-    if (path.isAbsolute(target)) {
-        return target;
-    }
-    if (fsSyncExists(directPath)) {
-        return directPath;
-    }
-    if (path.basename(cwd) === 'docs' && target.startsWith('docs/')) {
-        return path.resolve(cwd, target.slice('docs/'.length));
-    }
-    return directPath;
-}
-function fsSyncExists(targetPath) {
-    try {
-        return fsSync.existsSync(targetPath);
-    }
-    catch {
-        return false;
-    }
-}
-function splitFrontmatter(source) {
-    if (!source.startsWith('---\n')) {
-        return { frontmatter: '', body: source };
-    }
-    const closingIndex = source.indexOf('\n---\n', 4);
-    if (closingIndex === -1) {
-        return { frontmatter: '', body: source };
-    }
-    const frontmatter = source.slice(0, closingIndex + 5);
-    const body = source.slice(closingIndex + 5);
-    return { frontmatter, body };
-}
-function preprocessMarkdownBody(body) {
-    const lines = body.split('\n');
-    const output = [];
-    let inFence = false;
-    let fenceMarker = '';
-    let fenceLength = 0;
-    let previousNonBlankType = 'start';
-    for (const originalLine of lines) {
-        const line = originalLine.trimEnd();
-        const trimmed = line.trim();
-        if (inFence) {
-            pushLine(output, line);
-            if (isFenceClose(line, fenceMarker, fenceLength)) {
-                inFence = false;
-                previousNonBlankType = 'fence';
-            }
-            continue;
-        }
-        if (trimmed === '') {
-            pushBlankLine(output);
-            continue;
-        }
-        if (isFenceOpen(line)) {
-            if (needsBlankLineBefore(previousNonBlankType)) {
-                pushBlankLine(output);
-            }
-            pushLine(output, line);
-            ({ marker: fenceMarker, length: fenceLength } = getFenceInfo(line));
-            inFence = true;
-            previousNonBlankType = 'fence';
-            continue;
-        }
-        const lineType = classifyLine(line);
-        const previousLine = output.length > 0 ? findPreviousNonBlankLine(output) : '';
-        if (requiresBlankLineBetween(previousNonBlankType, lineType, previousLine, line)) {
-            pushBlankLine(output);
-        }
-        pushLine(output, line);
-        previousNonBlankType = lineType;
-    }
-    return collapseBlankLines(output).join('\n').trim();
-}
-function classifyLine(line) {
-    if (isTableLine(line))
-        return 'table';
-    if (/^\s{0,3}#{1,6}\s+\S/.test(line))
-        return 'heading';
-    if (/^\s{0,3}(?:[-*_])(?:\s*\1){2,}\s*$/.test(line))
-        return 'rule';
-    if (/^\s{0,3}>\s?/.test(line))
-        return 'blockquote';
-    if (/^\s{0,3}(?:[-+*]|\d+[.)])\s+/.test(line))
-        return 'list';
-    if (/^\s*<(?:[A-Za-z][^>]*)>\s*$/.test(line))
-        return 'html';
-    if (/^\s*(?:import|export)\s.+$/.test(line))
-        return 'mdx';
-    if (/^\s*<\/?[A-Z][^>]*>\s*$/.test(line))
-        return 'mdx';
-    return 'prose';
-}
-function isTableLine(line) {
-    const trimmed = line.trim();
-    return /^\|.*\|\s*$/.test(trimmed) || /^[:\-|\s]+$/.test(trimmed);
-}
-function isFenceOpen(line) {
-    return /^\s{0,3}(```+|~~~+)/.test(line);
-}
-function getFenceInfo(line) {
-    const match = line.match(/^\s{0,3}(```+|~~~+)/);
-    return {
-        length: match?.[1]?.length ?? 3,
-        marker: match?.[1]?.[0] ?? '`',
-    };
-}
-function isFenceClose(line, marker, requiredLength) {
-    return new RegExp(`^\\s{0,3}${escapeRegExp(marker)}{${requiredLength},}\\s*$`).test(line);
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function needsBlankLineBefore(previousType) {
-    return !['start', 'blank'].includes(previousType);
-}
-function requiresBlankLineBetween(previousType, currentType, previousLine, currentLine) {
-    if (previousType === 'start')
-        return false;
-    if (previousType === 'table' && currentType === 'table')
-        return false;
-    if (previousType === 'blockquote' && currentType === 'blockquote')
-        return false;
-    if (previousType === 'mdx' && currentType === 'mdx')
-        return false;
-    if (previousType === 'html' && currentType === 'prose' && /^\s*<a\b/i.test(currentLine))
-        return false;
-    if (previousType === 'prose' && currentType === 'prose' && looksLikeParagraphBoundary(previousLine, currentLine))
-        return true;
-    if (currentType === 'heading' || currentType === 'rule' || currentType === 'blockquote')
-        return true;
-    if (previousType === 'heading')
-        return true;
-    if (previousType === 'rule')
-        return true;
-    if (previousType === 'table' && currentType !== 'table')
-        return true;
-    if (previousType === 'list' && currentType === 'prose')
-        return true;
-    if (previousType === 'list' && ['heading', 'rule', 'table', 'html', 'mdx'].includes(currentType))
-        return true;
-    if (previousType === 'prose' && ['list', 'table', 'html', 'mdx'].includes(currentType))
-        return true;
-    if (['html', 'mdx'].includes(previousType) && currentType === 'prose')
-        return true;
-    return false;
-}
-function findPreviousNonBlankLine(lines) {
-    for (let index = lines.length - 1; index >= 0; index -= 1) {
-        if (lines[index].trim() !== '') {
-            return lines[index];
-        }
-    }
-    return '';
-}
-function pushLine(output, line) {
-    output.push(line);
-}
-function pushBlankLine(output) {
-    if (output.length === 0)
-        return;
-    if (output.at(-1) === '')
-        return;
-    output.push('');
-}
-function collapseBlankLines(lines) {
-    const collapsed = [];
-    for (const line of lines) {
-        if (line === '' && collapsed.at(-1) === '') {
-            continue;
-        }
-        collapsed.push(line);
-    }
-    return collapsed;
-}
-function postprocessMarkdown(content) {
-    return content
-        .replace(/\[\\\[(\d+)\\\]\]\(#ref-\1\)/g, '[[$1]](#ref-$1)')
-        .replace(/<a([^>]*?)\s*\/>/g, '<a$1></a>');
-}
-function looksLikeParagraphBoundary(previousLine, currentLine) {
-    const previous = previousLine.trim();
-    const current = currentLine.trim();
-    if (!previous || !current) {
-        return false;
-    }
-    if (/^\*\*\d+\./.test(current) || /^\*[^*]+:\*/.test(current)) {
-        return true;
-    }
-    if (/^\*\*.*\*\*$/.test(previous) && /^\*[^*]+:\*/.test(current)) {
-        return true;
-    }
-    return endsLikeStandaloneParagraph(previous) && startsLikeStandaloneParagraph(current);
-}
-function endsLikeStandaloneParagraph(line) {
-    return /(?:[.!?]["')\]]*|\*{1,2}|\d)\s*$/.test(line);
-}
-function startsLikeStandaloneParagraph(line) {
-    return /^(?:[A-Z0-9]|\*\*|\*[^*]+:\*|\[|["'(])/.test(line);
-}
-function parseArgs(argv) {
-    const args = { check: false, write: false, targets: [] };
-    for (const arg of argv) {
-        if (arg === '--check') {
-            args.check = true;
-            continue;
-        }
-        if (arg === '--write') {
-            args.write = true;
-            continue;
-        }
-        if (arg === '--help' || arg === '-h') {
-            args.help = true;
-            continue;
-        }
-        args.targets.push(arg);
-    }
-    if (!args.check && !args.write) {
-        args.write = true;
-    }
-    return args;
-}
-function printHelp() {
-    console.log(`Usage: tsx scripts/maintenance/cleanup-markdown.ts [--check|--write] [paths...]
-
-Normalizes Markdown/MDX files for public docs readability.
-
-Examples:
-  npm run cleanup:markdown --workspace docs -- src/content/knowledge/research
-  npm run cleanup:markdown:check --workspace docs -- src/content/pages/status.mdx
-`);
-}
-async function runCli(argv = process.argv.slice(2)) {
-    const args = parseArgs(argv);
-    if (args.help) {
-        printHelp();
-        return 0;
-    }
-    if (args.check && args.write) {
-        console.error('Choose either --check or --write, not both.');
-        return 1;
-    }
-    const mode = args.check ? 'check' : 'write';
-    const targets = await collectMarkdownTargets(args.targets);
-    if (targets.length === 0) {
-        if (mode === 'check') {
-            console.log('No Markdown files found for cleanup.');
-            return 0;
-        }
-        console.error('No Markdown files found for cleanup.');
-        return 1;
-    }
-    const changedFiles = [];
-    for (const filePath of targets) {
-        const original = await fs.readFile(filePath, 'utf8');
-        const normalized = await normalizeMarkdown(original, { filePath });
-        if (normalized === original) {
-            continue;
-        }
-        changedFiles.push(filePath);
-        if (mode === 'write') {
-            await fs.writeFile(filePath, normalized, 'utf8');
-        }
-    }
-    if (mode === 'check') {
-        if (changedFiles.length > 0) {
-            console.error('Markdown cleanup needed in:');
-            for (const filePath of changedFiles) {
-                console.error(`- ${path.relative(process.cwd(), filePath)}`);
-            }
-            return 1;
-        }
-        console.log(`Markdown cleanup check passed for ${targets.length} file(s).`);
-        return 0;
-    }
-    console.log(changedFiles.length > 0
-        ? `Normalized ${changedFiles.length} Markdown file(s).`
-        : `No Markdown changes needed across ${targets.length} file(s).`);
-    return 0;
-}
-if (process.argv[1] === __filename) {
-    const exitCode = await runCli();
-    process.exit(exitCode);
-}

package/dist/scripts/maintenance/install-managed-dependencies.js

@@ -1,12 +0,0 @@
-import { formatDependencyFailureDetails, installDependencies } from '../../entrypoints/runtime/managed-dependencies.js';
-const force = process.argv.includes('--force');
-const result = await installDependencies({
-    tenantRoot: process.cwd(),
-    force,
-    env: process.env,
-});
-process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-if (!result.ok) {
-    process.stderr.write(`Treeseed dependency initialization failed:\n- ${formatDependencyFailureDetails(result)}\n`);
-    process.exit(1);
-}

package/dist/scripts/maintenance/prepare.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-import { spawnSync } from 'node:child_process';
-if (process.env.TREESEED_SKIP_PACKAGE_PREPARE === '1') {
-    process.exit(0);
-}
-const result = spawnSync('npm', ['run', 'build:dist'], {
-    stdio: 'inherit',
-    shell: process.platform === 'win32',
-});
-process.exit(result.status ?? 1);

package/dist/scripts/maintenance/repair-extracted-class-interfaces.js

@@ -1,36 +0,0 @@
-import { readFileSync, writeFileSync } from 'node:fs';
-import { basename, dirname, resolve } from 'node:path';
-const genericMethodSignatures = {
-    'AgentSdk.envelope': "envelope<TPayload>(model: string, operation: import('../sdk-types.js').SdkJsonEnvelope<TPayload>['operation'], payload: TPayload, meta?: Record<string, unknown>): import('../sdk-types.js').SdkJsonEnvelope<TPayload>;",
-    'MarketClient.request': "request<T>(path: string, options?: { method?: string; body?: unknown; requireAuth?: boolean; headers?: Record<string, string> }): Promise<T>;",
-    'MarketClient.requestFirst': "requestFirst<T>(paths: string[], options?: { method?: string; body?: unknown; requireAuth?: boolean; headers?: Record<string, string> }): Promise<T>;",
-};
-const extractedClasses = [
-    { entry: 'src/sdk.ts', className: 'AgentSdk' },
-    { entry: 'src/market-client.ts', className: 'MarketClient' },
-];
-for (const { entry, className } of extractedClasses) {
-    const entryPath = resolve(entry);
-    const stem = basename(entryPath, '.ts');
-    const directory = resolve(dirname(entryPath), stem);
-    const methodsSource = readFileSync(resolve(directory, 'methods.ts'), 'utf8');
-    const methods = [...methodsSource.matchAll(/import \{ (\w+Method) \} from '\.\/(.+\.ts)';/gu)]
-        .map((match) => ({ functionName: match[1], file: match[2] }));
-    if (methods.length === 0)
-        throw new Error(`${entry}: no extracted methods found`);
-    const properties = methods.map(({ functionName, file }) => {
-        const methodName = functionName.replace(/Method$/u, '');
-        const genericSignature = genericMethodSignatures[`${className}.${methodName}`];
-        return `\t\t${genericSignature ?? `${methodName}: OmitThisParameter<typeof import('./${file}').${functionName}>;`}`;
-    }).join('\n');
-    const modulePath = `../${basename(entryPath)}`;
-    writeFileSync(resolve(directory, 'interface.ts'), `declare module '${modulePath}' {
-\tinterface ${className} {
-${properties}
-\t}
-}
-
-export {};
-`);
-    console.log(`${entry}: restored inferred types for ${methods.length} extracted methods`);
-}

package/dist/scripts/operations/consolidate-workflow-lifecycle-tests.js

@@ -1,87 +0,0 @@
-import { readFileSync, unlinkSync, writeFileSync } from 'node:fs';
-import { basename, dirname, join } from 'node:path';
-import ts from 'typescript';
-const paths = process.argv.slice(2);
-if (paths.length < 2)
-    throw new Error('Pass the split workflow lifecycle test files to consolidate.');
-function callName(statement) {
-    if (!ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression))
-        return null;
-    const expression = statement.expression.expression;
-    return ts.isIdentifier(expression) ? expression.text : null;
-}
-function describeBody(statement) {
-    if (callName(statement) !== 'describe' || !ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression))
-        return null;
-    const callback = statement.expression.arguments[1];
-    return callback && (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) && ts.isBlock(callback.body)
-        ? callback.body.statements
-        : null;
-}
-function titleOf(statement) {
-    if (!ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression))
-        return '';
-    const title = statement.expression.arguments[0];
-    return title && (ts.isStringLiteral(title) || ts.isNoSubstitutionTemplateLiteral(title)) ? title.text : '';
-}
-function groupFor(title) {
-    if (/release|production image|starter templates|hosted gate/u.test(title))
-        return 'release';
-    if (/recover|resume|failed save|workflow lock|partial recursive|dirty staging work/u.test(title))
-        return 'recovery';
-    if (/switch|worktree|close|detached|package staging history|branch checkout/u.test(title))
-        return 'branch-worktree';
-    return 'save-stage';
-}
-const parsed = paths.map((path) => {
-    const text = readFileSync(path, 'utf8');
-    return { path, source: ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS) };
-});
-const first = parsed[0];
-const firstDescribe = first.source.statements.find((statement) => callName(statement) === 'describe');
-if (!firstDescribe)
-    throw new Error('The first input has no describe suite.');
-const firstBody = describeBody(firstDescribe);
-if (!firstBody)
-    throw new Error('The first describe suite has no block body.');
-const prefix = first.source.statements
-    .filter((statement) => statement !== firstDescribe)
-    .map((statement) => statement.getFullText(first.source).trim())
-    .join('\n');
-const shared = firstBody
-    .filter((statement) => !['it', 'test', 'describe'].includes(callName(statement) ?? ''))
-    .map((statement) => statement.getFullText(first.source).trim())
-    .join('\n\n');
-const grouped = new Map([
-    ['save-stage', []],
-    ['branch-worktree', []],
-    ['recovery', []],
-    ['release', []],
-]);
-for (const { source } of parsed) {
-    const suite = source.statements.find((statement) => callName(statement) === 'describe');
-    const body = suite ? describeBody(suite) : null;
-    if (!body)
-        throw new Error(`${source.fileName}: expected a describe block`);
-    for (const statement of body) {
-        if (!['it', 'test', 'describe'].includes(callName(statement) ?? ''))
-            continue;
-        const title = titleOf(statement);
-        grouped.get(groupFor(title)).push({ source, statement, title });
-    }
-}
-for (const [group, scenarios] of grouped) {
-    const scenarioText = scenarios
-        .sort((left, right) => left.title.localeCompare(right.title))
-        .map(({ source, statement }) => statement.getFullText(source).trim())
-        .join('\n\n');
-    const output = `${prefix}\n\ndescribe('treeseed workflow lifecycle: ${group}', () => {\n${shared}\n\n${scenarioText}\n});\n`;
-    if (output.split('\n').length > 500)
-        throw new Error(`${group} output exceeds 500 lines`);
-    writeFileSync(join(dirname(first.path), `workflow-lifecycle.${group}.test.ts`), output);
-}
-for (const { path } of parsed) {
-    if (/workflow-lifecycle\.(?:branch-worktree|recovery|release|save-stage)\.test\.ts$/u.test(basename(path)))
-        continue;
-    unlinkSync(path);
-}

package/dist/scripts/operations/operations-runner-smoke.js

@@ -1,16 +0,0 @@
-import { runOperationsRunnerSmoke } from '../../operations/services/operations/operations-runner-smoke.js';
-function arg(name) {
-    const index = process.argv.indexOf(name);
-    return index >= 0 ? process.argv[index + 1] : null;
-}
-const environment = (arg('--environment') ?? 'staging') === 'prod' ? 'prod' : 'staging';
-const report = await runOperationsRunnerSmoke({
-    tenantRoot: process.cwd(),
-    environment,
-    baseUrl: arg('--base-url'),
-    timeoutMs: arg('--timeout-ms') ? Number(arg('--timeout-ms')) : undefined,
-});
-console.log(JSON.stringify(report, null, 2));
-if (!report.ok) {
-    process.exitCode = 1;
-}

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

@@ -1,131 +0,0 @@
-#!/usr/bin/env node
-import { pathToFileURL } from 'node:url';
-const tenantRoot = process.cwd();
-function writeStatus(message) {
-    process.stderr.write(`[tenant-workflow-action] ${message}\n`);
-}
-function parseArgs(argv) {
-    const parsed = {
-        action: 'deploy_web',
-        environment: null,
-        projectId: null,
-        previewId: null,
-        planOnly: false,
-    };
-    const rest = [...argv];
-    while (rest.length) {
-        const current = rest.shift();
-        if (!current)
-            continue;
-        if (current === '--action') {
-            parsed.action = parseAction(rest.shift() ?? parsed.action);
-            continue;
-        }
-        if (current.startsWith('--action=')) {
-            parsed.action = parseAction(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 === '--plan') {
-            parsed.planOnly = true;
-            continue;
-        }
-        throw new Error(`Unknown workflow action argument: ${current}`);
-    }
-    return parsed;
-}
-function parseAction(value) {
-    if (value === 'deploy_web' || value === 'publish_content' || value === 'monitor') {
-        return value;
-    }
-    throw new Error(`Unsupported workflow action "${value}". Expected deploy_web, publish_content, or monitor.`);
-}
-async function main() {
-    const options = parseArgs(process.argv.slice(2));
-    process.env.TREESEED_WORKFLOW_ACTION = options.action;
-    process.env.TREESEED_WORKFLOW_PLANE ||= 'web';
-    writeStatus(`start action=${options.action} environment=${options.environment ?? '(auto)'}`);
-    if (options.action === 'publish_content') {
-        const { reconcileContentPublication } = await import('../../platform/published-content/reconcile-content-publication.js');
-        const environment = options.environment ?? 'staging';
-        const validateOnly = options.planOnly;
-        const required = (value, name) => {
-            if (!value?.trim())
-                throw new Error(`${name} is required.`);
-            return value.trim();
-        };
-        const accountId = !validateOnly ? required(process.env.TREESEED_CLOUDFLARE_ACCOUNT_ID, 'TREESEED_CLOUDFLARE_ACCOUNT_ID') : null;
-        const bucket = !validateOnly ? required(process.env.TREESEED_CONTENT_BUCKET_NAME, 'TREESEED_CONTENT_BUCKET_NAME') : null;
-        const r2 = validateOnly ? null
-            : process.env.TREESEED_R2_ACCESS_KEY_ID && process.env.TREESEED_R2_SECRET_ACCESS_KEY
-                ? { accountId: accountId, bucket: bucket, accessKeyId: process.env.TREESEED_R2_ACCESS_KEY_ID, secretAccessKey: process.env.TREESEED_R2_SECRET_ACCESS_KEY }
-                : { authMode: 'api-token', accountId: accountId, bucket: bucket, apiToken: required(process.env.TREESEED_CLOUDFLARE_API_TOKEN, 'TREESEED_CLOUDFLARE_API_TOKEN or R2 access-key pair') };
-        const result = await reconcileContentPublication({
-            projectRoot: tenantRoot,
-            contentPath: process.env.TREESEED_CONTENT_PATH ?? 'src/content',
-            teamId: required(process.env.TREESEED_TEAM_ID, 'TREESEED_TEAM_ID'),
-            projectId: options.projectId ?? required(process.env.TREESEED_PROJECT_ID, 'TREESEED_PROJECT_ID'),
-            sourceCommit: required(process.env.GITHUB_SHA ?? process.env.TREESEED_SOURCE_COMMIT, 'source commit'),
-            ref: required(process.env.GITHUB_REF_NAME ?? process.env.TREESEED_SOURCE_REF, 'source ref'),
-            channel: options.previewId ? 'preview' : environment === 'prod' || environment === 'production' ? 'production' : 'staging',
-            validateOnly,
-            ...(r2 ? { r2 } : {}),
-        });
-        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-        writeStatus('complete.');
-        return;
-    }
-    writeStatus('loading project platform module...');
-    const { resolveScope, runProjectPlatformAction } = await import('../../operations/services/projects/projects-core/project-platform.js');
-    writeStatus('project platform module loaded.');
-    const scope = resolveScope(options.environment);
-    writeStatus(`resolved scope=${scope}; running action...`);
-    const result = await runProjectPlatformAction(options.action, {
-        tenantRoot,
-        scope,
-        projectId: options.projectId ?? process.env.TREESEED_PROJECT_ID ?? null,
-        previewId: options.previewId,
-        planOnly: options.planOnly,
-        write: (line) => writeStatus(line),
-    });
-    if (result !== undefined) {
-        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-    }
-    writeStatus('complete.');
-}
-function isCliEntrypoint() {
-    if (!process.argv[1]) {
-        return false;
-    }
-    if (import.meta.url === pathToFileURL(process.argv[1]).href) {
-        return true;
-    }
-    return /(?:^|\/)tenant-workflow-action\.(?:ts|js)$/u.test(process.argv[1]);
-}
-if (isCliEntrypoint()) {
-    await main();
-}
-export { isCliEntrypoint, parseArgs };