@pasko70/pibo 1.9.13 → 1.10.1

package/dist/runs/lifecycle.js

@@ -0,0 +1,59 @@
+export class PiboRunExecutionTimeoutError extends Error {
+    timeoutPhase;
+    constructor(message, timeoutPhase) {
+        super(message);
+        this.timeoutPhase = timeoutPhase;
+        this.name = "PiboRunExecutionTimeoutError";
+    }
+}
+export function resolveRunTimeoutMs(toolName, params) {
+    if (!params || typeof params !== "object" || Array.isArray(params))
+        return undefined;
+    const input = params;
+    if (typeof input.timeoutMs === "number")
+        return normalizePositiveTimeout(input.timeoutMs, "arguments.timeoutMs");
+    if (toolName === "bash" && typeof input.timeout === "number")
+        return normalizePositiveTimeout(input.timeout * 1000, "arguments.timeout");
+    return undefined;
+}
+export function foregroundServiceWarning(toolName, params, timeoutMs) {
+    if (toolName !== "bash" || timeoutMs === undefined || !params || typeof params !== "object" || Array.isArray(params))
+        return undefined;
+    const command = typeof params.command === "string" ? String(params.command) : "";
+    if (!isKnownForegroundServiceCommand(command))
+        return undefined;
+    return `Known long-lived service command is running in a finite yielded run (${timeoutMs}ms). It can start successfully and later end as timed_out. Use the managed gateway CLI, or launch a detached/background service with a separate bounded health check.`;
+}
+export function isConfiguredTimeoutError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /(?:timed?\s*out|timeout)/i.test(message);
+}
+export function hasMeaningfulTimeoutOutput(value) {
+    const text = extractText(value);
+    if (!text)
+        return false;
+    return text.split(/\r?\n/).some((line) => {
+        const trimmed = line.trim();
+        return !!trimmed && !/(?:timed?\s*out|timeout|command exited with code|process exited with code)/i.test(trimmed);
+    });
+}
+function isKnownForegroundServiceCommand(command) {
+    return /(?:^|[;&|]\s*|\b)(?:pibo\s+gateway(?::web|\s+web|\s+dev)?(?:\s|$)|node\s+[^\n]*pibo(?:\.js)?\s+gateway:web(?:\s|$)|(?:\.\/)?(?:scripts\/)?docker-entrypoint\.sh\s+gateway:web(?:\s|$)|npm\s+(?:run\s+)?gateway(?::web)?(?:\s|$)|(?:npm\s+run\s+)?(?:dev|start)\s+--[^\n]*\bgateway(?::web)?\b|vite(?:\s|$))/i.test(command);
+}
+function normalizePositiveTimeout(value, field) {
+    if (!Number.isFinite(value) || value <= 0)
+        throw new Error(`${field} must be a positive number`);
+    return Math.max(1, Math.round(value));
+}
+function extractText(value) {
+    if (typeof value === "string")
+        return value;
+    if (!value || typeof value !== "object")
+        return "";
+    const candidate = value;
+    if (typeof candidate.text === "string")
+        return candidate.text;
+    if (!Array.isArray(candidate.content))
+        return "";
+    return candidate.content.map((part) => part && typeof part === "object" && typeof part.text === "string" ? String(part.text) : "").filter(Boolean).join("\n");
+}

package/dist/runs/registry.js

@@ -4,6 +4,14 @@ const DEFAULT_DETACHED_TERMINAL_TTL_MS = 60 * 1000;
 function now() {
     return new Date().toISOString();
 }
