@zhanguym/chatroom 1.0.0

package/dist/plugins/process/infrastructure/pipe-process-backend.js

@@ -0,0 +1,71 @@
+import { spawn } from "node:child_process";
+export class PipeProcessBackend {
+    kind = "pipe";
+    async start(command, args, options) {
+        const child = spawn(command, args, {
+            cwd: options.cwd,
+            env: options.env,
+            stdio: ["pipe", "pipe", "pipe"],
+            detached: process.platform !== "win32",
+            windowsHide: true,
+        });
+        await new Promise((resolve, reject) => {
+            child.once("spawn", resolve);
+            child.once("error", reject);
+        });
+        return new PipeBackendProcess(child);
+    }
+}
+class PipeBackendProcess {
+    child;
+    constructor(child) {
+        this.child = child;
+    }
+    get pid() {
+        return this.child.pid ?? null;
+    }
+    write(data) {
+        this.child.stdin.write(data);
+    }
+    kill(signal = "SIGTERM") {
+        if (!this.child.pid)
+            return;
+        if (process.platform === "win32") {
+            const args = ["/PID", String(this.child.pid), "/T"];
+            if (signal === "SIGKILL")
+                args.push("/F");
+            const killer = spawn("taskkill.exe", args, {
+                stdio: "ignore",
+                windowsHide: true,
+            });
+            let fellBack = false;
+            const fallback = () => {
+                if (fellBack)
+                    return;
+                fellBack = true;
+                this.child.kill(signal);
+            };
+            killer.once("error", fallback);
+            killer.once("exit", (code) => {
+                if (code !== 0)
+                    fallback();
+            });
+            return;
+        }
+        try {
+            process.kill(-this.child.pid, signal);
+        }
+        catch {
+            this.child.kill(signal);
+        }
+    }
+    onStdout(listener) {
+        this.child.stdout.on("data", listener);
+    }
+    onStderr(listener) {
+        this.child.stderr.on("data", listener);
+    }
+    onExit(listener) {
+        this.child.once("close", (code, signal) => listener({ exitCode: code, signal }));
+    }
+}

package/dist/plugins/process/infrastructure/pty-process-backend.d.ts

@@ -0,0 +1,8 @@
+import type { BackendProcess, ProcessBackend } from "../backend.js";
+export declare class PtyProcessBackend implements ProcessBackend {
+    readonly kind: "pty";
+    start(command: string, args: string[], options: {
+        cwd: string;
+        env: NodeJS.ProcessEnv;
+    }): Promise<BackendProcess>;
+}

package/dist/plugins/process/infrastructure/pty-process-backend.js

@@ -0,0 +1,51 @@
+import { ChatRoomError } from "#core/errors/chatroom-error";
+export class PtyProcessBackend {
+    kind = "pty";
+    async start(command, args, options) {
+        let pty;
+        try {
+            pty = (await import("node-pty"));
+        }
+        catch (error) {
+            throw new ChatRoomError("UNSUPPORTED", "PTY support is unavailable; install optional dependency node-pty", undefined, { cause: error });
+        }
+        const env = Object.fromEntries(Object.entries(options.env).filter((entry) => typeof entry[1] === "string"));
+        const processHandle = pty.spawn(command, args, {
+            name: env.TERM ?? "xterm-256color",
+            cols: 120,
+            rows: 30,
+            cwd: options.cwd,
+            env,
+        });
+        return new PtyBackendProcess(processHandle);
+    }
+}
+class PtyBackendProcess {
+    processHandle;
+    constructor(processHandle) {
+        this.processHandle = processHandle;
+    }
+    get pid() {
+        return this.processHandle.pid;
+    }
+    write(data) {
+        this.processHandle.write(data);
+    }
+    kill(signal = "SIGTERM") {
+        if (process.platform === "win32") {
+            this.processHandle.kill();
+            return;
+        }
+        this.processHandle.kill(signal);
+    }
+    onStdout(listener) {
+        this.processHandle.onData((data) => listener(Buffer.from(data)));
+    }
+    onStderr(_listener) { }
+    onExit(listener) {
+        this.processHandle.onExit((event) => listener({
+            exitCode: event.exitCode,
+            signal: event.signal ? String(event.signal) : null,
+        }));
+    }
+}

package/dist/plugins/process/mcp.d.ts

@@ -0,0 +1,3 @@
+import type { PluginMcpRegistrar } from "#mcp/server/plugin-mcp-registrar";
+import type { ProcessSupervisor } from "./process-supervisor.js";
+export declare function registerProcessTools(mcp: PluginMcpRegistrar, processes: ProcessSupervisor): void;

