@treeseed/cli 0.1.1 → 0.4.0

package/dist/scripts/ensure-mailpit.d.ts

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

package/dist/scripts/ensure-mailpit.js

@@ -1,29 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { dockerIsAvailable, findRunningMailpitContainer } from './mailpit-runtime.js';
-import { mailpitComposeFile, packageRoot } from './paths.js';
-if (!dockerIsAvailable()) {
-    console.error('Docker is required for Treeseed form email testing. Start Docker and rerun the Mailpit command.');
-    process.exit(1);
-}
-const existingMailpit = findRunningMailpitContainer();
-if (existingMailpit) {
-    console.log(`Reusing existing Mailpit container "${existingMailpit.name}" on ports 1025 and 8025.`);
-    process.exit(0);
-}
-const result = spawnSync('docker', ['compose', '-f', mailpitComposeFile, 'up', '-d', 'mailpit'], {
-    encoding: 'utf8',
-    cwd: packageRoot,
-    env: { ...process.env },
-});
-if (result.status !== 0) {
-    const reusedMailpit = findRunningMailpitContainer();
-    if (reusedMailpit) {
-        console.log(`Reusing existing Mailpit container "${reusedMailpit.name}" on ports 1025 and 8025.`);
-        process.exit(0);
-    }
-    if (result.stdout)
-        process.stdout.write(result.stdout);
-    if (result.stderr)
-        process.stderr.write(result.stderr);
-}
-process.exit(result.status ?? 1);

package/dist/scripts/git-workflow-lib.d.ts

@@ -1,25 +0,0 @@
-export declare const STAGING_BRANCH = "staging";
-export declare const PRODUCTION_BRANCH = "main";
-export declare function gitWorkflowRoot(cwd?: string): string;
-export declare function assertCleanWorktree(cwd?: string): string;
-export declare function branchExists(repoDir: any, branchName: any): boolean;
-export declare function remoteBranchExists(repoDir: any, branchName: any): boolean;
-export declare function fetchOrigin(repoDir: any): void;
-export declare function ensureLocalBranchTracking(repoDir: any, branchName: any): void;
-export declare function checkoutBranch(repoDir: any, branchName: any): void;
-export declare function syncBranchWithOrigin(repoDir: any, branchName: any): void;
-export declare function createFeatureBranchFromStaging(cwd: any, branchName: any): {
-    repoDir: string;
-    baseBranch: string;
-    branchName: any;
-};
-export declare function pushBranch(repoDir: any, branchName: any, { setUpstream }?: {
-    setUpstream?: boolean | undefined;
-}): void;
-export declare function deleteLocalBranch(repoDir: any, branchName: any): void;
-export declare function deleteRemoteBranch(repoDir: any, branchName: any): boolean;
-export declare function mergeCurrentBranchIntoStaging(cwd: any, featureBranch: any): string;
-export declare function currentManagedBranch(cwd?: string): string;
-export declare function assertFeatureBranch(cwd?: string): string;
-export declare function prepareReleaseBranches(cwd?: string): string;
-export declare function mergeStagingIntoMain(cwd?: string): string;

package/dist/scripts/git-workflow-lib.js

