@treeseed/cli 0.1.1 → 0.4.2

package/dist/scripts/build-dist.js

@@ -1,108 +0,0 @@
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, chmodSync } from 'node:fs';
-import { 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 COPY_EXTENSIONS = new Set(['.d.js', '.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;
-}
-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 transpileScript(filePath) {
-    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 configPath = ts.findConfigFile(packageRoot, ts.sys.fileExists, 'tsconfig.json');
-    if (!configPath)
-        throw new Error('Unable to locate tsconfig.json for declaration build.');
-    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, packageRoot);
-    const program = ts.createProgram({
-        rootNames: parsed.fileNames,
-        options: { ...parsed.options, declaration: true, emitDeclarationOnly: true, declarationDir: distRoot, 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)) {
-    const extension = extname(filePath);
-    if (extension === '.ts')
-        await compileModule(filePath, srcRoot, distRoot);
-    else if (COPY_EXTENSIONS.has(extension))
-        copyAsset(filePath, srcRoot, distRoot);
-}
-for (const filePath of walkFiles(scriptsRoot)) {
-    const extension = extname(filePath);
-    if (extension === '.ts' || extension === '.ts')
-        transpileScript(filePath);
-}
-emitDeclarations();
-if (existsSync(resolve(packageRoot, 'README.md'))) {
-    copyFileSync(resolve(packageRoot, 'README.md'), resolve(distRoot, '..', 'README.md'));
-}

package/dist/scripts/build-tenant-worker.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/scripts/build-tenant-worker.js

@@ -1,36 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { build } from 'esbuild';
-import { loadTreeseedDeployConfig } from '@treeseed/core/deploy/config';
-import { loadTreeseedManifest } from '@treeseed/core/tenant-config';
-import { parseSiteConfig } from '@treeseed/core/utils/site-config-schema';
-import { corePackageRoot } from './package-tools.js';
-const tenantRoot = process.cwd();
-const workerEntry = resolve(corePackageRoot, 'dist/worker/forms-worker.js');
-const outFile = resolve(tenantRoot, '.treeseed/generated/worker/index.js');
-function ensureDir(filePath) {
-    mkdirSync(dirname(filePath), { recursive: true });
-}
-function loadSiteConfig(tenantConfig) {
-    const siteConfigPath = resolve(tenantRoot, tenantConfig.siteConfigPath);
-    return parseSiteConfig(readFileSync(siteConfigPath, 'utf8'));
-}
-const tenantConfig = loadTreeseedManifest();
-const siteConfig = loadSiteConfig(tenantConfig);
-const deployConfig = loadTreeseedDeployConfig();
-ensureDir(outFile);
-await build({
-    entryPoints: [workerEntry],
-    outfile: outFile,
-    bundle: true,
-    format: 'esm',
-    platform: 'browser',
-    target: 'es2022',
-    logLevel: 'silent',
-    external: ['cloudflare:sockets'],
-    define: {
-        __TREESEED_SITE_CONFIG__: JSON.stringify(siteConfig),
-        __TREESEED_DEPLOY_CONFIG__: JSON.stringify(deployConfig),
-    },
-});
-writeFileSync(resolve(tenantRoot, '.treeseed/generated/worker/package.json'), '{\n  "type": "module"\n}\n', 'utf8');

package/dist/scripts/cleanup-markdown.d.ts

@@ -1,2 +0,0 @@
-export declare function normalizeMarkdown(source: any, options?: {}): Promise<string>;
-export declare function collectMarkdownTargets(inputPaths: any, cwd?: string): Promise<any[]>;

package/dist/scripts/cleanup-markdown.js

@@ -1,373 +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: node scripts/cleanup-markdown.mjs [--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) {
-        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/config-runtime-lib.d.ts

@@ -1,122 +0,0 @@
-export declare function getTreeseedMachineConfigPaths(tenantRoot: any): {
-    configPath: string;
-    keyPath: string;
-};
-export declare function createDefaultTreeseedMachineConfig({ tenantRoot, deployConfig, tenantConfig }: {
-    tenantRoot: any;
-    deployConfig: any;
-    tenantConfig: any;
-}): {
-    version: number;
-    project: {
-        tenantRoot: any;
-        tenantId: any;
-        slug: any;
-        name: any;
-        siteUrl: any;
-        overlayPath: string;
-    };
-    settings: {
-        sync: {
-            github: boolean;
-            cloudflare: boolean;
-        };
-    };
-    environments: {
-        [k: string]: {
-            values: {};
-            secrets: {};
-        };
-    };
-};
-export declare function loadTreeseedMachineConfig(tenantRoot: any): any;
-export declare function writeTreeseedMachineConfig(tenantRoot: any, config: any): void;
-export declare function ensureTreeseedGitignoreEntries(tenantRoot: any): string;
-export declare function resolveTreeseedMachineEnvironmentValues(tenantRoot: any, scope: any): any;
-export declare function setTreeseedMachineEnvironmentValue(tenantRoot: any, scope: any, entry: any, value: any): any;
-export declare function collectTreeseedEnvironmentContext(tenantRoot: any): import("@treeseed/core/environment").TreeseedResolvedEnvironmentRegistry;
-export declare function collectTreeseedConfigSeedValues(tenantRoot: any, scope: any): any;
-export declare function applyTreeseedEnvironmentToProcess({ tenantRoot, scope }: {
-    tenantRoot: any;
-    scope: any;
-}): any;
-export declare function validateTreeseedCommandEnvironment({ tenantRoot, scope, purpose }: {
-    tenantRoot: any;
-    scope: any;
-    purpose: any;
-}): {
-    registry: import("@treeseed/core/environment").TreeseedResolvedEnvironmentRegistry;
-    values: any;
-    validation: import("@treeseed/core/environment").TreeseedEnvironmentValidationResult;
-};
-export declare function assertTreeseedCommandEnvironment({ tenantRoot, scope, purpose }: {
-    tenantRoot: any;
-    scope: any;
-    purpose: any;
-}): {
-    registry: import("@treeseed/core/environment").TreeseedResolvedEnvironmentRegistry;
-    values: any;
-    validation: import("@treeseed/core/environment").TreeseedEnvironmentValidationResult;
-};
-export declare function writeTreeseedLocalEnvironmentFiles(tenantRoot: any): {
-    envLocalPath: string;
-    devVarsPath: string;
-};
-export declare function syncTreeseedGitHubEnvironment({ tenantRoot, scope, dryRun }?: {
-    scope?: string | undefined;
-    dryRun?: boolean | undefined;
-}): {
-    secrets: never[];
-    variables: never[];
-    repository: string;
-    scope: string;
-};
-export declare function syncTreeseedCloudflareEnvironment({ tenantRoot, scope, dryRun }?: {
-    scope?: string | undefined;
-    dryRun?: boolean | undefined;
-}): {
-    scope: string;
-    target: {
-        kind: string;
-        scope: string;
-    };
-    wranglerPath: string;
-    secrets: string[];
-    varsManagedByWranglerConfig: string[];
-};
-export declare function initializeTreeseedPersistentEnvironment({ tenantRoot, scope, dryRun }?: {
-    scope?: string | undefined;
-    dryRun?: boolean | undefined;
-}): {
-    scope: string;
-    target: {
-        kind: string;
-        scope: string;
-    };
-    summary: {
-        target: any;
-        workerName: any;
-        siteUrl: any;
-        accountId: any;
-        formGuardKv: any;
-        sessionKv: any;
-        siteDataDb: any;
-    };
-    secrets: string[];
-};
-export declare function runTreeseedConfigWizard({ tenantRoot, scopes, sync, prompt, authStatus, write, }: {
-    tenantRoot: any;
-    scopes?: string[] | undefined;
-    sync?: string | undefined;
-    prompt: any;
-    authStatus: any;
-    write?: {
-        (...data: any[]): void;
-        (message?: any, ...optionalParams: any[]): void;
-    } | undefined;
-}): Promise<{
-    scopes: string[];
-    updated: never[];
-    synced: {};
-    initialized: never[];
-}>;