package/dist/plugins/process/mcp.js

@@ -0,0 +1,58 @@
+import { z } from "zod";
+import { closedRead, destructiveLocalMutation, openWorldMutation, processSnapshotSchema, } from "#mcp/server/tool-support";
+export function registerProcessTools(mcp, processes) {
+    mcp.registerTool("process_start", {
+        title: "Start process",
+        description: "Start a supervised executable directly and return a ProcessId immediately. Prefer invoking the target executable without a shell. For compound shell commands, use bash -c rather than bash -lc unless login-shell semantics are explicitly required, because a login shell may replace the inherited PATH (for example, removing NVM-managed Node.js commands).",
+        inputSchema: z.object({
+            command: z.string().min(1),
+            args: z.array(z.string()).default([]),
+            cwd: z.string().default("."),
+            env: z.record(z.string(), z.string()).optional(),
+            pty: z.boolean().default(false),
+            timeoutMs: z.number().int().positive().optional(),
+        }),
+        outputSchema: processSnapshotSchema,
+        annotations: openWorldMutation,
+        action: "start",
+    }, (input, execution) => {
+        execution.deferCompletion();
+        return processes.start({
+            cwd: input.cwd,
+            command: input.command,
+            args: input.args,
+            ...(input.env ? { env: input.env } : {}),
+            pty: input.pty,
+            ...(input.timeoutMs === undefined
+                ? {}
+                : { timeoutMs: input.timeoutMs }),
+        }, { source: "mcp", operationId: execution.operationId });
+    });
+    mcp.registerTool("process_read", {
+        title: "Read process",
+        description: "Read bounded stdout/stderr and current process state.",
+        inputSchema: z.object({ processId: z.string() }),
+        outputSchema: processSnapshotSchema,
+        annotations: closedRead,
+        action: "read",
+    }, (input) => processes.read(input.processId));
+    mcp.registerTool("process_write", {
+        title: "Write process stdin",
+        description: "Write to stdin of a running process.",
+        inputSchema: z.object({ processId: z.string(), data: z.string() }),
+        outputSchema: processSnapshotSchema,
+        annotations: openWorldMutation,
+        action: "write",
+    }, (input) => processes.write(input.processId, input.data));
+    mcp.registerTool("process_kill", {
+        title: "Stop process",
+        description: "Terminate or force-kill a supervised process.",
+        inputSchema: z.object({
+            processId: z.string(),
+            force: z.boolean().default(false),
+        }),
+        outputSchema: processSnapshotSchema,
+        annotations: destructiveLocalMutation,
+        action: (input) => (input.force ? "kill" : "terminate"),
+    }, (input) => processes.kill(input.processId, input.force));
+}

package/dist/plugins/process/plugin.d.ts

@@ -0,0 +1,4 @@
+import type { InternalPlugin } from "#plugins/types";
+import { ProcessSupervisor } from "./process-supervisor.js";
+export declare const ProcessService: import("#plugins/types").ServiceToken<ProcessSupervisor>;
+export declare function createProcessPlugin(): InternalPlugin;

package/dist/plugins/process/plugin.js

@@ -0,0 +1,25 @@
+import { createServiceToken } from "#plugins/types";
+import { PipeProcessBackend } from "./infrastructure/pipe-process-backend.js";
+import { PtyProcessBackend } from "./infrastructure/pty-process-backend.js";
+import { registerProcessTools } from "./mcp.js";
+import { ProcessSupervisor } from "./process-supervisor.js";
+export const ProcessService = createServiceToken("process");
+export function createProcessPlugin() {
+    let service = null;
+    return {
+        id: "process",
+        activate(context) {
+            service = new ProcessSupervisor({ pipe: new PipeProcessBackend(), pty: new PtyProcessBackend() }, context.operations, context.events, context.config.process.maxOutputBytes, context.config.process.defaultTimeoutMs, context.config.process.maxCompletedProcesses);
+            context.services.provide(ProcessService, service);
+        },
+        registerMcp(mcp) {
+            if (!service)
+                throw new Error("Process plugin is not active");
+            registerProcessTools(mcp, service);
+        },
+        async deactivate() {
+            await service?.shutdown();
+            service = null;
+        },
+    };
+}

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