@@ -1,136 +0,0 @@
-import { run, workspaceRoot } from './workspace-tools.js';
-import { currentBranch, gitStatusPorcelain, repoRoot } from './workspace-save-lib.js';
-export const STAGING_BRANCH = 'staging';
-export const PRODUCTION_BRANCH = 'main';
-function runGit(args, { cwd, capture = false } = {}) {
-    return run('git', args, { cwd, capture });
-}
-export function gitWorkflowRoot(cwd = workspaceRoot()) {
-    return repoRoot(cwd);
-}
-export function assertCleanWorktree(cwd = workspaceRoot()) {
-    const root = gitWorkflowRoot(cwd);
-    if (gitStatusPorcelain(root).length > 0) {
-        throw new Error('Treeseed requires a clean git worktree before changing branches.');
-    }
-    return root;
-}
-export function branchExists(repoDir, branchName) {
-    try {
-        runGit(['show-ref', '--verify', '--quiet', `refs/heads/${branchName}`], { cwd: repoDir });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function remoteBranchExists(repoDir, branchName) {
-    try {
-        const output = runGit(['ls-remote', '--heads', 'origin', branchName], { cwd: repoDir, capture: true });
-        return output.trim().length > 0;
-    }
-    catch {
-        return false;
-    }
-}
-export function fetchOrigin(repoDir) {
-    runGit(['fetch', 'origin'], { cwd: repoDir });
-}
-export function ensureLocalBranchTracking(repoDir, branchName) {
-    if (branchExists(repoDir, branchName)) {
-        return;
-    }
-    if (remoteBranchExists(repoDir, branchName)) {
-        runGit(['checkout', '-b', branchName, `origin/${branchName}`], { cwd: repoDir });
-        return;
-    }
-    runGit(['checkout', '--orphan', branchName], { cwd: repoDir });
-}
-export function checkoutBranch(repoDir, branchName) {
-    runGit(['checkout', branchName], { cwd: repoDir });
-}
-export function syncBranchWithOrigin(repoDir, branchName) {
-    fetchOrigin(repoDir);
-    if (!branchExists(repoDir, branchName) && remoteBranchExists(repoDir, branchName)) {
-        runGit(['checkout', '-b', branchName, `origin/${branchName}`], { cwd: repoDir });
-    }
-    else {
-        checkoutBranch(repoDir, branchName);
-    }
-    if (remoteBranchExists(repoDir, branchName)) {
-        runGit(['pull', '--rebase', 'origin', branchName], { cwd: repoDir });
-    }
-}
-export function createFeatureBranchFromStaging(cwd, branchName) {
-    const repoDir = assertCleanWorktree(cwd);
-    fetchOrigin(repoDir);
-    if (branchExists(repoDir, branchName) || remoteBranchExists(repoDir, branchName)) {
-        throw new Error(`Branch "${branchName}" already exists locally or on origin.`);
-    }
-    syncBranchWithOrigin(repoDir, STAGING_BRANCH);
-    runGit(['checkout', '-b', branchName], { cwd: repoDir });
-    return {
-        repoDir,
-        baseBranch: STAGING_BRANCH,
-        branchName,
-    };
-}
-export function pushBranch(repoDir, branchName, { setUpstream = false } = {}) {
-    const args = setUpstream ? ['push', '-u', 'origin', branchName] : ['push', 'origin', branchName];
-    runGit(args, { cwd: repoDir });
-}
-export function deleteLocalBranch(repoDir, branchName) {
-    if (!branchExists(repoDir, branchName)) {
-        return;
-    }
-    runGit(['branch', '-D', branchName], { cwd: repoDir });
-}
-export function deleteRemoteBranch(repoDir, branchName) {
-    if (!remoteBranchExists(repoDir, branchName)) {
-        return false;
-    }
-    runGit(['push', 'origin', '--delete', branchName], { cwd: repoDir });
-    return true;
-}
-export function mergeCurrentBranchIntoStaging(cwd, featureBranch) {
-    const repoDir = assertCleanWorktree(cwd);
-    fetchOrigin(repoDir);
-    syncBranchWithOrigin(repoDir, STAGING_BRANCH);
-    runGit(['merge', '--no-ff', featureBranch, '-m', `merge: ${featureBranch} -> ${STAGING_BRANCH}`], { cwd: repoDir });
-    pushBranch(repoDir, STAGING_BRANCH);
-    return repoDir;
-}
-export function currentManagedBranch(cwd = workspaceRoot()) {
-    return currentBranch(gitWorkflowRoot(cwd));
-}
-export function assertFeatureBranch(cwd = workspaceRoot()) {
-    const branchName = currentManagedBranch(cwd);
-    if (!branchName) {
-        throw new Error('Unable to determine the current git branch.');
-    }
-    if (branchName === STAGING_BRANCH || branchName === PRODUCTION_BRANCH) {
-        throw new Error(`Treeseed close only works on feature branches. Current branch: ${branchName}`);
-    }
-    return branchName;
-}
-export function prepareReleaseBranches(cwd = workspaceRoot()) {
-    const repoDir = assertCleanWorktree(cwd);
-    fetchOrigin(repoDir);
-    syncBranchWithOrigin(repoDir, STAGING_BRANCH);
-    if (remoteBranchExists(repoDir, PRODUCTION_BRANCH) || branchExists(repoDir, PRODUCTION_BRANCH)) {
-        syncBranchWithOrigin(repoDir, PRODUCTION_BRANCH);
-        syncBranchWithOrigin(repoDir, STAGING_BRANCH);
-    }
-    return repoDir;
-}
-export function mergeStagingIntoMain(cwd = workspaceRoot()) {
-    const repoDir = prepareReleaseBranches(cwd);
-    checkoutBranch(repoDir, PRODUCTION_BRANCH);
-    if (remoteBranchExists(repoDir, PRODUCTION_BRANCH)) {
-        runGit(['pull', '--rebase', 'origin', PRODUCTION_BRANCH], { cwd: repoDir });
-    }
-    runGit(['merge', '--no-ff', STAGING_BRANCH, '-m', `release: ${STAGING_BRANCH} -> ${PRODUCTION_BRANCH}`], { cwd: repoDir });
-    pushBranch(repoDir, STAGING_BRANCH);
-    pushBranch(repoDir, PRODUCTION_BRANCH);
-    return repoDir;
-}

package/dist/scripts/github-automation-lib.d.ts

@@ -1,156 +0,0 @@
-export declare function getGitHubAutomationMode(): "stub" | "real";
-export declare function parseGitHubRepositoryFromRemote(remoteUrl: any): string | null;
-export declare function resolveGitHubRepositorySlug(tenantRoot: any): string;
-export declare function maybeResolveGitHubRepositorySlug(tenantRoot: any): string | null;
-export declare function resolveGitRepositoryRoot(tenantRoot: any): any;
-export declare function requiredGitHubEnvironment(tenantRoot: any, { scope, purpose }?: {
-    scope?: string | undefined;
-    purpose?: string | undefined;
-}): {
-    secrets: string[];
-    variables: string[];
-};
-export declare function requiredGitHubSecrets(tenantRoot: any): string[];
-export declare function renderDeployWorkflow({ workingDirectory }: {
-    workingDirectory: any;
-}): string;
-export declare function ensureDeployWorkflow(tenantRoot: any): {
-    workflowPath: string;
-    changed: boolean;
-    workingDirectory: string;
-    mode: string;
-} | {
-    workflowPath: string;
-    changed: boolean;
-    workingDirectory: string;
-    mode?: undefined;
-};
-export declare function listGitHubSecretNames(repository: any, tenantRoot: any): Set<unknown>;
-export declare function listGitHubVariableNames(repository: any, tenantRoot: any): Set<unknown>;
-export declare function formatMissingSecretsReport(repository: any, missingSecrets: any, reason?: string): string;
-export declare function ensureGitHubSecrets(tenantRoot: any, { dryRun }?: {
-    dryRun?: boolean | undefined;
-}): {
-    existing: never[];
-    created: never[];
-} | {
-    existing: never[];
-    created: never[];
-} | {
-    existing: string[];
-    created: string[];
-};
-export declare function ensureGitHubEnvironment(tenantRoot: any, { dryRun, scope, purpose }?: {
-    dryRun?: boolean | undefined;
-    scope?: string | undefined;
-    purpose?: string | undefined;
-}): {
-    repository: string | null;
-    secrets: {
-        existing: never[];
-        created: never[];
-    };
-    variables: {
-        existing: never[];
-        created: never[];
-    };
-    skipped: string;
-    mode: string;
-} | {
-    repository: null;
-    secrets: {
-        existing: never[];
-        created: never[];
-    };
-    variables: {
-        existing: never[];
-        created: never[];
-    };
-    skipped: string;
-    mode?: undefined;
-} | {
-    repository: string;
-    secrets: {
-        existing: string[];
-        created: string[];
-    };
-    variables: {
-        existing: string[];
-        created: string[];
-    };
-    skipped?: undefined;
-    mode?: undefined;
-};
-export declare function ensureGitHubDeployAutomation(tenantRoot: any, { dryRun }?: {
-    dryRun?: boolean | undefined;
-}): {
-    mode: string;
-    workflow: {
-        workflowPath: string;
-        changed: boolean;
-        workingDirectory: string;
-        mode: string;
-    } | {
-        workflowPath: string;
-        changed: boolean;
-        workingDirectory: string;
-        mode?: undefined;
-    };
-    secrets: {
-        existing: never[];
-        created: never[];
-    } | {
-        existing: never[];
-        created: never[];
-    } | {
-        existing: string[];
-        created: string[];
-    };
-    variables: {
-        existing: never[];
-        created: never[];
-    } | {
-        existing: never[];
-        created: never[];
-    } | {
-        existing: string[];
-        created: string[];
-    };
-    environment: {
-        repository: string | null;
-        secrets: {
-            existing: never[];
-            created: never[];
-        };
-        variables: {
-            existing: never[];
-            created: never[];
-        };
-        skipped: string;
-        mode: string;
-    } | {
-        repository: null;
-        secrets: {
-            existing: never[];
-            created: never[];
-        };
-        variables: {
-            existing: never[];
-            created: never[];
-        };
-        skipped: string;
-        mode?: undefined;
-    } | {
-        repository: string;
-        secrets: {
-            existing: string[];
-            created: string[];
-        };
-        variables: {
-            existing: string[];
-            created: string[];
-        };
-        skipped?: undefined;
-        mode?: undefined;
-    };
-};

package/dist/scripts/github-automation-lib.js

@@ -1,242 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, relative, resolve } from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { resolveTreeseedEnvironmentRegistry } from '@treeseed/core/environment';
-import { corePackageRoot, loadCliDeployConfig } from './package-tools.js';
-function envOrNull(key) {
-    const value = process.env[key];
-    return typeof value === 'string' && value.length > 0 ? value : null;
-}
-export function getGitHubAutomationMode() {
-    return process.env.TREESEED_GITHUB_AUTOMATION_MODE === 'stub' ? 'stub' : 'real';
-}
-function isGitHubAutomationStubbed() {
-    return getGitHubAutomationMode() === 'stub';
-}
-export function parseGitHubRepositoryFromRemote(remoteUrl) {
-    if (!remoteUrl) {
-        return null;
-    }
-    const sshMatch = remoteUrl.match(/^git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/);
-    if (sshMatch) {
-        return `${sshMatch[1]}/${sshMatch[2]}`;
-    }
-    const httpsMatch = remoteUrl.match(/^https:\/\/github\.com\/([^/]+)\/(.+?)(?:\.git)?$/);
-    if (httpsMatch) {
-        return `${httpsMatch[1]}/${httpsMatch[2]}`;
-    }
-    return null;
-}
-function runGit(args, { cwd, allowFailure = false, capture = true } = {}) {
-    const result = spawnSync('git', args, {
-        cwd,
-        stdio: capture ? 'pipe' : 'inherit',
-        encoding: 'utf8',
-    });
-    if (result.status !== 0 && !allowFailure) {
-        throw new Error(result.stderr?.trim() || result.stdout?.trim() || `git ${args.join(' ')} failed`);
-    }
-    return result;
-}
-function runGh(args, { cwd, allowFailure = false, capture = true, input } = {}) {
-    const result = spawnSync('gh', args, {
-        cwd,
-        stdio: capture || input !== undefined ? ['pipe', 'pipe', 'pipe'] : 'inherit',
-        encoding: 'utf8',
-        input,
-    });
-    if (result.error && result.error.code === 'ENOENT') {
-        throw new Error('GitHub CLI `gh` is required for Treeseed GitHub automation.');
-    }
-    if (result.status !== 0 && !allowFailure) {
-        throw new Error(result.stderr?.trim() || result.stdout?.trim() || `gh ${args.join(' ')} failed`);
-    }
-    return result;
-}
-export function resolveGitHubRepositorySlug(tenantRoot) {
-    const remoteResult = runGit(['remote', 'get-url', 'origin'], { cwd: tenantRoot });
-    const remoteUrl = remoteResult.stdout?.trim() ?? '';
-    const repository = parseGitHubRepositoryFromRemote(remoteUrl);
-    if (!repository) {
-        throw new Error(`Unable to determine GitHub repository from origin remote "${remoteUrl}".`);
-    }
-    return repository;
-}
-export function maybeResolveGitHubRepositorySlug(tenantRoot) {
-    try {
-        return resolveGitHubRepositorySlug(tenantRoot);
-    }
-    catch {
-        return null;
-    }
-}
-export function resolveGitRepositoryRoot(tenantRoot) {
-    const result = runGit(['rev-parse', '--show-toplevel'], { cwd: tenantRoot, allowFailure: true });
-    return result.status === 0 ? result.stdout.trim() : tenantRoot;
-}
-export function requiredGitHubEnvironment(tenantRoot, { scope = 'prod', purpose = 'save' } = {}) {
-    const deployConfig = loadCliDeployConfig(tenantRoot);
-    const registry = resolveTreeseedEnvironmentRegistry({ deployConfig });
-    const relevant = registry.entries.filter((entry) => entry.scopes.includes(scope)
-        && entry.purposes.includes(purpose)
-        && (!entry.isRelevant || entry.isRelevant(registry.context, scope, purpose)));
-    return {
-        secrets: [...new Set(relevant.filter((entry) => entry.targets.includes('github-secret')).map((entry) => entry.id))],
-        variables: [...new Set(relevant.filter((entry) => entry.targets.includes('github-variable')).map((entry) => entry.id))],
-    };
-}
-export function requiredGitHubSecrets(tenantRoot) {
-    return requiredGitHubEnvironment(tenantRoot).secrets;
-}
-export function renderDeployWorkflow({ workingDirectory }) {
-    const normalizedWorkingDirectory = workingDirectory && workingDirectory !== '.' ? workingDirectory : '.';
-    const workingDirectoryLine = normalizedWorkingDirectory === '.'
-        ? ''
-        : `    defaults:\n      run:\n        working-directory: ${normalizedWorkingDirectory}\n`;
-    const templatePath = resolve(corePackageRoot, 'templates', 'github', 'deploy.workflow.yml');
-    const template = readFileSync(templatePath, 'utf8');
-    return template
-        .replace('__WORKING_DIRECTORY_BLOCK__', workingDirectoryLine)
-        .replace('__CACHE_DEPENDENCY_PATH__', normalizedWorkingDirectory === '.' ? 'package-lock.json' : `${normalizedWorkingDirectory}/package-lock.json`);
-}
-export function ensureDeployWorkflow(tenantRoot) {
-    if (isGitHubAutomationStubbed()) {
-        return {
-            workflowPath: resolve(tenantRoot, '.github', 'workflows', 'deploy.yml'),
-            changed: false,
-            workingDirectory: '.',
-            mode: 'stub',
-        };
-    }
-    const repositoryRoot = resolveGitRepositoryRoot(tenantRoot);
-    const workflowPath = resolve(tenantRoot, '.github', 'workflows', 'deploy.yml');
-    const workingDirectory = relative(repositoryRoot, tenantRoot).replaceAll('\\', '/') || '.';
-    const expected = renderDeployWorkflow({ workingDirectory });
-    const current = existsSync(workflowPath) ? readFileSync(workflowPath, 'utf8') : null;
-    if (current === expected) {
-        return { workflowPath, changed: false, workingDirectory };
-    }
-    mkdirSync(dirname(workflowPath), { recursive: true });
-    writeFileSync(workflowPath, expected, 'utf8');
-    return { workflowPath, changed: true, workingDirectory };
-}
-export function listGitHubSecretNames(repository, tenantRoot) {
-    const result = runGh(['secret', 'list', '--repo', repository, '--json', 'name'], {
-        cwd: tenantRoot,
-    });
-    return new Set((JSON.parse(result.stdout || '[]'))
-        .map((entry) => entry?.name)
-        .filter((value) => typeof value === 'string' && value.length > 0));
-}
-export function listGitHubVariableNames(repository, tenantRoot) {
-    const result = runGh(['variable', 'list', '--repo', repository, '--json', 'name'], {
-        cwd: tenantRoot,
-    });
-    return new Set((JSON.parse(result.stdout || '[]'))
-        .map((entry) => entry?.name)
-        .filter((value) => typeof value === 'string' && value.length > 0));
-}
-export function formatMissingSecretsReport(repository, missingSecrets, reason = 'missing_local_env') {
-    const lines = [
-        'Treeseed GitHub secret sync failed.',
-        `Repository: ${repository}`,
-        `Reason: ${reason}`,
-        'Missing secrets:',
-    ];
-    for (const secret of missingSecrets) {
-        lines.push(`- ${secret.name}: localEnv=${secret.localEnvPresent ? 'present' : 'missing'} remote=${secret.remotePresent ? 'present' : 'missing'}`);
-    }
-    return lines.join('\n');
-}
-export function ensureGitHubSecrets(tenantRoot, { dryRun = false } = {}) {
-    return ensureGitHubEnvironment(tenantRoot, { dryRun }).secrets;
-}
-export function ensureGitHubEnvironment(tenantRoot, { dryRun = false, scope = 'prod', purpose = 'save' } = {}) {
-    if (isGitHubAutomationStubbed()) {
-        return {
-            repository: maybeResolveGitHubRepositorySlug(tenantRoot),
-            secrets: {
-                existing: [],
-                created: [],
-            },
-            variables: {
-                existing: [],
-                created: [],
-            },
-            skipped: 'stubbed',
-            mode: 'stub',
-        };
-    }
-    const repository = maybeResolveGitHubRepositorySlug(tenantRoot);
-    if (!repository) {
-        if (dryRun) {
-            return {
-                repository: null,
-                secrets: { existing: [], created: [] },
-                variables: { existing: [], created: [] },
-                skipped: 'missing_repository',
-            };
-        }
-        throw new Error('Unable to determine GitHub repository from the current tenant. Configure an origin remote before syncing GitHub secrets.');
-    }
-    const required = requiredGitHubEnvironment(tenantRoot, { scope, purpose });
-    const requiredSecrets = required.secrets;
-    const requiredVariables = required.variables;
-    const existingSecrets = listGitHubSecretNames(repository, tenantRoot);
-    const existingVariables = listGitHubVariableNames(repository, tenantRoot);
-    const missingRemote = requiredSecrets.filter((name) => !existingSecrets.has(name));
-    const missingRemoteVariables = requiredVariables.filter((name) => !existingVariables.has(name));
-    const missingLocal = missingRemote
-        .filter((name) => !envOrNull(name))
-        .map((name) => ({ name, localEnvPresent: false, remotePresent: false }));
-    const missingLocalVariables = missingRemoteVariables
-        .filter((name) => !envOrNull(name))
-        .map((name) => ({ name, localEnvPresent: false, remotePresent: false }));
-    if (missingLocal.length > 0 || missingLocalVariables.length > 0) {
-        throw new Error(formatMissingSecretsReport(repository, [...missingLocal, ...missingLocalVariables]));
-    }
-    const createdSecrets = [];
-    for (const name of missingRemote) {
-        if (dryRun) {
-            createdSecrets.push(name);
-            continue;
-        }
-        runGh(['secret', 'set', name, '--repo', repository, '--body', envOrNull(name) ?? ''], {
-            cwd: tenantRoot,
-        });
-        createdSecrets.push(name);
-    }
-    const createdVariables = [];
-    for (const name of missingRemoteVariables) {
-        if (dryRun) {
-            createdVariables.push(name);
-            continue;
-        }
-        runGh(['variable', 'set', name, '--repo', repository, '--body', envOrNull(name) ?? ''], {
-            cwd: tenantRoot,
-        });
-        createdVariables.push(name);
-    }
-    return {
-        repository,
-        secrets: {
-            existing: requiredSecrets.filter((name) => existingSecrets.has(name)),
-            created: createdSecrets,
-        },
-        variables: {
-            existing: requiredVariables.filter((name) => existingVariables.has(name)),
-            created: createdVariables,
-        },
-    };
-}
-export function ensureGitHubDeployAutomation(tenantRoot, { dryRun = false } = {}) {
-    const workflow = ensureDeployWorkflow(tenantRoot);
-    const environment = ensureGitHubEnvironment(tenantRoot, { dryRun });
-    return {
-        mode: getGitHubAutomationMode(),
-        workflow,
-        secrets: environment.secrets,
-        variables: environment.variables,
-        environment,
-    };
-}

package/dist/scripts/local-dev-lib.d.ts

@@ -1,9 +0,0 @@
-export declare function runStep(command: any, args: any, options?: {}): void;
-export declare function runNodeScript(scriptRelativePath: any, args?: never[], options?: {}): void;
-export declare function spawnProcess(command: any, args: any, options?: {}): import("child_process").ChildProcessWithoutNullStreams;
-export declare function syncDevVars(overrides?: {}): void;
-export declare function runLocalD1Migration(persistTo: any): void;
-export declare function prepareCloudflareLocalRuntime({ envOverrides, persistTo, outDir }?: {
-    envOverrides?: {} | undefined;
-}): void;
-export declare function startWranglerDev(args?: never[], options?: {}): import("child_process").ChildProcessWithoutNullStreams;

package/dist/scripts/local-dev-lib.js

@@ -1,84 +0,0 @@
-import { spawn, spawnSync } from 'node:child_process';
-import { resolve } from 'node:path';
-import { runLocalD1Migrations as applyLocalD1Migrations } from './d1-migration-lib.js';
-import { fixtureMigrationsRoot, fixtureRoot, fixtureWranglerConfig, corePackageRoot, } from './paths.js';
-function mergeEnv(extraEnv = {}) {
-    return { ...process.env, ...extraEnv };
-}
-export function runStep(command, args, options = {}) {
-    const result = spawnSync(command, args, {
-        stdio: 'inherit',
-        shell: process.platform === 'win32',
-        env: mergeEnv(options.env),
-        cwd: options.cwd ?? process.cwd(),
-    });
-    if (result.status !== 0) {
-        process.exit(result.status ?? 1);
-    }
-}
-export function runNodeScript(scriptRelativePath, args = [], options = {}) {
-    return runStep(process.execPath, [resolve(corePackageRoot, scriptRelativePath), ...args], {
-        ...options,
-        cwd: options.cwd ?? corePackageRoot,
-    });
-}
-export function spawnProcess(command, args, options = {}) {
-    return spawn(command, args, {
-        stdio: options.stdio ?? 'inherit',
-        shell: process.platform === 'win32',
-        env: mergeEnv(options.env),
-        cwd: options.cwd ?? process.cwd(),
-        detached: options.detached ?? false,
-    });
-}
-export function syncDevVars(overrides = {}) {
-    const overrideEntries = Object.entries(overrides);
-    runNodeScript('./scripts/sync-dev-vars.js', overrideEntries.map(([key, value]) => `${key}=${value}`), { cwd: fixtureRoot });
-}
-export function runLocalD1Migration(persistTo) {
-    applyLocalD1Migrations({
-        cwd: fixtureRoot,
-        wranglerConfig: fixtureWranglerConfig,
-        migrationsRoot: fixtureMigrationsRoot,
-        persistTo,
-    });
-}
-export function prepareCloudflareLocalRuntime({ envOverrides = {}, persistTo, outDir } = {}) {
-    const mergedEnvOverrides = {
-        TREESEED_MAILPIT_SMTP_HOST: '127.0.0.1',
-        TREESEED_MAILPIT_SMTP_PORT: '1025',
-        ...envOverrides,
-    };
-    runNodeScript('./scripts/patch-starlight-content-path.js');
-    runNodeScript('./scripts/aggregate-book.js');
-    runNodeScript('./scripts/ensure-mailpit.js');
-    syncDevVars({
-        TREESEED_LOCAL_DEV_MODE: 'cloudflare',
-        ...mergedEnvOverrides,
-    });
-    runLocalD1Migration(persistTo);
-    const astroArgs = ['astro', 'build', '--root', fixtureRoot];
-    if (outDir) {
-        astroArgs.push('--outDir', outDir);
-    }
-    runStep('npx', astroArgs, {
-        env: {
-            TREESEED_LOCAL_DEV_MODE: 'cloudflare',
-            ...mergedEnvOverrides,
-        },
-        cwd: corePackageRoot,
-    });
-    runNodeScript('./scripts/build-tenant-worker.js', [], {
-        cwd: fixtureRoot,
-        env: {
-            TREESEED_LOCAL_DEV_MODE: 'cloudflare',
-            ...mergedEnvOverrides,
-        },
-    });
-}
-export function startWranglerDev(args = [], options = {}) {
-    return spawnProcess('wrangler', ['dev', '--local', '--config', fixtureWranglerConfig, ...args], {
-        ...options,
-        cwd: options.cwd ?? fixtureRoot,
-    });
-}

package/dist/scripts/local-dev.d.ts

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