@chainingintention/pi-web-cn 2.202610.5 → 2.202611.1

package/dist/pi-web-plugins/terminal/bunPtyProvider.js

@@ -0,0 +1,109 @@
+// Generated from pi-web-plugins/terminal/server/bunPtyProvider.ts. Do not edit directly.
+function isBunPtyRuntime(value) {
+    return typeof value === "object" && value !== null
+        && typeof Reflect.get(value, "Terminal") === "function"
+        && typeof Reflect.get(value, "spawn") === "function";
+}
+export function inspectBunPtyCapability() {
+    return isBunPtyRuntime(Reflect.get(globalThis, "Bun"))
+        ? { supported: true }
+        : { supported: false, reason: "Bun native Terminal and spawn APIs are required; upgrade Bun to use terminals" };
+}
+function requireBunPtyRuntime(runtime) {
+    if (!isBunPtyRuntime(runtime)) {
+        throw new Error("Bun native Terminal and spawn APIs are required; upgrade Bun to use terminals (node-pty fallback is not supported)");
+    }
+    return runtime;
+}
+export function createBunPtyProvider(api = Reflect.get(globalThis, "Bun")) {
+    const runtime = requireBunPtyRuntime(api);
+    return {
+        kind: "bun",
+        spawn(options, handlers) {
+            let disposed = false;
+            let completed = false;
+            let processExited = false;
+            let streamClosed = false;
+            let exitCode;
+            const decoder = new TextDecoder();
+            let terminal;
+            let terminalReleased = false;
+            const closeTerminal = () => {
+                if (terminal === undefined || terminalReleased)
+                    return;
+                terminalReleased = true;
+                terminal.close();
+            };
+            const finish = () => {
+                if (disposed || completed || !processExited || !streamClosed)
+                    return;
+                completed = true;
+                const tail = decoder.decode();
+                try {
+                    if (tail !== "")
+                        handlers.output(tail);
+                }
+                finally {
+                    // The process exit code and PTY EOF are separate events in Bun.
+                    // Close only after EOF so queued final output is not truncated.
+                    closeTerminal();
+                }
+                handlers.exit(exitCode);
+            };
+            // Inline terminal options give the child a controlling terminal/session.
+            // A pre-created reusable Bun.Terminal can keep its slave open past child exit.
+            let child;
+            try {
+                child = runtime.spawn([options.shell, ...options.args], {
+                    cwd: options.cwd,
+                    env: options.env,
+                    terminal: {
+                        name: "xterm-256color", cols: options.cols, rows: options.rows,
+                        data(handle, data) {
+                            terminal = handle;
+                            if (disposed || completed || streamClosed)
+                                return;
+                            const text = decoder.decode(data, { stream: true });
+                            if (text !== "")
+                                handlers.output(text);
+                        },
+                        exit(handle) {
+                            terminal = handle;
+                            streamClosed = true;
+                            finish();
+                        },
+                    },
+                    onExit(_child, code) {
+                        processExited = true;
+                        exitCode = code ?? undefined;
+                        finish();
+                    },
+                });
+            }
+            catch (error) {
+                disposed = true;
+                closeTerminal();
+                throw error;
+            }
+            terminal = child.terminal;
+            return {
+                write(data) { if (!disposed && !completed && !processExited)
+                    child.terminal.write(data); },
+                resize(cols, rows) { if (!disposed && !completed && !processExited)
+                    child.terminal.resize(cols, rows); },
+                dispose() {
+                    if (disposed)
+                        return;
+                    disposed = true;
+                    try {
+                        if (!processExited)
+                            child.kill("SIGKILL");
+                    }
+                    finally {
+                        closeTerminal();
+                    }
+                },
+            };
+        },
+    };
+}

package/dist/pi-web-plugins/terminal/nodePtyProvider.js