+function runTimeoutAt(createdAt, timeoutMs) {
+    return timeoutMs === undefined ? undefined : new Date(Date.parse(createdAt) + timeoutMs).toISOString();
+}
+function formatTimeout(timeoutMs) {
+    if (timeoutMs === undefined)
+        return "its configured timeout";
+    return timeoutMs % 1000 === 0 ? `${timeoutMs / 1000}s timeout` : `${timeoutMs}ms timeout`;
+}
 function snapshot(record) {
     const output = {
         runId: record.runId,
@@ -18,12 +26,20 @@ function snapshot(record) {
     };
     if (record.summary)
         output.summary = record.summary;
+    if (record.timeoutMs !== undefined)
+        output.timeoutMs = record.timeoutMs;
+    if (record.timeoutAt)
+        output.timeoutAt = record.timeoutAt;
+    if (record.timeoutPhase)
+        output.timeoutPhase = record.timeoutPhase;
+    if (record.serviceWarning)
+        output.serviceWarning = record.serviceWarning;
     if (record.completedAt)
         output.completedAt = record.completedAt;
     return output;
 }
 function terminal(status) {
-    return status === "completed" || status === "failed" || status === "cancelled";
+    return status === "completed" || status === "failed" || status === "timed_out" || status === "cancelled";
 }
 export class PiboRunRegistry {
     options;
@@ -53,6 +69,8 @@ export class PiboRunRegistry {
                 params: input.params,
                 retryable: input.retryable ?? false,
                 maxAttempts: input.maxAttempts ?? 1,
+                timeoutMs: input.timeoutMs,
+                serviceWarning: input.serviceWarning,
             });
             const record = recordFromStored(stored);
             this.runs.set(record.runId, record);
@@ -75,6 +93,8 @@ export class PiboRunRegistry {
             summary: `${input.toolName} run is running.`,
             retryable: input.retryable ?? false,
             maxAttempts: Math.max(1, input.maxAttempts ?? 1),
+            ...(input.timeoutMs !== undefined ? { timeoutMs: input.timeoutMs, timeoutAt: runTimeoutAt(timestamp, input.timeoutMs) } : {}),
+            ...(input.serviceWarning ? { serviceWarning: input.serviceWarning } : {}),
         };
         this.runs.set(runId, record);
         const output = snapshot(record);
@@ -113,6 +133,25 @@ export class PiboRunRegistry {
         this.notify({ type: "run_changed", run: output, previousStatus, reason: error });
         return output;
     }
+    timeOut(runId, error, timeoutPhase) {
+        const record = this.runs.get(runId);
+        if (!record || terminal(record.status))
+            return undefined;
+        const previousStatus = record.status;
+        record.status = "timed_out";
+        record.error = error;
+        record.timeoutPhase = timeoutPhase;
+        record.summary = timeoutPhase === "lifetime"
+            ? `${record.toolName} run started successfully, then reached ${formatTimeout(record.timeoutMs)}.`
+            : `${record.toolName} run reached ${formatTimeout(record.timeoutMs)} before startup was confirmed.`;
+        this.finish(record);
+        this.options.store?.updateRun(runId, record);
+        if (record.jobId)
+            this.options.store?.fail(record.jobId, `run-registry:${process.pid}`, error);
+        const output = snapshot(record);
+        this.notify({ type: "run_changed", run: output, previousStatus, reason: error });
+        return output;
+    }
     list(controllerPiboSessionId, options = {}) {
         this.prune();
         return [...this.runs.values()]
@@ -219,6 +258,7 @@ export class PiboRunRegistry {
         const notification = {
             completed: [],
             failed: [],
+            timedOut: [],
             cancelled: [],
             running: [],
         };
@@ -228,6 +268,8 @@ export class PiboRunRegistry {
                 notification.completed.push(item);
             else if (record.status === "failed")
                 notification.failed.push(item);
+            else if (record.status === "timed_out")
+                notification.timedOut.push(item);
             else if (record.status === "cancelled")
                 notification.cancelled.push(item);
             else
@@ -356,5 +398,9 @@ function recordFromStored(record) {
         jobId: record.jobId,
         retryable: record.retryable,
         maxAttempts: record.maxAttempts,
+        timeoutMs: record.timeoutMs,
+        timeoutAt: record.timeoutAt,
+        timeoutPhase: record.timeoutPhase,
+        serviceWarning: record.serviceWarning,
     };
 }

package/dist/runs/tools.js

@@ -1,5 +1,6 @@
 import { StringEnum, Type } from "@earendil-works/pi-ai";
 import { defineTool } from "@earendil-works/pi-coding-agent";
+import { foregroundServiceWarning, hasMeaningfulTimeoutOutput, isConfiguredTimeoutError, PiboRunExecutionTimeoutError, resolveRunTimeoutMs } from "./lifecycle.js";
 function resultText(prefix, value) {
     return `${prefix}\n${JSON.stringify(value, null, 2)}`;
 }
@@ -30,7 +31,7 @@ export function createRunToolDefinitions(yieldableTools, controller) {
         defineTool({
             name: "pibo_run_start",
             label: "Pibo Run Start",
-            description: "Start a yieldable tool as a yielded run. Use tracked when the result may matter later; use detached only for intentional fire-and-forget work.",
+            description: "Start a yieldable tool as a yielded run. The run records its configured timeout and classifies lifetime expiry separately from command failure. Use detached only for intentional fire-and-forget work.",
             promptSnippet: "Use pibo_run_start to run a yieldable tool in the background. It returns a runId. Use pibo_run_read for completed results and pibo_run_wait/status/list/cancel/ack to manage runs.",
             executionMode: "parallel",
             parameters: Type.Object({
@@ -43,25 +44,42 @@ export function createRunToolDefinitions(yieldableTools, controller) {
             }),
             async execute(toolCallId, params, signal, onUpdate, ctx) {
                 const tool = requireTool(yieldableTools, params.toolName);
+                const timeoutMs = resolveRunTimeoutMs(tool.name, params.arguments);
+                const serviceWarning = foregroundServiceWarning(tool.name, params.arguments, timeoutMs);
+                let observedOutput = false;
                 const run = controller.startToolRun({
                     toolName: tool.name,
                     params: params.arguments,
                     completionPolicy: params.completionPolicy,
+                    timeoutMs,
+                    serviceWarning,
                     async execute() {
-                        const result = await tool.execute(toolCallId, params.arguments, signal, onUpdate, ctx);
-                        const resultObject = result;
-                        const text = textFromToolResult(resultObject);
-                        if (resultObject.isError === true) {
-                            throw new Error(text ?? `${tool.name} returned an error result.`);
+                        try {
+                            const result = await tool.execute(toolCallId, params.arguments, signal, (update) => {
+                                observedOutput ||= hasMeaningfulTimeoutOutput(update);
+                                onUpdate?.(update);
+                            }, ctx);
+                            const resultObject = result;
+                            const text = textFromToolResult(resultObject);
+                            if (resultObject.isError === true) {
+                                if (timeoutMs !== undefined && isConfiguredTimeoutError(text ?? ""))
+                                    throw new PiboRunExecutionTimeoutError(text ?? `${tool.name} timed out.`, observedOutput || hasMeaningfulTimeoutOutput(text) ? "lifetime" : "startup");
+                                throw new Error(text ?? `${tool.name} returned an error result.`);
+                            }
+                            return { text, details: resultObject.details ?? result };
+                        }
+                        catch (error) {
+                            if (error instanceof PiboRunExecutionTimeoutError)
+                                throw error;
+                            if (timeoutMs !== undefined && isConfiguredTimeoutError(error))
+                                throw new PiboRunExecutionTimeoutError(error instanceof Error ? error.message : String(error), observedOutput ? "lifetime" : "startup");
+                            throw error;
                         }
-                        return {
-                            text,
-                            details: resultObject.details ?? result,
-                        };
                     },
                 });
+                const prefix = serviceWarning ? `Started yielded run ${run.runId}.\nWarning: ${serviceWarning}` : `Started yielded run ${run.runId}.`;
                 return {
-                    content: [{ type: "text", text: resultText(`Started yielded run ${run.runId}.`, run) }],
+                    content: [{ type: "text", text: resultText(prefix, run) }],
                     details: run,
                 };
             },
@@ -132,8 +150,8 @@ export function createRunToolDefinitions(yieldableTools, controller) {
         defineTool({
             name: "pibo_run_read",
             label: "Pibo Run Read",
-            description: "Read the terminal result or error for a yielded run.",
-            promptSnippet: "Use pibo_run_read to retrieve a completed or failed run result. Reading terminal tracked runs consumes reminders.",
+            description: "Read the terminal result, timeout reason, or error for a yielded run.",
+            promptSnippet: "Use pibo_run_read to retrieve a completed, failed, or timed_out run result. Reading terminal tracked runs consumes reminders.",
             executionMode: "parallel",
             parameters: Type.Object({
                 runId: Type.String({ description: "Run id returned by pibo_run_start" }),

package/dist/session-ui/terminalRows.js

@@ -11,7 +11,7 @@ export function buildCompactTerminalRows(traceView, options) {
         .filter((item) => item.node.type !== "agent.turn" && (options.showThinking || item.node.type !== "model.reasoning"));
     const candidates = syncThinkingToolRows(flatNodes.map((item) => createRowCandidate(item.node, item.turnId)));
     applyCompletedTurnTiming(candidates, turnById);
-    return groupRelatedToolCandidates(candidates).map((candidate) => candidate.row);
+    return groupRelatedToolCandidates(reconcileConceptualRowCandidates(candidates)).map((candidate) => candidate.row);
 }
 export function findActiveTurnStartedAt(traceView) {
     if (!traceView)
@@ -100,7 +100,71 @@ function createRowCandidate(node, turnId) {
             };
             break;
     }
-    return { ...candidate, row: { ...candidate.row, ...debugFields(node) } };
+    return {
+        ...candidate,
+        row: {
+            ...candidate.row,
+            id: compactTerminalRowIdentity(node),
+            ...debugFields(node),
+        },
+    };
+}
+export function compactTerminalRowIdentity(node) {
+    if (node.type === "tool.call" || node.type === "tool.result" || node.type === "agent.delegation") {
+        const toolCallId = node.toolCallId ?? stableKeySuffix(node.stableKey, "tool:");
+        if (toolCallId)
+            return `terminal:tool:${toolCallId}`;
+        if (node.type === "agent.delegation" && node.linkedPiboSessionId) {
+            return `terminal:delegation:${node.linkedPiboSessionId}`;
+        }
+    }
+    if ((node.type === "agent.async" || node.type === "yielded.run") && node.runId) {
+        return `terminal:run:${node.runId}`;
+    }
+    if (node.type === "assistant.message") {
+        const assistantId = stableKeySuffix(node.stableKey, "assistant:");
+        if (assistantId)
+            return `terminal:assistant:${assistantId}`;
+    }
+    if (node.type === "model.reasoning") {
+        const reasoningId = stableKeySuffix(node.stableKey, "reasoning:");
+        if (reasoningId)
+            return `terminal:reasoning:${reasoningId}`;
+    }
+    return node.id;
+}
+function stableKeySuffix(stableKey, prefix) {
+    if (!stableKey?.startsWith(prefix))
+        return undefined;
+    const suffix = stableKey.slice(prefix.length);
+    return suffix && suffix !== "undefined" ? suffix : undefined;
+}
+function reconcileConceptualRowCandidates(candidates) {
+    const reconciled = [];
+    const indexById = new Map();
+    for (const candidate of candidates) {
+        const existingIndex = indexById.get(candidate.row.id);
+        if (existingIndex === undefined) {
+            indexById.set(candidate.row.id, reconciled.length);
+            reconciled.push(candidate);
+            continue;
+        }
+        const existing = reconciled[existingIndex];
+        reconciled[existingIndex] = {
+            ...candidate,
+            turnId: candidate.turnId ?? existing.turnId,
+            row: {
+                ...existing.row,
+                ...candidate.row,
+                sourceNodeIds: [...new Set([...existing.row.sourceNodeIds, ...candidate.row.sourceNodeIds])],
+                input: candidate.row.input ?? existing.row.input,
+                output: candidate.row.output ?? existing.row.output,
+                error: candidate.row.error ?? existing.row.error,
+                payloadRefs: { ...existing.row.payloadRefs, ...candidate.row.payloadRefs },
+            },
+        };
+    }
+    return reconciled;
 }
 function applyCompletedTurnTiming(candidates, turnById) {
     for (const turn of turnById.values()) {

package/dist/sessions/pibo-data-store.js

@@ -53,20 +53,20 @@ export class PiboDataSessionStore {
             activeModel: input.activeModel === null ? undefined : input.activeModel ? { ...input.activeModel } : existing.activeModel,
             updatedAt: new Date().toISOString(),
         };
-        this.db.prepare(`
-			UPDATE sessions SET
-				pi_session_id = ?,
-				root_session_id = ?,
-				parent_id = ?,
-				origin_id = ?,
-				profile = ?,
-				active_model_json = ?,
-				workspace = ?,
-				title = ?,
-				metadata_json = ?,
-				updated_at = ?,
-				last_activity_at = MAX(last_activity_at, ?)
-			WHERE id = ? AND deleted_at IS NULL
+        this.db.prepare(`
+			UPDATE sessions SET
+				pi_session_id = ?,
+				root_session_id = ?,
+				parent_id = ?,
+				origin_id = ?,
+				profile = ?,
+				active_model_json = ?,
+				workspace = ?,
+				title = ?,
+				metadata_json = ?,
+				updated_at = ?,
+				last_activity_at = MAX(last_activity_at, ?)
+			WHERE id = ? AND deleted_at IS NULL
 		`).run(updated.piSessionId, rootSessionId(updated), updated.parentId ?? null, updated.originId ?? null, updated.profile, updated.activeModel ? JSON.stringify(updated.activeModel) : null, updated.workspace ?? null, updated.title ?? "Untitled Session", JSON.stringify(updated.metadata ?? {}), updated.updatedAt, updated.updatedAt, id);
         return this.get(id);
     }
@@ -129,8 +129,8 @@ export class PiboDataSessionStore {
             "channel", "kind", "profile", "active_model_json", "workspace", "title", "first_message_preview",
             "status", "metadata_json", "created_at", "updated_at", "last_activity_at",
         ];
-        this.db.prepare(`
-			INSERT INTO sessions (${columns.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})
+        this.db.prepare(`
+			INSERT INTO sessions (${columns.join(", ")}) VALUES (${columns.map(() => "?").join(", ")})
 		`).run(session.id, session.piSessionId, roomIdFromMetadata(session.metadata), rootSessionId(session), session.parentId ?? null, session.originId ?? null, session.channel, session.kind, session.profile, session.activeModel ? JSON.stringify(session.activeModel) : null, session.workspace ?? null, session.title ?? "Untitled Session", previewText(session.title ?? "") ?? null, "idle", JSON.stringify(session.metadata ?? {}), session.createdAt, session.updatedAt, session.updatedAt);
     }
 }

package/dist/sessions/sqlite-store.js

@@ -18,31 +18,31 @@ export class SqlitePiboSessionStore {
         this.ensureActiveModelColumn();
     }
     applySchema() {
-        this.db.exec(`
-			CREATE TABLE IF NOT EXISTS pibo_sessions (
-				id TEXT PRIMARY KEY,
-				pi_session_id TEXT NOT NULL UNIQUE,
-				channel TEXT NOT NULL,
-				kind TEXT NOT NULL,
-				profile TEXT NOT NULL,
-				parent_id TEXT,
-				origin_id TEXT,
-				workspace TEXT,
-				title TEXT,
-				metadata_json TEXT,
-				active_model_json TEXT,
-				created_at TEXT NOT NULL,
-				updated_at TEXT NOT NULL,
-				FOREIGN KEY(parent_id) REFERENCES pibo_sessions(id),
-				FOREIGN KEY(origin_id) REFERENCES pibo_sessions(id)
-			);
-
-			CREATE INDEX IF NOT EXISTS idx_pibo_sessions_parent
-				ON pibo_sessions(parent_id, updated_at);
-			CREATE INDEX IF NOT EXISTS idx_pibo_sessions_origin
-				ON pibo_sessions(origin_id, updated_at);
-			CREATE INDEX IF NOT EXISTS idx_pibo_sessions_channel_kind
-				ON pibo_sessions(channel, kind, updated_at);
+        this.db.exec(`
+			CREATE TABLE IF NOT EXISTS pibo_sessions (
+				id TEXT PRIMARY KEY,
+				pi_session_id TEXT NOT NULL UNIQUE,
+				channel TEXT NOT NULL,
+				kind TEXT NOT NULL,
+				profile TEXT NOT NULL,
+				parent_id TEXT,
+				origin_id TEXT,
+				workspace TEXT,
+				title TEXT,
+				metadata_json TEXT,
+				active_model_json TEXT,
+				created_at TEXT NOT NULL,
+				updated_at TEXT NOT NULL,
+				FOREIGN KEY(parent_id) REFERENCES pibo_sessions(id),
+				FOREIGN KEY(origin_id) REFERENCES pibo_sessions(id)
+			);
+
+			CREATE INDEX IF NOT EXISTS idx_pibo_sessions_parent
+				ON pibo_sessions(parent_id, updated_at);
+			CREATE INDEX IF NOT EXISTS idx_pibo_sessions_origin
+				ON pibo_sessions(origin_id, updated_at);
+			CREATE INDEX IF NOT EXISTS idx_pibo_sessions_channel_kind
+				ON pibo_sessions(channel, kind, updated_at);
 		`);
     }
     ensureActiveModelColumn() {
@@ -60,22 +60,22 @@ export class SqlitePiboSessionStore {
     create(input) {
         const session = createPiboSession(input);
         this.db
-            .prepare(`
-				INSERT INTO pibo_sessions (
-					id,
-					pi_session_id,
-					channel,
-					kind,
-					profile,
-					parent_id,
-					origin_id,
-					workspace,
-					title,
-					metadata_json,
-					active_model_json,
-					created_at,
-					updated_at
-				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            .prepare(`
+				INSERT INTO pibo_sessions (
+					id,
+					pi_session_id,
+					channel,
+					kind,
+					profile,
+					parent_id,
+					origin_id,
+					workspace,
+					title,
+					metadata_json,
+					active_model_json,
+					created_at,
+					updated_at
+				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
 			`)
             .run(session.id, session.piSessionId, session.channel, session.kind, session.profile, session.parentId ?? null, session.originId ?? null, session.workspace ?? null, session.title ?? null, JSON.stringify(session.metadata ?? {}), session.activeModel ? JSON.stringify(session.activeModel) : null, session.createdAt, session.updatedAt);
         const created = this.get(session.id);
@@ -100,18 +100,18 @@ export class SqlitePiboSessionStore {
             updatedAt: new Date().toISOString(),
         };
         this.db
-            .prepare(`
-				UPDATE pibo_sessions SET
-					pi_session_id = ?,
-					profile = ?,
-					parent_id = ?,
-					origin_id = ?,
-					workspace = ?,
-					title = ?,
-					metadata_json = ?,
-					active_model_json = ?,
-					updated_at = ?
-				WHERE id = ?
+            .prepare(`
+				UPDATE pibo_sessions SET
+					pi_session_id = ?,
+					profile = ?,
+					parent_id = ?,
+					origin_id = ?,
+					workspace = ?,
+					title = ?,
+					metadata_json = ?,
+					active_model_json = ?,
+					updated_at = ?
+				WHERE id = ?
 			`)
             .run(updated.piSessionId, updated.profile, updated.parentId ?? null, updated.originId ?? null, updated.workspace ?? null, updated.title ?? null, JSON.stringify(updated.metadata ?? {}), updated.activeModel ? JSON.stringify(updated.activeModel) : null, updated.updatedAt, id);
         return this.get(id);

package/dist/setup/cli.js

@@ -23,89 +23,89 @@ function shellQuote(value) {
 }
 function serviceUnit(options) {
     const gatewayPortEnv = options.serviceKind === "dev" ? `Environment=PIBO_GATEWAY_DEV_PORT=${options.webPort}\n` : `Environment=PIBO_GATEWAY_WEB_PORT=${options.webPort}\n`;
-    return `[Unit]
-Description=${options.description}
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-WorkingDirectory=${options.workingDirectory}
-Environment=HOME=/root
-Environment=PIBO_HOME=${options.piboHome}
-Environment=NODE_ENV=production
-${gatewayPortEnv}ExecStart=${options.execStart}
-Restart=always
-RestartSec=5
-KillSignal=SIGTERM
-TimeoutStopSec=30
-
-[Install]
-WantedBy=multi-user.target
+    return `[Unit]
+Description=${options.description}
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+WorkingDirectory=${options.workingDirectory}
+Environment=HOME=/root
+Environment=PIBO_HOME=${options.piboHome}
+Environment=NODE_ENV=production
+${gatewayPortEnv}ExecStart=${options.execStart}
+Restart=always
+RestartSec=5
+KillSignal=SIGTERM
+TimeoutStopSec=30
+
+[Install]
+WantedBy=multi-user.target
 `;
 }
 function devStartWrapper(options) {
-    return `#!/usr/bin/env node
-import { runWebGatewayServer } from ${JSON.stringify(`${options.repoDir}/dist/gateway/web.js`)};
-
-await runWebGatewayServer({
-  host: "127.0.0.1",
-  port: ${options.gatewayPort},
-  web: {
-    host: "127.0.0.1",
-    port: ${options.webPort},
-  },
-});
+    return `#!/usr/bin/env node
+import { runWebGatewayServer } from ${JSON.stringify(`${options.repoDir}/dist/gateway/web.js`)};
+
+await runWebGatewayServer({
+  host: "127.0.0.1",
+  port: ${options.gatewayPort},
+  web: {
+    host: "127.0.0.1",
+    port: ${options.webPort},
+  },
+});
 `;
 }
 function caddyfile(options) {
     const blocks = [];
     if (options.prodDomain) {
-        blocks.push(`${options.prodDomain} {
-	encode zstd gzip
-	reverse_proxy 127.0.0.1:${options.prodPort}
+        blocks.push(`${options.prodDomain} {
+	encode zstd gzip
+	reverse_proxy 127.0.0.1:${options.prodPort}
 }`);
     }
     if (options.prodWwwDomain && options.prodDomain) {
-        blocks.push(`${options.prodWwwDomain} {
-	redir https://${options.prodDomain}{uri} permanent
+        blocks.push(`${options.prodWwwDomain} {
+	redir https://${options.prodDomain}{uri} permanent
 }`);
     }
     if (options.devDomain && options.devPort) {
-        blocks.push(`${options.devDomain} {
-	encode zstd gzip
-	reverse_proxy 127.0.0.1:${options.devPort}
+        blocks.push(`${options.devDomain} {
+	encode zstd gzip
+	reverse_proxy 127.0.0.1:${options.devPort}
 }`);
     }
     if (options.devWwwDomain && options.devDomain) {
-        blocks.push(`${options.devWwwDomain} {
-	redir https://${options.devDomain}{uri} permanent
+        blocks.push(`${options.devWwwDomain} {
+	redir https://${options.devDomain}{uri} permanent
 }`);
     }
     return `${blocks.join("\n\n")}\n`;
 }
 function userEnvTemplate(options) {
-    return `# Pibo user-host setup
-PIBO_HOME=${options.piboHome}
-PIBO_AUTH_BASE_URL=${options.domain ? `https://${options.domain}` : "https://pibo.example.com"}
-# Set through \`pibo config set\` or your secret manager:
-# PIBO_AUTH_SECRET=<at-least-32-characters>
-# PIBO_GOOGLE_CLIENT_ID=<google-client-id>
-# PIBO_GOOGLE_CLIENT_SECRET=<google-client-secret>
-# PIBO_ALLOWED_EMAILS=you@example.com
+    return `# Pibo user-host setup
+PIBO_HOME=${options.piboHome}
+PIBO_AUTH_BASE_URL=${options.domain ? `https://${options.domain}` : "https://pibo.example.com"}
+# Set through \`pibo config set\` or your secret manager:
+# PIBO_AUTH_SECRET=<at-least-32-characters>
+# PIBO_GOOGLE_CLIENT_ID=<google-client-id>
+# PIBO_GOOGLE_CLIENT_SECRET=<google-client-secret>
+# PIBO_ALLOWED_EMAILS=you@example.com
 `;
 }
 function developerEnvTemplate(options) {
-    return `# Pibo developer-host setup
-PIBO_ORIGIN=${options.origin ?? "git@github.com:<your-fork>/pibo.git"}
-PIBO_UPSTREAM=${options.upstream ?? "git@github.com:Pascapone/pibo.git"}
-PIBO_REPO_DIR=${options.repoDir}
-PIBO_PROD_HOME=${options.prodHome}
-PIBO_DEV_HOME=${options.devHome}
-PIBO_PROD_BASE_URL=${options.prodDomain ? `https://${options.prodDomain}` : "https://pibo.example.com"}
-PIBO_DEV_BASE_URL=${options.devDomain ? `https://${options.devDomain}` : "https://dev.pibo.example.com"}
-# Optional: override the dev deploy reachability probe. If omitted, deploy uses PIBO_DEV_BASE_URL/apps/chat.
-# PIBO_DEV_PUBLIC_URL=${options.devDomain ? `https://${options.devDomain}/apps/chat` : "https://dev.pibo.example.com/apps/chat"}
+    return `# Pibo developer-host setup
+PIBO_ORIGIN=${options.origin ?? "git@github.com:<your-fork>/pibo.git"}
+PIBO_UPSTREAM=${options.upstream ?? "git@github.com:Pascapone/pibo.git"}
+PIBO_REPO_DIR=${options.repoDir}
+PIBO_PROD_HOME=${options.prodHome}
+PIBO_DEV_HOME=${options.devHome}
+PIBO_PROD_BASE_URL=${options.prodDomain ? `https://${options.prodDomain}` : "https://pibo.example.com"}
+PIBO_DEV_BASE_URL=${options.devDomain ? `https://${options.devDomain}` : "https://dev.pibo.example.com"}
+# Optional: override the dev deploy reachability probe. If omitted, deploy uses PIBO_DEV_BASE_URL/apps/chat.
+# PIBO_DEV_PUBLIC_URL=${options.devDomain ? `https://${options.devDomain}/apps/chat` : "https://dev.pibo.example.com/apps/chat"}
 `;
 }
 export function createUserHostSetupPlan(options = {}) {