@@ -0,0 +1,39 @@
+import type { ProcessId, ProcessSnapshot, ProcessStartRequest, ProcessSummary } from "./types.js";
+import type { RuntimeEventBus } from "#app/event-bus";
+import type { OperationLog } from "#operations/operation-log";
+import type { OperationSource } from "#core/operations/types";
+import type { ProcessBackend } from "./backend.js";
+interface ProcessOperationContext {
+    source: OperationSource;
+    action?: string;
+    operationId?: string;
+}
+export declare class ProcessSupervisor {
+    private readonly backends;
+    private readonly operations;
+    private readonly eventBus;
+    private readonly maxOutputBytes;
+    private readonly defaultTimeoutMs;
+    private readonly maxCompletedProcesses;
+    private readonly processes;
+    private shuttingDown;
+    constructor(backends: {
+        pipe: ProcessBackend;
+        pty: ProcessBackend;
+    }, operations: OperationLog, eventBus: RuntimeEventBus, maxOutputBytes: number, defaultTimeoutMs: number, maxCompletedProcesses: number);
+    start(request: ProcessStartRequest, operationContext: ProcessOperationContext): Promise<ProcessSnapshot>;
+    read(processId: ProcessId): ProcessSnapshot;
+    list(): ProcessSnapshot[];
+    summaries(): ProcessSummary[];
+    write(processId: ProcessId, data: string): ProcessSnapshot;
+    kill(processId: ProcessId, force?: boolean): ProcessSnapshot;
+    shutdown(): Promise<void>;
+    private onOutput;
+    private onExit;
+    private trimCompletedProcesses;
+    private require;
+    private requireRunning;
+    private summaryOf;
+    private snapshotOf;
+}
+export {};

package/dist/plugins/process/process-supervisor.js

