@pasko70/pibo 2.5.1 → 3.0.0

package/dist/plugins/registry.js

@@ -1,8 +1,77 @@
 import { randomUUID } from "node:crypto";
 import { normalizeToolProfile } from "../core/profiles.js";
+import { PiboSpeechError, } from "../speech/types.js";
 import { listInstalledCliToolAgentContexts } from "../tools/registry.js";
 import { listPiPackages } from "../pi-packages/store.js";
 import { AgentRuntimeAdapterRegistry } from "../agent-runtime/registry.js";
+const MAX_ACTIVE_SPEECH_SESSIONS = 8;
+const SPEECH_SESSION_IDLE_TIMEOUT_MS = 2 * 60 * 1_000;
+const SPEECH_SESSION_START_TIMEOUT_MS = 30_000;
+function deferred() {
+    let resolve;
+    const promise = new Promise((resolvePromise) => {
+        resolve = resolvePromise;
+    });
+    return { promise, resolve };
+}
+function ownSpeechProviderSession(session) {
+    let stopPromise;
+    return {
+        session,
+        stop() {
+            stopPromise ??= Promise.resolve().then(() => session.stop());
+            return stopPromise;
+        },
+    };
+}
+function speechAbortError(signal) {
+    if (signal.reason instanceof PiboSpeechError)
+        return signal.reason;
+    const message = signal.reason instanceof Error && signal.reason.message
+        ? signal.reason.message
+        : "Speech session startup was aborted.";
+    return new PiboSpeechError(message, "aborted", { cause: signal.reason });
+}
+async function waitForSpeechProviderStart(start, signal) {
+    if (signal.aborted)
+        throw speechAbortError(signal);
+    let onAbort;
+    try {
+        return await Promise.race([
+            start,
+            new Promise((_resolve, reject) => {
+                onAbort = () => reject(speechAbortError(signal));
+                signal.addEventListener("abort", onAbort, { once: true });
+            }),
+        ]);
+    }
+    finally {
+        if (onAbort)
+            signal.removeEventListener("abort", onAbort);
+    }
+}
+function positiveTimeout(value, fallback, name) {
+    const selected = value ?? fallback;
+    if (!Number.isSafeInteger(selected) || selected <= 0)
+        throw new Error(`${name} must be a positive safe integer`);
+    return selected;
+}
+async function waitBounded(promise, timeoutMs) {
+    let timer;
+    try {
+        await Promise.race([
+            promise,
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, timeoutMs);
+                timer.unref?.();
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 function getWebAppRoutes(app) {
     return [
         { label: "mountPath", prefix: app.mountPath },
@@ -33,6 +102,9 @@ function toolIsPortable(tool) {
     }
 }
 export class PiboPluginRegistry {
+    maxActiveSpeechSessions;
+    speechSessionIdleTimeoutMs;
+    speechSessionStartTimeoutMs;
     agentRuntimes = new AgentRuntimeAdapterRegistry();
     tools = new Map();
     subagents = new Map();
@@ -45,6 +117,11 @@ export class PiboPluginRegistry {
     channels = new Map();
     authService;
     transcriptionProviders = new Map();
+    speechProviders = new Map();
+    pendingSpeechStarts = new Map();
+    speechSessions = new Map();
+    speechProvidersDisposed = false;
+    speechDisposePromise;
     webApps = new Map();
     capabilityPackages = new Map();
     eventListeners = new Set();
@@ -53,8 +130,13 @@ export class PiboPluginRegistry {
     pluginIds = new Set();
     pluginNames = new Map();
     eventErrors = [];
+    constructor(options = {}) {
+        this.maxActiveSpeechSessions = positiveTimeout(options.maxActiveSpeechSessions, MAX_ACTIVE_SPEECH_SESSIONS, "maxActiveSpeechSessions");
+        this.speechSessionIdleTimeoutMs = positiveTimeout(options.speechSessionIdleTimeoutMs, SPEECH_SESSION_IDLE_TIMEOUT_MS, "speechSessionIdleTimeoutMs");
+        this.speechSessionStartTimeoutMs = positiveTimeout(options.speechSessionStartTimeoutMs, SPEECH_SESSION_START_TIMEOUT_MS, "speechSessionStartTimeoutMs");
+    }
     static create(options = {}) {
-        const registry = new PiboPluginRegistry();
+        const registry = new PiboPluginRegistry(options);
         for (const plugin of options.plugins ?? []) {
             registry.registerPlugin(plugin);
         }
@@ -199,6 +281,177 @@ export class PiboPluginRegistry {
         const provider = this.getRequired(this.transcriptionProviders, providerId, "transcription provider");
         return { providerId, ...await provider.transcribe(input) };
     }
+    registerSpeechProvider(provider) {
+        this.addUnique(this.speechProviders, provider.id, provider, "speech provider");
+    }
+    getSpeechProviderIds() {
+        return [...this.speechProviders.keys()];
+    }
+    async getSpeechProviderInfos() {
+        return await Promise.all([...this.speechProviders.values()].map(async (provider) => ({
+            id: provider.id,
+            name: provider.name,
+            description: provider.description,
+            configured: provider.isConfigured ? await Promise.resolve(provider.isConfigured()).catch(() => false) : true,
+            pluginId: provider.pluginId,
+            pluginName: provider.pluginId ? this.pluginNames.get(provider.pluginId) : undefined,
+        })));
+    }
+    async startSpeechSession(providerId, input, options = {}) {
+        const provider = this.getRequired(this.speechProviders, providerId, "speech provider");
+        if (this.speechProvidersDisposed)
+            throw new PiboSpeechError("Speech providers are shutting down.", "aborted");
+        if (this.speechSessions.size + this.pendingSpeechStarts.size >= this.maxActiveSpeechSessions) {
+            throw new PiboSpeechError("Too many speech sessions are active. Try again shortly.", "capacity_exceeded");
+        }
+        const reservationId = randomUUID();
+        const controller = new AbortController();
+        const settled = deferred();
+        const abortFromCaller = () => controller.abort(options.signal?.reason);
+        if (options.signal?.aborted)
+            abortFromCaller();
+        else
+            options.signal?.addEventListener("abort", abortFromCaller, { once: true });
+        const timeout = setTimeout(() => {
+            controller.abort(new PiboSpeechError("Speech session startup timed out.", "provider_error"));
+        }, this.speechSessionStartTimeoutMs);
+        timeout.unref?.();
+        let owned;
+        let published = false;
+        let releaseInFinally = true;
+        let reservationReleased = false;
+        const releaseReservation = () => {
+            if (reservationReleased)
+                return;
+            reservationReleased = true;
+            clearTimeout(timeout);
+            this.pendingSpeechStarts.delete(reservationId);
+            settled.resolve();
+            if (!published)
+                options.signal?.removeEventListener("abort", abortFromCaller);
+        };
+        this.pendingSpeechStarts.set(reservationId, { controller, timeout, settled, release: releaseReservation });
+        let providerSettled = false;
+        let providerResult;
+        const providerStart = Promise.resolve()
+            .then(() => provider.startSession(input, { signal: controller.signal }))
+            .then((session) => {
+            providerSettled = true;
+            providerResult = session;
+            return session;
+        }, (error) => {
+            providerSettled = true;
+            throw error;
+        });
+        try {
+            if (controller.signal.aborted)
+                throw speechAbortError(controller.signal);
+            owned = ownSpeechProviderSession(await waitForSpeechProviderStart(providerStart, controller.signal));
+            if (controller.signal.aborted || this.speechProvidersDisposed) {
+                await owned.stop().catch(() => { });
+                throw speechAbortError(controller.signal);
+            }
+            const { sessionId, answerSdp } = owned.session;
+            if (this.speechSessions.has(sessionId)) {
+                await owned.stop().catch(() => { });
+                throw new PiboSpeechError("Speech provider returned a duplicate session.", "provider_error");
+            }
+            const unlinkAbort = () => options.signal?.removeEventListener("abort", abortFromCaller);
+            const entry = {
+                provider,
+                owned,
+                timer: setTimeout(() => {
+                    void this.closeSpeechSession(sessionId, entry).catch(() => { });
+                }, this.speechSessionIdleTimeoutMs),
+                unlinkAbort,
+            };
+            entry.timer.unref?.();
+            this.speechSessions.set(sessionId, entry);
+            published = true;
+            controller.signal.addEventListener("abort", () => {
+                void this.closeSpeechSession(sessionId, entry).catch(() => { });
+            }, { once: true });
+            if (controller.signal.aborted) {
+                await this.closeSpeechSession(sessionId, entry).catch(() => { });
+                throw speechAbortError(controller.signal);
+            }
+            return { providerId, sessionId, answerSdp };
+        }
+        catch (error) {
+            if (controller.signal.aborted && !owned && providerResult) {
+                await ownSpeechProviderSession(providerResult).stop().catch(() => { });
+            }
+            else if (controller.signal.aborted && !providerSettled) {
+                releaseInFinally = false;
+                options.signal?.removeEventListener("abort", abortFromCaller);
+                void providerStart
+                    .then(async (lateSession) => await ownSpeechProviderSession(lateSession).stop())
+                    .catch(() => { })
+                    .finally(releaseReservation);
+            }
+            if (controller.signal.aborted)
+                throw speechAbortError(controller.signal);
+            throw error;
+        }
+        finally {
+            if (releaseInFinally)
+                releaseReservation();
+        }
+    }
+    async speakSpeechSession(sessionId, input) {
+        const entry = this.speechSessions.get(sessionId);
+        if (!entry)
+            throw new PiboSpeechError("Speech session was not found.", "session_not_found");
+        let speechError;
+        try {
+            await entry.owned.session.speak(input);
+        }
+        catch (error) {
+            speechError = error;
+        }
+        finally {
+            try {
+                await this.closeSpeechSession(sessionId, entry);
+            }
+            catch (error) {
+                if (speechError === undefined)
+                    speechError = error;
+            }
+        }
+        if (speechError !== undefined)
+            throw speechError;
+    }
+    async stopSpeechSession(sessionId) {
+        const entry = this.speechSessions.get(sessionId);
+        if (!entry)
+            return;
+        await this.closeSpeechSession(sessionId, entry);
+    }
+    async disposeSpeechProviders() {
+        this.speechDisposePromise ??= (async () => {
+            this.speechProvidersDisposed = true;
+            const shutdownError = new PiboSpeechError("Speech providers are shutting down.", "aborted");
+            const pending = [...this.pendingSpeechStarts.values()];
+            for (const reservation of pending)
+                reservation.controller.abort(shutdownError);
+            const cleanup = Promise.allSettled([
+                ...([...this.speechSessions.entries()].map(async ([sessionId, entry]) => await this.closeSpeechSession(sessionId, entry))),
+                ...pending.map((reservation) => reservation.settled.promise),
+                ...([...this.speechProviders.values()].map(async (provider) => await provider.dispose?.())),
+            ]);
+            await waitBounded(cleanup, this.speechSessionStartTimeoutMs);
+            for (const reservation of this.pendingSpeechStarts.values())
+                reservation.release();
+        })();
+        await this.speechDisposePromise;
+    }
+    closeSpeechSession(sessionId, entry) {
+        clearTimeout(entry.timer);
+        entry.unlinkAbort();
+        if (this.speechSessions.get(sessionId) === entry)
+            this.speechSessions.delete(sessionId);
+        return entry.owned.stop();
+    }
     registerWebApp(app) {
         if (this.webApps.has(app.name)) {
             throw new Error(`Duplicate web app "${app.name}"`);
@@ -316,6 +569,7 @@ export class PiboPluginRegistry {
                 timeoutMs: subagent.timeoutMs,
                 model: subagent.model ? { ...subagent.model } : undefined,
                 thinkingLevel: subagent.thinkingLevel,
+                ...(subagent.runtimeOptions ? { runtimeOptions: structuredClone(subagent.runtimeOptions) } : {}),
                 maxDepth: subagent.maxDepth,
             })),
             contextFiles: [...this.contextFiles.entries()].map(([key, contextFile]) => ({
@@ -436,6 +690,10 @@ export class PiboPluginRegistry {
             ...provider,
             pluginId: provider.pluginId ?? pluginId,
         });
+        const withPluginSpeechProviderContext = (provider) => ({
+            ...provider,
+            pluginId: provider.pluginId ?? pluginId,
+        });
         return {
             registerAgentRuntimeDriver: (driver) => this.registerAgentRuntimeDriver(driver),
             registerAgentRuntimeInstance: (instance) => this.registerAgentRuntimeInstance(instance),
@@ -453,6 +711,7 @@ export class PiboPluginRegistry {
             registerChannel: (channel) => this.registerChannel(channel),
             registerAuthService: (service) => this.registerAuthService(service),
             registerTranscriptionProvider: (provider) => this.registerTranscriptionProvider(withPluginTranscriptionProviderContext(provider)),
+            registerSpeechProvider: (provider) => this.registerSpeechProvider(withPluginSpeechProviderContext(provider)),
             registerWebApp: (app) => this.registerWebApp(app),
             registerCapabilityPackage: (pkg) => this.registerCapabilityPackage(withPluginPackageContext(pkg)),
             registerLoopStopCondition: (condition) => this.registerLoopStopCondition(condition, pluginId),

package/dist/previews/cli.js

@@ -0,0 +1,345 @@
+import { randomBytes } from "node:crypto";
+import { resolve } from "node:path";
+import { Command } from "commander";
+import { sanitizePreviewServerSettings } from "../core/preview-server-settings.js";
+import { createDefaultPiboDataSessionStore } from "../sessions/pibo-data-store.js";
+import { DEFAULT_PREVIEW_TTL_MINUTES, 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";
+function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+function parsePort(value) {
+    return validatePreviewPort(Number(value));
+}
+function parsePositiveInteger(value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1)
+        throw new Error("Value must be a positive integer");
+    return parsed;
+}
+function parsePreviewTtlMinutes(value) {
+    const parsed = parsePositiveInteger(value);
+    if (parsed > 7 * 24 * 60)
+        throw new Error("Preview lifetime cannot exceed 7 days");
+    return parsed;
+}
+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")
+        return state;
+    if (exposure.managementMode === "managed") {
+        if (exposure.serverState === "starting")
+            return "starting";
+        if (exposure.serverState === "stopping")
+            return "stopping";
+        if (exposure.serverState === "stopped")
+            return "stopped";
+        if (exposure.serverState === "error")
+            return "error";
+    }
+    const processCurrent = isPreviewTargetProcessCurrent(exposure, { cacheMs: 0 });
+    const target = processCurrent ? await probePreviewTarget(exposure.targetPort) : undefined;
+    return target ? "online" : "offline";
+}
+async function exposureView(exposure) {
+    const health = await previewHealth(exposure);
+    const target = health === "online" ? await probePreviewTarget(exposure.targetPort) : undefined;
+    return {
+        ...exposure,
+        managed: exposure.managementMode === "managed",
+        state: previewExposureState(exposure),
+        health,
+        publicUrl: previewPublicURL(exposure.id).toString(),
+        ...(target ? { latencyMs: target.latencyMs } : {}),
+    };
+}
+function printPreviewDiscovery() {
+    console.log(`pibo preview - Session-linked live development previews
+
+Commands:
+  expose <port>       Register an external port or start a managed server with --command
+  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
+  remove <preview-id> Stop and remove a preview definition
+  close <preview-id>  Alias for remove
+
+Next:
+  pibo preview expose --help
+`);
+}
+export async function runPreviewCli(argv = process.argv) {
+    if (argv.length <= 2 || argv[2] === "--help" || argv[2] === "-h") {
+        printPreviewDiscovery();
+        return;
+    }
+    const program = new Command();
+    program.name("pibo preview").description("Manage session-linked live development previews");
+    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}`);
+        }
+    });
+    program
+        .command("list")
+        .option("--session <pibo-session-id>", "Filter by Pibo Session")
+        .option("--all", "Include expired and closed previews")
+        .option("--json", "Print JSON")
+        .action(async (options) => {
+        requirePreviewBaseURL();
+        const store = createDefaultPreviewStore();
+        let exposures;
+        try {
+            await reconcileManagedPreviews(store);
+            exposures = store.listExposures({ piboSessionId: options.session, includeInactive: options.all === true });
+        }
+        finally {
+            store.close();
+        }
+        const rows = await Promise.all(exposures.map(exposureView));
+        if (options.json)
+            printJson(rows);
+        else if (rows.length === 0)
+            console.log("No previews.");
+        else
+            for (const row of rows)
+                console.log(`${row.id}\t${row.health}\t${row.targetPort}\t${row.piboSessionId}\t${row.label}`);
+    });
+    program
+        .command("show")
+        .argument("<preview-id>")
+        .option("--json", "Print JSON")
+        .action(async (id, options) => {
+        requirePreviewBaseURL();
+        const store = createDefaultPreviewStore();
+        let exposure;
+        try {
+            await reconcileManagedPreviews(store);
+            exposure = store.requireExposure(id);
+        }
+        finally {
+            store.close();
+        }
+        const row = await exposureView(exposure);
+        if (options.json)
+            printJson(row);
+        else
+            for (const [key, value] of Object.entries(row))
+                console.log(`${key}\t${String(value)}`);
+    });
+    program
+        .command("start")
+        .argument("<preview-id>")
+        .option("--json", "Print JSON")
+        .action(async (id, options) => {
+        requirePreviewBaseURL();
+        const store = createDefaultPreviewStore();
+        let exposure;
+        try {
+            exposure = await startManagedPreview(store, id);
+        }
+        finally {
+            store.close();
+        }
+        const row = await exposureView(exposure);
+        if (options.json)
+            printJson(row);
+        else
+            console.log(`${row.id}\t${row.health}\tautoStop=${row.serverStopAt ?? "-"}`);
+    });
+    program
+        .command("stop")
+        .argument("<preview-id>")
+        .option("--json", "Print JSON")
+        .action(async (id, options) => {
+        const store = createDefaultPreviewStore();
+        let exposure;
+        try {
+            exposure = await stopManagedPreview(store, id);
+        }
+        finally {
+            store.close();
+        }
+        const row = await exposureView(exposure);
+        if (options.json)
+            printJson(row);
+        else
+            console.log(`${row.id}\t${row.health}`);
+    });
+    program
+        .command("doctor")
+        .argument("[preview-id]")
+        .option("--json", "Print JSON")
+        .action(async (id, options) => {
+        const baseURL = requirePreviewBaseURL();
+        if (!id) {
+            const config = loadPreviewConfig();
+            const serverLimits = sanitizePreviewServerSettings({
+                maxRunningServers: config.maxRunningServers,
+                autoStopMinutes: config.autoStopMinutes,
+            });
+            const store = createDefaultPreviewStore();
+            let diagnostics;
+            try {
+                await reconcileManagedPreviews(store);
+                store.prune();
+                diagnostics = store.diagnostics();
+            }
+            finally {
+                store.close();
+            }
+            const result = {
+                configured: true,
+                baseURL: baseURL.toString(),
+                limits: {
+                    ...serverLimits,
+                    maxProxyConnections: config.maxProxyConnections ?? DEFAULT_MAX_PREVIEW_PROXY_CONNECTIONS,
+                    maxProxyConnectionsPerPreview: config.maxProxyConnectionsPerPreview ?? DEFAULT_MAX_PREVIEW_PROXY_CONNECTIONS_PER_PREVIEW,
+                },
+                diagnostics,
+                next: "pibo preview list",
+            };
+            if (options.json)
+                printJson(result);
+            else {
+                console.log("preview configuration\tok");
+                console.log(`baseURL\t${result.baseURL}`);
+                console.log(`active\t${diagnostics.activeExposures}`);
+                console.log(`managed\t${diagnostics.managedStartingOrRunning}`);
+            }
+            return;
+        }
+        const store = createDefaultPreviewStore();
+        let exposure;
+        try {
+            await reconcileManagedPreviews(store);
+            exposure = store.requireExposure(id);
+        }
+        finally {
+            store.close();
+        }
+        const result = await exposureView(exposure);
+        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 (result.health !== "online")
+            process.exitCode = 1;
+    });
+    const removeAction = async (id, options) => {
+        const store = createDefaultPreviewStore();
+        let exposure;
+        try {
+            const current = store.requireExposure(id);
+            if (current.managementMode === "managed" && ["running", "starting", "stopping", "error"].includes(current.serverState ?? "")) {
+                await stopManagedPreview(store, id);
+            }
+            exposure = store.closeExposure(id);
+        }
+        finally {
+            store.close();
+        }
+        if (!exposure)
+            throw new Error(`Preview "${id}" was not found`);
+        if (options.json)
+            printJson({ removed: true, preview: exposure });
+        else
+            console.log(`${id}\tremoved`);
+    };
+    program.command("remove").argument("<preview-id>").option("--json", "Print JSON").action(removeAction);
+    program.command("close").argument("<preview-id>").option("--json", "Print JSON").action(removeAction);
+    await program.parseAsync(argv);
+}