@@ -0,0 +1,75 @@
+// Generated from pi-web-plugins/terminal/server/nodePtyProvider.ts. Do not edit directly.
+import { createRequire } from "node:module";
+import { ensureNodePtySpawnHelper } from "./nodePtySpawnHelper.js";
+function loadNodePty() {
+    const require = createRequire(import.meta.url);
+    const loaded = require("node-pty");
+    if (!isNodePtyModule(loaded)) {
+        throw new Error("node-pty does not expose spawn()");
+    }
+    ensureNodePtySpawnHelper(require);
+    return loaded;
+}
+function isNodePtyModule(value) {
+    return typeof value === "object" && value !== null && typeof Reflect.get(value, "spawn") === "function";
+}
+export function inspectNodePtyCapability() {
+    try {
+        loadNodePty();
+        return { supported: true };
+    }
+    catch (error) {
+        return { supported: false, reason: error instanceof Error ? error.message : String(error) };
+    }
+}
+/** Native loading happens only on spawn or explicit inspection, never on import. */
+export function createNodePtyProvider(load = loadNodePty) {
+    return {
+        kind: "node",
+        spawn(options, handlers) {
+            let module;
+            try {
+                module = load();
+            }
+            catch (cause) {
+                const detail = cause instanceof Error ? cause.message : String(cause);
+                throw new Error(`Terminal PTY unavailable: ${detail}`, { cause });
+            }
+            const child = module.spawn(options.shell, options.args, {
+                name: "xterm-256color", cwd: options.cwd, cols: options.cols, rows: options.rows, env: options.env,
+            });
+            let disposed = false;
+            const state = { exited: false };
+            const dataSubscription = child.onData((data) => {
+                if (!disposed && !state.exited)
+                    handlers.output(data);
+            });
+            state.exitSubscription = child.onExit(({ exitCode }) => {
+                if (disposed || state.exited)
+                    return;
+                state.exited = true;
+                dataSubscription.dispose();
+                state.exitSubscription?.dispose();
+                // node-pty closes its master before publishing onExit.
+                handlers.exit(exitCode);
+            });
+            if (state.exited)
+                state.exitSubscription.dispose();
+            return {
+                write(data) { if (!disposed && !state.exited)
+                    child.write(data); },
+                resize(cols, rows) { if (!disposed && !state.exited)
+                    child.resize(cols, rows); },
+                dispose() {
+                    if (disposed)
+                        return;
+                    disposed = true;
+                    dataSubscription.dispose();
+                    state.exitSubscription?.dispose();
+                    if (!state.exited)
+                        child.kill();
+                },
+            };
+        },
+    };
+}

package/dist/pi-web-plugins/terminal/nodePtySpawnHelper.js