@@ -0,0 +1,244 @@
+import { randomUUID } from "node:crypto";
+import { ChatRoomError } from "#core/errors/chatroom-error";
+import { childEnvironment } from "#core/runtime/child-environment";
+import { HeadTailBuffer } from "./head-tail-buffer.js";
+export class ProcessSupervisor {
+    backends;
+    operations;
+    eventBus;
+    maxOutputBytes;
+    defaultTimeoutMs;
+    maxCompletedProcesses;
+    processes = new Map();
+    shuttingDown = false;
+    constructor(backends, operations, eventBus, maxOutputBytes, defaultTimeoutMs, maxCompletedProcesses) {
+        this.backends = backends;
+        this.operations = operations;
+        this.eventBus = eventBus;
+        this.maxOutputBytes = maxOutputBytes;
+        this.defaultTimeoutMs = defaultTimeoutMs;
+        this.maxCompletedProcesses = maxCompletedProcesses;
+    }
+    async start(request, operationContext) {
+        if (this.shuttingDown)
+            throw new ChatRoomError("CONFLICT", "Process supervisor is shutting down");
+        const processId = `proc_${randomUUID()}`;
+        const args = request.args ?? [];
+        const adoptedOperation = operationContext.operationId !== undefined;
+        const operationId = operationContext.operationId ??
+            this.operations.start({
+                pluginId: "process",
+                source: operationContext.source,
+                action: operationContext.action ?? "start",
+                processId,
+                input: {
+                    command: request.command,
+                    args,
+                    cwd: request.cwd,
+                    pty: request.pty ?? false,
+                    timeoutMs: request.timeoutMs ?? this.defaultTimeoutMs,
+                    env: request.env ?? {},
+                },
+            }).operationId;
+        if (adoptedOperation)
+            this.operations.associate(operationId, { processId });
+        let backend;
+        try {
+            backend = await (request.pty ? this.backends.pty : this.backends.pipe).start(request.command, args, {
+                cwd: request.cwd,
+                env: childEnvironment(request.env),
+            });
+        }
+        catch (error) {
+            if (!adoptedOperation)
+                this.operations.finish(operationId, "error", null, error);
+            throw new ChatRoomError("PROCESS_FAILED", `Failed to start process: ${request.command}`, undefined, { cause: error });
+        }
+        let resolveSettled;
+        const settled = new Promise((resolve) => {
+            resolveSettled = resolve;
+        });
+        const managed = {
+            request: {
+                ...request,
+                args: [...args],
+                ...(request.env ? { env: { ...request.env } } : {}),
+            },
+            backend,
+            stdout: new HeadTailBuffer(this.maxOutputBytes),
+            stderr: new HeadTailBuffer(this.maxOutputBytes),
+            state: "running",
+            startedAt: new Date(),
+            finishedAt: null,
+            exitCode: null,
+            signal: null,
+            timeout: null,
+            forceTimeout: null,
+            outputEventTimer: null,
+            timedOut: false,
+            operationId,
+            settled,
+            resolveSettled,
+        };
+        this.processes.set(processId, managed);
+        backend.onStdout((chunk) => this.onOutput(processId, "stdout", chunk));
+        backend.onStderr((chunk) => this.onOutput(processId, "stderr", chunk));
+        backend.onExit((exit) => this.onExit(processId, exit.exitCode, exit.signal));
+        const timeoutMs = request.timeoutMs ?? this.defaultTimeoutMs;
+        if (timeoutMs > 0)
+            managed.timeout = setTimeout(() => {
+                if (managed.state !== "running")
+                    return;
+                managed.timedOut = true;
+                managed.backend.kill("SIGTERM");
+                managed.forceTimeout = setTimeout(() => {
+                    if (managed.state === "running")
+                        managed.backend.kill("SIGKILL");
+                }, 2000).unref();
+            }, timeoutMs).unref();
+        const snapshot = this.snapshotOf(processId, managed);
+        this.eventBus.emit({ type: "process", process: snapshot });
+        return snapshot;
+    }
+    read(processId) {
+        const item = this.require(processId);
+        return this.snapshotOf(processId, item);
+    }
+    list() {
+        return [...this.processes.entries()]
+            .map(([id, item]) => this.snapshotOf(id, item))
+            .sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+    }
+    summaries() {
+        return [...this.processes.entries()]
+            .map(([id, item]) => this.summaryOf(id, item))
+            .sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+    }
+    write(processId, data) {
+        const item = this.requireRunning(processId);
+        item.backend.write(data);
+        return this.snapshotOf(processId, item);
+    }
+    kill(processId, force = false) {
+        const item = this.requireRunning(processId);
+        item.backend.kill(force ? "SIGKILL" : "SIGTERM");
+        return this.snapshotOf(processId, item);
+    }
+    async shutdown() {
+        this.shuttingDown = true;
+        const running = [...this.processes.entries()].filter(([, item]) => item.state === "running");
+        for (const [, item] of running)
+            item.backend.kill("SIGTERM");
+        await Promise.race([
+            Promise.allSettled(running.map(([, item]) => item.settled)),
+            new Promise((resolve) => setTimeout(resolve, 1500)),
+        ]);
+        const survivors = running.filter(([, item]) => item.state === "running");
+        for (const [, item] of survivors)
+            item.backend.kill("SIGKILL");
+        if (survivors.length) {
+            await Promise.race([
+                Promise.allSettled(survivors.map(([, item]) => item.settled)),
+                new Promise((resolve) => setTimeout(resolve, 1500)),
+            ]);
+            for (const [processId, item] of survivors)
+                if (item.state === "running")
+                    this.onExit(processId, null, "SIGKILL");
+        }
+    }
+    onOutput(processId, stream, chunk) {
+        const item = this.processes.get(processId);
+        if (!item || item.state !== "running")
+            return;
+        (stream === "stdout" ? item.stdout : item.stderr).append(chunk);
+        if (!item.outputEventTimer) {
+            item.outputEventTimer = setTimeout(() => {
+                item.outputEventTimer = null;
+                if (item.state === "running")
+                    this.eventBus.emit({ type: "process-output", processId });
+            }, 500).unref();
+        }
+    }
+    onExit(processId, exitCode, signal) {
+        const item = this.processes.get(processId);
+        if (!item || item.state !== "running")
+            return;
+        if (item.timeout)
+            clearTimeout(item.timeout);
+        if (item.forceTimeout)
+            clearTimeout(item.forceTimeout);
+        if (item.outputEventTimer)
+            clearTimeout(item.outputEventTimer);
+        item.finishedAt = new Date();
+        item.exitCode = exitCode;
+        item.signal = signal;
+        item.state = signal ? "killed" : exitCode === 0 ? "exited" : "failed";
+        const snapshot = this.snapshotOf(processId, item);
+        this.operations.finish(item.operationId, exitCode === 0 && !signal ? "success" : signal ? "cancelled" : "error", {
+            stdout: snapshot.stdout,
+            stderr: snapshot.stderr,
+            exitCode,
+            signal,
+            durationMs: snapshot.durationMs,
+            outputTruncated: snapshot.outputTruncated,
+            timedOut: snapshot.timedOut,
+        }, exitCode === 0 && !signal
+            ? undefined
+            : { exitCode, signal, timedOut: snapshot.timedOut });
+        this.eventBus.emit({ type: "process", process: snapshot });
+        item.resolveSettled(snapshot);
+        this.trimCompletedProcesses();
+    }
+    trimCompletedProcesses() {
+        const completed = [...this.processes.entries()]
+            .filter(([, item]) => item.state !== "running")
+            .sort(([, a], [, b]) => b.startedAt.getTime() - a.startedAt.getTime());
+        for (const [processId] of completed.slice(this.maxCompletedProcesses)) {
+            this.processes.delete(processId);
+        }
+    }
+    require(processId) {
+        const item = this.processes.get(processId);
+        if (!item)
+            throw new ChatRoomError("NOT_FOUND", `Unknown ProcessId: ${processId}`);
+        return item;
+    }
+    requireRunning(processId) {
+        const item = this.require(processId);
+        if (item.state !== "running")
+            throw new ChatRoomError("CONFLICT", `Process is not running: ${processId}`);
+        return item;
+    }
+    summaryOf(id, item) {
+        const finish = item.finishedAt?.getTime() ?? Date.now();
+        return {
+            processId: id,
+            command: item.request.command,
+            args: [...(item.request.args ?? [])],
+            state: item.state,
+            startedAt: item.startedAt.toISOString(),
+            durationMs: Math.max(0, finish - item.startedAt.getTime()),
+        };
+    }
+    snapshotOf(id, item) {
+        const stdout = item.stdout.snapshot(), stderr = item.stderr.snapshot(), finish = item.finishedAt?.getTime() ?? Date.now();
+        return {
+            processId: id,
+            command: item.request.command,
+            args: [...(item.request.args ?? [])],
+            cwd: item.request.cwd,
+            pid: item.backend.pid,
+            state: item.state,
+            startedAt: item.startedAt.toISOString(),
+            finishedAt: item.finishedAt?.toISOString() ?? null,
+            durationMs: Math.max(0, finish - item.startedAt.getTime()),
+            exitCode: item.exitCode,
+            signal: item.signal,
+            stdout: stdout.text,
+            stderr: stderr.text,
+            outputTruncated: stdout.outputTruncated || stderr.outputTruncated,
+            timedOut: item.timedOut,
+            operationId: item.operationId,
+        };
+    }
+}

