@jmfederico/pi-web 1.202609.0 → 1.202609.1

package/dist/pi-web-plugins/terminal/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@pi-web/terminal-plugin",
+  "private": true,
+  "type": "module",
+  "piWeb": {
+    "plugins": [
+      {
+        "id": "pi-web.terminal",
+        "browserRoot": "browser",
+        "module": "browser/pi-web-plugin.js",
+        "serverModule": "server-plugin.js",
+        "machineSpecific": true
+      }
+    ]
+  }
+}

package/dist/pi-web-plugins/terminal/server-plugin.js

@@ -0,0 +1,365 @@
+// Generated from pi-web-plugins/terminal/server/server-plugin.ts. Do not edit directly.
+import { TerminalService, } from "./terminalService.js";
+const TERMINAL_CHANNEL_OUTPUT_FRAME_TARGET_BYTES = 60 * 1024;
+export const TERMINAL_SERVICE_CAPABILITY = Object.freeze({
+    pluginId: "pi-web.terminal",
+    id: "service",
+    version: 1,
+    parse: snapshotTerminalServiceCapability,
+});
+const plugin = {
+    apiVersion: 3,
+    name: "Terminal",
+    activate(context) {
+        return activateTerminalPlugin(context);
+    },
+};
+export default plugin;
+export function activateTerminalPlugin(context) {
+    if (context.pluginId !== "pi-web.terminal") {
+        throw new Error(`Terminal server entry must activate as plugin id pi-web.terminal, received ${context.pluginId}`);
+    }
+    const notices = context.notices;
+    if (notices?.version !== 1) {
+        throw new Error("Terminal server entry requires server notice reporter version 1");
+    }
+    const service = new TerminalService((input) => { notices.record(input); });
+    const requiredTerminalService = Object.freeze({
+        closeForCwd: (cwd) => { service.closeForCwd(cwd); },
+        runCommand: (options) => service.runCommand(options),
+        bindActivitySink: (sink) => { service.bindActivitySink(sink); },
+    });
+    const serviceProvision = Object.freeze({
+        capability: TERMINAL_SERVICE_CAPABILITY,
+        value: requiredTerminalService,
+    });
+    let stopped = false;
+    return Object.freeze({
+        peer: createTerminalPeer(service, context),
+        provides: Object.freeze([serviceProvision]),
+        health: () => stopped
+            ? Object.freeze({ status: "unhealthy", message: "Terminal service is stopped" })
+            : Object.freeze({ status: "healthy" }),
+        dispose: () => {
+            if (stopped)
+                return;
+            stopped = true;
+            service.dispose();
+        },
+    });
+}
+function snapshotTerminalServiceCapability(value) {
+    if (!isRequiredTerminalServiceContribution(value)) {
+        throw new Error("Terminal service capability must expose closeForCwd, runCommand, and bindActivitySink");
+    }
+    return Object.freeze({
+        closeForCwd: (cwd) => { value.closeForCwd(cwd); },
+        runCommand: (options) => value.runCommand(options),
+        bindActivitySink: (sink) => { value.bindActivitySink(sink); },
+    });
+}
+function isRequiredTerminalServiceContribution(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    return typeof Reflect.get(value, "closeForCwd") === "function"
+        && typeof Reflect.get(value, "runCommand") === "function"
+        && typeof Reflect.get(value, "bindActivitySink") === "function";
+}
+export function createTerminalPeer(service, activationContext) {
+    return Object.freeze({
+        request: (context) => terminalRequest(service, context),
+        openChannel: (context) => openTerminalChannel(service, context, activationContext),
+    });
+}
+function terminalRequest(service, context) {
+    throwIfAborted(context.signal);
+    const scope = terminalScope(context);
+    switch (context.operation) {
+        case "terminal.list":
+            requireNullishInput(context.input, context.operation);
+            return service.list(scope).map(terminalInfoJson);
+        case "terminal.create": {
+            const input = requireObject(context.input, context.operation);
+            return terminalInfoJson(service.create({
+                ...scope,
+                ...optionalTerminalName(input),
+                ...optionalTerminalSize(input),
+            }));
+        }
+        case "terminal.close": {
+            service.close(scope, requireIdInput(context.input, context.operation, "terminalId"));
+            return { closed: true };
+        }
+        case "terminal.continue":
+            return terminalInfoJson(service.continue(scope, requireIdInput(context.input, context.operation, "terminalId")));
+        case "terminal.run": {
+            const input = requireObject(context.input, context.operation);
+            return commandRunJson(service.runCommand(parseRunCommand(scope, input)));
+        }
+        case "terminal.list-runs": {
+            const input = requireObjectOrEmpty(context.input, context.operation);
+            return service.listCommandRunsForScope(scope, parseCommandRunFilter(input)).map(commandRunJson);
+        }
+        case "terminal.get-run": {
+            const run = service.getCommandRunForScope(scope, requireIdInput(context.input, context.operation, "runId"));
+            return run === undefined ? null : commandRunJson(run);
+        }
+        case "terminal.cancel-run":
+            return commandRunJson(service.cancelCommandRunForScope(scope, requireIdInput(context.input, context.operation, "runId")));
+        default:
+            throw new Error(`Unsupported Terminal operation: ${context.operation}`);
+    }
+}
+function openTerminalChannel(service, context, activationContext) {
+    if (context.operation !== "terminal.attach") {
+        throw new Error(`Unsupported Terminal channel operation: ${context.operation}`);
+    }
+    throwIfAborted(context.signal);
+    const scope = terminalScope(context);
+    const input = requireObject(context.input, context.operation);
+    const terminalId = requireString(input, "terminalId", context.operation);
+    const size = optionalTerminalSize(input);
+    if (size.cols !== undefined && size.rows !== undefined) {
+        service.resize(scope, terminalId, size.cols, size.rows);
+    }
+    let resolveCompleted = () => undefined;
+    const completed = new Promise((resolve) => { resolveCompleted = resolve; });
+    let opening = true;
+    let detach = () => undefined;
+    const send = (frame) => {
+        try {
+            context.send(frame);
+        }
+        catch (error) {
+            if (opening)
+                throw error;
+            detach();
+            activationContext?.logger.error("Terminal channel output failed", {
+                terminalId,
+                message: boundedErrorMessage(error),
+            });
+        }
+    };
+    detach = service.attach(scope, terminalId, {
+        output(data, replay) {
+            for (const frame of terminalOutputFrames(data, replay))
+                send(frame);
+        },
+        exit(exitCode) {
+            send({ type: "exit", ...(exitCode === undefined ? {} : { exitCode }) });
+        },
+        closed() {
+            resolveCompleted();
+        },
+    });
+    opening = false;
+    let cleanedUp = false;
+    const cleanup = () => {
+        if (cleanedUp)
+            return;
+        cleanedUp = true;
+        context.signal.removeEventListener("abort", cleanup);
+        detach();
+    };
+    context.signal.addEventListener("abort", cleanup, { once: true });
+    return Object.freeze({
+        closed: completed,
+        receive(data, signal) {
+            throwIfAborted(signal);
+            throwIfAborted(context.signal);
+            const frame = requireObject(data, "terminal.attach frame");
+            const type = requireString(frame, "type", "terminal.attach frame");
+            if (type === "input") {
+                service.write(scope, terminalId, requireTerminalInputData(frame));
+                return;
+            }
+            if (type === "resize") {
+                const parsed = requireTerminalSize(frame, "terminal.attach resize frame");
+                service.resize(scope, terminalId, parsed.cols, parsed.rows);
+                return;
+            }
+            throw new Error(`Unsupported Terminal channel frame: ${type}`);
+        },
+        close() {
+            cleanup();
+        },
+    });
+}
+function terminalScope(context) {
+    if (context.workspace.projectId !== context.project.id) {
+        throw new Error("Terminal workspace project scope does not match the host project");
+    }
+    return Object.freeze({
+        projectId: context.project.id,
+        workspaceId: context.workspace.id,
+        cwd: context.workspace.path,
+    });
+}
+function parseRunCommand(scope, input) {
+    const metadata = input["metadata"];
+    return {
+        ...scope,
+        origin: requireString(input, "origin", "terminal.run"),
+        title: requireString(input, "title", "terminal.run"),
+        command: requireString(input, "command", "terminal.run"),
+        ...(metadata === undefined ? {} : { metadata }),
+        ...optionalTerminalSize(input),
+    };
+}
+function parseCommandRunFilter(input) {
+    const terminalId = optionalString(input, "terminalId", "terminal.list-runs");
+    const metadataValue = input["metadata"];
+    const statusesValue = input["statuses"];
+    const metadata = metadataValue === undefined ? undefined : stringRecord(metadataValue, "terminal.list-runs metadata");
+    const statuses = statusesValue === undefined ? undefined : requireArray(statusesValue, "terminal.list-runs statuses").map((status) => parseCommandRunStatus(status));
+    return {
+        ...(terminalId === undefined ? {} : { terminalId }),
+        ...(statuses === undefined ? {} : { statuses }),
+        ...(metadata === undefined ? {} : { metadata }),
+    };
+}
+function terminalInfoJson(info) {
+    return {
+        id: info.id,
+        cwd: info.cwd,
+        name: info.name,
+        createdAt: info.createdAt,
+        exited: info.exited,
+        ...(info.exitCode === undefined ? {} : { exitCode: info.exitCode }),
+        ...(info.commandRunId === undefined ? {} : { commandRunId: info.commandRunId }),
+    };
+}
+function commandRunJson(run) {
+    return {
+        id: run.id,
+        origin: run.origin,
+        projectId: run.projectId,
+        workspaceId: run.workspaceId,
+        terminalId: run.terminalId,
+        title: run.title,
+        command: run.command,
+        status: run.status,
+        ...(run.exitCode === undefined ? {} : { exitCode: run.exitCode }),
+        createdAt: run.createdAt,
+        ...(run.startedAt === undefined ? {} : { startedAt: run.startedAt }),
+        ...(run.completedAt === undefined ? {} : { completedAt: run.completedAt }),
+        metadata: { ...run.metadata },
+    };
+}
+function optionalTerminalName(input) {
+    const name = optionalString(input, "name", "terminal.create");
+    return name === undefined ? {} : { name };
+}
+function optionalTerminalSize(input) {
+    const cols = input["cols"];
+    const rows = input["rows"];
+    if (cols === undefined && rows === undefined)
+        return {};
+    return requireTerminalSize(input, "Terminal size");
+}
+function requireTerminalSize(input, label) {
+    const cols = input["cols"];
+    const rows = input["rows"];
+    if (typeof cols !== "number" || !Number.isFinite(cols) || cols <= 0)
+        throw new Error(`${label} cols must be a positive number`);
+    if (typeof rows !== "number" || !Number.isFinite(rows) || rows <= 0)
+        throw new Error(`${label} rows must be a positive number`);
+    return { cols: Math.floor(cols), rows: Math.floor(rows) };
+}
+function requireIdInput(input, operation, key) {
+    return requireString(requireObject(input, operation), key, operation);
+}
+function requireObject(value, label) {
+    if (!isJsonObject(value))
+        throw new Error(`${label} input must be an object`);
+    return value;
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireObjectOrEmpty(value, label) {
+    return value === null ? {} : requireObject(value, label);
+}
+function requireNullishInput(value, label) {
+    if (value !== null && (typeof value !== "object" || Array.isArray(value) || Object.keys(value).length > 0)) {
+        throw new Error(`${label} input must be null or an empty object`);
+    }
+}
+function requireString(record, key, label) {
+    const value = record[key];
+    if (typeof value !== "string" || value.trim() === "")
+        throw new Error(`${label} ${key} must be a non-empty string`);
+    return value;
+}
+function requireTerminalInputData(record) {
+    const value = record["data"];
+    if (typeof value !== "string" || value === "")
+        throw new Error("terminal.attach input frame data must be a non-empty string");
+    return value;
+}
+function optionalString(record, key, label) {
+    const value = record[key];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string")
+        throw new Error(`${label} ${key} must be a string`);
+    return value;
+}
+function stringRecord(value, label) {
+    const record = requireObject(value, label);
+    return Object.fromEntries(Object.entries(record).map(([key, child]) => {
+        if (typeof child !== "string")
+            throw new Error(`${label} ${key} must be a string`);
+        return [key, child];
+    }));
+}
+function requireArray(value, label) {
+    if (!isJsonArray(value))
+        throw new Error(`${label} must be an array`);
+    return value;
+}
+function isJsonArray(value) {
+    return Array.isArray(value);
+}
+function parseCommandRunStatus(value) {
+    if (value === "queued" || value === "running" || value === "succeeded" || value === "failed")
+        return value;
+    throw new Error(`Invalid Terminal command run status: ${JSON.stringify(value)}`);
+}
+export function terminalOutputFrames(value, replay) {
+    const emptyFrame = terminalOutputFrame("", replay, false);
+    const emptyFrameBytes = Buffer.byteLength(JSON.stringify(emptyFrame), "utf8");
+    const chunks = [];
+    let chunk = "";
+    let encodedBytes = emptyFrameBytes;
+    for (const character of value) {
+        // JSON escaping can expand control characters well beyond their raw UTF-8
+        // size, so budget the serialized representation rather than the PTY text.
+        const characterBytes = Buffer.byteLength(JSON.stringify(character), "utf8") - 2;
+        if (encodedBytes + characterBytes > TERMINAL_CHANNEL_OUTPUT_FRAME_TARGET_BYTES && chunk !== "") {
+            chunks.push(chunk);
+            chunk = "";
+            encodedBytes = emptyFrameBytes;
+        }
+        chunk += character;
+        encodedBytes += characterBytes;
+    }
+    if (chunk !== "" || value === "")
+        chunks.push(chunk);
+    return chunks.map((data, index) => terminalOutputFrame(data, replay, index === chunks.length - 1));
+}
+function terminalOutputFrame(data, replay, replayComplete) {
+    return replay
+        ? { type: "output", data, replay: true, replayComplete }
+        : { type: "output", data, replay: false };
+}
+function throwIfAborted(signal) {
+    if (!signal.aborted)
+        return;
+    const reason = signal.reason;
+    throw reason instanceof Error ? reason : new Error("Terminal operation was cancelled", { cause: reason });
+}
+function boundedErrorMessage(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.length <= 1_024 ? message : `${message.slice(0, 1_021)}...`;
+}