cloudflare-tunnel-kit 0.1.2 → 0.1.4

package/README.md

@@ -35,40 +35,52 @@ The toolkit does not concatenate user input into shell commands, print secrets t
 
 ## Installation
 
-Install the package after it is published:
+Install the package in the project that needs a tunnel:
 
 ```bash
 npm install --save-dev cloudflare-tunnel-kit
 ```
 
-For a source checkout:
+The package exposes the `cf-tunnel` binary locally. Run it through `npx` so no global installation is required:
 
 ```bash
-npm install
-npm run build
-node ./dist/cli/main.js --help
+npx cf-tunnel
+npx cf-tunnel ui
+```
+
+You can also add project scripts:
+
+```json
+{
+  "scripts": {
+    "tunnel": "cf-tunnel",
+    "tunnel:ui": "cf-tunnel ui"
+  }
+}
 ```
 
+Then run `npm run tunnel` or `npm run tunnel:ui`.
+
 ## CLI usage
 
 Check the local environment:
 
 ```bash
-cf-tunnel doctor
+npx cf-tunnel doctor
 ```
 
-Run `cf-tunnel` or `cf-tunnel init` without options to start the interactive text-only wizard. It asks for each value, validates before execution, prints a command preview, and asks for confirmation.
+Run `npx cf-tunnel` without options to start the interactive text-only wizard. It asks for each value, validates before execution, prints a command preview, and asks for confirmation.
 
 Preview a Quick Tunnel without starting `cloudflared`:
 
 ```bash
-cf-tunnel quick --url http://127.0.0.1:8000 --dry-run
+npx cf-tunnel quick --url http://127.0.0.1:8000 --dry-run
 ```
 
 Preview a named tunnel:
 
 ```bash
-cf-tunnel create \
+npx cf-tunnel create \
   --url http://127.0.0.1:8000 \
   --name my-project \
   --hostname tunnel.example.com \
@@ -78,39 +90,22 @@ cf-tunnel create \
 Lifecycle commands:
 
 ```text
-cf-tunnel start --name my-project
-cf-tunnel stop --name my-project
-cf-tunnel status --name my-project
+npx cf-tunnel start --name my-project
+npx cf-tunnel stop --name my-project
+npx cf-tunnel status --name my-project
 ```
 
 `--yes` does not bypass validation or Laravel `.env` confirmation.
 
-## Makefile shortcuts
-
-The repository includes a small Makefile for discoverable commands:
-
-```bash
-make setup
-make help
-make init
-make ui
-make quick URL=http://127.0.0.1:8000
-make create NAME=law-firm URL=http://127.0.0.1:8000
-make doctor
-make test
-```
-
-`make quick` and `make create` use `--dry-run` by default. Review the plan, then use the CLI to execute and confirm the operation explicitly.
-
 ## Live UI
 
 Start the local UI:
 
 ```bash
-cf-tunnel ui
+npx cf-tunnel ui
 ```
 
-Open the URL printed in the terminal, usually `http://127.0.0.1:<port>`. The wizard includes profile selection, local URL input, tunnel name, validation, plan preview, confirmation, execution, and a button to copy a redacted AI-help prompt.
+The command prints startup progress, chooses an available loopback port, and opens the browser automatically. If the browser cannot be opened, copy the printed `http://127.0.0.1:<port>` URL. Use `npx cf-tunnel ui --no-open` when you only want the URL.
 
 The UI binds to loopback by default and does not send the copied prompt anywhere.
 
@@ -119,8 +114,8 @@ The UI binds to loopback by default and does not send the copied prompt anywhere
 The custom profile makes no framework assumptions:
 
 ```bash
-cf-tunnel quick --profile custom --url http://127.0.0.1:3000 --dry-run
-cf-tunnel create --profile custom --url http://127.0.0.1:8000 --name billing --dry-run
+npx cf-tunnel quick --profile custom --url http://127.0.0.1:3000 --dry-run
+npx cf-tunnel create --profile custom --url http://127.0.0.1:8000 --name billing --hostname billing.example.com --dry-run
 ```
 
 ## Laravel profile
@@ -130,10 +125,11 @@ The Laravel adapter checks for `artisan` and Laravel evidence in `composer.json`
 Every mapping is shown as a diff and requires explicit confirmation. If `.env` is missing or ambiguous, the adapter stops with a remediation message instead of guessing.
 
 ```bash
-cf-tunnel create \
+npx cf-tunnel create \
   --profile laravel \
   --url http://127.0.0.1:8000 \
   --name law-firm \
+  --hostname law.example.com \
   --dry-run
 ```
 
