npm - @pasko70/pibo - Versions diffs - 3.3.0 → 3.4.0 - Mend

@pasko70/pibo 3.3.0 → 3.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (237) hide show

package/dist/apps/chat-vscode-web/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
 		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
 		<meta name="theme-color" content="#101d22" />
 		<title>Pibo</title>
-		<script type="module" crossorigin src="/apps/chat-vscode/assets/index-D1bpAUkR.js"></script>
+		<script type="module" crossorigin src="/apps/chat-vscode/assets/index-Spj6M0tn.js"></script>
 		<link rel="stylesheet" crossorigin href="/apps/chat-vscode/assets/index-b18ZkEo0.css">
 	</head>
 	<body>

package/dist/compute/pool/cli.js CHANGED Viewed

@@ -149,7 +149,7 @@ Provide exactly one source:
     program.command("seed")
         .action(() => console.log(`Deployment seed modes:
   full    Nearly complete Pibo home plus configured workspace; excludes active runtime, lock, browser, debug, and pool state.
-  medium  Operational config, selected product databases, projects, contexts, agents, and user skills; excludes heavy payload/tool/browser/debug state.
+  medium  Operational config, selected product and workflow databases, contexts, agents, and user skills; excludes heavy payload/tool/browser/debug state.
   fresh   Operational config, Google/Machine auth configuration, model defaults, contexts, and user skills; no existing product databases.
 `));
     await program.parseAsync(argv);

package/dist/compute/pool/seeds.js CHANGED Viewed

