@blinkhost/cli 2.0.0

package/dist/detect.js

@@ -0,0 +1,61 @@
+import { lstat, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+async function readable(path) {
+    try {
+        await readFile(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function detectManifest(root) {
+    const rootStat = await lstat(root);
+    if (!rootStat.isDirectory() || rootStat.isSymbolicLink())
+        throw new Error('Project path must be a regular directory.');
+    let packageJson = {};
+    try {
+        const packagePath = join(root, 'package.json');
+        if ((await lstat(packagePath)).isSymbolicLink())
+            throw new Error('package.json cannot be a symbolic link.');
+        packageJson = JSON.parse(await readFile(packagePath, 'utf8'));
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    let framework = 'html';
+    if ('astro' in dependencies)
+        framework = 'astro';
+    else if ('react' in dependencies)
+        framework = 'react';
+    else if ('vue' in dependencies)
+        framework = 'vue';
+    else if ('svelte' in dependencies)
+        framework = 'svelte';
+    else if ('solid-js' in dependencies)
+        framework = 'solid';
+    let packageManager = 'npm';
+    if (await readable(join(root, 'pnpm-lock.yaml')))
+        packageManager = 'pnpm';
+    else if (await readable(join(root, 'yarn.lock')))
+        packageManager = 'yarn';
+    else if (await readable(join(root, 'bun.lock')) || await readable(join(root, 'bun.lockb')))
+        packageManager = 'bun';
+    const install = packageManager === 'npm' ? 'npm ci' : `${packageManager} install --frozen-lockfile`;
+    return {
+        schema: 'blinkhost/v1', application: { root: '.' },
+        frontend: {
+            root: '.', dependency_root: '.', framework, package_manager: packageManager,
+            install: framework === 'html' ? '' : install,
+            build: framework === 'html' ? '' : `${packageManager} run build`,
+            dev: framework === 'html' ? '' : `${packageManager} run dev`,
+            output: framework === 'html' ? '.' : 'dist',
+        },
+        modules: [], resources: { databases: [], secrets: [] },
+        preview: { enabled: true, database_mode: 'none' },
+        ignore: ['.blinkhost', 'node_modules', 'dist'],
+    };
+}
+//# sourceMappingURL=detect.js.map

package/dist/errors.d.ts

@@ -0,0 +1,20 @@
+export declare const EXIT: {
+    readonly success: 0;
+    readonly usage: 2;
+    readonly validation: 3;
+    readonly filesystem: 4;
+    readonly internal: 5;
+    readonly auth: 6;
+    readonly network: 7;
+    readonly remote: 8;
+    readonly conflict: 9;
+};
+export declare class CliError extends Error {
+    readonly exitCode: number;
+    readonly code: string;
+    readonly details: string[];
+    constructor(message: string, exitCode: number, code: string, details?: string[]);
+}
+export declare class ManifestError extends CliError {
+    constructor(message: string, details?: string[]);
+}

package/dist/errors.js

@@ -0,0 +1,20 @@
+export const EXIT = { success: 0, usage: 2, validation: 3, filesystem: 4, internal: 5, auth: 6, network: 7, remote: 8, conflict: 9 };
+export class CliError extends Error {
+    exitCode;
+    code;
+    details;
+    constructor(message, exitCode, code, details = []) {
+        super(message);
+        this.exitCode = exitCode;
+        this.code = code;
+        this.details = details;
+        this.name = 'CliError';
+    }
+}
+export class ManifestError extends CliError {
+    constructor(message, details = []) {
+        super(message, EXIT.validation, 'manifest_invalid', details);
+        this.name = 'ManifestError';
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/manifest.d.ts

@@ -0,0 +1,50 @@
+export declare const MANIFEST_SCHEMA = "blinkhost/v1";
+export declare const MANIFEST_FILENAME = "blinkhost.yaml";
+export declare const MAX_MANIFEST_BYTES: number;
+export declare const SUPPORTED_FRONTENDS: readonly ["astro", "html", "react", "solid", "svelte", "vue"];
+export declare const SUPPORTED_MANAGERS: readonly ["bun", "npm", "pnpm", "yarn"];
+export declare const SUPPORTED_MODULES: readonly ["go", "python", "rust"];
+export type FrontendFramework = typeof SUPPORTED_FRONTENDS[number];
+export type PackageManager = typeof SUPPORTED_MANAGERS[number];
+export type ModuleLanguage = typeof SUPPORTED_MODULES[number];
+export interface BlinkHostManifest {
+    schema: typeof MANIFEST_SCHEMA;
+    application: {
+        root: string;
+    };
+    frontend: {
+        root: string;
+        dependency_root: string;
+        framework: FrontendFramework;
+        package_manager: PackageManager;
+        install: string;
+        build: string;
+        dev: string;
+        output: string;
+    };
+    modules: Array<{
+        name: string;
+        path: string;
+        language: ModuleLanguage;
+        entrypoint: string;
+        abi: string;
+        sdk: string;
+    }>;
+    resources: {
+        databases: Array<{
+            binding: string;
+            schema?: string;
+            migrations?: string;
+            seeds?: string;
+        }>;
+        secrets: string[];
+    };
+    preview: {
+        enabled: boolean;
+        database_mode: 'none' | 'isolated_branch';
+    };
+    ignore: string[];
+}
+export declare function normalizeRepositoryPath(value: unknown, field: string, allowRoot?: boolean): string;
+export declare function parseManifest(raw: string | Uint8Array): BlinkHostManifest;
+export declare function serializeManifest(manifest: BlinkHostManifest): string;

package/dist/manifest.js

@@ -0,0 +1,193 @@
+import { parseDocument, stringify, visit } from 'yaml';
+import { ManifestError } from './errors.js';
+export const MANIFEST_SCHEMA = 'blinkhost/v1';
+export const MANIFEST_FILENAME = 'blinkhost.yaml';
+export const MAX_MANIFEST_BYTES = 128 * 1024;
+export const SUPPORTED_FRONTENDS = ['astro', 'html', 'react', 'solid', 'svelte', 'vue'];
+export const SUPPORTED_MANAGERS = ['bun', 'npm', 'pnpm', 'yarn'];
+export const SUPPORTED_MODULES = ['go', 'python', 'rust'];
+const TOP_LEVEL = new Set(['schema', 'application', 'frontend', 'modules', 'resources', 'preview', 'ignore']);
+const APPLICATION_FIELDS = new Set(['root']);
+const FRONTEND_FIELDS = new Set(['root', 'dependency_root', 'framework', 'package_manager', 'install', 'build', 'dev', 'output']);
+const MODULE_FIELDS = new Set(['name', 'path', 'language', 'entrypoint', 'abi', 'sdk']);
+const RESOURCE_FIELDS = new Set(['databases', 'secrets']);
+const DATABASE_FIELDS = new Set(['binding', 'schema', 'migrations', 'seeds']);
+const PREVIEW_FIELDS = new Set(['enabled', 'database_mode']);
+const WINDOWS_NAMES = new Set(['con', 'prn', 'aux', 'nul', ...Array.from({ length: 9 }, (_, i) => `com${i + 1}`), ...Array.from({ length: 9 }, (_, i) => `lpt${i + 1}`)]);
+const MODULE_NAME = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
+const BINDING_NAME = /^[A-Z][A-Z0-9_]{0,127}$/;
+function fail(field, message) {
+    throw new ManifestError(`${field}: ${message}`);
+}
+function object(value, field, allowed) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        fail(field, 'Must be an object.');
+    const result = value;
+    const unknown = Object.keys(result).filter((key) => !allowed.has(key)).sort();
+    if (unknown.length)
+        fail(field, `Unsupported fields: ${unknown.join(', ')}.`);
+    return result;
+}
+function stringValue(value, field, maximum = 512, required = true) {
+    if (value === undefined || value === null) {
+        if (!required)
+            return '';
+        fail(field, 'Must be a non-empty string.');
+    }
+    if (typeof value !== 'string' || (required && !value.trim()))
+        fail(field, 'Must be a non-empty string.');
+    const normalized = value.trim();
+    if (Buffer.byteLength(normalized, 'utf8') > maximum)
+        fail(field, `Must not exceed ${maximum} UTF-8 bytes.`);
+    if (/[\u0000-\u001f\u007f]/.test(normalized))
+        fail(field, 'Control characters are not supported.');
+    return normalized;
+}
+export function normalizeRepositoryPath(value, field, allowRoot = false) {
+    const path = stringValue(value, field, 1024);
+    if (path === '.' && allowRoot)
+        return path;
+    if (path.startsWith('/') || path.startsWith('\\') || path.includes('\\') || path.includes('\0'))
+        fail(field, 'Must be a repository-relative POSIX path.');
+    if (path.endsWith('/') || path === '.' || path === '..' || path.includes('//'))
+        fail(field, 'Must be a normalized repository-relative path.');
+    const parts = path.split('/');
+    if (parts.length > 64)
+        fail(field, 'Must not exceed 64 path segments.');
+    for (const part of parts) {
+        const folded = part.toLowerCase();
+        const stem = folded.split('.', 1)[0] ?? folded;
+        if (!part || part === '.' || part === '..' || folded === '.git' || WINDOWS_NAMES.has(stem))
+            fail(field, `Contains reserved path segment: ${part}.`);
+        if (part.endsWith(' ') || part.endsWith('.'))
+            fail(field, 'Path segments cannot end with a space or period.');
+        if (/[\u0000-\u001f\u007f]/.test(part))
+            fail(field, 'Path contains control characters.');
+    }
+    return parts.join('/');
+}
+function command(value, field, required = true) {
+    const result = stringValue(value, field, 1024, required);
+    if (/[\r\n]/.test(result))
+        fail(field, 'Build commands must be single-line values.');
+    return result;
+}
+export function parseManifest(raw) {
+    const bytes = typeof raw === 'string' ? Buffer.from(raw, 'utf8') : Buffer.from(raw);
+    if (bytes.byteLength > MAX_MANIFEST_BYTES)
+        fail('manifest', `Manifest exceeds ${MAX_MANIFEST_BYTES} bytes.`);
+    const text = bytes.toString('utf8');
+    if (!Buffer.from(text, 'utf8').equals(bytes))
+        fail('manifest', 'Manifest must be valid UTF-8.');
+    const document = parseDocument(text, { strict: true, uniqueKeys: true });
+    let hasAlias = false;
+    visit(document, { Alias: () => { hasAlias = true; } });
+    if (hasAlias)
+        fail('manifest', 'YAML aliases are not supported.');
+    if (document.errors.length)
+        fail('manifest', `Manifest YAML is invalid: ${document.errors[0]?.message ?? 'unknown error'}`);
+    const rootObject = object(document.toJS({ maxAliasCount: 0 }), 'manifest', TOP_LEVEL);
+    if (rootObject.schema !== MANIFEST_SCHEMA)
+        fail('schema', `Only ${MANIFEST_SCHEMA} is supported.`);
+    const application = object(rootObject.application ?? {}, 'application', APPLICATION_FIELDS);
+    const applicationRoot = normalizeRepositoryPath(application.root ?? '.', 'application.root', true);
+    const frontend = object(rootObject.frontend, 'frontend', FRONTEND_FIELDS);
+    const frontendRoot = normalizeRepositoryPath(frontend.root ?? '.', 'frontend.root', true);
+    const dependencyRoot = normalizeRepositoryPath(frontend.dependency_root ?? frontendRoot, 'frontend.dependency_root', true);
+    if (dependencyRoot !== '.' && frontendRoot !== dependencyRoot && !frontendRoot.startsWith(`${dependencyRoot}/`))
+        fail('frontend.dependency_root', 'Must be the frontend directory or one of its parent directories.');
+    const framework = stringValue(frontend.framework, 'frontend.framework', 32).toLowerCase();
+    if (!SUPPORTED_FRONTENDS.includes(framework))
+        fail('frontend.framework', 'Unsupported frontend framework.');
+    const packageManager = stringValue(frontend.package_manager, 'frontend.package_manager', 16).toLowerCase();
+    if (!SUPPORTED_MANAGERS.includes(packageManager))
+        fail('frontend.package_manager', 'Unsupported package manager.');
+    const normalizedFrontend = {
+        root: frontendRoot,
+        dependency_root: dependencyRoot,
+        framework: framework,
+        package_manager: packageManager,
+        install: command(frontend.install ?? '', 'frontend.install', framework !== 'html'),
+        build: command(frontend.build ?? '', 'frontend.build', framework !== 'html'),
+        dev: command(frontend.dev, 'frontend.dev', false),
+        output: normalizeRepositoryPath(frontend.output, 'frontend.output', framework === 'html'),
+    };
+    const rawModules = rootObject.modules ?? [];
+    if (!Array.isArray(rawModules) || rawModules.length > 100)
+        fail('modules', 'Must be an array containing at most 100 modules.');
+    const moduleNames = new Set();
+    const modulePaths = new Set();
+    const modules = rawModules.map((rawModule, index) => {
+        const field = `modules.${index}`;
+        const module = object(rawModule, field, MODULE_FIELDS);
+        const name = stringValue(module.name, `${field}.name`, 64).toLowerCase();
+        if (!MODULE_NAME.test(name))
+            fail(`${field}.name`, 'Use lowercase letters, numbers and internal hyphens.');
+        const path = normalizeRepositoryPath(module.path, `${field}.path`);
+        const absolutePath = applicationRoot === '.' ? path : `${applicationRoot}/${path}`;
+        const language = stringValue(module.language, `${field}.language`, 16).toLowerCase();
+        if (!SUPPORTED_MODULES.includes(language))
+            fail(`${field}.language`, 'Only Rust, Go and Python modules are supported.');
+        if (moduleNames.has(name))
+            fail(`${field}.name`, 'Module names must be unique.');
+        if (modulePaths.has(absolutePath.toLowerCase()))
+            fail(`${field}.path`, 'Module paths must be unique, including case.');
+        moduleNames.add(name);
+        modulePaths.add(absolutePath.toLowerCase());
+        return {
+            name,
+            path,
+            language: language,
+            entrypoint: normalizeRepositoryPath(module.entrypoint, `${field}.entrypoint`),
+            abi: stringValue(module.abi ?? 'blinkhost-wasi-1', `${field}.abi`, 64),
+            sdk: stringValue(module.sdk ?? '1.1', `${field}.sdk`, 32),
+        };
+    });
+    const resources = object(rootObject.resources ?? {}, 'resources', RESOURCE_FIELDS);
+    const rawDatabases = resources.databases ?? [];
+    if (!Array.isArray(rawDatabases) || rawDatabases.length > 32)
+        fail('resources.databases', 'Must be an array containing at most 32 bindings.');
+    const bindings = new Set();
+    const databases = rawDatabases.map((rawDatabase, index) => {
+        const field = `resources.databases.${index}`;
+        const database = object(rawDatabase, field, DATABASE_FIELDS);
+        const binding = stringValue(database.binding, `${field}.binding`, 128);
+        if (!BINDING_NAME.test(binding) || bindings.has(binding))
+            fail(`${field}.binding`, 'Bindings must be unique uppercase environment names.');
+        bindings.add(binding);
+        const result = { binding };
+        for (const key of ['schema', 'migrations', 'seeds'])
+            if (database[key] !== undefined)
+                result[key] = normalizeRepositoryPath(database[key], `${field}.${key}`);
+        return result;
+    });
+    const rawSecrets = resources.secrets ?? [];
+    if (!Array.isArray(rawSecrets) || rawSecrets.length > 256)
+        fail('resources.secrets', 'Must be an array containing at most 256 names.');
+    const secrets = rawSecrets.map((value, index) => stringValue(value, `resources.secrets.${index}`, 128));
+    if (new Set(secrets).size !== secrets.length || secrets.some((secret) => !BINDING_NAME.test(secret)))
+        fail('resources.secrets', 'Secret names must be unique uppercase environment names.');
+    const preview = object(rootObject.preview ?? {}, 'preview', PREVIEW_FIELDS);
+    const enabled = preview.enabled ?? true;
+    if (typeof enabled !== 'boolean')
+        fail('preview.enabled', 'Must be a boolean.');
+    const databaseMode = stringValue(preview.database_mode ?? 'none', 'preview.database_mode', 32).toLowerCase();
+    if (databaseMode !== 'none' && databaseMode !== 'isolated_branch')
+        fail('preview.database_mode', 'Unsupported preview database mode.');
+    const rawIgnore = rootObject.ignore ?? [];
+    if (!Array.isArray(rawIgnore) || rawIgnore.length > 256)
+        fail('ignore', 'Must be an array containing at most 256 paths.');
+    return {
+        schema: MANIFEST_SCHEMA,
+        application: { root: applicationRoot },
+        frontend: normalizedFrontend,
+        modules,
+        resources: { databases, secrets },
+        preview: { enabled, database_mode: databaseMode },
+        ignore: rawIgnore.map((value, index) => normalizeRepositoryPath(value, `ignore.${index}`)),
+    };
+}
+export function serializeManifest(manifest) {
+    return stringify(manifest, { lineWidth: 100, aliasDuplicateObjects: false });
+}
+//# sourceMappingURL=manifest.js.map

package/dist/project.d.ts

@@ -0,0 +1,13 @@
+import { type BlinkHostManifest } from './manifest.js';
+export interface ValidationResult {
+    manifest: BlinkHostManifest;
+    errors: string[];
+    warnings: string[];
+}
+export declare function resolveLocalPath(input: string | undefined): string;
+export declare function readProjectManifest(root: string): Promise<BlinkHostManifest>;
+export declare function validateProject(root: string): Promise<ValidationResult>;
+export declare function writeScaffoldAtomically(target: string, files: Map<string, string>, manifest: BlinkHostManifest): Promise<void>;
+export declare function writeManifest(root: string, manifest: BlinkHostManifest, force: boolean): Promise<void>;
+export declare function directoryEntries(root: string): Promise<string[]>;
+export declare function temporaryProjectRoot(): string;

package/dist/project.js

@@ -0,0 +1,177 @@
+import { constants } from 'node:fs';
+import { access, lstat, mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+import { CliError, EXIT } from './errors.js';
+import { MANIFEST_FILENAME, parseManifest, serializeManifest } from './manifest.js';
+export function resolveLocalPath(input) {
+    const value = input ?? '.';
+    if (/[\u0000-\u001f\u007f]/.test(value))
+        throw new CliError('Project paths cannot contain control characters.', EXIT.usage, 'unsafe_path');
+    return isAbsolute(value) ? resolve(value) : resolve(process.cwd(), value);
+}
+async function safeDeclaredPath(root, declared) {
+    const target = resolve(root, declared === '.' ? '' : declared);
+    const offset = relative(root, target);
+    if (offset.startsWith('..') || isAbsolute(offset))
+        throw new CliError(`Declared path escapes the project: ${declared}`, EXIT.validation, 'unsafe_path');
+    let cursor = root;
+    for (const segment of offset.split(/[\\/]/).filter(Boolean)) {
+        cursor = join(cursor, segment);
+        try {
+            if ((await lstat(cursor)).isSymbolicLink())
+                throw new CliError(`Declared path uses a symbolic link: ${declared}`, EXIT.validation, 'symlink_rejected');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                break;
+            throw error;
+        }
+    }
+    return target;
+}
+async function exists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function regularFile(path) {
+    try {
+        const stat = await lstat(path);
+        return stat.isFile() && !stat.isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+async function regularDirectory(path) {
+    try {
+        const stat = await lstat(path);
+        return stat.isDirectory() && !stat.isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+export async function readProjectManifest(root) {
+    const manifestPath = join(root, MANIFEST_FILENAME);
+    let stat;
+    try {
+        stat = await lstat(manifestPath);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            throw new CliError(`No ${MANIFEST_FILENAME} was found.`, EXIT.validation, 'manifest_missing');
+        throw error;
+    }
+    if (!stat.isFile() || stat.isSymbolicLink())
+        throw new CliError(`${MANIFEST_FILENAME} must be a regular file, not a symbolic link.`, EXIT.validation, 'manifest_unsafe');
+    return parseManifest(await readFile(manifestPath));
+}
+export async function validateProject(root) {
+    const rootStat = await lstat(root);
+    if (!rootStat.isDirectory() || rootStat.isSymbolicLink())
+        throw new CliError('Project path must be a regular directory.', EXIT.validation, 'unsafe_project');
+    const manifest = await readProjectManifest(root);
+    const errors = [];
+    const warnings = [];
+    const frontendRoot = await safeDeclaredPath(root, manifest.frontend.root);
+    if (!await regularDirectory(frontendRoot))
+        errors.push(`Frontend directory does not exist or is not a regular directory: ${manifest.frontend.root}`);
+    if (manifest.frontend.framework !== 'html') {
+        const dependencyRoot = await safeDeclaredPath(root, manifest.frontend.dependency_root);
+        if (!await regularDirectory(dependencyRoot))
+            errors.push(`Dependency directory does not exist or is not a regular directory: ${manifest.frontend.dependency_root}`);
+        const dependencyPrefix = manifest.frontend.dependency_root === '.' ? '' : `${manifest.frontend.dependency_root}/`;
+        const packagePath = await safeDeclaredPath(root, `${dependencyPrefix}package.json`);
+        if (!await regularFile(packagePath)) {
+            errors.push(`Missing regular package.json in ${manifest.frontend.dependency_root}.`);
+        }
+        else {
+            try {
+                const packageJson = JSON.parse(await readFile(packagePath, 'utf8'));
+                if (!packageJson || typeof packageJson !== 'object' || Array.isArray(packageJson))
+                    throw new Error('not an object');
+                if (typeof packageJson.packageManager === 'string' && !packageJson.packageManager.startsWith(`${manifest.frontend.package_manager}@`)) {
+                    errors.push('package.json and blinkhost.yaml select different package managers.');
+                }
+            }
+            catch {
+                errors.push('package.json must contain a valid JSON object.');
+            }
+        }
+        const locks = { npm: ['package-lock.json', 'npm-shrinkwrap.json'], pnpm: ['pnpm-lock.yaml'], yarn: ['yarn.lock'], bun: ['bun.lock', 'bun.lockb'] };
+        const lockResults = await Promise.all(locks[manifest.frontend.package_manager].map(async (name) => {
+            const lockPath = await safeDeclaredPath(root, `${dependencyPrefix}${name}`);
+            return regularFile(lockPath);
+        }));
+        if (!lockResults.some(Boolean)) {
+            warnings.push(`Add and commit the ${manifest.frontend.package_manager} lockfile for reproducible, faster dependency installation.`);
+        }
+    }
+    for (const module of manifest.modules) {
+        const moduleRoot = await safeDeclaredPath(root, module.path);
+        const entrypoint = await safeDeclaredPath(moduleRoot, module.entrypoint);
+        if (!await regularDirectory(moduleRoot))
+            errors.push(`Backend module directory does not exist or is not a regular directory: ${module.path}`);
+        if (!await regularFile(entrypoint))
+            errors.push(`Backend module entrypoint does not exist or is not a regular file: ${module.path}/${module.entrypoint}`);
+    }
+    for (const database of manifest.resources.databases) {
+        for (const key of ['schema', 'migrations', 'seeds']) {
+            const path = database[key];
+            if (path) {
+                const target = await safeDeclaredPath(root, path);
+                const valid = key === 'schema' ? await regularFile(target) : await regularDirectory(target);
+                if (!valid)
+                    errors.push(`Database ${database.binding} ${key} path has the wrong type or does not exist: ${path}`);
+            }
+        }
+    }
+    return { manifest, errors, warnings };
+}
+export async function writeScaffoldAtomically(target, files, manifest) {
+    if (await exists(target))
+        throw new CliError(`Refusing to overwrite existing path: ${target}`, EXIT.filesystem, 'target_exists');
+    const parent = dirname(target);
+    await mkdir(parent, { recursive: true });
+    const staging = await mkdtemp(join(parent, `.${basename(target)}.blinkhost-`));
+    try {
+        const all = new Map(files);
+        all.set(MANIFEST_FILENAME, serializeManifest(manifest));
+        for (const [declaredPath, contents] of all) {
+            const destination = resolve(staging, declaredPath);
+            if (relative(staging, destination).startsWith('..'))
+                throw new CliError(`Unsafe generated path: ${declaredPath}`, EXIT.internal, 'unsafe_template');
+            await mkdir(dirname(destination), { recursive: true, mode: 0o755 });
+            await writeFile(destination, contents, { encoding: 'utf8', flag: 'wx', mode: 0o644 });
+        }
+        await rename(staging, target);
+    }
+    catch (error) {
+        await rm(staging, { recursive: true, force: true });
+        throw error;
+    }
+}
+export async function writeManifest(root, manifest, force) {
+    const path = join(root, MANIFEST_FILENAME);
+    const stat = await lstat(root);
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        throw new CliError('Project path must be a regular directory.', EXIT.filesystem, 'unsafe_project');
+    if (!force && await exists(path))
+        throw new CliError(`${MANIFEST_FILENAME} already exists. Use --force only after reviewing the generated manifest.`, EXIT.filesystem, 'manifest_exists');
+    if (await exists(path) && (await lstat(path)).isSymbolicLink())
+        throw new CliError(`Refusing to replace a symbolic-link ${MANIFEST_FILENAME}.`, EXIT.filesystem, 'manifest_unsafe');
+    await writeFile(path, serializeManifest(manifest), { encoding: 'utf8', mode: 0o644 });
+}
+export async function directoryEntries(root) {
+    return readdir(root);
+}
+export function temporaryProjectRoot() {
+    return tmpdir();
+}
+//# sourceMappingURL=project.js.map

package/dist/remote.d.ts

@@ -0,0 +1,19 @@
+export declare function runRemote(group: string, input: string[], profile?: string): Promise<unknown>;
+interface ProjectLink {
+    schema: 'blinkhost/project-link/v1';
+    project_id: string;
+    profile: string;
+}
+export declare function writeProjectLink(projectId: string, profile: string, root?: string): Promise<ProjectLink>;
+export declare function readProjectLink(root?: string): Promise<ProjectLink>;
+export declare function unlinkProject(root?: string): Promise<{
+    unlinked: boolean;
+}>;
+export declare function projectStatus(profile?: string): Promise<unknown>;
+export declare function syncProject(kind: 'pull' | 'push', input: string[], profile?: string): Promise<unknown>;
+export declare function runSecrets(input: string[], profile?: string): Promise<unknown>;
+export declare function rawApi(input: string[], profile?: string): Promise<unknown>;
+export declare function waitForRemote(group: 'builds' | 'deployments' | 'previews', input: string[], profile?: string): Promise<unknown>;
+export declare function openPreview(input: string[], profile?: string): Promise<unknown>;
+export declare function uploadAsset(input: string[], profile?: string): Promise<unknown>;
+export {};