@@ -214,6 +210,8 @@ An already-published `name@version` cannot be published again. See the [npm publ
 
 ## Development
 
+These commands are only for contributors working from a source checkout. Projects that install the npm package do not need this repository's Makefile.
+
 ```bash
 npm install
 npm test

package/dist/app/service.d.ts

@@ -0,0 +1,46 @@
+import type Database from 'better-sqlite3';
+interface PreparedPlan {
+    id: string;
+    kind: 'quick' | 'named';
+    input: any;
+    effects: string[];
+    confirmations: string[];
+    createdAt: number;
+}
+export declare class TunnelKitService {
+    private readonly plans;
+    private readonly store;
+    private readonly supervisor;
+    private readonly quickWorkflow;
+    private readonly namedWorkflow;
+    private readonly cloudflare;
+    constructor(options: {
+        store: any;
+        supervisor: any;
+        quickWorkflow: any;
+        namedWorkflow: any;
+        cloudflare: any;
+        database?: Database.Database;
+    });
+    private readonly database?;
+    listProjects(): Promise<any[]>;
+    getProject(id: string): Promise<any>;
+    prepareQuick(input: any): Promise<PreparedPlan>;
+    prepareNamed(input: any): Promise<PreparedPlan>;
+    private savePlan;
+    execute(id: string, confirmations: string[]): Promise<any>;
+    retry(projectId: string): Promise<any>;
+    stop(projectId: string): Promise<void>;
+    start(projectId: string): Promise<any>;
+    restart(projectId: string): Promise<any>;
+    relinkProject(projectId: string, nextPath: string): Promise<void>;
+    removeLocal(projectId: string): Promise<void>;
+    prepareCloudflareCleanup(projectId: string): Promise<any>;
+    doctor(): Promise<any>;
+    close(): void;
+}
+export declare function createTunnelKitService(options?: {
+    dataDir?: string;
+    cloudflaredExecutable?: string;
+}): TunnelKitService;
+export {};

package/dist/app/service.js

@@ -0,0 +1,102 @@
+import crypto from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { resolveAppPaths } from './paths.js';
+import { openStateDatabase } from '../persistence/database.js';
+import { StateStore } from '../persistence/store.js';
+import { ProcessSupervisor } from '../providers/process-supervisor.js';
+import { CloudflaredAdapter } from '../providers/cloudflared.js';
+import { QuickTunnelWorkflow } from '../core/quick-workflow.js';
+import { NamedTunnelWorkflow } from '../core/named-workflow.js';
+export class TunnelKitService {
+    plans = new Map();
+    store;
+    supervisor;
+    quickWorkflow;
+    namedWorkflow;
+    cloudflare;
+    constructor(options) {
+        Object.assign(this, options);
+        this.database = options.database;
+    }
+    database;
+    async listProjects() {
+        return this.store.listProjects().map((project) => {
+            const tunnel = this.store.getTunnelForProject(project.id);
+            let session;
+            try {
+                session = this.store.getLatestSession(project.id);
+            }
+            catch { }
+            const observed = session ? this.supervisor.status(session.processKey) : { state: 'stopped', logs: '' };
+            const status = !existsSync(project.path) ? 'Needs attention' : observed.state === 'running' ? 'Running' : 'Stopped';
+            return { ...project, status, kind: tunnel?.kind, hostname: tunnel?.hostname, localUrl: tunnel?.localUrl, publicUrl: session?.ephemeralUrlExpired ? undefined : session?.ephemeralUrl, processState: observed.state };
+        });
+    }
+    async getProject(id) {
+        const project = this.store.getProject(id);
+        const tunnel = this.store.getTunnelForProject(id);
+        let session;
+        try {
+            session = this.store.getLatestSession(id);
+        }
+        catch { }
+        const observed = session ? this.supervisor.status(session.processKey) : { state: 'stopped', logs: '' };
+        return { ...project, tunnel, session, health: { localProcess: observed.state, cloudflareConnector: 'unknown', publicHostname: 'unchecked' }, logs: observed.logs };
+    }
+    async prepareQuick(input) { return this.savePlan('quick', input, [`Start a temporary Quick Tunnel to ${input.localUrl}.`], ['start-connector']); }
+    async prepareNamed(input) { return this.savePlan('named', input, [`Create or reuse tunnel ${input.tunnelName}.`, `Create DNS route ${input.hostname}.`, `Start a connector to ${input.localUrl}.`], ['cloudflare-resources', 'start-connector']); }
+    savePlan(kind, input, effects, confirmations) {
+        const plan = { id: crypto.randomUUID(), kind, input, effects, confirmations, createdAt: Date.now() };
+        this.plans.set(plan.id, plan);
+        return plan;
+    }
+    async execute(id, confirmations) {
+        const plan = this.plans.get(id);
+        if (!plan)
+            throw new Error('Plan not found or expired.');
+        if (Date.now() - plan.createdAt > 10 * 60_000) {
+            this.plans.delete(id);
+            throw new Error('Plan expired. Review the settings again.');
+        }
+        const missing = plan.confirmations.filter(item => !confirmations.includes(item));
+        if (missing.length)
+            throw new Error(`Confirmation required for: ${missing.join(', ')}`);
+        this.plans.delete(id);
+        return plan.kind === 'quick' ? this.quickWorkflow.run(plan.input) : this.namedWorkflow.run(plan.input);
+    }
+    async retry(projectId) { const tunnel = this.store.getTunnelForProject(projectId); return tunnel?.kind === 'named' ? this.namedWorkflow.retry(projectId) : this.quickWorkflow.restart(projectId); }
+    async stop(projectId) { const tunnel = this.store.getTunnelForProject(projectId); return tunnel?.kind === 'named' ? this.namedWorkflow.stop(projectId) : this.quickWorkflow.stop(projectId); }
+    async start(projectId) { return this.retry(projectId); }
+    async restart(projectId) { try {
+        await this.stop(projectId);
+    }
+    catch { } return this.start(projectId); }
+    async relinkProject(projectId, nextPath) { if (!nextPath?.trim())
+        throw new Error('A new project folder is required.'); this.store.relinkProject(projectId, nextPath); }
+    async removeLocal(projectId) {
+        let session;
+        try {
+            session = this.store.getLatestSession(projectId);
+        }
+        catch { }
+        if (session && this.supervisor.status(session.processKey).state === 'running')
+            throw new Error('Stop the connector before removing this project from the local dashboard.');
+        this.store.removeProject(projectId);
+    }
+    async prepareCloudflareCleanup(projectId) {
+        const tunnel = this.store.getTunnelForProject(projectId);
+        return { enabled: false, code: 'CLOUDFLARE_CLEANUP_NOT_ENABLED', resources: tunnel ? { tunnelUuid: tunnel.uuid, hostname: tunnel.hostname, configPath: tunnel.configPath } : {}, message: 'Cloudflare resource deletion is not enabled in this release. Remove resources explicitly in the Cloudflare dashboard.' };
+    }
+    async doctor() { const version = await this.cloudflare.version(); return { ok: version.ok, checks: [{ name: 'Node.js', state: 'passed', detail: process.version }, { name: 'cloudflared', state: version.ok ? 'passed' : 'failed', detail: version.ok ? version.value.version : version.error.summary }] }; }
+    close() { this.database?.close(); }
+}
+export function createTunnelKitService(options = {}) {
+    const paths = options.dataDir ? { dataDir: options.dataDir, database: `${options.dataDir}/state.db`, projectsDir: `${options.dataDir}/projects`, backupsDir: `${options.dataDir}/backups` } : resolveAppPaths();
+    const database = openStateDatabase(paths.database);
+    const store = new StateStore(database);
+    const supervisor = new ProcessSupervisor();
+    const cloudflare = new CloudflaredAdapter({ executable: options.cloudflaredExecutable });
+    const quickWorkflow = new QuickTunnelWorkflow({ store, supervisor, executable: options.cloudflaredExecutable });
+    const namedWorkflow = new NamedTunnelWorkflow({ store, supervisor, cloudflare, projectsDir: paths.projectsDir, executable: options.cloudflaredExecutable });
+    return new TunnelKitService({ store, supervisor, quickWorkflow, namedWorkflow, cloudflare, database });
+}

package/dist/cli/main.js

@@ -1,37 +1,86 @@
 #!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { stdin } from 'node:process';
 import { createServer } from '../ui/server.js';
-import { createTunnelPlan, executeTunnelPlan } from '../index.js';
-import { createLaravelPlan } from '../index.js';
+import { launchBrowser } from '../providers/browser.js';
+import { createTunnelKitService } from '../app/service.js';
 import { runWizard } from './wizard.js';
 const args = process.argv.slice(2);
 const command = args[0] ?? 'init';
-const value = (name) => { const i = args.indexOf(name); return i >= 0 ? args[i + 1] : undefined; };
-function help() { console.log(`cloudflare-tunnel-kit 0.1.0\n\nUsage: cf-tunnel <command> [options]\n\nCommands: init create quick start stop status doctor ui\nOptions: --url URL --name NAME --hostname HOST --profile custom|laravel --config PATH --dry-run --yes --no-open`); }
+const packageVersion = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8')).version;
+const value = (name) => { const index = args.indexOf(name); return index >= 0 ? args[index + 1] : undefined; };
+function help() { console.log(`cloudflare-tunnel-kit ${packageVersion}\n\nUsage from an installed project:\n  npx cf-tunnel\n  npx cf-tunnel ui\n\nCommands: init create quick start stop restart status doctor ui\nOptions: --url URL --name NAME --hostname HOST --profile custom|laravel --project ID --dry-run --yes --json --no-open`); }
+function interactiveRequired() { console.error('[INTERACTIVE_INPUT_REQUIRED] This command needs wizard input, but the terminal is not interactive.\nRun `npx cf-tunnel ui` or provide all required flags with `--yes`.'); process.exit(2); }
+async function startUi() {
+    console.log('Starting Cloudflare Tunnel Kit UI on this machine...');
+    const service = createTunnelKitService({ dataDir: process.env.CLOUDFLARE_TUNNEL_KIT_DATA_DIR });
+    const server = createServer({ service });
+    server.once('error', error => { console.error(`Unable to start the local UI: ${error.message}`); console.error('Run `npx cf-tunnel ui` again after checking local server permissions.'); process.exitCode = 1; service.close(); });
+    server.listen(0, '127.0.0.1', async () => { const address = server.address(); if (!address || typeof address === 'string')
+        return; const url = `http://127.0.0.1:${address.port}`; console.log(`UI ready at ${url}`); if (!args.includes('--no-open'))
+        console.log((await launchBrowser(url)).message); });
+    process.once('SIGINT', () => server.close(() => { service.close(); process.exit(130); }));
+}
 async function main() {
-    if (command === 'init') {
-        if (args.length === 1)
-            return runWizard();
-    }
-    if (command === 'help' || command === '--help')
+    if (['help', '--help', '-h'].includes(command))
         return help();
-    if (command === 'ui') {
-        const server = createServer();
-        server.listen(0, '127.0.0.1', () => { const a = server.address(); console.log(`UI ready at http://127.0.0.1:${a.port}`); });
+    if (command === 'ui')
+        return startUi();
+    if (command === 'init' && !stdin.isTTY)
+        interactiveRequired();
+    const service = createTunnelKitService({ dataDir: process.env.CLOUDFLARE_TUNNEL_KIT_DATA_DIR });
+    if (command === 'init')
+        return runWizard(service);
+    if (command === 'doctor') {
+        const report = await service.doctor();
+        console.log(JSON.stringify(report, null, 2));
+        service.close();
         return;
     }
-    if (command === 'doctor') {
-        console.log('Doctor: use `cf-tunnel quick --url http://127.0.0.1:8000 --dry-run` to validate a project without starting cloudflared.');
+    if (command === 'quick' || command === 'create') {
+        const mode = command === 'quick' ? 'quick' : 'named';
+        const localUrl = value('--url');
+        const tunnelName = value('--name');
+        const hostname = value('--hostname');
+        if (!localUrl || (mode === 'named' && (!tunnelName || !hostname))) {
+            if (!stdin.isTTY)
+                interactiveRequired();
+            return runWizard(service, mode);
+        }
+        const input = { projectPath: value('--path') ?? process.cwd(), displayName: value('--project-name'), profile: value('--profile') === 'laravel' ? 'laravel' : 'custom', localUrl, tunnelName, hostname };
+        const plan = mode === 'quick' ? await service.prepareQuick(input) : await service.prepareNamed(input);
+        if (args.includes('--dry-run')) {
+            console.log(JSON.stringify(plan, null, 2));
+            service.close();
+            return;
+        }
+        if (!args.includes('--yes')) {
+            if (!stdin.isTTY)
+                interactiveRequired();
+            return runWizard(service, mode);
+        }
+        console.log(JSON.stringify(await service.execute(plan.id, plan.confirmations), null, 2));
         return;
     }
-    const operation = (command === 'init' ? 'create' : command);
-    const config = { profile: value('--profile') ?? 'custom', operation, localUrl: value('--url') ?? 'http://127.0.0.1:8000', tunnelName: value('--name'), hostname: value('--hostname'), configPath: value('--config') };
-    const plan = config.profile === 'laravel' ? createLaravelPlan(config) : createTunnelPlan(config);
-    console.log(JSON.stringify({ summary: plan.summary, issues: plan.issues, argv: plan.argv, confirmations: plan.confirmations }, null, 2));
-    if (!plan.valid || args.includes('--dry-run'))
+    if (['start', 'stop', 'restart', 'status', 'retry'].includes(command)) {
+        const projectId = value('--project');
+        if (!projectId) {
+            if (!stdin.isTTY)
+                interactiveRequired();
+            return runWizard(service);
+        }
+        const result = command === 'status' ? await service.getProject(projectId)
+            : command === 'start' ? await service.start(projectId)
+                : command === 'stop' ? await service.stop(projectId)
+                    : command === 'restart' ? await service.restart(projectId)
+                        : await service.retry(projectId);
+        console.log(JSON.stringify(result, null, 2));
+        if (command === 'status' || command === 'stop')
+            service.close();
         return;
-    const result = await executeTunnelPlan(plan, { confirmed: args.includes('--yes') ? plan.confirmations : [] });
-    console.log(JSON.stringify(result, null, 2));
-    if (!result.ok)
-        process.exitCode = 1;
+    }
+    help();
+    process.exitCode = 2;
+    service.close();
 }
-main().catch(e => { console.error(e instanceof Error ? e.message : String(e)); process.exitCode = 1; });
+main().catch(error => { console.error(error instanceof Error ? error.message : String(error)); process.exitCode = 1; });

package/dist/cli/wizard.d.ts

@@ -1,3 +1,4 @@
 import type { TunnelPlan } from '../core/types.js';
 export declare function formatWizardSummary(plan: Pick<TunnelPlan, 'valid' | 'summary' | 'issues' | 'argv' | 'confirmations'>): string;
-export declare function runWizard(): Promise<void>;
+export declare function mainMenu(): string;
+export declare function runWizard(service: any, initialMode?: 'quick' | 'named'): Promise<void>;

package/dist/cli/wizard.js

@@ -1,38 +1,82 @@
 import { createInterface } from 'node:readline/promises';
 import { stdin, stdout } from 'node:process';
-import { createTunnelPlan } from '../core/plan.js';
-import { createLaravelPlan } from '../adapters/laravel.js';
-import { executeTunnelPlan } from '../core/execution.js';
 export function formatWizardSummary(plan) {
     const lines = [plan.valid ? 'Validation passed.' : 'Validation failed.', plan.summary];
-    for (const i of plan.issues)
-        lines.push(`\n[${i.code}]${i.field ? ` ${i.field}` : ''}\nReason: ${i.reason}\nFix: ${i.fix}`);
+    for (const issue of plan.issues)
+        lines.push(`\n[${issue.code}]${issue.field ? ` ${issue.field}` : ''}\nReason: ${issue.reason}\nFix: ${issue.fix}`);
     if (plan.valid)
         lines.push(`\nCommand preview: cloudflared ${plan.argv.join(' ')}`);
     if (plan.confirmations.length)
         lines.push(`\nConfirmation required: ${plan.confirmations.join(', ')}`);
     return lines.join('\n');
 }
-export async function runWizard() {
+export function mainMenu() {
+    return `What would you like to do?\n\n  1. Create a Quick Tunnel\n  2. Set up a custom domain\n  3. Open a saved project\n  4. Check system requirements`;
+}
+export async function runWizard(service, initialMode) {
     const rl = createInterface({ input: stdin, output: stdout });
     try {
-        const profileInput = (await rl.question('Profile [custom/laravel] (custom): ')).trim() || 'custom';
-        const operationInput = (await rl.question('Operation [quick/create] (quick): ')).trim() || 'quick';
-        const localUrl = (await rl.question('Local URL (http://127.0.0.1:8000): ')).trim() || 'http://127.0.0.1:8000';
-        const tunnelName = (await rl.question('Tunnel name (optional): ')).trim() || undefined;
-        const hostname = (await rl.question('Hostname (optional): ')).trim() || undefined;
-        const config = { profile: profileInput, operation: operationInput, localUrl, tunnelName, hostname };
-        const plan = config.profile === 'laravel' ? createLaravelPlan(config) : createTunnelPlan(config);
-        console.log(`\n${formatWizardSummary(plan)}`);
-        if (!plan.valid)
-            return;
-        const answer = (await rl.question('\nExecute this plan? [y/N]: ')).trim().toLowerCase();
-        if (answer === 'y' || answer === 'yes')
-            console.log(JSON.stringify(await executeTunnelPlan(plan, { confirmed: plan.confirmations }), null, 2));
-        else
+        console.log('\nCloudflare Tunnel Kit\n');
+        let mode = initialMode;
+        if (!mode) {
+            console.log(mainMenu());
+            const choice = (await rl.question('\nChoose [1-4]: ')).trim();
+            if (choice === '3')
+                return openSaved(service, rl);
+            if (choice === '4')
+                return printDoctor(await service.doctor());
+            mode = choice === '2' ? 'named' : 'quick';
+        }
+        const displayName = (await rl.question('Project name: ')).trim() || 'Local project';
+        const projectPath = (await rl.question(`Project folder (${process.cwd()}): `)).trim() || process.cwd();
+        const localUrl = (await rl.question('Local application URL (http://127.0.0.1:8000): ')).trim() || 'http://127.0.0.1:8000';
+        const profileInput = (await rl.question('Project type [custom/laravel] (custom): ')).trim() || 'custom';
+        const input = { displayName, projectPath, localUrl, profile: profileInput === 'laravel' ? 'laravel' : 'custom' };
+        if (mode === 'named') {
+            input.tunnelName = (await rl.question('Tunnel name: ')).trim();
+            input.hostname = (await rl.question('Public hostname (for example dev.example.com): ')).trim();
+        }
+        const plan = mode === 'quick' ? await service.prepareQuick(input) : await service.prepareNamed(input);
+        console.log('\nReview changes:');
+        for (const effect of plan.effects)
+            console.log(`  - ${effect}`);
+        if (mode === 'named')
+            console.log('  - Cloudflare login may open in your browser if authentication is missing or stale.');
+        const answer = (await rl.question('\nConfirm and run? [y/N]: ')).trim().toLowerCase();
+        if (!['y', 'yes'].includes(answer)) {
             console.log('Cancelled. No changes were made.');
+            return;
+        }
+        console.log('\nRunning validated workflow...');
+        console.log(JSON.stringify(await service.execute(plan.id, plan.confirmations), null, 2));
     }
     finally {
         rl.close();
     }
 }
+async function openSaved(service, rl) {
+    const projects = await service.listProjects();
+    if (!projects.length) {
+        console.log('No saved projects were found on this machine.');
+        return;
+    }
+    projects.forEach((project, index) => console.log(`  ${index + 1}. ${project.displayName} — ${project.status}`));
+    const selected = Number((await rl.question('Choose a project: ')).trim()) - 1;
+    const project = projects[selected];
+    if (!project) {
+        console.log('Invalid project selection.');
+        return;
+    }
+    const action = (await rl.question('Action [start/stop/retry/status] (status): ')).trim() || 'status';
+    if (action === 'status')
+        console.log(JSON.stringify(await service.getProject(project.id), null, 2));
+    else if (['start', 'stop', 'retry'].includes(action))
+        console.log(JSON.stringify(await service[action](project.id), null, 2));
+    else
+        console.log('Unknown action.');
+}
+function printDoctor(report) {
+    console.log('\nSystem requirements:');
+    for (const check of report.checks)
+        console.log(`  ${check.state === 'passed' ? '✓' : '✗'} ${check.name}: ${check.detail}`);
+}

package/dist/core/named-workflow.d.ts

@@ -0,0 +1,47 @@
+import type { Profile } from './types.js';
+import { type OriginCheckResult } from './origin-check.js';
+import type { StateStore } from '../persistence/store.js';
+import type { ProcessSupervisor } from '../providers/process-supervisor.js';
+interface CloudflarePort {
+    version(): Promise<any>;
+    login(): Promise<any>;
+    listTunnels(): Promise<any>;
+    createTunnel(name: string): Promise<any>;
+    validateIngress(configPath: string): Promise<any>;
+    routeDns(tunnel: string, hostname: string): Promise<any>;
+    info(tunnel: string): Promise<any>;
+}
+export declare class NamedTunnelWorkflow {
+    private readonly store;
+    private readonly cloudflare;
+    private readonly supervisor;
+    private readonly projectsDir;
+    private readonly executable;
+    private readonly baseArgs;
+    private readonly env?;
+    private readonly originCheck;
+    private readonly publicCheck;
+    constructor(options: {
+        store: StateStore;
+        cloudflare: CloudflarePort;
+        supervisor: ProcessSupervisor;
+        projectsDir: string;
+        executable?: string;
+        baseArgs?: string[];
+        env?: NodeJS.ProcessEnv;
+        originCheck?: (url: string) => Promise<OriginCheckResult>;
+        publicCheck?: (url: string) => Promise<OriginCheckResult>;
+    });
+    run(input: {
+        projectPath: string;
+        displayName?: string;
+        profile: Profile;
+        localUrl: string;
+        tunnelName: string;
+        hostname: string;
+    }): Promise<any>;
+    retry(projectId: string): Promise<any>;
+    private execute;
+    stop(projectId: string): Promise<void>;
+}
+export {};

package/dist/core/named-workflow.js

@@ -0,0 +1,134 @@
+import path from 'node:path';
+import { mkdir, rename, stat, writeFile } from 'node:fs/promises';
+import { checkOrigin } from './origin-check.js';
+import { validateTunnelConfig } from './validation.js';
+import { WorkflowRunner } from './workflow.js';
+export class NamedTunnelWorkflow {
+    store;
+    cloudflare;
+    supervisor;
+    projectsDir;
+    executable;
+    baseArgs;
+    env;
+    originCheck;
+    publicCheck;
+    constructor(options) {
+        this.store = options.store;
+        this.cloudflare = options.cloudflare;
+        this.supervisor = options.supervisor;
+        this.projectsDir = options.projectsDir;
+        this.executable = options.executable ?? 'cloudflared';
+        this.baseArgs = options.baseArgs ?? [];
+        this.env = options.env;
+        this.originCheck = options.originCheck ?? (url => checkOrigin(url));
+        this.publicCheck = options.publicCheck ?? (url => checkOrigin(url, { timeoutMs: 10_000 }));
+    }
+    async run(input) {
+        const project = this.store.saveProject({ displayName: input.displayName ?? path.basename(input.projectPath), path: path.resolve(input.projectPath), profile: input.profile });
+        return this.execute(project.id, input);
+    }
+    async retry(projectId) {
+        const project = this.store.getProject(projectId);
+        const tunnel = this.store.getTunnelForProject(projectId);
+        if (!tunnel?.name || !tunnel.hostname || !tunnel.localUrl)
+            throw new Error('Saved named tunnel settings are incomplete.');
+        return this.execute(projectId, { projectPath: project.path, displayName: project.displayName, profile: project.profile, localUrl: tunnel.localUrl, tunnelName: tunnel.name, hostname: tunnel.hostname });
+    }
+    async execute(projectId, input) {
+        const run = this.store.createWorkflow({ projectId, kind: 'named' });
+        const runner = new WorkflowRunner(this.store, run.id);
+        const validation = validateTunnelConfig({ profile: input.profile, operation: 'create', localUrl: input.localUrl, tunnelName: input.tunnelName, hostname: input.hostname, projectRoot: input.projectPath });
+        if (!validation.ok) {
+            runner.fail('input', validation.issues);
+            return { state: 'failed', projectId, runId: run.id, error: validation.issues[0] };
+        }
+        await runner.step('input', async () => ({ value: validation.normalized, effects: ['Validated tunnel settings.'] }));
+        const origin = await this.originCheck(input.localUrl);
+        if (!origin.reachable) {
+            runner.fail('origin', origin.error);
+            return { state: 'failed', projectId, runId: run.id, error: origin.error };
+        }
+        await runner.step('origin', async () => ({ state: origin.warning ? 'warning' : 'succeeded', value: origin, effects: ['Verified the local application.'] }));
+        const version = await this.cloudflare.version();
+        if (!version.ok) {
+            runner.fail('environment', version.error);
+            return { state: 'failed', projectId, runId: run.id, error: version.error };
+        }
+        await runner.step('environment', async () => ({ value: version.value, effects: ['Found cloudflared.'] }));
+        let listed = await this.cloudflare.listTunnels();
+        if (!listed.ok && ['AUTH_REQUIRED', 'AUTH_STALE'].includes(listed.error.code)) {
+            const login = await this.cloudflare.login();
+            if (!login.ok) {
+                runner.fail('authentication', login.error);
+                return { state: 'failed', projectId, runId: run.id, error: login.error };
+            }
+            await runner.step('authentication', async () => ({ value: login.value, effects: ['Signed in to Cloudflare.'] }));
+            listed = await this.cloudflare.listTunnels();
+        }
+        if (!listed.ok) {
+            runner.fail('account-access', listed.error);
+            return { state: 'failed', projectId, runId: run.id, error: listed.error };
+        }
+        await runner.step('account-access', async () => ({ value: { tunnelCount: listed.value.length }, effects: ['Verified Cloudflare account access.'] }));
+        let tunnel = this.store.getTunnelForProject(projectId);
+        if (!tunnel?.uuid) {
+            const conflict = listed.value.find((item) => item.name === input.tunnelName);
+            if (conflict) {
+                const error = { code: 'TUNNEL_NAME_CONFLICT', reason: `Tunnel ${input.tunnelName} already exists but is not managed by this local project.`, fix: 'Choose another name or explicitly adopt the existing tunnel.' };
+                runner.fail('tunnel', error);
+                return { state: 'failed', projectId, runId: run.id, error };
+            }
+            const created = await this.cloudflare.createTunnel(input.tunnelName);
+            if (!created.ok) {
+                runner.fail('tunnel', created.error);
+                return { state: 'failed', projectId, runId: run.id, error: created.error };
+            }
+            const configPath = path.join(this.projectsDir, projectId, 'config.yml');
+            tunnel = this.store.saveTunnel({ projectId, kind: 'named', name: input.tunnelName, uuid: created.value.uuid, hostname: input.hostname, localUrl: input.localUrl, configPath, credentialsPath: created.value.credentialsFile });
+            await runner.step('tunnel', async () => ({ value: { uuid: tunnel.uuid }, effects: [`Created tunnel ${input.tunnelName} (${tunnel.uuid}).`] }));
+        }
+        if (!tunnel.uuid || !tunnel.credentialsPath || !tunnel.configPath)
+            throw new Error('Saved tunnel identity is incomplete.');
+        try {
+            const credentialStat = await stat(tunnel.credentialsPath);
+            if (!credentialStat.isFile())
+                throw new Error();
+        }
+        catch {
+            const error = { code: 'TUNNEL_CREDENTIALS_MISSING', reason: 'The tunnel credential file is missing.', fix: 'Restore the credential file or create a new tunnel.' };
+            runner.fail('configuration', error);
+            return { state: 'failed', projectId, runId: run.id, error };
+        }
+        await mkdir(path.dirname(tunnel.configPath), { recursive: true, mode: 0o700 });
+        const yaml = `tunnel: ${JSON.stringify(tunnel.uuid)}\ncredentials-file: ${JSON.stringify(tunnel.credentialsPath)}\ningress:\n  - hostname: ${JSON.stringify(input.hostname)}\n    service: ${JSON.stringify(input.localUrl)}\n  - service: http_status:404\n`;
+        const temporary = `${tunnel.configPath}.tmp`;
+        await writeFile(temporary, yaml, { mode: 0o600 });
+        await rename(temporary, tunnel.configPath);
+        await runner.step('configuration', async () => ({ value: { configPath: tunnel.configPath }, effects: ['Wrote application-owned tunnel config outside the repository.'] }));
+        const ingress = await this.cloudflare.validateIngress(tunnel.configPath);
+        if (!ingress.ok) {
+            runner.fail('ingress-validation', ingress.error);
+            return { state: 'failed', projectId, runId: run.id, error: ingress.error };
+        }
+        await runner.step('ingress-validation', async () => ({ value: ingress.value, effects: ['Validated ingress rules.'] }));
+        const routed = await this.cloudflare.routeDns(tunnel.uuid, input.hostname);
+        if (!routed.ok) {
+            runner.fail('dns-route', routed.error);
+            return { state: 'failed', projectId, runId: run.id, error: routed.error, configPath: tunnel.configPath };
+        }
+        await runner.step('dns-route', async () => ({ value: routed.value, effects: [`Routed ${input.hostname} to the tunnel.`] }));
+        const sessionKey = `named:${tunnel.uuid}`;
+        const session = await this.supervisor.start({ key: sessionKey, executable: this.executable, args: [...this.baseArgs, 'tunnel', '--config', tunnel.configPath, 'run', tunnel.uuid], env: this.env });
+        await runner.step('connector', async () => ({ value: { pid: session.pid }, effects: ['Started the Cloudflare connector.'] }));
+        const info = await this.cloudflare.info(tunnel.uuid);
+        await runner.step('cloudflare-health', async () => ({ state: info.ok && info.value.connectorState === 'healthy' ? 'succeeded' : 'warning', value: info.ok ? info.value : info.error, effects: [] }));
+        const publicUrl = `https://${input.hostname}`;
+        const publicHealth = await this.publicCheck(publicUrl);
+        await runner.step('public-health', async () => ({ state: publicHealth.reachable ? 'succeeded' : 'warning', value: publicHealth, effects: [] }));
+        this.store.saveSession({ projectId, processKey: sessionKey, pid: session.pid, state: 'running', executable: this.executable });
+        this.store.completeWorkflow(run.id, 'succeeded');
+        return { state: 'succeeded', projectId, runId: run.id, publicUrl, configPath: tunnel.configPath, sessionKey, tunnelUuid: tunnel.uuid };
+    }
+    async stop(projectId) { const session = this.store.getLatestSession(projectId); await this.supervisor.stop(session.processKey); this.store.stopSession(session.id); }
+}

package/dist/core/quick-workflow.d.ts

@@ -0,0 +1,28 @@
+import type { Profile } from './types.js';
+import { type OriginCheckResult } from './origin-check.js';
+import type { StateStore } from '../persistence/store.js';
+import type { ProcessSupervisor } from '../providers/process-supervisor.js';
+export declare class QuickTunnelWorkflow {
+    private readonly store;
+    private readonly supervisor;
+    private readonly executable;
+    private readonly baseArgs;
+    private readonly env?;
+    private readonly originCheck;
+    constructor(options: {
+        store: StateStore;
+        supervisor: ProcessSupervisor;
+        executable?: string;
+        baseArgs?: string[];
+        env?: NodeJS.ProcessEnv;
+        originCheck?: (url: string) => Promise<OriginCheckResult>;
+    });
+    run(input: {
+        projectPath: string;
+        displayName?: string;
+        profile: Profile;
+        localUrl: string;
+    }): Promise<any>;
+    stop(projectId: string): Promise<void>;
+    restart(projectId: string): Promise<any>;
+}

package/dist/core/quick-workflow.js

@@ -0,0 +1,61 @@
+import path from 'node:path';
+import { checkOrigin } from './origin-check.js';
+import { WorkflowRunner } from './workflow.js';
+export class QuickTunnelWorkflow {
+    store;
+    supervisor;
+    executable;
+    baseArgs;
+    env;
+    originCheck;
+    constructor(options) {
+        this.store = options.store;
+        this.supervisor = options.supervisor;
+        this.executable = options.executable ?? 'cloudflared';
+        this.baseArgs = options.baseArgs ?? [];
+        this.env = options.env;
+        this.originCheck = options.originCheck ?? (url => checkOrigin(url));
+    }
+    async run(input) {
+        const project = this.store.saveProject({ displayName: input.displayName ?? path.basename(input.projectPath), path: path.resolve(input.projectPath), profile: input.profile });
+        this.store.saveTunnel({ projectId: project.id, kind: 'quick', localUrl: input.localUrl });
+        const run = this.store.createWorkflow({ projectId: project.id, kind: 'quick' });
+        const runner = new WorkflowRunner(this.store, run.id);
+        const origin = await this.originCheck(input.localUrl);
+        if (!origin.reachable) {
+            runner.fail('origin', origin.error);
+            return { state: 'failed', projectId: project.id, runId: run.id, error: origin.error };
+        }
+        await runner.step('origin', async () => ({ state: origin.warning ? 'warning' : 'succeeded', value: origin, effects: ['Verified the local application is reachable.'] }));
+        const sessionKey = `quick:${project.id}`;
+        try {
+            const session = await this.supervisor.start({ key: sessionKey, executable: this.executable, args: [...this.baseArgs, 'tunnel', '--url', input.localUrl], env: this.env });
+            const logs = await session.waitForOutput(/https:\/\/[-a-z0-9]+\.trycloudflare\.com/i, 15_000);
+            const publicUrl = logs.match(/https:\/\/[-a-z0-9]+\.trycloudflare\.com/i)?.[0];
+            if (!publicUrl)
+                throw new Error('Quick Tunnel URL was not received.');
+            await runner.step('connector', async () => ({ value: { publicUrl }, effects: [`Started Quick Tunnel at ${publicUrl}.`] }));
+            this.store.saveSession({ projectId: project.id, processKey: sessionKey, pid: session.pid, state: 'running', ephemeralUrl: publicUrl, executable: this.executable });
+            this.store.completeWorkflow(run.id, 'succeeded');
+            return { state: 'succeeded', projectId: project.id, runId: run.id, sessionKey, publicUrl };
+        }
+        catch (error) {
+            await this.supervisor.stop(sessionKey);
+            const safe = { code: 'QUICK_URL_NOT_RECEIVED', reason: error instanceof Error ? error.message : String(error), fix: 'Check cloudflared connectivity and retry.' };
+            runner.fail('connector', safe);
+            return { state: 'failed', projectId: project.id, runId: run.id, error: safe };
+        }
+    }
+    async stop(projectId) {
+        const saved = this.store.getLatestSession(projectId);
+        await this.supervisor.stop(saved.processKey);
+        this.store.stopSession(saved.id);
+    }
+    async restart(projectId) {
+        const project = this.store.getProject(projectId);
+        const tunnel = this.store.getTunnelForProject(projectId);
+        if (!tunnel?.localUrl)
+            throw new Error('Saved Quick Tunnel settings are incomplete.');
+        return this.run({ projectPath: project.path, displayName: project.displayName, profile: project.profile, localUrl: tunnel.localUrl });
+    }
+}

package/dist/core/workflow.d.ts

@@ -0,0 +1,12 @@
+import type { StateStore } from '../persistence/store.js';
+export declare class WorkflowRunner {
+    private readonly store;
+    readonly runId: string;
+    constructor(store: StateStore, runId: string);
+    step<T>(name: string, operation: () => Promise<{
+        state?: 'succeeded' | 'warning';
+        value?: T;
+        effects?: string[];
+    }>): Promise<T | undefined>;
+    fail(name: string, error: unknown): void;
+}

package/dist/core/workflow.js

@@ -0,0 +1,19 @@
+export class WorkflowRunner {
+    store;
+    runId;
+    constructor(store, runId) {
+        this.store = store;
+        this.runId = runId;
+    }
+    async step(name, operation) {
+        this.store.recordStep(this.runId, { name, state: 'running', attempts: 1, effects: [], safeResult: {} });
+        const result = await operation();
+        const state = result.state ?? 'succeeded';
+        this.store.recordStep(this.runId, { name, state, attempts: 1, effects: result.effects ?? [], safeResult: result.value ?? {} });
+        return result.value;
+    }
+    fail(name, error) {
+        this.store.recordStep(this.runId, { name, state: 'failed', attempts: 1, effects: [], safeResult: {}, error });
+        this.store.completeWorkflow(this.runId, 'failed');
+    }
+}

package/dist/index.d.ts

@@ -2,14 +2,19 @@ export * from './core/types.js';
 export * from './core/errors.js';
 export * from './core/validation.js';
 export * from './core/origin-check.js';
+export * from './core/workflow.js';
+export * from './core/quick-workflow.js';
+export * from './core/named-workflow.js';
 export * from './core/plan.js';
 export * from './core/execution.js';
 export * from './core/redact.js';
 export * from './adapters/laravel.js';
 export * from './app/paths.js';
+export * from './app/service.js';
 export * from './persistence/database.js';
 export * from './persistence/store.js';
 export * from './providers/command-runner.js';
 export * from './providers/cloudflared.js';
 export * from './providers/git-safety.js';
 export * from './providers/process-supervisor.js';
+export * from './providers/browser.js';

package/dist/index.js

@@ -2,14 +2,19 @@ export * from './core/types.js';
 export * from './core/errors.js';
 export * from './core/validation.js';
 export * from './core/origin-check.js';
+export * from './core/workflow.js';
+export * from './core/quick-workflow.js';
+export * from './core/named-workflow.js';
 export * from './core/plan.js';
 export * from './core/execution.js';
 export * from './core/redact.js';
 export * from './adapters/laravel.js';
 export * from './app/paths.js';
+export * from './app/service.js';
 export * from './persistence/database.js';
 export * from './persistence/store.js';
 export * from './providers/command-runner.js';
 export * from './providers/cloudflared.js';
 export * from './providers/git-safety.js';
 export * from './providers/process-supervisor.js';
+export * from './providers/browser.js';

package/dist/persistence/store.d.ts

@@ -24,6 +24,28 @@ export interface SavedWorkflowStep {
     safeResult: unknown;
     error?: unknown;
 }
+export interface SavedSession {
+    id: string;
+    projectId: string;
+    processKey: string;
+    pid?: number;
+    state: string;
+    ephemeralUrl?: string;
+    ephemeralUrlExpired: boolean;
+    startedAt: string;
+    stoppedAt?: string;
+}
+export interface SavedTunnel {
+    id: string;
+    projectId: string;
+    kind: TunnelKind;
+    name?: string;
+    uuid?: string;
+    hostname?: string;
+    localUrl?: string;
+    configPath?: string;
+    credentialsPath?: string;
+}
 export declare class StateStore {
     private readonly db;
     constructor(db: Database.Database);
@@ -33,6 +55,11 @@ export declare class StateStore {
         profile: Profile;
     }): SavedProject;
     listProjects(): SavedProject[];
+    getProject(id: string): SavedProject;
+    relinkProject(id: string, nextPath: string): void;
+    removeProject(id: string): void;
+    saveTunnel(input: Omit<SavedTunnel, 'id'>): SavedTunnel;
+    getTunnelForProject(projectId: string): SavedTunnel | undefined;
     createWorkflow(input: {
         projectId: string;
         kind: TunnelKind;
@@ -48,4 +75,15 @@ export declare class StateStore {
         error?: unknown;
     }): void;
     getWorkflow(id: string): SavedWorkflow;
+    completeWorkflow(id: string, state: 'succeeded' | 'failed' | 'cancelled'): void;
+    saveSession(input: {
+        projectId: string;
+        processKey: string;
+        pid?: number;
+        state: string;
+        ephemeralUrl?: string;
+        executable?: string;
+    }): SavedSession;
+    getLatestSession(projectId: string): SavedSession;
+    stopSession(id: string): void;
 }

package/dist/persistence/store.js

@@ -22,6 +22,37 @@ export class StateStore {
         const rows = this.db.prepare('SELECT id, display_name, path, profile, created_at, updated_at FROM projects ORDER BY updated_at DESC').all();
         return rows.map(row => ({ id: row.id, displayName: row.display_name, path: row.path, profile: row.profile, createdAt: row.created_at, updatedAt: row.updated_at }));
     }
+    getProject(id) {
+        const row = this.db.prepare('SELECT id, display_name, path, profile, created_at, updated_at FROM projects WHERE id=?').get(id);
+        if (!row)
+            throw new Error(`Project not found: ${id}`);
+        return { id: row.id, displayName: row.display_name, path: row.path, profile: row.profile, createdAt: row.created_at, updatedAt: row.updated_at };
+    }
+    relinkProject(id, nextPath) {
+        const result = this.db.prepare('UPDATE projects SET path=?, updated_at=? WHERE id=?').run(nextPath, new Date().toISOString(), id);
+        if (!result.changes)
+            throw new Error(`Project not found: ${id}`);
+    }
+    removeProject(id) {
+        const result = this.db.prepare('DELETE FROM projects WHERE id=?').run(id);
+        if (!result.changes)
+            throw new Error(`Project not found: ${id}`);
+    }
+    saveTunnel(input) {
+        const existing = this.db.prepare('SELECT id FROM tunnels WHERE project_id=? ORDER BY updated_at DESC LIMIT 1').get(input.projectId);
+        const id = existing?.id ?? crypto.randomUUID();
+        const now = new Date().toISOString();
+        this.db.prepare(`INSERT INTO tunnels(id, project_id, kind, name, uuid, hostname, local_url, config_path, credentials_path, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET kind=excluded.kind, name=excluded.name, uuid=excluded.uuid, hostname=excluded.hostname,
+      local_url=excluded.local_url, config_path=excluded.config_path, credentials_path=excluded.credentials_path, updated_at=excluded.updated_at`)
+            .run(id, input.projectId, input.kind, input.name ?? null, input.uuid ?? null, input.hostname ?? null, input.localUrl ?? null, input.configPath ?? null, input.credentialsPath ?? null, now, now);
+        return { id, ...input };
+    }
+    getTunnelForProject(projectId) {
+        const row = this.db.prepare('SELECT * FROM tunnels WHERE project_id=? ORDER BY updated_at DESC LIMIT 1').get(projectId);
+        return row ? { id: row.id, projectId: row.project_id, kind: row.kind, name: row.name ?? undefined, uuid: row.uuid ?? undefined, hostname: row.hostname ?? undefined, localUrl: row.local_url ?? undefined, configPath: row.config_path ?? undefined, credentialsPath: row.credentials_path ?? undefined } : undefined;
+    }
     createWorkflow(input) {
         const id = crypto.randomUUID();
         const now = new Date().toISOString();
@@ -56,4 +87,25 @@ export class StateStore {
             })),
         };
     }
