@di-code/coding-agent 0.1.7 → 0.1.8

package/dist/webui.js

@@ -0,0 +1,882 @@
+import { execFile } from "node:child_process";
+import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { basename, extname, relative, resolve, sep } from "node:path";
+import { promisify } from "node:util";
+import { commandRegistryKey } from "@di-code/builtins";
+import { createProjectTrustStore } from "./project-trust-entry.js";
+import { RpcDispatcher } from "./rpc/dispatcher.js";
+import { parseRpcRequest, RPC_PROTOCOL_VERSION } from "./rpc/protocol.js";
+import { createManagedAttachmentStore } from "./runtime/attachment-store.js";
+import { createProductHost } from "./runtime/product-host.js";
+import { HostManager } from "./runtime/session-host.js";
+import { loadStartupConfiguration, resolveStartupRuntime, } from "./startup.js";
+function json(res, status, value) {
+    const body = JSON.stringify(value);
+    res.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+    res.end(body);
+}
+function tokenFrom(req) {
+    const authorization = req.headers.authorization;
+    if (authorization?.startsWith("Bearer "))
+        return authorization.slice("Bearer ".length).trim();
+    const header = req.headers["x-di-code-token"];
+    return typeof header === "string" ? header : undefined;
+}
+function cookieToken(req) {
+    const cookies = req.headers.cookie;
+    if (!cookies)
+        return undefined;
+    for (const part of cookies.split(";")) {
+        const [name, value] = part.trim().split("=", 2);
+        if (name === "di_code_web")
+            return value;
+    }
+    return undefined;
+}
+const MIME_TYPES = {
+    ".css": "text/css; charset=utf-8",
+    ".html": "text/html; charset=utf-8",
+    ".ico": "image/x-icon",
+    ".js": "text/javascript; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".map": "application/json; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".woff2": "font/woff2",
+};
+const execFileAsync = promisify(execFile);
+async function body(req, maxBytes) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += data.byteLength;
+        if (size > maxBytes)
+            throw new Error("Request body exceeds the permitted size.");
+        chunks.push(data);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+function requestFromValue(value) {
+    const line = JSON.stringify(value);
+    if (!line)
+        throw new Error("RPC body must be a JSON object.");
+    return parseRpcRequest(line);
+}
+/** Local-first HTTP/SSE adapter. It authenticates and queues transport messages; Agent work remains in RpcDispatcher. */
+export class WebUiServer {
+    options;
+    hostManager;
+    clients = new Map();
+    clientsByResumeToken = new Map();
+    server;
+    addedWorkspaceRoots = new Set();
+    removedWorkspaceRoots = new Set();
+    workspaceRegistryLoaded = false;
+    workspaceNames = new Map();
+    tokenValue;
+    sseConnections = 0;
+    disposed = false;
+    constructor(options) {
+        if (options.token === undefined || options.token.length < 32)
+            throw new Error("WebUI requires a token of at least 32 characters.");
+        if (options.resumeTokenTtlMs !== undefined &&
+            (!Number.isSafeInteger(options.resumeTokenTtlMs) || options.resumeTokenTtlMs <= 0))
+            throw new Error("WebUI resume token TTL must be a positive integer.");
+        if ((options.maxSseConnectionsPerClient !== undefined &&
+            (!Number.isSafeInteger(options.maxSseConnectionsPerClient) || options.maxSseConnectionsPerClient <= 0)) ||
+            (options.maxSseConnections !== undefined &&
+                (!Number.isSafeInteger(options.maxSseConnections) || options.maxSseConnections <= 0)))
+            throw new Error("WebUI SSE connection limits must be positive integers.");
+        this.options = options;
+        this.tokenValue = options.token;
+        this.hostManager = new HostManager(options.context);
+        this.server = createServer((req, res) => void this.handle(req, res));
+    }
+    get token() {
+        return this.tokenValue;
+    }
+    rotateToken() {
+        this.tokenValue = randomBytes(32).toString("base64url");
+        for (const client of this.clients.values())
+            this.closeClient(client);
+        this.clients.clear();
+        this.clientsByResumeToken.clear();
+        return this.tokenValue;
+    }
+    revokeToken() {
+        this.tokenValue = randomBytes(32).toString("base64url");
+        for (const client of this.clients.values())
+            this.closeClient(client);
+        this.clients.clear();
+        this.clientsByResumeToken.clear();
+    }
+    listen() {
+        const host = this.options.host ?? "127.0.0.1";
+        if (host !== "127.0.0.1" && host !== "::1" && !this.options.allowRemote)
+            return Promise.reject(new Error("Remote WebUI binding requires explicit allowRemote."));
+        return new Promise((resolvePromise, reject) => {
+            this.server.once("error", reject);
+            this.server.listen(this.options.port ?? 0, host, () => {
+                const address = this.server.address();
+                if (!address || typeof address === "string")
+                    return reject(new Error("WebUI did not expose a TCP address."));
+                resolvePromise({ host, port: address.port });
+            });
+        });
+    }
+    async close() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        for (const client of this.clients.values())
+            this.closeClient(client);
+        await this.hostManager.dispose();
+        await new Promise((resolvePromise) => this.server.close(() => resolvePromise()));
+    }
+    async handle(req, res) {
+        try {
+            if (this.disposed)
+                return json(res, 503, { error: "WebUI is shutting down." });
+            if (!this.hostAllowed(req))
+                return json(res, 403, { error: "Host is not allowed." });
+            if (!this.originAllowed(req))
+                return json(res, 403, { error: "Origin is not allowed." });
+            const url = new URL(req.url ?? "/", "http://127.0.0.1");
+            if (req.method === "GET" && url.pathname === "/healthz")
+                return json(res, 200, { status: "ok" });
+            if (this.options.staticRoot && !isApiRoute(url.pathname)) {
+                if (await this.staticAsset(req, res, url))
+                    return;
+            }
+            this.setCors(req, res);
+            if (req.method === "OPTIONS") {
+                res.writeHead(204).end();
+                return;
+            }
+            if (req.method === "GET" && url.pathname === "/api/session" && this.isDevelopmentSessionRequest(req)) {
+                this.setWebCookie(res);
+                res.writeHead(204).end();
+                return;
+            }
+            const client = this.authenticate(req, res, url.pathname.startsWith("/api/"));
+            if (!client)
+                return;
+            if (!this.rateAllowed(client))
+                return json(res, 429, { error: "Rate limit exceeded." });
+            if (req.method === "GET" && url.pathname === "/api/boot")
+                return await this.boot(res, client, url);
+            if (req.method === "POST" && url.pathname === "/api/workspaces")
+                return await this.addWorkspaceRoute(req, res);
+            if (req.method === "POST" && url.pathname === "/api/workspaces/rename")
+                return await this.renameWorkspaceRoute(req, res);
+            if (req.method === "POST" && url.pathname === "/api/workspaces/delete")
+                return await this.deleteWorkspaceRoute(req, res);
+            if (req.method === "POST" && url.pathname === "/api/workspaces/pick")
+                return await this.pickWorkspaceRoute(res);
+            if (req.method === "POST" && url.pathname === "/api/rpc")
+                return await this.rpc(req, res, client, url);
+            if (req.method === "GET" && url.pathname === "/api/events")
+                return await this.events(req, res, client, url);
+            if (req.method === "POST" && url.pathname === "/api/attachments")
+                return await this.attachments(req, res, client, url);
+            if (req.method === "POST" && url.pathname === "/rpc")
+                return await this.rpc(req, res, client, url);
+            if (req.method === "GET" && url.pathname === "/events")
+                return await this.events(req, res, client, url);
+            if (req.method === "POST" && url.pathname === "/attachments")
+                return await this.attachments(req, res, client, url);
+            json(res, 404, { error: "Not found." });
+        }
+        catch {
+            json(res, 400, { error: "Request rejected." });
+        }
+    }
+    authenticate(req, res, allowCookie) {
+        const token = tokenFrom(req) ?? (allowCookie ? cookieToken(req) : undefined);
+        if (!token || !constantEquals(token, this.tokenValue)) {
+            json(res, 401, { error: "Unauthorized." });
+            return undefined;
+        }
+        const requestedResumeToken = req.headers["x-di-code-resume-token"];
+        if (typeof requestedResumeToken === "string") {
+            const resumed = this.clientsByResumeToken.get(requestedResumeToken);
+            if (resumed && resumed.resumeTokenExpiresAt > Date.now()) {
+                this.rotateResumeToken(resumed);
+                res.setHeader("x-di-code-client-id", resumed.id);
+                return resumed;
+            }
+            if (resumed)
+                this.revokeResumeToken(resumed);
+            json(res, 401, { error: "Resume credential is invalid or expired." });
+            return undefined;
+        }
+        const requestedId = req.headers["x-di-code-client-id"];
+        const id = typeof requestedId === "string" && /^[A-Za-z0-9_-]{16,128}$/.test(requestedId)
+            ? requestedId
+            : randomBytes(18).toString("base64url");
+        res.setHeader("x-di-code-client-id", id);
+        let client = this.clients.get(id);
+        if (!client) {
+            client = {
+                id,
+                principal: `webui:${id}`,
+                resumeToken: randomBytes(24).toString("base64url"),
+                resumeTokenExpiresAt: Date.now() + (this.options.resumeTokenTtlMs ?? 10 * 60 * 1000),
+                dispatchers: new Map(),
+                productHosts: new Map(),
+                connections: new Set(),
+                requestTimes: [],
+            };
+            this.clients.set(id, client);
+            this.clientsByResumeToken.set(client.resumeToken, client);
+        }
+        return client;
+    }
+    rotateResumeToken(client) {
+        this.clientsByResumeToken.delete(client.resumeToken);
+        client.resumeToken = randomBytes(24).toString("base64url");
+        client.resumeTokenExpiresAt = Date.now() + (this.options.resumeTokenTtlMs ?? 10 * 60 * 1000);
+        this.clientsByResumeToken.set(client.resumeToken, client);
+    }
+    revokeResumeToken(client) {
+        this.clientsByResumeToken.delete(client.resumeToken);
+        client.resumeTokenExpiresAt = 0;
+    }
+    hostAllowed(req) {
+        const host = req.headers.host;
+        if (!host)
+            return false;
+        try {
+            const expected = this.options.host ?? "127.0.0.1";
+            return new URL(`http://${host}`).hostname === expected;
+        }
+        catch {
+            return false;
+        }
+    }
+    originAllowed(req) {
+        const origin = req.headers.origin;
+        if (origin === undefined)
+            return true;
+        const allowed = this.options.origins;
+        if (allowed)
+            return allowed.includes(origin) || origin === this.options.developmentOrigin;
+        if (origin === this.options.developmentOrigin)
+            return true;
+        if (origin === `http://${req.headers.host}`)
+            return true;
+        try {
+            const parsed = new URL(origin);
+            return parsed.protocol === "http:" && parsed.hostname === (this.options.host ?? "127.0.0.1");
+        }
+        catch {
+            return false;
+        }
+    }
+    setCors(req, res) {
+        const origin = req.headers.origin;
+        if (origin && this.originAllowed(req)) {
+            res.setHeader("access-control-allow-origin", origin);
+            res.setHeader("access-control-allow-headers", "authorization, content-type, x-di-code-token, x-di-code-client-id, x-di-code-resume-token, last-event-id");
+            res.setHeader("access-control-allow-methods", "GET, POST, OPTIONS");
+            res.setHeader("vary", "Origin");
+        }
+    }
+    rateAllowed(client) {
+        const now = Date.now();
+        const config = this.options.rateLimit ?? { windowMs: 10_000, maxRequests: 60 };
+        while (client.requestTimes[0] !== undefined && client.requestTimes[0] < now - config.windowMs)
+            client.requestTimes.shift();
+        if (client.requestTimes.length >= config.maxRequests)
+            return false;
+        client.requestTimes.push(now);
+        return true;
+    }
+    async staticAsset(req, res, url) {
+        if (req.method !== "GET" && req.method !== "HEAD")
+            return false;
+        const configuredRoot = this.options.staticRoot;
+        if (!configuredRoot)
+            return false;
+        const staticRoot = await realpath(configuredRoot);
+        let pathname;
+        try {
+            pathname = decodeURIComponent(url.pathname);
+        }
+        catch {
+            json(res, 400, { error: "Invalid URL path." });
+            return true;
+        }
+        if (pathname.includes("\0")) {
+            json(res, 400, { error: "Invalid URL path." });
+            return true;
+        }
+        const requested = resolve(staticRoot, `.${pathname}`);
+        const pathIsInsideRoot = relative(staticRoot, requested);
+        if (pathIsInsideRoot.startsWith("..") || pathIsInsideRoot.startsWith(`..${sep}`)) {
+            json(res, 403, { error: "Static path is not allowed." });
+            return true;
+        }
+        const candidate = await this.fileOrFallback(requested === staticRoot ? resolve(staticRoot, "index.html") : requested, resolve(staticRoot, "index.html"));
+        if (!candidate)
+            return false;
+        const realCandidate = await realpath(candidate);
+        const candidatePath = relative(staticRoot, realCandidate);
+        if (candidatePath.startsWith("..") || candidatePath.startsWith(`..${sep}`)) {
+            json(res, 403, { error: "Static path is not allowed." });
+            return true;
+        }
+        this.setWebCookie(res);
+        const asset = await readFile(realCandidate);
+        const cacheControl = realCandidate.endsWith("index.html")
+            ? "no-cache"
+            : realCandidate.includes(`${sep}assets${sep}`)
+                ? "public, max-age=31536000, immutable"
+                : "public, max-age=3600";
+        res.writeHead(200, {
+            "content-type": MIME_TYPES[extname(realCandidate)] ?? "application/octet-stream",
+            "cache-control": cacheControl,
+        });
+        if (req.method === "GET")
+            res.end(asset);
+        else
+            res.end();
+        return true;
+    }
+    async fileOrFallback(path, fallback) {
+        try {
+            if ((await stat(path)).isFile())
+                return path;
+        }
+        catch { }
+        try {
+            if ((await stat(fallback)).isFile())
+                return fallback;
+        }
+        catch { }
+        return undefined;
+    }
+    setWebCookie(res) {
+        res.setHeader("set-cookie", `di_code_web=${this.tokenValue}; HttpOnly; SameSite=Strict; Path=/`);
+    }
+    isDevelopmentSessionRequest(req) {
+        return this.options.developmentOrigin !== undefined && req.headers.origin === this.options.developmentOrigin;
+    }
+    async boot(res, client, url) {
+        const { actor, dispatcher } = await this.actor(client, url);
+        const workspace = await this.resolveWorkspace(url);
+        const [capabilities, state, runtime] = await Promise.all([
+            dispatcher.dispatch({
+                version: RPC_PROTOCOL_VERSION,
+                kind: "request",
+                id: `boot-capabilities:${randomUUID()}`,
+                method: "get_capabilities",
+                params: { events: [] },
+            }),
+            dispatcher.dispatch({
+                version: RPC_PROTOCOL_VERSION,
+                kind: "request",
+                id: `boot-state:${randomUUID()}`,
+                method: "get_state",
+                params: {},
+            }),
+            dispatcher.dispatch({
+                version: RPC_PROTOCOL_VERSION,
+                kind: "request",
+                id: `boot-runtime:${randomUUID()}`,
+                method: "get_runtime",
+                params: {},
+            }),
+        ]);
+        json(res, 200, {
+            protocolVersion: RPC_PROTOCOL_VERSION,
+            capabilities: capabilities.ok ? capabilities.result : undefined,
+            state: state.ok ? state.result.state : actor.state(),
+            runtime: runtime.ok ? runtime.result : undefined,
+            workspaceId: workspace.id,
+            workspaces: (await this.authorizedWorkspaces()).map(({ id, name }) => ({ id, name })),
+        });
+    }
+    async actor(client, url) {
+        const allowed = (await this.resolveWorkspace(url)).root;
+        let dispatcher = client.dispatchers.get(allowed);
+        if (!dispatcher) {
+            const primary = await realpath(resolve(this.options.allowedRoot));
+            const projectTrusted = allowed.toLowerCase() === primary.toLowerCase()
+                ? (this.options.projectTrusted ?? false)
+                : (await createProjectTrustStore(resolve(this.options.agentDir, "trust.json")).get(allowed)) === true;
+            const startupConfiguration = await loadStartupConfiguration(allowed, process.env, this.options.agentDir);
+            const hostOptions = this.hostOptions(client.principal, allowed, this.resolveActorRuntime(startupConfiguration), projectTrusted);
+            let permissionMode = startupConfiguration.permissionMode ?? "ask";
+            let requestApproval;
+            const toolApproval = {
+                request: async (toolName, parameters, signal) => {
+                    if (permissionMode === "allow")
+                        return;
+                    if (permissionMode === "deny")
+                        throw new Error("Tool approval denied.");
+                    if (!requestApproval)
+                        throw new Error("Tool approval is unavailable.");
+                    if (!(await requestApproval(toolName, parameters, signal)))
+                        throw new Error("Tool approval denied.");
+                },
+            };
+            const actor = await this.hostManager.get({
+                ...hostOptions,
+                principal: client.principal,
+                cwd: allowed,
+                ...(toolApproval ? { toolApproval } : {}),
+            });
+            if (!actor.state().activeSession)
+                await actor.createSession();
+            const product = createProductHost({
+                context: this.options.context,
+                cwd: allowed,
+                agentDir: hostOptions.agentDir,
+                projectTrusted,
+                provider: hostOptions.provider,
+                model: hostOptions.model,
+                runtimeSnapshot: () => {
+                    const ui = actor.ui();
+                    return {
+                        providerId: ui.providerId,
+                        modelId: ui.modelId,
+                        ...(ui.thinkingLevel ? { thinkingLevel: ui.thinkingLevel } : {}),
+                    };
+                },
+                startupConfiguration,
+                reloadRuntime: async () => {
+                    const refreshed = await loadStartupConfiguration(allowed, process.env, this.options.agentDir);
+                    let runtime;
+                    try {
+                        runtime = resolveStartupRuntime(refreshed.environment, refreshed.providers, refreshed.defaults);
+                    }
+                    catch {
+                        runtime = resolveStartupRuntime({ DI_CODE_PROVIDER: "faux" }, []);
+                    }
+                    actor.setRuntimeValue(runtime.provider, runtime.model);
+                    return refreshed;
+                },
+                reloadConfiguration: () => loadStartupConfiguration(allowed, process.env, this.options.agentDir),
+                onPermissionModeChange: (mode) => {
+                    permissionMode = mode;
+                },
+                refreshResources: (projectTrusted) => actor.refreshResources(projectTrusted),
+            });
+            const attachments = await createManagedAttachmentStore({
+                directory: resolve(this.clientTempRoot(client), "attachments"),
+            });
+            dispatcher = new RpcDispatcher({
+                session: actor,
+                commandRegistry: this.options.context.get(commandRegistryKey),
+                productState: { projectTrusted },
+                productHost: product,
+                attachmentStore: attachments,
+            });
+            const actorDispatcher = dispatcher;
+            requestApproval = (toolName, parameters, signal) => actorDispatcher.requestToolApproval(toolName, parameters, signal);
+            await actorDispatcher.dispatch({
+                version: RPC_PROTOCOL_VERSION,
+                kind: "request",
+                id: `webui-capabilities:${randomUUID()}`,
+                method: "get_capabilities",
+                params: {
+                    events: [
+                        "sequence",
+                        "operation_update",
+                        "snapshot_required",
+                        "session_changed",
+                        "tool_approval",
+                        "product_audit",
+                    ],
+                },
+            });
+            client.productHosts.set(allowed, product);
+            client.dispatchers.set(allowed, dispatcher);
+        }
+        const actor = await this.hostManager.get({
+            ...this.hostOptions(client.principal, allowed),
+            principal: client.principal,
+            cwd: allowed,
+        });
+        return { actor, dispatcher };
+    }
+    async authorizedWorkspaces() {
+        await this.loadWorkspaceRegistry();
+        const primary = await realpath(resolve(this.options.allowedRoot));
+        const candidates = [
+            this.options.allowedRoot,
+            ...(this.options.allowedWorkspaces ?? []),
+            ...this.addedWorkspaceRoots,
+        ];
+        const seen = new Set();
+        const result = [];
+        for (const candidate of candidates) {
+            let root;
+            try {
+                root = await realpath(resolve(candidate));
+            }
+            catch {
+                continue;
+            }
+            const key = root.toLowerCase();
+            if (this.removedWorkspaceRoots.has(key))
+                continue;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            if (key !== primary.toLowerCase()) {
+                const trusted = await createProjectTrustStore(resolve(this.options.agentDir, "trust.json")).get(root);
+                if (!trusted)
+                    continue;
+            }
+            result.push({
+                id: createHash("sha256").update(root).digest("hex").slice(0, 24),
+                name: this.workspaceNames.get(key) ?? (basename(root) || "Workspace"),
+                root,
+            });
+        }
+        return result;
+    }
+    async addWorkspaceRoute(req, res) {
+        const value = JSON.parse(await body(req, 64 * 1024));
+        if (typeof value !== "object" || value === null || typeof value.path !== "string")
+            throw new Error("Workspace path is required.");
+        const workspace = await this.addWorkspace(value.path);
+        json(res, 200, { workspace });
+    }
+    async renameWorkspaceRoute(req, res) {
+        const value = JSON.parse(await body(req, 64 * 1024));
+        if (typeof value !== "object" || value === null)
+            throw new Error("Workspace details are required.");
+        const input = value;
+        if (typeof input.workspaceId !== "string" || typeof input.name !== "string")
+            throw new Error("Workspace details are invalid.");
+        const workspace = await this.workspaceById(input.workspaceId);
+        const name = input.name.trim();
+        if (!name || name.length > 120)
+            throw new Error("Workspace name is invalid.");
+        this.workspaceNames.set(workspace.root.toLowerCase(), name);
+        await this.saveWorkspaceRegistry();
+        json(res, 200, { workspace: { id: workspace.id, name } });
+    }
+    async deleteWorkspaceRoute(req, res) {
+        const value = JSON.parse(await body(req, 64 * 1024));
+        if (typeof value !== "object" ||
+            value === null ||
+            typeof value.workspaceId !== "string")
+            throw new Error("Workspace ID is required.");
+        const workspace = await this.workspaceById(value.workspaceId);
+        const primary = await realpath(resolve(this.options.allowedRoot));
+        if (workspace.root.toLowerCase() === primary.toLowerCase())
+            throw new Error("The startup workspace cannot be deleted.");
+        this.addedWorkspaceRoots.delete(workspace.root);
+        this.removedWorkspaceRoots.add(workspace.root.toLowerCase());
+        this.workspaceNames.delete(workspace.root.toLowerCase());
+        await this.saveWorkspaceRegistry();
+        json(res, 200, { deleted: true, workspaceId: workspace.id });
+    }
+    async workspaceById(id) {
+        const workspace = (await this.authorizedWorkspaces()).find((item) => item.id === id);
+        if (!workspace)
+            throw new Error("Workspace is not authorized for this WebUI token.");
+        return workspace;
+    }
+    async pickWorkspaceRoute(res) {
+        const requestedPath = await this.pickWorkspacePath();
+        if (!requestedPath)
+            return json(res, 200, { cancelled: true });
+        const workspace = await this.addWorkspace(requestedPath);
+        json(res, 200, { cancelled: false, workspace });
+    }
+    async pickWorkspacePath() {
+        if (process.platform === "win32") {
+            const script = "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; Add-Type -AssemblyName System.Windows.Forms; $dialog = New-Object System.Windows.Forms.FolderBrowserDialog; if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) { [Console]::Out.Write($dialog.SelectedPath) }";
+            const result = await this.runWorkspacePicker("powershell.exe", ["-NoProfile", "-STA", "-Command", script], {
+                windowsHide: true,
+            });
+            return result.stdout.trim() || undefined;
+        }
+        if (process.platform === "darwin") {
+            const result = await this.runWorkspacePicker("osascript", [
+                "-e",
+                'POSIX path of (choose folder with prompt "Choose a workspace")',
+            ]);
+            return result.stdout.trim() || undefined;
+        }
+        const result = await this.runWorkspacePicker("zenity", [
+            "--file-selection",
+            "--directory",
+            "--title=Choose a workspace",
+        ]);
+        return result.stdout.trim() || undefined;
+    }
+    async runWorkspacePicker(command, args, options = {}) {
+        try {
+            const result = await execFileAsync(command, [...args], {
+                ...options,
+                timeout: 5 * 60 * 1000,
+                maxBuffer: 64 * 1024,
+            });
+            return { stdout: result.stdout };
+        }
+        catch (cause) {
+            const error = cause;
+            // osascript and zenity use non-zero exit codes for an explicit cancel.
+            if (error.code === 1 || error.code === 255 || error.code === -128)
+                return { stdout: "" };
+            if (typeof error.code === "string" && error.code === "ENOENT")
+                throw new Error(`Unable to open the ${command} directory picker. Install ${command} or choose a workspace another way.`);
+            throw new Error(`Workspace directory picker failed.${error.stderr?.trim() ? ` ${error.stderr.trim()}` : ""}`);
+        }
+    }
+    /** Adds a validated local directory to this server's explicitly authorized workspace set. */
+    async addWorkspace(requestedPath) {
+        if (!requestedPath.trim() || requestedPath.includes("\0"))
+            throw new Error("Workspace path is invalid.");
+        const root = await realpath(resolve(requestedPath));
+        if (!(await stat(root)).isDirectory())
+            throw new Error("Workspace path is not a directory.");
+        const primary = await realpath(resolve(this.options.allowedRoot));
+        if (root.toLowerCase() !== primary.toLowerCase()) {
+            await createProjectTrustStore(resolve(this.options.agentDir, "trust.json")).set(root, true);
+        }
+        this.addedWorkspaceRoots.add(root);
+        this.removedWorkspaceRoots.delete(root.toLowerCase());
+        await this.saveWorkspaceRegistry();
+        const id = createHash("sha256").update(root).digest("hex").slice(0, 24);
+        return { id, name: this.workspaceNames.get(root.toLowerCase()) ?? (basename(root) || "Workspace") };
+    }
+    workspaceRegistryPath() {
+        return resolve(this.options.workspaceRegistryDir ?? this.options.agentDir, "webui", "workspaces.json");
+    }
+    async loadWorkspaceRegistry() {
+        if (this.workspaceRegistryLoaded)
+            return;
+        this.workspaceRegistryLoaded = true;
+        try {
+            const value = JSON.parse(await readFile(this.workspaceRegistryPath(), "utf8"));
+            if (Array.isArray(value.roots))
+                for (const root of value.roots)
+                    if (typeof root === "string")
+                        this.addedWorkspaceRoots.add(root);
+            if (Array.isArray(value.removed))
+                for (const root of value.removed)
+                    if (typeof root === "string")
+                        this.removedWorkspaceRoots.add(root);
+            if (value.names && typeof value.names === "object")
+                for (const [root, name] of Object.entries(value.names))
+                    if (typeof name === "string")
+                        this.workspaceNames.set(root, name);
+        }
+        catch { }
+    }
+    async saveWorkspaceRegistry() {
+        await mkdir(resolve(this.options.workspaceRegistryDir ?? this.options.agentDir, "webui"), {
+            recursive: true,
+        });
+        await writeFile(this.workspaceRegistryPath(), JSON.stringify({
+            roots: [...this.addedWorkspaceRoots],
+            removed: [...this.removedWorkspaceRoots],
+            names: Object.fromEntries(this.workspaceNames.entries()),
+        }), "utf8");
+    }
+    async resolveWorkspace(url) {
+        const workspaces = await this.authorizedWorkspaces();
+        const id = url.searchParams.get("workspaceId");
+        if (id) {
+            const selected = workspaces.find((workspace) => workspace.id === id);
+            if (selected)
+                return selected;
+            throw new Error("Workspace is not authorized for this WebUI token.");
+        }
+        // Preserve the embedding transport's existing path query while the SPA uses opaque workspace IDs.
+        const legacy = url.searchParams.get("workspace");
+        if (legacy) {
+            const requested = await realpath(resolve(legacy));
+            const selected = workspaces.find((workspace) => workspace.root.toLowerCase() === requested.toLowerCase());
+            if (selected)
+                return selected;
+            throw new Error("Workspace is not authorized for this WebUI token.");
+        }
+        const primary = workspaces[0];
+        if (!primary)
+            throw new Error("No trusted Workspace is available for this WebUI token.");
+        return primary;
+    }
+    resolveActorRuntime(configuration) {
+        const initialProvider = this.options.provider;
+        const initialModel = this.options.model;
+        const providerId = configuration.environment.DI_CODE_PROVIDER?.trim() || configuration.defaults?.providerId;
+        const modelId = configuration.environment.DI_CODE_MODEL?.trim() ||
+            (configuration.defaults?.providerId === providerId ? configuration.defaults?.modelId : undefined);
+        if (initialProvider && providerId === initialProvider.id && modelId) {
+            const model = initialProvider.models.find((candidate) => candidate.id === modelId);
+            if (model)
+                return { provider: initialProvider, model };
+        }
+        try {
+            return resolveStartupRuntime(configuration.environment, configuration.providers, configuration.defaults);
+        }
+        catch {
+            // Embedders may inject a runtime without a corresponding settings file.
+            if (initialProvider && initialModel)
+                return { provider: initialProvider, model: initialModel };
+            throw new Error("Provider is not configured.");
+        }
+    }
+    hostOptions(_principal, cwd, runtime, projectTrusted = this.options.projectTrusted) {
+        return {
+            cwd,
+            // SessionHost uses the same durable root as TUI. Browser identity only
+            // scopes transport state and must never become a settings root.
+            agentDir: resolve(this.options.agentDir),
+            projectTrusted,
+            noSkills: this.options.noSkills,
+            noContextFiles: this.options.noContextFiles,
+            skillPaths: this.options.skillPaths,
+            provider: runtime?.provider ?? this.options.provider,
+            model: runtime?.model ?? this.options.model,
+            signal: this.options.signal,
+            compaction: this.options.compaction,
+        };
+    }
+    clientTempRoot(client) {
+        const id = createHash("sha256").update(client.principal).digest("hex");
+        return resolve(this.options.agentDir, "webui", "actors", id);
+    }
+    async rpc(req, res, client, url) {
+        const request = requestFromValue(JSON.parse(await body(req, this.options.maxBodyBytes ?? 2 * 1024 * 1024)));
+        const { dispatcher } = await this.actor(client, url);
+        const response = await dispatcher.dispatch(request);
+        json(res, 200, response);
+    }
+    async attachments(req, res, client, url) {
+        // A 5 MiB binary attachment expands to nearly 7 MiB in base64 before JSON framing.
+        const value = JSON.parse(await body(req, this.options.maxBodyBytes ?? 10 * 1024 * 1024));
+        if (typeof value !== "object" || value === null)
+            throw new Error("Attachment body must be an object.");
+        const request = requestFromValue({
+            version: RPC_PROTOCOL_VERSION,
+            kind: "request",
+            id: randomUUID(),
+            method: "create_attachment",
+            params: value,
+        });
+        const { dispatcher } = await this.actor(client, url);
+        json(res, 200, await dispatcher.dispatch(request));
+    }
+    async events(req, res, client, url) {
+        if (typeof req.headers["x-di-code-resume-token"] === "string")
+            this.closeConnections(client);
+        const perClientLimit = this.options.maxSseConnectionsPerClient ?? 8;
+        const globalLimit = this.options.maxSseConnections ?? 64;
+        if (client.connections.size >= perClientLimit || this.sseConnections >= globalLimit) {
+            json(res, 429, { error: "SSE connection limit exceeded." });
+            return;
+        }
+        const { dispatcher } = await this.actor(client, url);
+        let released = false;
+        const connection = {
+            queue: [],
+            waiters: [],
+            maxQueue: 128,
+            closed: false,
+            closeResponse: () => res.end(),
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                connection.closed = true;
+                connection.waiters.splice(0).forEach((wake) => void wake());
+                client.connections.delete(connection);
+                this.sseConnections = Math.max(0, this.sseConnections - 1);
+            },
+        };
+        client.connections.add(connection);
+        this.sseConnections += 1;
+        req.once("close", () => {
+            connection.release();
+        });
+        const unsubscribe = dispatcher.subscribe((message) => {
+            if (connection.closed)
+                return;
+            if (connection.queue.length >= connection.maxQueue) {
+                connection.queue.shift();
+                connection.queue.push({ version: 1, kind: "event", requestId: "webui", event: { type: "snapshot_required" } });
+            }
+            else
+                connection.queue.push(message);
+            connection.waiters.splice(0).forEach((wake) => void wake());
+        });
+        const keepalive = setInterval(() => {
+            if (connection.closed)
+                return;
+            if (connection.queue.length >= connection.maxQueue)
+                connection.queue.shift();
+            connection.queue.push({ keepalive: true });
+            connection.waiters.splice(0).forEach((wake) => void wake());
+        }, 15_000);
+        res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" });
+        res.write(`event: ready\ndata: ${JSON.stringify({ resumeToken: client.resumeToken })}\n\n`);
+        const last = Number(req.headers["last-event-id"] ?? "0");
+        if (Number.isSafeInteger(last) && last >= 0)
+            await dispatcher.dispatch({
+                version: 1,
+                kind: "request",
+                id: `resume:${randomUUID()}`,
+                method: "resume_events",
+                params: { lastSequence: last },
+            });
+        try {
+            while (!connection.closed) {
+                const next = connection.queue.shift();
+                if (!next)
+                    await new Promise((resolvePromise) => connection.waiters.push(resolvePromise));
+                else {
+                    const payload = "keepalive" in next
+                        ? ": keepalive\n\n"
+                        : `${next.kind === "event" && next.sequence !== undefined ? `id: ${next.sequence}\n` : ""}data: ${JSON.stringify(next)}\n\n`;
+                    if (!res.write(payload))
+                        await new Promise((resolvePromise) => res.once("drain", resolvePromise));
+                }
+            }
+        }
+        finally {
+            clearInterval(keepalive);
+            unsubscribe();
+            connection.release();
+        }
+    }
+    closeConnections(client) {
+        for (const connection of client.connections) {
+            connection.release();
+            connection.closeResponse();
+        }
+    }
+    closeClient(client) {
+        this.closeConnections(client);
+        for (const dispatcher of client.dispatchers.values())
+            void dispatcher.dispose();
+        for (const product of client.productHosts.values())
+            void product.dispose();
+        client.dispatchers.clear();
+        client.productHosts.clear();
+        this.clientsByResumeToken.delete(client.resumeToken);
+    }
+}
+function constantEquals(left, right) {
+    const leftBytes = Buffer.from(left);
+    const rightBytes = Buffer.from(right);
+    return leftBytes.byteLength === rightBytes.byteLength && timingSafeEqual(leftBytes, rightBytes);
+}
+function isApiRoute(pathname) {
+    return (pathname === "/rpc" ||
+        pathname === "/events" ||
+        pathname === "/attachments" ||
+        pathname === "/healthz" ||
+        pathname.startsWith("/api/"));
+}
+//# sourceMappingURL=webui.js.map