package/dist/plugins/process/types.d.ts

@@ -0,0 +1,30 @@
+type ProcessState = "running" | "exited" | "killed" | "failed";
+export type ProcessId = string;
+export interface ProcessStartRequest {
+    cwd: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    pty?: boolean;
+    timeoutMs?: number;
+}
+export interface ProcessSnapshot {
+    processId: ProcessId;
+    command: string;
+    args: string[];
+    cwd: string;
+    pid: number | null;
+    state: ProcessState;
+    startedAt: string;
+    finishedAt: string | null;
+    durationMs: number;
+    exitCode: number | null;
+    signal: string | null;
+    stdout: string;
+    stderr: string;
+    outputTruncated: boolean;
+    timedOut: boolean;
+    operationId: string;
+}
+export type ProcessSummary = Pick<ProcessSnapshot, "processId" | "command" | "args" | "state" | "startedAt" | "durationMs">;
+export {};

package/dist/plugins/process/types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/types.d.ts

@@ -0,0 +1,35 @@
+import type { ChatRoomConfig } from "#config/types";
+import type { AppDatabase } from "#infrastructure/database/app-database";
+import type { PluginMcpRegistrar } from "#mcp/server/plugin-mcp-registrar";
+import type { OperationLog } from "#operations/operation-log";
+import type { McpToolControl } from "#mcp/server/tool-control";
+import type { RuntimeEventBus } from "#app/event-bus";
+import type { ExternalAccessRegistry } from "#app/external-access-registry";
+import type { LogWriter } from "#core/logging/types";
+export interface ServiceToken<T> {
+    readonly key: symbol;
+    readonly name: string;
+    readonly __type?: T;
+}
+export declare function createServiceToken<T>(name: string): ServiceToken<T>;
+export declare class ServiceRegistry {
+    private readonly values;
+    provide<T>(token: ServiceToken<T>, value: T): void;
+    require<T>(token: ServiceToken<T>): T;
+}
+export interface PluginContext {
+    config: ChatRoomConfig;
+    database: AppDatabase;
+    operations: OperationLog;
+    mcpTools: McpToolControl;
+    events: RuntimeEventBus;
+    externalAccess: ExternalAccessRegistry;
+    services: ServiceRegistry;
+    logs: LogWriter;
+}
+export interface InternalPlugin {
+    id: string;
+    activate(context: PluginContext): Promise<void> | void;
+    registerMcp?(mcp: PluginMcpRegistrar): void;
+    deactivate?(): Promise<void> | void;
+}