@@ -35,11 +35,10 @@ const MEDIUM_ALLOWED_TOP_LEVEL = new Set([
     "chat-agents.sqlite",
     "pibo.sqlite",
     "pibo-events.sqlite",
-    "web-projects.sqlite",
+    "pibo-workflows.sqlite",
     "web-annotations.sqlite",
     "context-files",
     "user-skills",
-    "projects",
 ]);
 const FRESH_ALLOWED_TOP_LEVEL = new Set([
     "config.json",
@@ -137,7 +136,7 @@ async function backupSeedDatabases(sourceHome, destinationHome, mode) {
     if (mode === "fresh")
         return [];
     const allowed = mode === "medium"
-        ? new Set(["chat-agents.sqlite", "pibo.sqlite", "pibo-events.sqlite", "web-projects.sqlite", "web-annotations.sqlite"])
+        ? new Set(["chat-agents.sqlite", "pibo.sqlite", "pibo-events.sqlite", "pibo-workflows.sqlite", "web-annotations.sqlite"])
         : undefined;
     const copied = [];
     for (const entry of await readdir(sourceHome, { withFileTypes: true })) {

package/dist/config/config.js CHANGED Viewed

@@ -59,7 +59,7 @@ export const PIBO_CONFIG_KEYS = [
     {
         key: "preview.baseURL",
         type: "string",
-        description: "Public preview base URL. Preview ids become subdomains, for example https://preview.example.com.",
+        description: "Public Preview base URL. Run `pibo preview setup --base-url https://preview.example.com` before enabling it.",
     },
     {
         key: "preview.databasePath",

package/dist/core/session-router.js CHANGED Viewed

@@ -231,7 +231,6 @@ function derivedSessionMetadata(value) {
     for (const key of [
         DERIVED_SESSION_RECONCILIATION_METADATA_KEY,
         "workflowSessionKind",
-        "projectSessionKind",
         "subagentName",
         "subagentToolName",
         "agentStatus",
@@ -1692,9 +1691,13 @@ export class PiboSessionRouter {
             catch (error) {
                 transitionError = error;
             }
-            // Always discard the source live handle after derivation. Bound native
-            // branches move that handle to the derived session; first-message Codex
-            // branches intentionally leave it on the source and persist unbound.
+            if (result.sourceSessionUnchanged) {
+                if (transitionError)
+                    throw transitionError;
+                return;
+            }
+            // Identity-moving forks and clones transfer the live native handle to the
+            // derived session, so the source must be reopened from its persisted binding.
             try {
                 await this.resetCachedSession(event.piboSessionId);
             }

package/dist/previews/cli.js CHANGED Viewed

@@ -2,11 +2,13 @@ import { randomBytes } from "node:crypto";
 import { resolve } from "node:path";
 import { Command } from "commander";
 import { createDefaultPiboDataSessionStore } from "../sessions/pibo-data-store.js";
+import { resolvePreviewComputeWorkerTarget } from "./compute-worker.js";
 import { DEFAULT_PREVIEW_TTL_MINUTES, loadEffectivePreviewServerSettings, loadPreviewConfig, previewPublicURL, requirePreviewBaseURL } from "./config.js";
 import { reconcileManagedPreviews, startManagedPreview, stopManagedPreview, validatePreviewStartCommand, } from "./manager.js";
 import { findPreviewTargetProcess, isPiboControlProcess, isPiboYieldedProcess, isPreviewTargetProcessCurrent, probePreviewTarget, validatePreviewPort, } from "./network.js";
 import { createDefaultPreviewStore, previewExposureState } from "./store.js";
 import { DEFAULT_MAX_PREVIEW_PROXY_CONNECTIONS, DEFAULT_MAX_PREVIEW_PROXY_CONNECTIONS_PER_PREVIEW, } from "./proxy.js";
+import { createPreviewProductionSetupPlan, inspectPreviewPublicRoute } from "./public-setup.js";
 function printJson(value) {
     console.log(JSON.stringify(value, null, 2));
 }
@@ -19,6 +21,12 @@ function parsePositiveInteger(value) {
         throw new Error("Value must be a positive integer");
     return parsed;
 }
+function parseGatewayPort(value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535)
+        throw new Error("Gateway port must be an integer between 1 and 65535");
+    return parsed;
+}
 function parsePreviewTtlMinutes(value) {
     const parsed = parsePositiveInteger(value);
     if (parsed > 7 * 24 * 60)
@@ -28,12 +36,6 @@ function parsePreviewTtlMinutes(value) {
 function createPreviewId() {
     return `pv-${randomBytes(9).toString("hex")}`;
 }
-function inferredProjectId(metadata) {
-    if (!metadata || typeof metadata !== "object" || Array.isArray(metadata))
-        return undefined;
-    const projectId = metadata.projectId;
-    return typeof projectId === "string" && projectId.trim() ? projectId.trim() : undefined;
-}
 async function previewHealth(exposure) {
     const state = previewExposureState(exposure);
     if (state !== "active")
@@ -64,23 +66,117 @@ async function exposureView(exposure) {
         ...(target ? { latencyMs: target.latencyMs } : {}),
     };
 }
+async function createPreviewExposure(port, options, defaults = {}) {
+    const baseURL = requirePreviewBaseURL();
+    const piboSessionId = options.session.trim();
+    if (!piboSessionId)
+        throw new Error("--session must contain a Pibo Session ID");
+    const sessionStore = createDefaultPiboDataSessionStore();
+    let session;
+    try {
+        session = sessionStore.get(piboSessionId);
+    }
+    finally {
+        sessionStore.close();
+    }
+    if (!session)
+        throw new Error(`Pibo Session "${piboSessionId}" was not found`);
+    const command = options.command === undefined ? undefined : validatePreviewStartCommand(options.command);
+    const target = command ? undefined : await probePreviewTarget(port);
+    if (!command && !target)
+        throw new Error(`No development server is reachable on loopback port ${port}`);
+    if (command && await probePreviewTarget(port, { timeoutMs: 150 }))
+        throw new Error(`Preview port ${port} is already occupied`);
+    const now = new Date();
+    const id = createPreviewId();
+    const targetProcess = target ? findPreviewTargetProcess(target.host, port) : undefined;
+    if (!command && process.platform === "linux" && !targetProcess) {
+        throw new Error(`Preview port ${port} is not bound exclusively to the selected loopback address`);
+    }
+    if (!command && targetProcess && isPiboControlProcess(targetProcess.pid)) {
+        throw new Error(`Preview port ${port} belongs to a Pibo control process and cannot be exposed`);
+    }
+    if (!command && process.env.NODE_ENV !== "test" && targetProcess && isPiboYieldedProcess(targetProcess.pid)) {
+        throw new Error("Preview servers cannot run as yielded agent resources; stop that process and use --command so Preview owns its lifecycle");
+    }
+    const store = createDefaultPreviewStore();
+    let exposure;
+    try {
+        exposure = store.createExposure({
+            id,
+            piboSessionId,
+            label: options.name?.trim() || defaults.label || `Preview ${port}`,
+            targetHost: target?.host ?? "127.0.0.1",
+            targetPort: port,
+            targetProcessId: targetProcess?.pid,
+            targetProcessStartTicks: targetProcess?.startTicks,
+            workspace: resolve(options.workspace ?? defaults.workspace ?? session.workspace ?? process.cwd()),
+            managementMode: command ? "managed" : "external",
+            proxyMode: defaults.proxyMode,
+            startCommand: command,
+            serverState: command ? "stopped" : undefined,
+            createdAt: now.toISOString(),
+            expiresAt: new Date(now.getTime() + options.ttlMinutes * 60_000).toISOString(),
+        });
+        if (command)
+            exposure = await startManagedPreview(store, id);
+    }
+    finally {
+        store.close();
+    }
+    return { ...await exposureView(exposure), publicUrl: previewPublicURL(id, baseURL).toString() };
+}
+function printCreatedPreview(result, json = false) {
+    if (json) {
+        printJson(result);
+        return;
+    }
+    console.log(`${result.id}\t${result.health}\t${result.label}`);
+    console.log(`url\t${result.publicUrl}`);
+    console.log(`session\t${result.piboSessionId}`);
+    console.log(`managed\t${result.managed}`);
+    console.log(`proxyMode\t${result.proxyMode}`);
+    if (result.serverStopAt)
+        console.log(`autoStop\t${result.serverStopAt}`);
+    console.log(`expires\t${result.expiresAt}`);
+}
 function printPreviewDiscovery() {
     console.log(`pibo preview - Session-linked live development previews
 Commands:
+  setup               Print production DNS, TLS, proxy, and restart instructions
   expose <port>       Register an external port or start a managed server with --command
+  expose-worker <id>  Register a running Pibo compute worker with local dev auth
   list                List preview registrations
   show <preview-id>   Inspect one preview
   start <preview-id>  Start a saved managed Preview server
   stop <preview-id>   Stop a managed Preview server without removing it
-  doctor [preview-id] Check preview configuration and reachability
+  doctor [preview-id] Check local state; add --public to verify DNS, TLS, and routing
   remove <preview-id> Stop and remove a preview definition
   close <preview-id>  Alias for remove
 Next:
+  pibo preview setup --help
   pibo preview expose --help
+  pibo preview expose-worker --help
 `);
 }
+function printProductionSetupPlan(plan) {
+    console.log("Preview production setup");
+    console.log(`baseURL\t${plan.baseURL}`);
+    console.log(`DNS\t${plan.dnsRecord.type} ${plan.dnsRecord.name} -> ${plan.dnsRecord.value}`);
+    console.log("\nCaddy global options (merge into an existing global block):");
+    console.log(plan.caddy.globalOptions);
+    console.log("\nCaddy site block:");
+    console.log(plan.caddy.siteBlock);
+    console.log("\nCommands:");
+    console.log(`configure\t${plan.commands.configure}`);
+    console.log(`validate proxy\t${plan.commands.validateCaddy}`);
+    console.log(`restart gateway\t${plan.commands.restartGateway}`);
+    console.log(`verify\t${plan.commands.verify}`);
+    for (const warning of plan.warnings)
+        console.log(`warning\t${warning}`);
+}
 export async function runPreviewCli(argv = process.argv) {
     if (argv.length <= 2 || argv[2] === "--help" || argv[2] === "-h") {
         printPreviewDiscovery();
@@ -88,86 +184,51 @@ export async function runPreviewCli(argv = process.argv) {
     }
     const program = new Command();
     program.name("pibo preview").description("Manage session-linked live development previews");
+    program
+        .command("setup")
+        .requiredOption("--base-url <url>", "Dedicated HTTPS base URL whose subdomains host Previews")
+        .option("--gateway-port <port>", "Loopback Pibo Web Gateway port", parseGatewayPort, 4788)
+        .option("--public-ip <address>", "Public IPv4 or IPv6 address for the exact DNS record")
+        .option("--json", "Print JSON")
+        .action((options) => {
+        const plan = createPreviewProductionSetupPlan({
+            baseURL: options.baseUrl,
+            gatewayPort: options.gatewayPort,
+            publicIp: options.publicIp,
+        });
+        if (options.json)
+            printJson(plan);
+        else
+            printProductionSetupPlan(plan);
+    });
     program
         .command("expose")
         .argument("<port>", "Reachable loopback development port", parsePort)
         .requiredOption("--session <pibo-session-id>", "Pibo Session that owns the preview")
-        .option("--project <project-id>", "Optional Project association")
         .option("--name <label>", "Preview label")
         .option("--workspace <path>", "Workspace used by the managed command and recorded for diagnostics")
         .option("--command <shell-command>", "Save and start this command as a Preview-managed server")
         .option("--ttl-minutes <minutes>", "Automatic preview-definition lifetime", parsePreviewTtlMinutes, DEFAULT_PREVIEW_TTL_MINUTES)
         .option("--json", "Print JSON")
         .action(async (port, options) => {
-        const baseURL = requirePreviewBaseURL();
-        const piboSessionId = options.session.trim();
-        if (!piboSessionId)
-            throw new Error("--session must contain a Pibo Session ID");
-        const sessionStore = createDefaultPiboDataSessionStore();
-        let session;
-        try {
-            session = sessionStore.get(piboSessionId);
-        }
-        finally {
-            sessionStore.close();
-        }
-        if (!session)
-            throw new Error(`Pibo Session "${piboSessionId}" was not found`);
-        const command = options.command === undefined ? undefined : validatePreviewStartCommand(options.command);
-        let target = command ? undefined : await probePreviewTarget(port);
-        if (!command && !target)
-            throw new Error(`No development server is reachable on loopback port ${port}`);
-        if (command && await probePreviewTarget(port, { timeoutMs: 150 }))
-            throw new Error(`Preview port ${port} is already occupied`);
-        const now = new Date();
-        const id = createPreviewId();
-        const targetProcess = target ? findPreviewTargetProcess(target.host, port) : undefined;
-        if (!command && process.platform === "linux" && !targetProcess) {
-            throw new Error(`Preview port ${port} is not bound exclusively to the selected loopback address`);
-        }
-        if (!command && targetProcess && isPiboControlProcess(targetProcess.pid)) {
-            throw new Error(`Preview port ${port} belongs to a Pibo control process and cannot be exposed`);
-        }
-        if (!command && process.env.NODE_ENV !== "test" && targetProcess && isPiboYieldedProcess(targetProcess.pid)) {
-            throw new Error("Preview servers cannot run as yielded agent resources; stop that process and use --command so Preview owns its lifecycle");
-        }
-        const store = createDefaultPreviewStore();
-        let exposure;
-        try {
-            exposure = store.createExposure({
-                id,
-                piboSessionId,
-                projectId: options.project?.trim() || inferredProjectId(session.metadata),
-                label: options.name?.trim() || `Preview ${port}`,
-                targetHost: target?.host ?? "127.0.0.1",
-                targetPort: port,
-                targetProcessId: targetProcess?.pid,
-                targetProcessStartTicks: targetProcess?.startTicks,
-                workspace: resolve(options.workspace ?? session.workspace ?? process.cwd()),
-                managementMode: command ? "managed" : "external",
-                startCommand: command,
-                serverState: command ? "stopped" : undefined,
-                createdAt: now.toISOString(),
-                expiresAt: new Date(now.getTime() + options.ttlMinutes * 60_000).toISOString(),
-            });
-            if (command)
-                exposure = await startManagedPreview(store, id);
-        }
-        finally {
-            store.close();
-        }
-        const result = { ...await exposureView(exposure), publicUrl: previewPublicURL(id, baseURL).toString() };
-        if (options.json)
-            printJson(result);
-        else {
-            console.log(`${result.id}\t${result.health}\t${result.label}`);
-            console.log(`url\t${result.publicUrl}`);
-            console.log(`session\t${result.piboSessionId}`);
-            console.log(`managed\t${result.managed}`);
-            if (result.serverStopAt)
-                console.log(`autoStop\t${result.serverStopAt}`);
-            console.log(`expires\t${result.expiresAt}`);
-        }
+        printCreatedPreview(await createPreviewExposure(port, options), options.json);
+    });
+    program
+        .command("expose-worker")
+        .argument("<worker>", "Running Pibo compute worker name or id")
+        .requiredOption("--session <pibo-session-id>", "Pibo Session that owns the preview")
+        .option("--name <label>", "Preview label")
+        .option("--workspace <path>", "Workspace recorded for diagnostics")
+        .option("--ttl-minutes <minutes>", "Automatic preview-definition lifetime", parsePreviewTtlMinutes, DEFAULT_PREVIEW_TTL_MINUTES)
+        .option("--json", "Print JSON")
+        .action(async (workerSelector, options) => {
+        const worker = await resolvePreviewComputeWorkerTarget(workerSelector);
+        const result = await createPreviewExposure(worker.webPort, options, {
+            label: worker.name,
+            workspace: worker.worktreePath,
+            proxyMode: "pibo-compute-dev-auth",
+        });
+        printCreatedPreview(result, options.json);
     });
     program
         .command("list")
@@ -258,9 +319,12 @@ export async function runPreviewCli(argv = process.argv) {
     program
         .command("doctor")
         .argument("[preview-id]")
+        .option("--public", "Verify public DNS, trusted TLS, and Preview-host routing")
         .option("--json", "Print JSON")
         .action(async (id, options) => {
         const baseURL = requirePreviewBaseURL();
+        if (options.public && !id)
+            throw new Error("--public requires a preview id. Create an active Preview, then run `pibo preview doctor <preview-id> --public`.");
         if (!id) {
             const config = loadPreviewConfig();
             const serverLimits = loadEffectivePreviewServerSettings();
@@ -277,6 +341,7 @@ export async function runPreviewCli(argv = process.argv) {
             const result = {
                 configured: true,
                 baseURL: baseURL.toString(),
+                productionSetup: createPreviewProductionSetupPlan({ baseURL: baseURL.toString() }),
                 limits: {
                     ...serverLimits,
                     maxProxyConnections: config.maxProxyConnections ?? DEFAULT_MAX_PREVIEW_PROXY_CONNECTIONS,
@@ -292,6 +357,8 @@ export async function runPreviewCli(argv = process.argv) {
                 console.log(`baseURL\t${result.baseURL}`);
                 console.log(`active\t${diagnostics.activeExposures}`);
                 console.log(`managed\t${diagnostics.managedStartingOrRunning}`);
+                console.log(`DNS required\t${result.productionSetup.dnsRecord.name}`);
+                console.log(`production guide\tpibo preview setup --base-url ${baseURL.origin}`);
             }
             return;
         }
@@ -304,15 +371,23 @@ export async function runPreviewCli(argv = process.argv) {
         finally {
             store.close();
         }
-        const result = await exposureView(exposure);
+        const publicChecks = options.public ? await inspectPreviewPublicRoute(baseURL, id) : undefined;
+        const result = {
+            ...await exposureView(exposure),
+            ...(publicChecks ? { publicChecks } : {}),
+        };
         if (options.json)
             printJson(result);
         else {
             console.log(`${result.id}\t${result.health}`);
             console.log(`target\t${result.targetHost}:${result.targetPort}`);
             console.log(`url\t${result.publicUrl}`);
+            if (publicChecks) {
+                console.log(`DNS\t${publicChecks.dns.status}\t${publicChecks.dns.detail}`);
+                console.log(`TLS and routing\t${publicChecks.tlsAndRouting.status}\t${publicChecks.tlsAndRouting.detail}`);
+            }
         }
-        if (result.health !== "online")
+        if (result.health !== "online" || publicChecks && (publicChecks.dns.status !== "ok" || publicChecks.tlsAndRouting.status !== "ok"))
             process.exitCode = 1;
     });
     const removeAction = async (id, options) => {

package/dist/previews/compute-worker.js ADDED Viewed

@@ -0,0 +1,37 @@
+import { listWorkers } from "../compute/docker.js";
+import { validatePreviewPort } from "./network.js";
+export function selectPreviewComputeWorkerTarget(workers, selector) {
+    const normalized = selector.trim();
+    if (!normalized)
+        throw new Error("Compute worker name or id is required");
+    const worker = workers.find((candidate) => candidate.name === normalized || candidate.id === normalized);
+    if (!worker)
+        throw new Error(`Pibo compute worker "${normalized}" was not found`);
+    if (worker.role !== "worker" && worker.role !== "dev")
+        throw new Error(`Pibo compute target "${worker.name}" is not a managed worker`);
+    if (worker.state !== "running")
+        throw new Error(`Pibo compute worker "${worker.name}" is not running`);
+    const webPort = Number(worker.portMap.web);
+    if (!Number.isInteger(webPort))
+        throw new Error(`Pibo compute worker "${worker.name}" does not publish a labeled Web port`);
+    const bindings = worker.portMap["4788/tcp"]?.split(",") ?? [];
+    if (!bindings.includes(`127.0.0.1:${webPort}`)) {
+        throw new Error(`Pibo compute worker "${worker.name}" Web port is not published on host loopback`);
+    }
+    return {
+        id: worker.id,
+        name: worker.name,
+        webPort: validatePreviewPort(webPort),
+        worktreePath: worker.worktreePath,
+    };
+}
+export async function resolvePreviewComputeWorkerTarget(selector) {
+    let workers;
+    try {
+        workers = await listWorkers({ all: true });
+    }
+    catch (error) {
+        throw new Error(`Unable to inspect Pibo compute workers: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return selectPreviewComputeWorkerTarget(workers, selector);
+}

package/dist/previews/config.js CHANGED Viewed

@@ -5,6 +5,7 @@ import { parsePreviewBaseURL } from "./base-url.js";
 export const DEFAULT_PREVIEW_TTL_MINUTES = 8 * 60;
 export const DEFAULT_PREVIEW_TICKET_TTL_SECONDS = 60;
 export const DEFAULT_PREVIEW_SESSION_TTL_MINUTES = 8 * 60;
+export const PREVIEW_TLS_AUTHORIZATION_PATH = "/api/previews/tls-authorize";
 export function loadPreviewConfig() {
     return loadPiboConfig().preview ?? {};
 }
@@ -18,7 +19,7 @@ export function loadEffectivePreviewServerSettings() {
 }
 export function requirePreviewBaseURL(value = loadPreviewConfig().baseURL) {
     if (!value)
-        throw new Error("preview.baseURL is required. Set it with `pibo config set preview.baseURL https://preview.example.com`.");
+        throw new Error("preview.baseURL is required. Run `pibo preview setup --base-url https://preview.example.com` for DNS, TLS, proxy, and restart instructions.");
     return parsePreviewBaseURL(value);
 }
 export function previewPublicURL(previewId, baseURL = requirePreviewBaseURL()) {

package/dist/previews/migrations/session-ownership.js ADDED Viewed

@@ -0,0 +1,7 @@
+/** One-time v4 upgrade: session identity already owns every exposure and authorization. */
+export function migratePreviewSessionOwnership(db) {
+    const columns = db.prepare("PRAGMA table_info(preview_exposures)").all();
+    if (columns.some((column) => column.name === "project_id")) {
+        db.exec("ALTER TABLE preview_exposures DROP COLUMN project_id");
+    }
+}

package/dist/previews/proxy.js CHANGED Viewed

@@ -154,8 +154,10 @@ function requestHeaders(incoming, exposure, requestURL, websocket) {
     }
     const targetHost = exposure.targetHost === "::1" ? `[::1]` : exposure.targetHost;
     headers.host = `${targetHost}:${exposure.targetPort}`;
-    headers["x-forwarded-host"] = requestURL.host;
-    headers["x-forwarded-proto"] = requestURL.protocol.slice(0, -1);
+    if (exposure.proxyMode !== "pibo-compute-dev-auth") {
+        headers["x-forwarded-host"] = requestURL.host;
+        headers["x-forwarded-proto"] = requestURL.protocol.slice(0, -1);
+    }
     if (websocket) {
         headers.connection = "Upgrade";
         headers.upgrade = incoming.upgrade ?? "websocket";

package/dist/previews/public-setup.js ADDED Viewed

@@ -0,0 +1,108 @@
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
+import { PREVIEW_TLS_AUTHORIZATION_PATH, previewPublicURL, requirePreviewBaseURL } from "./config.js";
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function validateGatewayPort(port) {
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+        throw new Error("Gateway port must be an integer between 1 and 65535");
+    return port;
+}
+function validatePublicIp(value) {
+    if (!value)
+        return { type: "A or AAAA", value: "<public-gateway-ip>" };
+    const family = isIP(value);
+    if (family === 0)
+        throw new Error("Public IP must be a valid IPv4 or IPv6 address");
+    return { type: family === 4 ? "A" : "AAAA", value };
+}
+export function createPreviewProductionSetupPlan(input) {
+    const baseURL = requirePreviewBaseURL(input.baseURL);
+    const gatewayPort = validateGatewayPort(input.gatewayPort ?? 4788);
+    const publicIp = validatePublicIp(input.publicIp);
+    const wildcardHostname = `*.${baseURL.hostname}`;
+    const caddySiteAddress = baseURL.port ? `${wildcardHostname}:${baseURL.port}` : wildcardHostname;
+    const tlsAuthorizationURL = `http://127.0.0.1:${gatewayPort}${PREVIEW_TLS_AUTHORIZATION_PATH}`;
+    return {
+        baseURL: baseURL.toString(),
+        wildcardHostname,
+        dnsRecord: {
+            type: publicIp.type,
+            name: wildcardHostname,
+            value: publicIp.value,
+        },
+        gateway: {
+            host: "127.0.0.1",
+            port: gatewayPort,
+            tlsAuthorizationURL,
+        },
+        caddy: {
+            globalOptions: `on_demand_tls {\n\task ${tlsAuthorizationURL}\n}`,
+            siteBlock: `${caddySiteAddress} {\n\ttls {\n\t\ton_demand\n\t}\n\treverse_proxy 127.0.0.1:${gatewayPort}\n}`,
+        },
+        commands: {
+            configure: `pibo config set preview.baseURL ${shellQuote(baseURL.origin)}`,
+            restartGateway: "pibo gateway web restart",
+            validateCaddy: "caddy validate --config /etc/caddy/Caddyfile && systemctl reload caddy",
+            verify: "pibo preview doctor <preview-id> --public",
+        },
+        warnings: [
+            "Merge the on_demand_tls stanza into an existing Caddy global options block; a Caddyfile may contain only one global options block.",
+            "Create the wildcard DNS record before Caddy requests the first Preview certificate.",
+            "Restart the Pibo gateway after setting preview.baseURL; the safe restart may wait for active sessions.",
+        ],
+    };
+}
+async function resolveHostname(hostname) {
+    return (await lookup(hostname, { all: true })).map((entry) => entry.address);
+}
+async function requestPreview(url) {
+    const response = await fetch(url, {
+        method: "GET",
+        redirect: "manual",
+        signal: AbortSignal.timeout(10_000),
+    });
+    return { status: response.status, location: response.headers.get("location") ?? undefined };
+}
+function errorDetail(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export async function inspectPreviewPublicRoute(baseURLValue, previewId, options = {}) {
+    const baseURL = requirePreviewBaseURL(baseURLValue instanceof URL ? baseURLValue.toString() : baseURLValue);
+    const publicURL = previewPublicURL(previewId, baseURL);
+    let addresses = [];
+    let dns;
+    try {
+        addresses = await (options.resolveHostname ?? resolveHostname)(publicURL.hostname);
+        dns = addresses.length > 0
+            ? { status: "ok", detail: `Resolved ${publicURL.hostname}`, addresses }
+            : { status: "fail", detail: `${publicURL.hostname} returned no addresses`, addresses };
+    }
+    catch (error) {
+        dns = { status: "fail", detail: `DNS lookup failed: ${errorDetail(error)}`, addresses };
+    }
+    let tlsAndRouting;
+    try {
+        const response = await (options.request ?? requestPreview)(publicURL);
+        if (response.status === 401) {
+            tlsAndRouting = {
+                status: "ok",
+                detail: "HTTPS reached the Preview gateway and anonymous access was rejected",
+                httpStatus: response.status,
+            };
+        }
+        else {
+            tlsAndRouting = {
+                status: "fail",
+                detail: `Expected HTTP 401 from the Preview gateway, received HTTP ${response.status}`,
+                httpStatus: response.status,
+                ...(response.location ? { location: response.location } : {}),
+            };
+        }
+    }
+    catch (error) {
+        tlsAndRouting = { status: "fail", detail: `HTTPS request failed: ${errorDetail(error)}` };
+    }
+    return { publicURL: publicURL.toString(), dns, tlsAndRouting };
+}