+    completeWorkflow(id, state) {
+        const now = new Date().toISOString();
+        this.db.prepare('UPDATE workflow_runs SET state=?, updated_at=?, finished_at=? WHERE id=?').run(state, now, now, id);
+    }
+    saveSession(input) {
+        const id = crypto.randomUUID();
+        const startedAt = new Date().toISOString();
+        this.db.prepare(`INSERT INTO process_sessions(id, project_id, process_key, pid, executable, state, ephemeral_url, started_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(id, input.projectId, input.processKey, input.pid ?? null, input.executable ?? null, input.state, input.ephemeralUrl ?? null, startedAt);
+        return { id, projectId: input.projectId, processKey: input.processKey, pid: input.pid, state: input.state, ephemeralUrl: input.ephemeralUrl, ephemeralUrlExpired: false, startedAt };
+    }
+    getLatestSession(projectId) {
+        const row = this.db.prepare('SELECT * FROM process_sessions WHERE project_id=? ORDER BY started_at DESC LIMIT 1').get(projectId);
+        if (!row)
+            throw new Error(`Process session not found for project: ${projectId}`);
+        return { id: row.id, projectId: row.project_id, processKey: row.process_key, pid: row.pid ?? undefined, state: row.state, ephemeralUrl: row.ephemeral_url ?? undefined, ephemeralUrlExpired: Boolean(row.ephemeral_url_expired), startedAt: row.started_at, stoppedAt: row.stopped_at ?? undefined };
+    }
+    stopSession(id) {
+        this.db.prepare('UPDATE process_sessions SET state=?, ephemeral_url_expired=1, stopped_at=? WHERE id=?').run('stopped', new Date().toISOString(), id);
+    }
 }

package/dist/providers/browser.d.ts

@@ -0,0 +1,9 @@
+export declare function launchBrowser(url: string, options?: {
+    platform?: string;
+    run?: (executable: string, args: string[]) => Promise<{
+        exitCode: number;
+    }>;
+}): Promise<{
+    opened: boolean;
+    message: string;
+}>;

package/dist/providers/browser.js

@@ -0,0 +1,17 @@
+import { runCommand } from './command-runner.js';
+export async function launchBrowser(url, options = {}) {
+    const platform = options.platform ?? process.platform;
+    const run = options.run ?? ((executable, args) => runCommand({ executable, args, timeoutMs: 10_000 }));
+    const command = platform === 'darwin'
+        ? ['open', [url]]
+        : platform === 'win32'
+            ? ['cmd.exe', ['/c', 'start', '', url]]
+            : ['xdg-open', [url]];
+    try {
+        const result = await run(command[0], [...command[1]]);
+        if (result.exitCode === 0)
+            return { opened: true, message: `Opened ${url}` };
+    }
+    catch { }
+    return { opened: false, message: `Open this URL manually: ${url}` };
+}

package/dist/ui/page.d.ts

@@ -0,0 +1 @@
+export declare function dashboardPage(): string;

package/dist/ui/page.js

@@ -0,0 +1,34 @@
+export function dashboardPage() {
+    return String.raw `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Cloudflare Tunnel Kit</title>
+<style>
+:root{color-scheme:light;--ink:#172033;--muted:#68738a;--line:#e4e8f0;--panel:#fff;--bg:#f4f6fa;--blue:#1665d8;--blue2:#0c4fad;--orange:#f48120;--green:#11845b;--red:#c93c4b;--shadow:0 18px 50px rgba(26,39,70,.10)}
+*{box-sizing:border-box}body{margin:0;font:15px/1.5 Inter,ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;color:var(--ink);background:var(--bg)}button,input,select{font:inherit}button{cursor:pointer}.shell{min-height:100vh}.topbar{height:68px;background:#101827;color:white;display:flex;align-items:center;justify-content:space-between;padding:0 clamp(20px,5vw,72px);box-shadow:0 1px 0 #ffffff18}.brand{display:flex;align-items:center;gap:12px;font-weight:760;letter-spacing:-.02em}.logo{width:34px;height:34px;border-radius:11px;background:linear-gradient(145deg,#ffad38,var(--orange));display:grid;place-items:center;color:white;font-size:19px;box-shadow:0 8px 24px #f4812050}.top-actions{display:flex;gap:10px}.main{max-width:1180px;margin:0 auto;padding:42px 28px 70px}.hero{display:grid;grid-template-columns:1.4fr .8fr;gap:24px;align-items:stretch}.hero-copy,.health-panel,.section{background:var(--panel);border:1px solid var(--line);border-radius:22px;box-shadow:var(--shadow)}.hero-copy{padding:38px;background:radial-gradient(circle at 100% 0,#eaf3ff 0,transparent 42%),#fff}.eyebrow{font-size:12px;font-weight:800;letter-spacing:.12em;text-transform:uppercase;color:var(--blue)}h1{font-size:clamp(30px,4vw,48px);line-height:1.05;letter-spacing:-.045em;margin:10px 0 14px}.lead{font-size:17px;color:var(--muted);max-width:650px;margin:0 0 26px}.actions{display:flex;flex-wrap:wrap;gap:12px}.btn{border:0;border-radius:11px;padding:11px 16px;font-weight:700;display:inline-flex;align-items:center;justify-content:center;gap:8px}.btn.primary{background:var(--blue);color:white;box-shadow:0 8px 18px #1665d835}.btn.primary:hover{background:var(--blue2)}.btn.secondary{background:#edf3fc;color:#174b91}.btn.ghost{background:white;color:var(--ink);border:1px solid var(--line)}.btn.danger{background:#fff0f1;color:var(--red)}.health-panel{padding:28px}.health-title{display:flex;justify-content:space-between;align-items:center;margin-bottom:20px}.health-title h2,.section-head h2{margin:0;font-size:19px;letter-spacing:-.02em}.check{display:flex;gap:12px;padding:12px 0;border-top:1px solid var(--line)}.check:first-of-type{border:0}.dot{width:10px;height:10px;border-radius:50%;margin-top:6px;background:#aab3c3}.dot.ok{background:var(--green);box-shadow:0 0 0 4px #dff5ed}.check b{display:block}.check span{color:var(--muted);font-size:13px}.section{margin-top:24px;padding:28px}.section-head{display:flex;justify-content:space-between;align-items:center;gap:18px;margin-bottom:20px}.section-head p{margin:4px 0 0;color:var(--muted)}.projects{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:16px}.empty{grid-column:1/-1;border:1px dashed #cfd6e3;border-radius:16px;padding:42px;text-align:center;color:var(--muted);background:#fafbfc}.card{border:1px solid var(--line);border-radius:16px;padding:20px;background:#fff;min-width:0}.card-top{display:flex;justify-content:space-between;gap:12px}.card h3{margin:0;font-size:17px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.badge{font-size:12px;font-weight:750;padding:4px 9px;border-radius:999px;background:#eef1f6;color:#536078;white-space:nowrap}.badge.running{background:#dcf6eb;color:#08734d}.badge.attention{background:#fff0d9;color:#9a5b00}.meta{margin:16px 0;color:var(--muted);font-size:13px;display:grid;gap:6px}.meta code{overflow:hidden;text-overflow:ellipsis}.card-actions{display:flex;gap:8px}.card-actions .btn{padding:8px 11px;font-size:13px}.notice{padding:12px 14px;border-radius:11px;background:#fff6e9;color:#854e00;margin:14px 0;font-size:13px}.hidden{display:none!important}
+dialog{border:0;border-radius:22px;padding:0;width:min(680px,calc(100vw - 30px));box-shadow:0 30px 100px #11182755}dialog::backdrop{background:#10182799;backdrop-filter:blur(3px)}.dialog-head{padding:24px 28px 18px;border-bottom:1px solid var(--line);display:flex;justify-content:space-between;align-items:flex-start}.dialog-head h2{margin:0;font-size:22px}.dialog-head p{margin:5px 0 0;color:var(--muted)}.close{border:0;background:#f0f2f6;border-radius:9px;width:34px;height:34px}.dialog-body{padding:25px 28px}.steps{display:flex;gap:8px;margin-bottom:24px}.step{height:5px;flex:1;border-radius:4px;background:#e3e7ee}.step.active{background:var(--blue)}label{display:block;font-weight:700;margin:15px 0 6px}.hint{font-size:12px;color:var(--muted);margin-top:5px}input,select{width:100%;padding:11px 12px;border:1px solid #cfd6e3;border-radius:10px;background:white;color:var(--ink);outline:none}input:focus,select:focus{border-color:var(--blue);box-shadow:0 0 0 3px #1665d81a}.grid2{display:grid;grid-template-columns:1fr 1fr;gap:14px}.dialog-foot{padding:18px 28px;border-top:1px solid var(--line);display:flex;justify-content:flex-end;gap:10px}.review{background:#f6f8fb;border-radius:13px;padding:16px}.review ul{margin:8px 0 0;padding-left:20px}.result{white-space:pre-wrap;background:#101827;color:#e7edf8;border-radius:13px;padding:16px;max-height:280px;overflow:auto;font:12px/1.6 ui-monospace,SFMono-Regular,Menlo,monospace}.toast{position:fixed;right:24px;bottom:24px;background:#101827;color:#fff;padding:13px 17px;border-radius:11px;box-shadow:var(--shadow);z-index:20}
+@media(max-width:850px){.hero{grid-template-columns:1fr}.projects{grid-template-columns:1fr 1fr}}@media(max-width:580px){.main{padding:24px 15px}.topbar{padding:0 16px}.top-actions .btn span{display:none}.hero-copy,.health-panel,.section{border-radius:16px}.hero-copy{padding:26px}.projects{grid-template-columns:1fr}.grid2{grid-template-columns:1fr}.dialog-head,.dialog-body,.dialog-foot{padding-left:19px;padding-right:19px}.actions>.btn{width:100%}}
+</style></head><body><div class="shell">
+<header class="topbar"><div class="brand"><div class="logo">☁</div><span>Cloudflare Tunnel Kit</span></div><div class="top-actions"><button class="btn ghost" data-action="doctor">System check</button></div></header>
+<main class="main"><section class="hero"><div class="hero-copy"><div class="eyebrow">Local tunnel manager</div><h1>Your tunnels,<br>without the guesswork.</h1><p class="lead">Expose a local project through a temporary URL or connect your own Cloudflare domain. Every change is reviewed before it runs.</p><div class="actions"><button class="btn primary" data-new="quick">⚡ Create Quick Tunnel</button><button class="btn secondary" data-new="named">◎ Use a custom domain</button></div></div><aside class="health-panel"><div class="health-title"><h2>Environment</h2><button class="btn ghost" data-action="doctor">Run checks</button></div><div id="checks"><div class="check"><i class="dot"></i><div><b>Not checked yet</b><span>Run system checks before your first tunnel.</span></div></div></div></aside></section>
+<section class="section"><div class="section-head"><div><h2>Saved projects</h2><p>Settings and history stored only on this machine.</p></div><button class="btn ghost" data-action="refresh">↻ Refresh</button></div><div class="projects" id="projects"><div class="empty">Loading your projects…</div></div></section></main></div>
+<dialog id="wizard"><div class="dialog-head"><div><h2 id="wizard-title">Create a tunnel</h2><p id="wizard-subtitle">Step-by-step setup</p></div><button class="close" data-close aria-label="Close">×</button></div><div class="dialog-body"><div class="steps"><i class="step active"></i><i class="step"></i><i class="step"></i></div>
+<form id="setup-form"><div id="fields"><label>Project name</label><input name="displayName" required placeholder="My local app"><label>Project folder</label><input name="projectPath" required value="${escapeAttribute(process.cwd())}"><label>Local application URL</label><input name="localUrl" required value="http://127.0.0.1:8000"><div id="named-fields" class="hidden"><div class="grid2"><div><label>Tunnel name</label><input name="tunnelName" placeholder="my-project"></div><div><label>Public hostname</label><input name="hostname" placeholder="dev.example.com"></div></div><p class="hint">The root domain must already be managed by your Cloudflare account.</p></div><label>Project type</label><select name="profile"><option value="custom">Custom</option><option value="laravel">Laravel</option></select></div>
+<div id="review" class="hidden"><div class="review"><b>Review changes</b><ul id="effects"></ul></div><div class="notice" id="named-notice">A custom domain setup may open Cloudflare login in your browser. Existing DNS records are never overwritten automatically.</div></div><div id="running" class="hidden"><div class="result" id="result">Waiting…</div></div></form></div><div class="dialog-foot"><button class="btn ghost" data-close>Cancel</button><button class="btn primary" id="continue">Review changes</button></div></dialog>
+<div class="toast hidden" id="toast"></div>
+<script>
+let mode='quick',stage=0,plan=null,token='';const q=s=>document.querySelector(s),qa=s=>[...document.querySelectorAll(s)];
+const esc=v=>String(v??'').replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
+async function api(url,options={}){const headers={'content-type':'application/json',...(options.headers||{})};if(token)headers['x-confirmation-token']=token;const r=await fetch(url,{...options,headers});const body=await r.json().catch(()=>({error:'Invalid server response'}));if(!r.ok)throw new Error(body.error||body.issues?.[0]?.reason||'Request failed');return body}
+function toast(message){const el=q('#toast');el.textContent=message;el.classList.remove('hidden');setTimeout(()=>el.classList.add('hidden'),3200)}
+async function load(){try{const data=await api('/api/projects');renderProjects(data.projects)}catch(e){q('#projects').innerHTML='<div class="empty">'+esc(e.message)+'</div>'}}
+function renderProjects(items){q('#projects').innerHTML=items.length?items.map(p=>'<article class="card"><div class="card-top"><h3>'+esc(p.displayName)+'</h3><span class="badge '+(p.status==='Running'?'running':p.status==='Needs attention'?'attention':'')+'">'+esc(p.status)+'</span></div><div class="meta"><span>'+esc(p.kind==='named'?p.hostname||'Custom domain':'Quick Tunnel')+'</span><code>'+esc(p.localUrl||p.path)+'</code></div><div class="card-actions">'+(p.status==='Running'?'<button class="btn ghost" data-project="'+p.id+'" data-command="stop">Stop</button>':'<button class="btn secondary" data-project="'+p.id+'" data-command="start">Start</button>')+'<button class="btn ghost" data-project="'+p.id+'" data-command="retry">Retry setup</button></div></article>').join(''):'<div class="empty"><b>No saved projects yet.</b><br>Create a Quick Tunnel or connect a custom domain to get started.</div>'}
+function openWizard(nextMode){mode=nextMode;stage=0;plan=null;q('#setup-form').reset();q('[name=projectPath]').value=${JSON.stringify(process.cwd())};q('[name=localUrl]').value='http://127.0.0.1:8000';q('#named-fields').classList.toggle('hidden',mode!=='named');q('#named-notice').classList.toggle('hidden',mode!=='named');q('#wizard-title').textContent=mode==='named'?'Set up a custom domain':'Create a Quick Tunnel';q('#wizard-subtitle').textContent=mode==='named'?'Cloudflare login, tunnel, DNS, and connector':'No Cloudflare login required';showStage();q('#wizard').showModal()}
+function showStage(){q('#fields').classList.toggle('hidden',stage!==0);q('#review').classList.toggle('hidden',stage!==1);q('#running').classList.toggle('hidden',stage!==2);qa('.step').forEach((el,i)=>el.classList.toggle('active',i<=stage));q('#continue').textContent=stage===0?'Review changes':stage===1?'Confirm and run':'Done'}
+function values(){const data=Object.fromEntries(new FormData(q('#setup-form')));return {...data,profile:data.profile||'custom'}}
+async function next(){try{if(stage===0){const data=values();if(mode==='named'&&(!data.tunnelName||!data.hostname))throw new Error('Tunnel name and public hostname are required.');plan=await api('/api/plans/'+mode,{method:'POST',body:JSON.stringify(data)});q('#effects').innerHTML=plan.effects.map(x=>'<li>'+esc(x)+'</li>').join('');stage=1;showStage()}else if(stage===1){stage=2;showStage();q('#result').textContent='Running validated workflow…';const result=await api('/api/execute',{method:'POST',body:JSON.stringify({planId:plan.id,confirmations:plan.confirmations})});q('#result').textContent=JSON.stringify(result,null,2);await load()}else q('#wizard').close()}catch(e){toast(e.message)}}
+async function doctor(){try{const data=await api('/api/doctor');q('#checks').innerHTML=data.checks.map(c=>'<div class="check"><i class="dot '+(c.state==='passed'?'ok':'')+'"></i><div><b>'+esc(c.name)+'</b><span>'+esc(c.detail)+'</span></div></div>').join('')}catch(e){toast(e.message)}}
+document.addEventListener('click',async e=>{const t=e.target.closest('button');if(!t)return;if(t.dataset.new)openWizard(t.dataset.new);if(t.dataset.close)q('#wizard').close();if(t.id==='continue'){e.preventDefault();await next()}if(t.dataset.action==='refresh')await load();if(t.dataset.action==='doctor')await doctor();if(t.dataset.project){try{await api('/api/projects/'+t.dataset.project+'/'+t.dataset.command,{method:'POST',body:'{}'});await load()}catch(err){toast(err.message)}}});
+api('/api/session').then(x=>{token=x.confirmationToken;load();doctor()}).catch(e=>toast(e.message));
+</script></body></html>`;
+}
+function escapeAttribute(value) { return value.replace(/[&<>"]/g, character => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' })[character]); }

package/dist/ui/server.d.ts

@@ -1,2 +1,6 @@
 import { type Server } from 'node:http';
-export declare function createServer(): Server;
+export declare function createServer(options?: {
+    service?: any;
+    sessionToken?: string;
+    maxBodyBytes?: number;
+}): Server;

package/dist/ui/server.js

@@ -1,38 +1,82 @@
 import { createServer as httpServer } from 'node:http';
 import crypto from 'node:crypto';
-import { createTunnelPlan } from '../core/plan.js';
-import { createLaravelPlan } from '../adapters/laravel.js';
-import { executeTunnelPlan } from '../core/execution.js';
-export function createServer() {
-    const token = crypto.randomUUID();
+import { dashboardPage } from './page.js';
+const emptyService = {
+    listProjects: async () => [], getProject: async () => ({}), doctor: async () => ({ ok: true, checks: [] }),
+    prepareQuick: async (input) => ({ id: 'preview', effects: [`Start Quick Tunnel to ${input.localUrl}.`], confirmations: ['start-connector'] }),
+    prepareNamed: async (input) => ({ id: 'preview', effects: [`Create ${input.hostname}.`], confirmations: ['cloudflare-resources', 'start-connector'] }),
+    execute: async () => ({ state: 'skipped', message: 'No service configured.' }), start: async () => ({}), stop: async () => ({}), retry: async () => ({}), restart: async () => ({}),
+};
+export function createServer(options = {}) {
+    const service = options.service ?? emptyService;
+    const token = options.sessionToken ?? crypto.randomUUID();
+    const maxBodyBytes = options.maxBodyBytes ?? 64 * 1024;
     return httpServer(async (req, res) => {
-        res.setHeader('X-Content-Type-Options', 'nosniff');
-        if (req.method === 'GET' && req.url === '/') {
-            res.setHeader('Content-Type', 'text/html; charset=utf-8');
-            res.end(html);
-            return;
-        }
-        if (req.method === 'GET' && req.url === '/api/session')
+        secureHeaders(res);
+        const url = new URL(req.url ?? '/', 'http://127.0.0.1');
+        if (req.method === 'GET' && url.pathname === '/')
+            return html(res, dashboardPage());
+        if (req.method === 'GET' && url.pathname === '/api/session')
             return json(res, { confirmationToken: token });
-        if (req.method === 'POST' && ['/api/plan', '/api/validate', '/api/execute'].includes(req.url ?? '')) {
-            if (req.url === '/api/execute' && req.headers['x-confirmation-token'] !== token)
-                return json(res, { ok: false, issues: [{ code: 'UI_CONFIRMATION_TOKEN_INVALID', reason: 'The UI confirmation token is missing or invalid.', fix: 'Reload the local UI and confirm from the same browser session.' }] }, 403);
+        if (req.method === 'GET' && url.pathname === '/api/projects')
+            return handle(res, async () => ({ projects: await service.listProjects() }));
+        if (req.method === 'GET' && url.pathname === '/api/doctor')
+            return handle(res, () => service.doctor());
+        const detail = url.pathname.match(/^\/api\/projects\/([^/]+)$/);
+        if (req.method === 'GET' && detail)
+            return handle(res, () => service.getProject(detail[1]));
+        if (req.method === 'POST') {
+            if (!validMutationRequest(req, token))
+                return json(res, { error: 'The local UI session is missing or invalid. Reload the page and try again.' }, 403);
+            if (!String(req.headers['content-type'] ?? '').toLowerCase().startsWith('application/json'))
+                return json(res, { error: 'Requests must use application/json.' }, 415);
+            let body;
             try {
-                const body = JSON.parse(await readBody(req));
-                const config = body.config;
-                const plan = config.profile === 'laravel' ? createLaravelPlan(config) : createTunnelPlan(config);
-                if (req.url === '/api/execute')
-                    return json(res, await executeTunnelPlan(plan, { confirmed: body.confirmed ?? [], dryRun: body.dryRun ?? false }));
-                return json(res, { valid: plan.valid, issues: plan.issues, plan });
+                body = JSON.parse(await readBody(req, maxBodyBytes));
+            }
+            catch (error) {
+                return json(res, { error: error instanceof Error ? error.message : 'Invalid JSON request.' }, error?.code === 'BODY_TOO_LARGE' ? 413 : 400);
             }
-            catch {
-                return json(res, { ok: false, issues: [{ code: 'UI_INVALID_JSON', reason: 'Request body is not valid JSON.', fix: 'Submit the wizard form again.' }] }, 400);
+            if (url.pathname === '/api/plans/quick')
+                return handle(res, () => service.prepareQuick(body));
+            if (url.pathname === '/api/plans/named')
+                return handle(res, () => service.prepareNamed(body));
+            if (url.pathname === '/api/execute')
+                return handle(res, () => service.execute(body.planId, body.confirmations ?? []));
+            const action = url.pathname.match(/^\/api\/projects\/([^/]+)\/(start|stop|retry|restart)$/);
+            if (action)
+                return handle(res, () => service[action[2]](action[1]));
+            if (url.pathname === '/api/plan') {
+                const config = body.config ?? {};
+                return handle(res, async () => ({ plan: config.operation === 'quick' ? await service.prepareQuick({ projectPath: config.projectRoot ?? process.cwd(), ...config }) : await service.prepareNamed({ projectPath: config.projectRoot ?? process.cwd(), ...config }) }));
             }
         }
-        res.statusCode = 404;
-        res.end('Not found');
+        return json(res, { error: 'Not found.' }, 404);
     });
 }
-function readBody(req) { return new Promise(resolve => { let data = ''; req.on('data', (chunk) => data += chunk); req.on('end', () => resolve(data)); }); }
+function validMutationRequest(req, token) {
+    const received = String(req.headers['x-confirmation-token'] ?? '');
+    if (received.length !== token.length || !crypto.timingSafeEqual(Buffer.from(received), Buffer.from(token)))
+        return false;
+    const host = String(req.headers.host ?? '');
+    if (host && !/^(127\.0\.0\.1|localhost)(:\d+)?$/i.test(host))
+        return false;
+    const origin = String(req.headers.origin ?? '');
+    return !origin || /^http:\/\/(127\.0\.0\.1|localhost)(:\d+)?$/i.test(origin);
+}
+function readBody(req, limit) { return new Promise((resolve, reject) => { let data = '', size = 0; req.on('data', chunk => { size += chunk.length; if (size > limit) {
+    const error = new Error('Request body is too large.');
+    error.code = 'BODY_TOO_LARGE';
+    reject(error);
+    req.destroy();
+    return;
+} data += chunk; }); req.on('end', () => resolve(data || '{}')); req.on('error', reject); }); }
+async function handle(res, operation) { try {
+    return json(res, await operation());
+}
+catch (error) {
+    return json(res, { error: error instanceof Error ? error.message : String(error) }, 400);
+} }
+function secureHeaders(res) { res.setHeader('X-Content-Type-Options', 'nosniff'); res.setHeader('Content-Security-Policy', "default-src 'self'; style-src 'unsafe-inline'; script-src 'unsafe-inline'; connect-src 'self'; frame-ancestors 'none'"); res.setHeader('Referrer-Policy', 'no-referrer'); res.setHeader('Cache-Control', 'no-store'); }
+function html(res, value) { res.statusCode = 200; res.setHeader('Content-Type', 'text/html; charset=utf-8'); res.end(value); }
 function json(res, value, status = 200) { res.statusCode = status; res.setHeader('Content-Type', 'application/json; charset=utf-8'); res.end(JSON.stringify(value)); }
-const html = `<!doctype html><html lang="en"><meta name="viewport" content="width=device-width"><title>Cloudflare Tunnel Kit</title><style>body{font:16px system-ui;max-width:720px;margin:40px auto;padding:0 20px;background:#f6f7fb;color:#18202a}main{background:white;padding:28px;border-radius:16px;box-shadow:0 8px 30px #0001}label{display:block;margin:14px 0 6px}input,select,button{font:inherit;padding:10px;border:1px solid #ccd3df;border-radius:8px;width:100%;box-sizing:border-box}button{margin-top:20px;background:#2457d6;color:white;cursor:pointer}pre{white-space:pre-wrap;background:#f1f3f7;padding:12px;border-radius:8px}.ok{color:#087443}.error{color:#a21b1b}</style><main><h1>Cloudflare Tunnel Kit</h1><p>Validate first. Review the plan. Confirm before running.</p><label>Profile</label><select id="profile"><option>custom</option><option>laravel</option></select><label>Local URL</label><input id="url" value="http://127.0.0.1:8000"><label>Tunnel name (named tunnel only)</label><input id="name" placeholder="my-project"><button id="check">Validate plan</button><button id="run" hidden>Confirm and execute</button><button id="copy" hidden>Copy AI help prompt</button><pre id="result">No plan yet.</pre></main><script>let plan,token;const $=id=>document.getElementById(id);fetch('/api/session').then(r=>r.json()).then(x=>token=x.confirmationToken);$('check').onclick=async()=>{const config={profile:$('profile').value,operation:$('name').value?'create':'quick',localUrl:$('url').value,tunnelName:$('name').value||undefined};const r=await fetch('/api/plan',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({config})});const x=await r.json();plan=x.plan;$('result').textContent=JSON.stringify({summary:plan?.summary,issues:x.issues,argv:plan?.argv,confirmations:plan?.confirmations},null,2);$('run').hidden=!x.valid;$('copy').hidden=x.valid;};$('run').onclick=async()=>{const r=await fetch('/api/execute',{method:'POST',headers:{'content-type':'application/json','x-confirmation-token':token},body:JSON.stringify({config:plan.config,confirmed:plan.confirmations})});$('result').textContent=JSON.stringify(await r.json(),null,2);};$('copy').onclick=()=>navigator.clipboard.writeText('I am configuring cloudflare-tunnel-kit. Here is the redacted diagnostic:\n'+$('result').textContent);</script>`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-tunnel-kit",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Safe, reusable Cloudflare Tunnel setup for custom and Laravel projects.",
   "type": "module",
   "bin": {
@@ -34,6 +34,6 @@
   },
   "license": "MIT",
   "dependencies": {
-    "better-sqlite3": "^13.0.3"
+    "better-sqlite3": "^12.11.1"
   }
 }