@blinkhost/cli 2.0.0

package/dist/remote.js

@@ -0,0 +1,366 @@
+import { lstat, mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { basename, extname } from 'node:path';
+import { join } from 'node:path';
+import { stdin } from 'node:process';
+import { spawn } from 'node:child_process';
+import { ApiClient, encodeQuery } from './api.js';
+import { CliError, EXIT } from './errors.js';
+import { resolveLocalPath } from './project.js';
+const COLLECTIONS = {
+    projects: '/api/sites/',
+    repositories: '/api/source-control/repositories/',
+    connections: '/api/source-control/connections/',
+    previews: '/api/source-control/previews/',
+    builds: '/api/source-control/builds/',
+    deployments: '/api/deployments/',
+    modules: '/api/backend-modules/',
+    databases: '/api/databases/',
+    bindings: '/api/bindings/',
+    assets: '/api/sites/{project}/assets/',
+    secrets: '/api/project-secrets/',
+    organizations: '/api/organizations/',
+    templates: '/api/source-control/template-releases/',
+    approvals: '/api/source-control/deployment-approvals/',
+    handoffs: '/api/source-control/agency-handoffs/',
+    policies: '/api/source-control/enterprise/policies/',
+    workloads: '/api/cli/v2/workload-identities/',
+};
+function takeOption(args, name) {
+    const index = args.indexOf(name);
+    if (index < 0)
+        return undefined;
+    const value = args[index + 1];
+    if (!value || value.startsWith('--'))
+        throw new CliError(`${name} requires a value.`, EXIT.usage, 'missing_option_value');
+    args.splice(index, 2);
+    return value;
+}
+function takeRepeated(args, name) {
+    const result = [];
+    while (args.includes(name))
+        result.push(takeOption(args, name));
+    return result;
+}
+function takeFlag(args, name) {
+    const index = args.indexOf(name);
+    if (index < 0)
+        return false;
+    args.splice(index, 1);
+    return true;
+}
+function noExtra(args) {
+    if (args.length)
+        throw new CliError(`Unexpected argument: ${args[0]}`, EXIT.usage, 'unexpected_argument');
+}
+function safeIdentifier(value, label = 'ID') {
+    if (!value || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,199}$/.test(value))
+        throw new CliError(`${label} is missing or invalid.`, EXIT.usage, 'invalid_identifier');
+    return encodeURIComponent(value);
+}
+async function readPayload(value) {
+    if (!value)
+        return {};
+    let raw = value;
+    if (value.startsWith('@')) {
+        const path = resolveLocalPath(value.slice(1));
+        const metadata = await lstat(path);
+        if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size > 1024 * 1024)
+            throw new CliError('Payload files must be regular files no larger than 1 MiB.', EXIT.validation, 'invalid_payload_file');
+        raw = await readFile(path, 'utf8');
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            throw new Error();
+        return parsed;
+    }
+    catch {
+        throw new CliError('Request data must be a JSON object or @path to a JSON file.', EXIT.usage, 'invalid_request_data');
+    }
+}
+function queryString(pairs) {
+    const query = new URLSearchParams();
+    for (const pair of pairs) {
+        const separator = pair.indexOf('=');
+        if (separator < 1)
+            throw new CliError('Use --query name=value.', EXIT.usage, 'invalid_query');
+        query.append(pair.slice(0, separator), pair.slice(separator + 1));
+    }
+    const value = query.toString();
+    return value ? `?${value}` : '';
+}
+function collectionPath(group, project) {
+    const template = COLLECTIONS[group];
+    if (!template)
+        throw new CliError(`Unknown remote resource: ${group}.`, EXIT.usage, 'unknown_resource');
+    if (template.includes('{project}'))
+        return template.replace('{project}', safeIdentifier(project, 'Project ID'));
+    return template;
+}
+export async function runRemote(group, input, profile) {
+    const args = [...input];
+    const action = args.shift() || 'list';
+    const project = takeOption(args, '--project');
+    const query = takeRepeated(args, '--query');
+    const dataOption = takeOption(args, '--data');
+    const client = await ApiClient.create(profile);
+    const base = collectionPath(group, project);
+    const data = await readPayload(dataOption);
+    if (action === 'list') {
+        noExtra(args);
+        return client.request(`${base}${queryString(query)}`);
+    }
+    if (action === 'get') {
+        const id = safeIdentifier(args.shift());
+        noExtra(args);
+        return client.request(`${base}${id}/${queryString(query)}`);
+    }
+    if (action === 'create') {
+        noExtra(args);
+        return client.request(base, { method: 'POST', body: JSON.stringify(data) });
+    }
+    if (action === 'update') {
+        const id = safeIdentifier(args.shift());
+        noExtra(args);
+        return client.request(`${base}${id}/`, { method: 'PATCH', body: JSON.stringify(data) });
+    }
+    if (action === 'delete') {
+        const idRaw = args.shift();
+        const id = safeIdentifier(idRaw);
+        const confirmed = takeOption(args, '--confirm');
+        noExtra(args);
+        if (confirmed !== idRaw)
+            throw new CliError('Repeat the resource ID with --confirm before deleting it.', EXIT.usage, 'confirmation_required');
+        return client.request(`${base}${id}/`, { method: 'DELETE' });
+    }
+    if (action === 'action') {
+        const id = safeIdentifier(args.shift());
+        const operation = safeIdentifier(args.shift(), 'Action');
+        noExtra(args);
+        return client.request(`${base}${id}/${operation}/`, { method: 'POST', body: JSON.stringify(data) });
+    }
+    throw new CliError(`Unknown ${group} action: ${action}.`, EXIT.usage, 'unknown_action');
+}
+export async function writeProjectLink(projectId, profile, root) {
+    safeIdentifier(projectId, 'Project ID');
+    const directory = join(resolveLocalPath(root), '.blinkhost');
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const target = join(directory, 'project.json');
+    try {
+        if ((await lstat(target)).isSymbolicLink())
+            throw new CliError('Refusing to replace a symbolic project link.', EXIT.filesystem, 'unsafe_project_link');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    const record = { schema: 'blinkhost/project-link/v1', project_id: projectId, profile };
+    const temporary = `${target}.${process.pid}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(record, null, 2)}\n`, { mode: 0o600, flag: 'wx' });
+    await rename(temporary, target);
+    return record;
+}
+export async function readProjectLink(root) {
+    const path = join(resolveLocalPath(root), '.blinkhost', 'project.json');
+    const metadata = await lstat(path);
+    if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size > 4096)
+        throw new CliError('The local BlinkHost project link is unsafe or invalid.', EXIT.validation, 'invalid_project_link');
+    const record = JSON.parse(await readFile(path, 'utf8'));
+    if (record.schema !== 'blinkhost/project-link/v1')
+        throw new CliError('The local BlinkHost project link uses an unsupported schema.', EXIT.validation, 'invalid_project_link');
+    safeIdentifier(record.project_id, 'Project ID');
+    return record;
+}
+export async function unlinkProject(root) {
+    const path = join(resolveLocalPath(root), '.blinkhost', 'project.json');
+    const metadata = await lstat(path);
+    if (!metadata.isFile() || metadata.isSymbolicLink())
+        throw new CliError('The local BlinkHost project link is unsafe or invalid.', EXIT.validation, 'invalid_project_link');
+    await unlink(path);
+    return { unlinked: true };
+}
+export async function projectStatus(profile) {
+    const link = await readProjectLink();
+    const client = await ApiClient.create(profile || link.profile);
+    const [project, connections] = await Promise.all([
+        client.request(`/api/sites/${encodeURIComponent(link.project_id)}/`),
+        client.request(`/api/source-control/connections/?project=${encodeURIComponent(link.project_id)}`),
+    ]);
+    return { link, project, connections };
+}
+export async function syncProject(kind, input, profile) {
+    const args = [...input];
+    const connection = safeIdentifier(args.shift(), 'Connection ID');
+    const data = await readPayload(takeOption(args, '--data'));
+    noExtra(args);
+    const client = await ApiClient.create(profile);
+    return client.request(`/api/source-control/connections/${connection}/${kind}/`, { method: 'POST', body: JSON.stringify(data) });
+}
+async function readStdin(limit = 64 * 1024) {
+    if (stdin.isTTY)
+        throw new CliError('Pipe the secret value through standard input; values are never accepted as command arguments.', EXIT.usage, 'secret_stdin_required');
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of stdin) {
+        const buffer = Buffer.from(chunk);
+        size += buffer.length;
+        if (size > limit)
+            throw new CliError('Secret values must not exceed 64 KiB.', EXIT.validation, 'secret_too_large');
+        chunks.push(buffer);
+    }
+    const value = Buffer.concat(chunks).toString('utf8').replace(/\r?\n$/, '');
+    if (!value)
+        throw new CliError('The secret value is empty.', EXIT.validation, 'secret_empty');
+    return value;
+}
+export async function runSecrets(input, profile) {
+    const args = [...input];
+    const action = args.shift() || 'list';
+    const client = await ApiClient.create(profile);
+    if (action === 'list') {
+        const project = takeOption(args, '--project');
+        noExtra(args);
+        return client.request(`/api/project-secrets/${encodeQuery({ site_id: project })}`);
+    }
+    if (action === 'set') {
+        const key = args.shift();
+        const project = takeOption(args, '--project');
+        const scope = takeOption(args, '--environment') || 'production';
+        const expires = takeOption(args, '--expires-in-days');
+        noExtra(args);
+        if (!key || !/^[A-Z][A-Z0-9_]{0,127}$/.test(key) || !project)
+            throw new CliError('Use `secrets set NAME --project ID` with an uppercase secret name.', EXIT.usage, 'invalid_secret');
+        const value = await readStdin();
+        return client.request('/api/project-secrets/', { method: 'POST', body: JSON.stringify({ site: project, key, scope, value, ...(expires ? { expires_in_days: Number(expires) } : {}) }) });
+    }
+    if (action === 'rotate') {
+        const id = safeIdentifier(args.shift(), 'Secret ID');
+        noExtra(args);
+        const value = await readStdin();
+        return client.request(`/api/project-secrets/${id}/rotate/`, { method: 'POST', body: JSON.stringify({ value, reason: 'CLI rotation' }) });
+    }
+    if (action === 'delete') {
+        const raw = args.shift();
+        const id = safeIdentifier(raw, 'Secret ID');
+        const confirmed = takeOption(args, '--confirm');
+        noExtra(args);
+        if (confirmed !== raw)
+            throw new CliError('Repeat the secret ID with --confirm before deleting it.', EXIT.usage, 'confirmation_required');
+        return client.request(`/api/project-secrets/${id}/`, { method: 'DELETE' });
+    }
+    throw new CliError(`Unknown secrets action: ${action}.`, EXIT.usage, 'unknown_action');
+}
+export async function rawApi(input, profile) {
+    const args = [...input];
+    const method = (args.shift() || 'GET').toUpperCase();
+    const path = args.shift();
+    const data = await readPayload(takeOption(args, '--data'));
+    noExtra(args);
+    if (!['GET', 'POST', 'PUT', 'PATCH', 'DELETE'].includes(method))
+        throw new CliError('API method must be GET, POST, PUT, PATCH, or DELETE.', EXIT.usage, 'invalid_method');
+    if (!path || path.includes('://') || /[%\\\r\n]/.test(path))
+        throw new CliError('Use a normalized customer API path beginning with /api/.', EXIT.usage, 'invalid_api_path');
+    const parsed = new URL(path, 'https://api.blinkhost.me');
+    if (!parsed.pathname.startsWith('/api/') || parsed.pathname.includes('/../') || parsed.pathname.startsWith('/api/internal/') || parsed.pathname.startsWith('/api/ops/') || parsed.pathname.startsWith('/api/auth/'))
+        throw new CliError('Internal, staff, and authentication API paths are unavailable.', EXIT.usage, 'invalid_api_path');
+    if (method !== 'GET' && parsed.pathname.startsWith('/api/project-secrets/'))
+        throw new CliError('Use the dedicated `blinkhost secrets` commands so values never enter shell history.', EXIT.usage, 'unsafe_secret_command');
+    const client = await ApiClient.create(profile);
+    return client.request(path, { method, ...(method === 'GET' ? {} : { body: JSON.stringify(data) }) });
+}
+export async function waitForRemote(group, input, profile) {
+    const args = [...input];
+    const id = safeIdentifier(args.shift());
+    const timeoutRaw = takeOption(args, '--timeout') || '1200';
+    noExtra(args);
+    const timeout = Number(timeoutRaw);
+    if (!Number.isInteger(timeout) || timeout < 10 || timeout > 3600)
+        throw new CliError('Timeout must be an integer from 10 to 3600 seconds.', EXIT.usage, 'invalid_timeout');
+    const client = await ApiClient.create(profile);
+    const base = collectionPath(group);
+    const deadline = Date.now() + timeout * 1000;
+    const success = new Set(['ready', 'succeeded', 'success', 'completed', 'active', 'deployed']);
+    const failure = new Set(['failed', 'cancelled', 'canceled', 'expired', 'revoked']);
+    while (Date.now() < deadline) {
+        const data = await client.request(`${base}${id}/`);
+        const state = String(data.status || data.state || data.phase || '').toLowerCase();
+        if (success.has(state))
+            return data;
+        if (failure.has(state))
+            throw new CliError(`${group.slice(0, -1)} ${id} finished with status ${state}.`, EXIT.remote, `${group.slice(0, -1)}_failed`);
+        await new Promise((resolve) => setTimeout(resolve, 3000));
+    }
+    throw new CliError(`Timed out waiting for ${group.slice(0, -1)} ${id}.`, EXIT.network, 'wait_timeout');
+}
+export async function openPreview(input, profile) {
+    const args = [...input];
+    const id = safeIdentifier(args.shift());
+    noExtra(args);
+    const client = await ApiClient.create(profile);
+    const data = await client.request(`${collectionPath('previews')}${id}/`);
+    const value = data.url || data.preview_url || data.public_url;
+    if (typeof value !== 'string')
+        throw new CliError('This preview does not have a ready URL.', EXIT.conflict, 'preview_not_ready');
+    const url = new URL(value);
+    const trusted = url.protocol === 'https:' && (url.hostname === 'preview.blinkhost.me' || url.hostname.endsWith('.preview.blinkhost.me') || url.hostname.endsWith('.blinkhost.website'));
+    if (!trusted || url.username || url.password)
+        throw new CliError('BlinkHost returned an untrusted preview URL.', EXIT.remote, 'preview_url_untrusted');
+    const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd.exe' : 'xdg-open';
+    const commandArgs = process.platform === 'win32' ? ['/d', '/s', '/c', 'start', '', url.toString()] : [url.toString()];
+    const child = spawn(command, commandArgs, { detached: true, shell: false, stdio: 'ignore' });
+    child.on('error', () => { });
+    child.unref();
+    return { id: decodeURIComponent(id), url: url.toString() };
+}
+const ASSET_MEDIA_TYPES = {
+    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif',
+    '.webp': 'image/webp', '.ico': 'image/x-icon', '.woff': 'font/woff', '.woff2': 'font/woff2',
+    '.mp3': 'audio/mpeg', '.mp4': 'video/mp4',
+};
+export async function uploadAsset(input, profile) {
+    const args = [...input];
+    const source = args.shift();
+    const project = takeOption(args, '--project');
+    const parentId = takeOption(args, '--parent');
+    const revision = takeOption(args, '--revision');
+    const replaceAssetId = takeOption(args, '--replace');
+    noExtra(args);
+    if (!source || !project)
+        throw new CliError('Use `assets upload FILE --project PROJECT_ID`.', EXIT.usage, 'asset_arguments_required');
+    const path = resolveLocalPath(source);
+    const metadata = await lstat(path);
+    if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size < 1)
+        throw new CliError('Assets must be non-empty regular files, not symbolic links.', EXIT.validation, 'invalid_asset_file');
+    const mediaType = ASSET_MEDIA_TYPES[extname(path).toLowerCase()];
+    if (!mediaType)
+        throw new CliError('Upload PNG, JPEG, GIF, WebP, ICO, WOFF, WOFF2, MP3, or MP4 files.', EXIT.validation, 'asset_type_not_supported');
+    const body = await readFile(path);
+    const checksum = createHash('sha256').update(body).digest('hex');
+    const client = await ApiClient.create(profile);
+    const reservation = await client.request(`/api/sites/${encodeURIComponent(project)}/assets/`, { method: 'POST', body: JSON.stringify({ name: basename(path), media_type: mediaType, size_bytes: body.length, checksum_sha256: checksum, ...(parentId ? { parent_id: parentId } : {}), ...(revision ? { revision } : {}), ...(replaceAssetId ? { replace_asset_id: replaceAssetId } : {}) }) });
+    let uploadUrl;
+    try {
+        uploadUrl = new URL(reservation.upload_url);
+    }
+    catch {
+        throw new CliError('BlinkHost returned an invalid upload address.', EXIT.remote, 'asset_upload_url_invalid');
+    }
+    if (uploadUrl.protocol !== 'https:' || !uploadUrl.hostname.endsWith('.blob.core.windows.net'))
+        throw new CliError('BlinkHost returned an untrusted upload address.', EXIT.remote, 'asset_upload_url_untrusted');
+    const uploaded = await fetch(uploadUrl, { method: 'PUT', redirect: 'error', headers: { ...reservation.required_headers, 'Content-Length': String(body.length) }, body });
+    if (!uploaded.ok)
+        throw new CliError(`Asset storage rejected the upload with HTTP ${uploaded.status}.`, EXIT.remote, 'asset_upload_failed');
+    for (let attempt = 0; attempt < 15; attempt += 1) {
+        try {
+            return await client.request(`/api/sites/${encodeURIComponent(project)}/assets/${encodeURIComponent(reservation.asset_id)}/complete/`, { method: 'POST', body: JSON.stringify({ ...(revision ? { revision } : {}) }) });
+        }
+        catch (error) {
+            if (!(error instanceof CliError) || error.code !== 'api_409' || attempt === 14)
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+        }
+    }
+    throw new CliError('Asset validation did not complete in time.', EXIT.remote, 'asset_validation_timeout');
+}
+//# sourceMappingURL=remote.js.map

