cloudflare-tunnel-kit 0.1.8 → 0.1.9

package/dist/app/service.js

@@ -1,4 +1,5 @@
 import crypto from 'node:crypto';
+import path from 'node:path';
 import { existsSync, realpathSync, statSync } from 'node:fs';
 import { resolveAppPaths } from './paths.js';
 import { openStateDatabase } from '../persistence/database.js';
@@ -7,6 +8,7 @@ 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';
+const PLAN_TTL_MS = 10 * 60_000;
 export class TunnelKitService {
     plans = new Map();
     store;
@@ -46,6 +48,9 @@ export class TunnelKitService {
     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) {
+        for (const [id, saved] of this.plans)
+            if (Date.now() - saved.createdAt > PLAN_TTL_MS)
+                this.plans.delete(id);
         const plan = { id: crypto.randomUUID(), kind, input, effects, confirmations, createdAt: Date.now() };
         this.plans.set(plan.id, plan);
         return plan;
@@ -54,10 +59,12 @@ export class TunnelKitService {
         const plan = this.plans.get(id);
         if (!plan)
             throw new Error('Plan not found or expired.');
-        if (Date.now() - plan.createdAt > 10 * 60_000) {
+        if (Date.now() - plan.createdAt > PLAN_TTL_MS) {
             this.plans.delete(id);
             throw new Error('Plan expired. Review the settings again.');
         }
+        if (!Array.isArray(confirmations))
+            throw new Error('Confirmations must be a list of confirmed operations.');
         const missing = plan.confirmations.filter(item => !confirmations.includes(item));
         if (missing.length)
             throw new Error(`Confirmation required for: ${missing.join(', ')}`);
@@ -106,7 +113,7 @@ export class TunnelKitService {
     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 paths = options.dataDir ? { dataDir: options.dataDir, database: path.join(options.dataDir, 'state.db'), projectsDir: path.join(options.dataDir, 'projects'), backupsDir: path.join(options.dataDir, 'backups') } : resolveAppPaths();
     const database = openStateDatabase(paths.database);
     const store = new StateStore(database);
     const supervisor = new ProcessSupervisor();

package/dist/cli/main.js

@@ -9,18 +9,19 @@ const args = process.argv.slice(2);
 const command = args[0] ?? 'init';
 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 [--port PORT]\n\nCommands: init create quick start stop restart status doctor ui\nOptions: --url URL --name NAME --hostname HOST --profile custom|laravel --project ID --port PORT --dry-run --yes --json --no-open\nUI port precedence: --port, CLOUDFLARE_TUNNEL_KIT_UI_PORT, automatic`); }
+function help() { console.log(`cloudflare-tunnel-kit ${packageVersion}\n\nUsage from an installed project:\n  npx cf-tunnel\n  npx cf-tunnel ui [--port PORT]\n\nCommands: init create quick start stop restart status doctor ui\nOptions: --url URL --name NAME --hostname HOST --path DIR --project-name NAME --profile custom|laravel --project ID --port PORT --dry-run --yes --json --no-open\nUI port precedence: --port, CLOUDFLARE_TUNNEL_KIT_UI_PORT, automatic`); }
 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); }
 function resolveUiPort() { const raw = value('--port') ?? process.env.CLOUDFLARE_TUNNEL_KIT_UI_PORT; if (raw === undefined || raw === '')
     return 0; const port = Number(raw); if (!Number.isInteger(port) || port < 0 || port > 65535)
     throw new Error(`Invalid UI port "${raw}". Use an integer from 0 to 65535.`); return port; }
 async function startUi() {
+    const port = resolveUiPort();
     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, version: packageVersion });
     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(); });
     console.log(`Cloudflare Tunnel Kit v${packageVersion}`);
-    server.listen(resolveUiPort(), '127.0.0.1', async () => { const address = server.address(); if (!address || typeof address === 'string')
+    server.listen(port, '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); }));

package/dist/core/named-workflow.js

@@ -124,7 +124,15 @@ export class NamedTunnelWorkflow {
         }
         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 });
+        let session;
+        try {
+            session = await this.supervisor.start({ key: sessionKey, executable: this.executable, args: [...this.baseArgs, 'tunnel', '--config', tunnel.configPath, 'run', tunnel.uuid], env: this.env });
+        }
+        catch (cause) {
+            const error = { code: 'CONNECTOR_START_FAILED', reason: cause instanceof Error ? cause.message : String(cause), fix: 'Stop any running connector for this project, check that cloudflared is installed, and retry.' };
+            runner.fail('connector', error);
+            return { state: 'failed', projectId, runId: run.id, error, configPath: tunnel.configPath };
+        }
         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: [] }));

package/dist/core/quick-workflow.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { validateTunnelConfig } from './validation.js';
 import { checkOrigin } from './origin-check.js';
 import { WorkflowRunner } from './workflow.js';
 export class QuickTunnelWorkflow {
@@ -17,6 +18,9 @@ export class QuickTunnelWorkflow {
         this.originCheck = options.originCheck ?? (url => checkOrigin(url));
     }
     async run(input) {
+        const validation = validateTunnelConfig({ profile: input.profile, operation: 'quick', localUrl: input.localUrl, projectRoot: input.projectPath });
+        if (!validation.ok)
+            return { state: 'failed', error: validation.issues[0], issues: validation.issues };
         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' });
@@ -28,6 +32,11 @@ export class QuickTunnelWorkflow {
         }
         await runner.step('origin', async () => ({ state: origin.warning ? 'warning' : 'succeeded', value: origin, effects: ['Verified the local application is reachable.'] }));
         const sessionKey = `quick:${project.id}`;
+        if (['starting', 'running', 'stopping'].includes(this.supervisor.status(sessionKey).state)) {
+            const error = { code: 'CONNECTOR_ALREADY_RUNNING', reason: 'A Quick Tunnel connector is already running for this project.', fix: 'Stop or restart the project instead of starting it again.' };
+            runner.fail('connector', error);
+            return { state: 'failed', projectId: project.id, runId: run.id, error };
+        }
         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);

package/dist/core/redact.js

@@ -6,7 +6,7 @@ export function redact(value, key) {
         .replace(/-----BEGIN [^-]+-----[\s\S]*?-----END [^-]+-----/gi, '[REDACTED PEM]')
         .replace(/(Bearer\s+)[^\s]+/gi, '$1[REDACTED]')
         .replace(/([?&](?:token|secret|password|api[_-]?key|signature|credential)=)[^&\s]+/gi, '$1[REDACTED]')
-        .replace(/([A-Za-z0-9_-]{24,})/g, '[REDACTED]');
+        .replace(/(?<![A-Za-z0-9_-])[A-Za-z0-9_-]{24,}(?![A-Za-z0-9_-]|\.trycloudflare\.com)/g, '[REDACTED]');
 }
 export function redactValue(value, key) {
     if (key && secretKey.test(key))

package/dist/providers/process-supervisor.d.ts

@@ -10,6 +10,7 @@ export declare class ManagedSession {
     private logText;
     private readonly events;
     constructor(key: string, child: ChildProcess, maxLogBytes: number);
+    markExited(): void;
     append(value: string): void;
     logs(): string;
     waitForOutput(pattern: RegExp, timeoutMs: number): Promise<string>;

package/dist/providers/process-supervisor.js

@@ -16,6 +16,7 @@ export class ManagedSession {
         this.maxLogBytes = maxLogBytes;
         this.pid = child.pid;
     }
+    markExited() { this.events.emit('exit'); }
     append(value) {
         this.logText = Buffer.from(this.logText + redact(value)).subarray(-this.maxLogBytes).toString('utf8');
         this.events.emit('output', this.logText);
@@ -31,9 +32,13 @@ export class ManagedSession {
                 cleanup();
                 resolve(logs);
             };
+            const exited = () => { cleanup(); reject(new Error('The process exited before producing the expected output.')); };
             const timeout = setTimeout(() => { cleanup(); reject(new Error(`Timed out waiting for process output: ${pattern}`)); }, timeoutMs);
-            const cleanup = () => { clearTimeout(timeout); this.events.off('output', output); };
+            const cleanup = () => { clearTimeout(timeout); this.events.off('output', output); this.events.off('exit', exited); };
             this.events.on('output', output);
+            if (['stopped', 'failed'].includes(this.state))
+                return exited();
+            this.events.once('exit', exited);
         });
     }
 }
@@ -50,7 +55,7 @@ export class ProcessSupervisor {
         this.sessions.set(options.key, session);
         child.stdout?.on('data', chunk => session.append(chunk.toString('utf8')));
         child.stderr?.on('data', chunk => session.append(chunk.toString('utf8')));
-        child.on('close', code => { session.state = code === 0 || session.state === 'stopping' ? 'stopped' : 'failed'; });
+        child.on('close', code => { session.state = code === 0 || session.state === 'stopping' ? 'stopped' : 'failed'; session.markExited(); });
         return new Promise((resolve, reject) => {
             child.once('spawn', () => { session.state = 'running'; resolve(session); });
             child.once('error', error => { session.state = 'failed'; session.append(error.message); reject(error); });

package/dist/ui/server.js

@@ -24,7 +24,7 @@ export function createServer(options = {}) {
             return handle(res, () => service.doctor());
         const detail = url.pathname.match(/^\/api\/projects\/([^/]+)$/);
         if (req.method === 'GET' && detail)
-            return handle(res, () => service.getProject(detail[1]));
+            return handle(res, () => service.getProject(decodeURIComponent(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);
@@ -47,10 +47,10 @@ export function createServer(options = {}) {
                 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]));
+                return handle(res, () => service[action[2]](decodeURIComponent(action[1])));
             const management = url.pathname.match(/^\/api\/projects\/([^/]+)\/(relink|remove-local)$/);
             if (management)
-                return handle(res, () => management[2] === 'relink' ? service.relinkProject(management[1], body.path) : service.removeLocal(management[1]));
+                return handle(res, () => management[2] === 'relink' ? service.relinkProject(decodeURIComponent(management[1]), body.path) : service.removeLocal(decodeURIComponent(management[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 }) }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudflare-tunnel-kit",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Safe, reusable Cloudflare Tunnel setup for custom and Laravel projects.",
   "type": "module",
   "bin": {