@@ -0,0 +1,36 @@
+// Generated from pi-web-plugins/terminal/server/nodePtySpawnHelper.ts. Do not edit directly.
+import { accessSync, chmodSync, constants, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+/** Match node-pty's native-module search, including fallback after a broken build. */
+export function ensureNodePtySpawnHelper(require, platform = process.platform, arch = process.arch) {
+    if (platform !== "darwin")
+        return;
+    const root = dirname(require.resolve("node-pty/package.json"));
+    for (const directory of ["build/Release", "build/Debug", `prebuilds/${platform}-${arch}`]) {
+        for (const base of [root, join(root, "lib")]) {
+            const nativePath = join(base, directory, "pty.node");
+            try {
+                require(nativePath);
+            }
+            catch {
+                continue;
+            }
+            const helperPath = join(base, directory, "spawn-helper");
+            try {
+                const stat = statSync(helperPath);
+                if (!stat.isFile())
+                    throw new Error("not a regular file");
+                // node-pty 1.1.0 ships macOS helpers as 0644. Preserve other mode bits.
+                if ((stat.mode & 0o111) === 0)
+                    chmodSync(helperPath, stat.mode | 0o111);
+                accessSync(helperPath, constants.X_OK);
+            }
+            catch (cause) {
+                const detail = cause instanceof Error ? cause.message : String(cause);
+                throw new Error(`Terminal helper is not executable: ${helperPath}: ${detail}. Run chmod +x '${helperPath.replaceAll("'", "'\\''")}' and retry.`, { cause });
+            }
+            return;
+        }
+    }
+    throw new Error(`Could not locate node-pty's native module under ${root}`);
+}

package/dist/pi-web-plugins/terminal/ptyComposition.js

@@ -0,0 +1,12 @@
+// Generated from pi-web-plugins/terminal/server/ptyComposition.ts. Do not edit directly.
+import { createBunPtyProvider, inspectBunPtyCapability } from "./bunPtyProvider.js";
+import { createNodePtyProvider, inspectNodePtyCapability } from "./nodePtyProvider.js";
+/** Startup prerequisite probe using the selected provider's APIs/loaders. Never activates the service or allocates a PTY. */
+export function inspectPtyProvider() {
+    if (process.versions["bun"] === undefined)
+        return { kind: "node", ...inspectNodePtyCapability() };
+    return { kind: "bun", ...inspectBunPtyCapability() };
+}
+export function createDefaultPtyProvider() {
+    return process.versions["bun"] === undefined ? createNodePtyProvider() : createBunPtyProvider();
+}

package/dist/pi-web-plugins/terminal/ptyProvider.js

@@ -0,0 +1,2 @@
+// Generated from pi-web-plugins/terminal/server/ptyProvider.ts. Do not edit directly.
+export {};

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

@@ -1,6 +1,7 @@
 // Generated from pi-web-plugins/terminal/server/server-plugin.ts. Do not edit directly.
 import { t, setTranslator } from "./i18n.js";
-import { TerminalService, } from "./terminalService.js";
+import { TerminalService, snapshotMaintenanceExecutionContext, } from "./terminalService.js";
+import { createDefaultPtyProvider } from "./ptyComposition.js";
 const TERMINAL_CHANNEL_OUTPUT_FRAME_TARGET_BYTES = 60 * 1024;
 export const TERMINAL_SERVICE_CAPABILITY = Object.freeze({
     pluginId: "pi-web.terminal",
@@ -8,9 +9,17 @@ export const TERMINAL_SERVICE_CAPABILITY = Object.freeze({
     version: 1,
     parse: snapshotTerminalServiceCapability,
 });
+/** Private host composition capability; never derived from plugin dataDirectory. */
+export const MAINTENANCE_TERMINAL_CAPABILITY = Object.freeze({
+    pluginId: "pi-web.host",
+    id: "terminal-maintenance",
+    version: 1,
+    parse: snapshotMaintenanceExecutionContext,
+});
 const plugin = {
-    apiVersion: 3,
-    name: t("client.panels.terminal.e2a76e", "Terminal"),
+    apiVersion: 5,
+    requires: [MAINTENANCE_TERMINAL_CAPABILITY],
+    name: "Terminal",
     activate(context) {
         return activateTerminalPlugin(context);
     },
@@ -25,7 +34,7 @@ export function activateTerminalPlugin(context) {
     if (notices?.version !== 1) {
         throw new Error(t("ui.main.1bf6de0c1567", "Terminal server entry requires server notice reporter version 1"));
     }
-    const service = new TerminalService((input) => { notices.record(input); });
+    const service = new TerminalService(createDefaultPtyProvider(), (input) => { notices.record(input); });
     const requiredTerminalService = Object.freeze({
         closeForCwd: (cwd) => { service.closeForCwd(cwd); },
         runCommand: (options) => service.runCommand(options),
@@ -38,6 +47,9 @@ export function activateTerminalPlugin(context) {
     let stopped = false;
     return Object.freeze({
         peer: createTerminalPeer(service, context),
+        start: ({ capabilities }) => {
+            service.bindMaintenanceExecutionContext(capabilities.resolve(MAINTENANCE_TERMINAL_CAPABILITY));
+        },
         provides: Object.freeze([serviceProvision]),
         health: () => stopped
             ? Object.freeze({ status: "unhealthy", message: t("ui.main.ee0fa7cb477f", "Terminal service is stopped") })
@@ -75,12 +87,14 @@ export function createTerminalPeer(service, activationContext) {
 }
 function terminalRequest(service, context) {
     throwIfAborted(context.signal);
-    const scope = terminalScope(context);
+    const scope = terminalScope(service, context);
     switch (context.operation) {
         case "terminal.list":
             requireNullishInput(context.input, context.operation);
             return service.list(scope).map(terminalInfoJson);
         case "terminal.create": {
+            if (scope.scope === "maintenance")
+                throw new Error("New terminals require a workspace. Maintenance terminals start from actions such as Update.");
             const input = requireObject(context.input, context.operation);
             return terminalInfoJson(service.create({
                 ...scope,
@@ -117,7 +131,7 @@ function openTerminalChannel(service, context, activationContext) {
         throw new Error(t("ui.main.745a3a62852f", "Unsupported terminal channel operation: {arg0}", { arg0: context.operation }));
     }
     throwIfAborted(context.signal);
-    const scope = terminalScope(context);
+    const scope = terminalScope(service, context);
     const input = requireObject(context.input, context.operation);
     const terminalId = requireString(input, "terminalId", context.operation);
     const size = optionalTerminalSize(input);
@@ -187,14 +201,20 @@ function openTerminalChannel(service, context, activationContext) {
         },
     });
 }
-function terminalScope(context) {
-    if (context.workspace.projectId !== context.project.id) {
-        throw new Error(t("ui.main.0e2bca4bb08e", "Terminal workspace project scope does not match the host project"));
+function terminalScope(service, context) {
+    const scope = context.scope;
+    if (scope.kind === "machine")
+        return service.maintenanceScope();
+    if (scope.kind !== "workspace")
+        throw new Error("Terminal requires machine or workspace scope");
+    if (scope.workspace.projectId !== scope.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,
+        scope: "workspace",
+        projectId: scope.project.id,
+        workspaceId: scope.workspace.id,
+        cwd: scope.workspace.path,
     });
 }
 function parseRunCommand(scope, input) {
@@ -223,8 +243,11 @@ function parseCommandRunFilter(input) {
 function terminalInfoJson(info) {
     return {
         id: info.id,
+        ...scopeJson(info),
         cwd: info.cwd,
         name: info.name,
+        ...(info.titlePresentation === undefined ? {} : { titlePresentation: { ...info.titlePresentation } }),
+        ...(info.defaultShellNumber === undefined ? {} : { defaultShellNumber: info.defaultShellNumber }),
         createdAt: info.createdAt,
         exited: info.exited,
         ...(info.exitCode === undefined ? {} : { exitCode: info.exitCode }),
@@ -235,10 +258,10 @@ function commandRunJson(run) {
     return {
         id: run.id,
         origin: run.origin,
-        projectId: run.projectId,
-        workspaceId: run.workspaceId,
+        ...scopeJson(run),
         terminalId: run.terminalId,
         title: run.title,
+        ...(run.titlePresentation === undefined ? {} : { titlePresentation: { ...run.titlePresentation } }),
         command: run.command,
         status: run.status,
         ...(run.exitCode === undefined ? {} : { exitCode: run.exitCode }),
@@ -248,6 +271,11 @@ function commandRunJson(run) {
         metadata: { ...run.metadata },
     };
 }
+function scopeJson(value) {
+    return value.scope === "maintenance"
+        ? { scope: "maintenance" }
+        : { ...(value.scope === undefined ? {} : { scope: "workspace" }), projectId: value.projectId, workspaceId: value.workspaceId };
+}
 function optionalTerminalName(input) {
     const name = optionalString(input, "name", "terminal.create");
     return name === undefined ? {} : { name };