package/dist/templates.d.ts

@@ -0,0 +1,17 @@
+import type { BlinkHostManifest, FrontendFramework, ModuleLanguage, PackageManager } from './manifest.js';
+export interface ScaffoldModule {
+    name: string;
+    language: ModuleLanguage;
+}
+export interface ScaffoldOptions {
+    name: string;
+    framework: FrontendFramework;
+    packageManager: PackageManager;
+    modules: ScaffoldModule[];
+    database?: string;
+}
+export interface Scaffold {
+    manifest: BlinkHostManifest;
+    files: Map<string, string>;
+}
+export declare function createScaffold(options: ScaffoldOptions): Scaffold;

package/dist/templates.js

@@ -0,0 +1,109 @@
+const VERSIONS = {
+    vite: '6.4.3', typescript: '5.9.3', react: '19.2.8', vue: '3.5.40',
+    svelte: '5.56.8', solid: '1.9.14', astro: '7.1.6',
+};
+function commands(manager) {
+    return {
+        install: manager === 'npm' ? 'npm ci' : `${manager} install --frozen-lockfile`,
+        build: `${manager} run build`,
+        dev: `${manager} run dev`,
+    };
+}
+function frontendFiles(name, framework) {
+    const files = new Map();
+    files.set('.npmrc', 'engine-strict=true\nignore-scripts=true\naudit=false\nfund=false\nprefer-offline=true\n');
+    if (framework === 'html') {
+        files.set('index.html', '<!doctype html>\n<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>BlinkHost project</title><link rel="stylesheet" href="style.css"></head><body><main><h1>Ready to build on BlinkHost</h1></main><script type="module" src="script.js"></script></body></html>\n');
+        files.set('style.css', ':root { font-family: Inter, system-ui, sans-serif; color-scheme: dark; }\nbody { margin: 0; padding: 3rem; background: #071113; color: #f8fafc; }\n');
+        files.set('script.js', "console.info('BlinkHost project ready');\n");
+        return files;
+    }
+    if (framework === 'astro') {
+        files.set('package.json', JSON.stringify({ name, private: true, version: '0.1.0', type: 'module', scripts: { dev: 'astro dev --host 0.0.0.0 --port 3000', build: 'astro build' }, dependencies: { astro: VERSIONS.astro } }, null, 2) + '\n');
+        files.set('astro.config.mjs', "import { defineConfig } from 'astro/config';\nexport default defineConfig({ server: { host: '0.0.0.0', port: 3000 } });\n");
+        files.set('src/pages/index.astro', '---\nconst title = "Ready to build on BlinkHost";\n---\n<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width"><title>{title}</title></head><body><main><h1>{title}</h1></main></body></html>\n');
+        return files;
+    }
+    const base = { name, private: true, version: '0.1.0', type: 'module', scripts: { dev: 'vite --host 0.0.0.0 --port 3000', build: 'vite build' } };
+    files.set('index.html', '<!doctype html>\n<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>BlinkHost project</title></head><body><div id="root"></div><script type="module" src="/src/main.tsx"></script></body></html>\n');
+    if (framework === 'react') {
+        files.set('package.json', JSON.stringify({ ...base, dependencies: { react: VERSIONS.react, 'react-dom': VERSIONS.react }, devDependencies: { '@vitejs/plugin-react': '4.7.0', '@types/react': '19.2.17', '@types/react-dom': '19.2.3', typescript: VERSIONS.typescript, vite: VERSIONS.vite } }, null, 2) + '\n');
+        files.set('vite.config.ts', "import { defineConfig } from 'vite';\nimport react from '@vitejs/plugin-react';\nexport default defineConfig({ plugins: [react()], server: { host: '0.0.0.0', port: 3000 } });\n");
+        files.set('src/main.tsx', "import React from 'react';\nimport { createRoot } from 'react-dom/client';\nimport './style.css';\ncreateRoot(document.getElementById('root')!).render(<React.StrictMode><main><h1>Ready to build on BlinkHost</h1></main></React.StrictMode>);\n");
+    }
+    else if (framework === 'vue') {
+        files.set('package.json', JSON.stringify({ ...base, dependencies: { vue: VERSIONS.vue }, devDependencies: { '@vitejs/plugin-vue': '5.2.4', typescript: VERSIONS.typescript, vite: VERSIONS.vite, 'vue-tsc': '3.3.8' } }, null, 2) + '\n');
+        files.set('vite.config.ts', "import { defineConfig } from 'vite';\nimport vue from '@vitejs/plugin-vue';\nexport default defineConfig({ plugins: [vue()], server: { host: '0.0.0.0', port: 3000 } });\n");
+        files.set('index.html', files.get('index.html').replace('/src/main.tsx', '/src/main.ts'));
+        files.set('src/main.ts', "import { createApp } from 'vue';\nimport App from './App.vue';\ncreateApp(App).mount('#root');\n");
+        files.set('src/App.vue', '<template><main><h1>Ready to build on BlinkHost</h1></main></template>\n');
+    }
+    else if (framework === 'svelte') {
+        files.set('package.json', JSON.stringify({ ...base, devDependencies: { '@sveltejs/vite-plugin-svelte': '5.1.1', svelte: VERSIONS.svelte, vite: VERSIONS.vite } }, null, 2) + '\n');
+        files.set('vite.config.ts', "import { defineConfig } from 'vite';\nimport { svelte } from '@sveltejs/vite-plugin-svelte';\nexport default defineConfig({ plugins: [svelte()], server: { host: '0.0.0.0', port: 3000 } });\n");
+        files.set('index.html', files.get('index.html').replace('/src/main.tsx', '/src/main.ts'));
+        files.set('src/main.ts', "import { mount } from 'svelte';\nimport App from './App.svelte';\nmount(App, { target: document.getElementById('root')! });\n");
+        files.set('src/App.svelte', '<main><h1>Ready to build on BlinkHost</h1></main>\n');
+    }
+    else {
+        files.set('package.json', JSON.stringify({ ...base, dependencies: { 'solid-js': VERSIONS.solid }, devDependencies: { 'vite-plugin-solid': '2.11.14', vite: VERSIONS.vite } }, null, 2) + '\n');
+        files.set('vite.config.ts', "import { defineConfig } from 'vite';\nimport solid from 'vite-plugin-solid';\nexport default defineConfig({ plugins: [solid()], server: { host: '0.0.0.0', port: 3000 } });\n");
+        files.set('src/main.tsx', "import { render } from 'solid-js/web';\nrender(() => <main><h1>Ready to build on BlinkHost</h1></main>, document.getElementById('root')!);\n");
+    }
+    files.set('src/style.css', ':root { font-family: Inter, system-ui, sans-serif; color-scheme: dark; }\nbody { margin: 0; padding: 3rem; background: #071113; color: #f8fafc; }\n');
+    files.set('tsconfig.json', JSON.stringify({ compilerOptions: { target: 'ES2022', module: 'ESNext', moduleResolution: 'bundler', strict: true, noEmit: true, jsx: framework === 'solid' ? 'preserve' : 'react-jsx' }, include: ['src'] }, null, 2) + '\n');
+    return files;
+}
+function moduleFiles(module) {
+    const root = `_server_islands/${module.name}`;
+    const files = new Map();
+    if (module.language === 'python') {
+        files.set(`${root}/main.py`, 'def handler(request):\n    return {"status": 200, "body": {"ok": True}}\n');
+        files.set(`${root}/requirements.txt`, '# Add pinned runtime dependencies here.\n');
+        return { entrypoint: 'main.py', files };
+    }
+    if (module.language === 'go') {
+        files.set(`${root}/go.mod`, `module blinkhost/${module.name}\n\ngo 1.23\n`);
+        files.set(`${root}/main.go`, 'package main\n\nfunc main() {}\n');
+        return { entrypoint: 'main.go', files };
+    }
+    files.set(`${root}/Cargo.toml`, `[package]\nname = "${module.name}"\nversion = "0.1.0"\nedition = "2021"\n\n[lib]\ncrate-type = ["cdylib"]\n`);
+    files.set(`${root}/src/lib.rs`, '#[no_mangle]\npub extern "C" fn blinkhost_module_version() -> u32 { 1 }\n');
+    return { entrypoint: 'src/lib.rs', files };
+}
+export function createScaffold(options) {
+    const packageCommands = commands(options.packageManager);
+    const files = frontendFiles(options.name, options.framework);
+    const modules = [];
+    for (const item of options.modules) {
+        const generated = moduleFiles(item);
+        for (const [path, contents] of generated.files)
+            files.set(path, contents);
+        modules.push({ name: item.name, path: `_server_islands/${item.name}`, language: item.language, entrypoint: generated.entrypoint, abi: 'blinkhost-wasi-1', sdk: '1.1' });
+    }
+    const databases = options.database ? [{ binding: options.database, schema: `database/${options.database}/schema.sql`, migrations: `database/${options.database}/migrations` }] : [];
+    if (options.database) {
+        files.set(`database/${options.database}/schema.sql`, '-- Keep the current reviewable schema here.\n');
+        files.set(`database/${options.database}/migrations/README.md`, 'Add ordered, forward-only SQL migrations in this directory.\n');
+    }
+    files.set('.gitignore', 'node_modules/\ndist/\n.env\n.env.*\n!.env.example\n.blinkhost/\n');
+    files.set('README.md', `# ${options.name}\n\nCreated with the BlinkHost CLI. Run \`blinkhost validate\` before connecting this repository.\n`);
+    return {
+        manifest: {
+            schema: 'blinkhost/v1', application: { root: '.' },
+            frontend: {
+                root: '.', dependency_root: '.', framework: options.framework, package_manager: options.packageManager,
+                install: options.framework === 'html' ? '' : packageCommands.install,
+                build: options.framework === 'html' ? '' : packageCommands.build,
+                dev: options.framework === 'html' ? '' : packageCommands.dev,
+                output: options.framework === 'html' ? '.' : 'dist',
+            },
+            modules,
+            resources: { databases, secrets: [] },
+            preview: { enabled: true, database_mode: options.database ? 'isolated_branch' : 'none' },
+            ignore: ['.blinkhost', 'node_modules', 'dist'],
+        },
+        files,
+    };
+}
+//# sourceMappingURL=templates.js.map

package/dist/workflows.d.ts

@@ -0,0 +1,8 @@
+export declare function runDev(input: string[]): Promise<unknown>;
+export declare function testProject(input: string[]): Promise<unknown>;
+export declare function observability(kind: 'logs' | 'metrics' | 'analytics', input: string[], profile?: string): Promise<unknown>;
+export declare function runPlugins(input: string[]): Promise<unknown>;
+export declare function completion(shell: string | undefined): string;
+export declare function checkForUpdate(): Promise<unknown>;
+export declare function ciCheck(profile?: string): Promise<unknown>;
+export declare function supportBundle(input: string[], profile?: string): Promise<unknown>;