package/dist/plugins/types.js

@@ -0,0 +1,17 @@
+export function createServiceToken(name) {
+    return { key: Symbol(name), name };
+}
+export class ServiceRegistry {
+    values = new Map();
+    provide(token, value) {
+        if (this.values.has(token.key))
+            throw new Error(`Service already provided: ${token.name}`);
+        this.values.set(token.key, value);
+    }
+    require(token) {
+        const value = this.values.get(token.key);
+        if (value === undefined)
+            throw new Error(`Required service unavailable: ${token.name}`);
+        return value;
+    }
+}

package/dist/plugins/web/api-types.d.ts

@@ -0,0 +1,56 @@
+import type { Operation as DomainOperation } from "#core/operations/types";
+import type { GitBranch, GitChange, GitCommit, GitDiff, GitStatus } from "#plugins/git/types";
+import type { ProcessSnapshot, ProcessSummary } from "#plugins/process/types";
+import type { McpToolSummary as DomainMcpToolSummary } from "#mcp/server/tool-control";
+import type { CloudServiceId, CloudStatus as DomainCloudStatus } from "#plugins/cloud/types";
+import type { ComputerDisplay, ComputerPermission, ComputerSnapshot, ComputerStatus } from "#plugins/computer/types";
+import type { WorkspaceEntry, WorkspaceFile, WorkspaceInfo, WorkspaceSkill } from "#plugins/workspace/types";
+export type { ComputerDisplay, ComputerPermission, ComputerStatus, GitBranch, GitChange, GitCommit, GitDiff, GitStatus, ProcessSnapshot, ProcessSummary, WorkspaceEntry, WorkspaceFile, WorkspaceInfo, WorkspaceSkill, };
+export interface ComputerPreviewView {
+    snapshotId: string;
+    revision: number;
+    capturedAt: string | null;
+    display: ComputerDisplay | null;
+    activeApp: string | null;
+    activeWindow: string | null;
+    cursor: {
+        x: number;
+        y: number;
+    } | null;
+    elementCount: number;
+    screenshot: ComputerSnapshot["screenshot"] | null;
+}
+export type Operation = DomainOperation;
+export interface AuthStatus {
+    authenticated: boolean;
+    passkeyAvailable: boolean;
+    passkeyRegistered: boolean;
+}
+export interface PasskeySummary {
+    id: string;
+    name: string;
+    lastUsedAt: string;
+}
+export interface RuntimeStatus {
+    version: string;
+    mcpRequests: number;
+    uptimeMinutes: number;
+}
+export interface UpdateStatus {
+    latestVersion: string | null;
+    updateAvailable: boolean;
+    releaseUrl: string | null;
+}
+export type McpToolSummary = DomainMcpToolSummary;
+export type CloudService = CloudServiceId;
+export type CloudStatus = DomainCloudStatus;
+export interface WorkspaceFileContent {
+    content: string;
+}
+export interface CloudManagementSession {
+    url: string;
+}
+export interface CloudRestoreResult {
+    status: CloudStatus;
+}
+export type { LogLevel, LogPage, LogRecord } from "#core/logging/types";

package/dist/plugins/web/api-types.js

@@ -0,0 +1 @@
+export {};

package/dist/plugins/web/http/api-router.d.ts

@@ -0,0 +1,13 @@
+import { Router } from "express";
+import type { WebRuntime } from "#plugins/web/runtime";
+import type { RuntimeEventBus } from "#app/event-bus";
+import type { AuthService } from "#auth/auth-service";
+import type { PasskeyService } from "#auth/passkey-service";
+import type { IngressPolicy } from "#auth/ingress-policy";
+import type { CloudController } from "#plugins/cloud/controller";
+import type { LogService } from "#core/logging/types";
+export declare function createApiRouter(application: WebRuntime, eventBus: RuntimeEventBus, auth: AuthService, passkeys: PasskeyService, ingress: IngressPolicy, cloud: CloudController, logs: LogService, runtimeStatus: () => {
+    version: string;
+    mcpRequests: number;
+    uptimeMinutes: number;
+}): Router;