@chainingintention/pi-web-cn 2.0.0 → 2.202610.0

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

@@ -0,0 +1,436 @@
+// Generated from pi-web-plugins/terminal/server/terminalService.ts. Do not edit directly.
+import { t } from "./i18n.js";
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+import { existsSync } from "node:fs";
+import * as pty from "node-pty";
+const MAX_REPLAY_BUFFER = 200_000;
+export class TerminalService {
+    recordNotice;
+    spawnPty;
+    terminals = new Map();
+    commandRuns = new Map();
+    activitySink;
+    disposed = false;
+    constructor(recordNotice, spawnPty = pty.spawn) {
+        this.recordNotice = recordNotice;
+        this.spawnPty = spawnPty;
+    }
+    bindActivitySink(sink) {
+        if (this.activitySink !== undefined)
+            throw new Error(t("ui.main.5d3c64acebaa", "Terminal activity sink is already bound"));
+        this.activitySink = sink;
+    }
+    list(scope) {
+        validateScope(scope);
+        return [...this.terminals.values()]
+            .filter((terminal) => matchesScope(terminal, scope))
+            .map(toInfo);
+    }
+    closeForCwd(cwd) {
+        if (cwd === "")
+            throw new Error(t("ui.main.3554e67956ef", "cwd is required"));
+        for (const terminal of [...this.terminals.values()].filter((candidate) => candidate.cwd === cwd)) {
+            this.closeRecord(terminal);
+        }
+    }
+    create(options) {
+        validateScope(options);
+        const shell = interactiveShell();
+        return this.createTerminal({ ...options, shell, shellArgs: interactiveShellArgs(shell) });
+    }
+    runCommand(options) {
+        validateCommandRunOptions(options);
+        this.requireAvailable();
+        const commandRunId = randomUUID();
+        const terminalId = randomUUID();
+        const createdAt = new Date().toISOString();
+        const metadata = parseMetadata(options.metadata);
+        const failureNotice = parseFailureNotice(options.failureNotice);
+        if (failureNotice !== undefined && this.recordNotice === undefined) {
+            throw new Error(t("ui.main.e4f11dab9de6", "Terminal command failure notices are unavailable"));
+        }
+        const queued = {
+            id: commandRunId,
+            origin: options.origin,
+            projectId: options.projectId,
+            workspaceId: options.workspaceId,
+            terminalId,
+            title: options.title,
+            command: options.command,
+            status: "queued",
+            createdAt,
+            metadata,
+        };
+        const running = { ...queued, status: "running", startedAt: new Date().toISOString() };
+        this.commandRuns.set(commandRunId, running);
+        try {
+            this.createTerminal({
+                id: terminalId,
+                projectId: options.projectId,
+                workspaceId: options.workspaceId,
+                cwd: options.cwd,
+                name: options.title,
+                ...(options.cols === undefined ? {} : { cols: options.cols }),
+                ...(options.rows === undefined ? {} : { rows: options.rows }),
+                shellArgs: ["-lc", commandRunShellScript(options.command)],
+                shell: commandRunShell(),
+                commandRunId,
+                ...(failureNotice === undefined ? {} : { failureNotice }),
+            });
+        }
+        catch (error) {
+            this.commandRuns.delete(commandRunId);
+            throw error;
+        }
+        return copyCommandRun(this.commandRuns.get(commandRunId) ?? running);
+    }
+    listCommandRuns(filter = {}) {
+        return [...this.commandRuns.values()]
+            .filter((run) => matchesCommandRunFilter(run, filter))
+            .map(copyCommandRun);
+    }
+    listCommandRunsForScope(scope, filter = {}) {
+        validateScope(scope);
+        return this.listCommandRuns({ ...filter, projectId: scope.projectId, workspaceId: scope.workspaceId });
+    }
+    getCommandRun(runId) {
+        const run = this.commandRuns.get(runId);
+        return run === undefined ? undefined : copyCommandRun(run);
+    }
+    getCommandRunForScope(scope, runId) {
+        validateScope(scope);
+        const run = this.commandRuns.get(runId);
+        return run?.projectId === scope.projectId && run.workspaceId === scope.workspaceId
+            ? copyCommandRun(run)
+            : undefined;
+    }
+    cancelCommandRun(runId) {
+        return this.cancelCommandRunRecord(this.requireCommandRun(runId));
+    }
+    cancelCommandRunForScope(scope, runId) {
+        const run = this.getCommandRunForScope(scope, runId);
+        if (run === undefined)
+            throw new Error(t("ui.main.3bea6b3edcd2", "Terminal command run not found in this workspace"));
+        return this.cancelCommandRunRecord(this.requireCommandRun(runId));
+    }
+    get(scope, id) {
+        const terminal = this.terminals.get(id);
+        return terminal === undefined || !matchesScope(terminal, scope) ? undefined : toInfo(terminal);
+    }
+    attach(scope, id, handlers) {
+        const terminal = this.requireScoped(scope, id);
+        if (terminal.buffer !== "")
+            handlers.output(terminal.buffer, true);
+        if (terminal.exited)
+            handlers.exit(terminal.exitCode);
+        const onOutput = (data) => { handlers.output(data, false); };
+        const onExit = (exitCode) => { handlers.exit(exitCode); };
+        const onClosed = () => { handlers.closed?.(); };
+        terminal.events.on("output", onOutput);
+        terminal.events.on("exit", onExit);
+        terminal.events.on("closed", onClosed);
+        let detached = false;
+        return () => {
+            if (detached)
+                return;
+            detached = true;
+            terminal.events.off("output", onOutput);
+            terminal.events.off("exit", onExit);
+            terminal.events.off("closed", onClosed);
+        };
+    }
+    write(scope, id, data) {
+        const terminal = this.requireScoped(scope, id);
+        if (!terminal.exited)
+            terminal.pty.write(data);
+    }
+    resize(scope, id, cols, rows) {
+        const terminal = this.requireScoped(scope, id);
+        if (!terminal.exited && Number.isFinite(cols) && Number.isFinite(rows) && cols > 0 && rows > 0) {
+            terminal.pty.resize(Math.floor(cols), Math.floor(rows));
+        }
+    }
+    continue(scope, id) {
+        const record = this.requireScoped(scope, id);
+        if (!record.exited)
+            return toInfo(record);
+        delete record.exitCode;
+        delete record.commandRunId;
+        record.exited = false;
+        const marker = t("ui.main.7e39d66ff416", "\r\n[continued in interactive shell]\r\n");
+        record.buffer = trimReplayBuffer(record.buffer + marker);
+        record.events.emit("output", marker);
+        const shell = interactiveShell();
+        record.pty = this.spawnPty(shell, interactiveShellArgs(shell), {
+            name: "xterm-256color",
+            cwd: record.cwd,
+            cols: 100,
+            rows: 30,
+            env: terminalEnvironment(),
+        });
+        this.attachPtyEvents(record);
+        const info = toInfo(record);
+        this.activitySink?.updateTerminal(info);
+        return info;
+    }
+    closeAll(scope) {
+        validateScope(scope);
+        for (const terminal of [...this.terminals.values()].filter((candidate) => matchesScope(candidate, scope))) {
+            this.closeRecord(terminal);
+        }
+    }
+    close(scope, id) {
+        validateScope(scope);
+        const terminal = this.terminals.get(id);
+        if (terminal === undefined)
+            return;
+        if (!matchesScope(terminal, scope))
+            throw new Error(t("ui.main.002ca07f2de5", "Terminal not found in this workspace"));
+        this.closeRecord(terminal);
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        for (const terminal of [...this.terminals.values()])
+            this.closeRecord(terminal);
+    }
+    createTerminal(options) {
+        this.requireAvailable();
+        validateScope(options);
+        const id = options.id ?? randomUUID();
+        const createdAt = new Date().toISOString();
+        const shell = options.shell ?? interactiveShell();
+        const terminal = this.spawnPty(shell, options.shellArgs, {
+            name: "xterm-256color",
+            cwd: options.cwd,
+            cols: options.cols ?? 100,
+            rows: options.rows ?? 30,
+            env: terminalEnvironment(),
+        });
+        const requestedName = options.name?.trim();
+        const record = {
+            id,
+            projectId: options.projectId,
+            workspaceId: options.workspaceId,
+            cwd: options.cwd,
+            name: requestedName !== undefined && requestedName !== "" ? requestedName : `Shell ${String(this.list(options).length + 1)}`,
+            createdAt,
+            exited: false,
+            pty: terminal,
+            buffer: "",
+            events: new EventEmitter(),
+            ...(options.commandRunId === undefined ? {} : { commandRunId: options.commandRunId }),
+            ...(options.failureNotice === undefined ? {} : { failureNotice: options.failureNotice }),
+        };
+        this.attachPtyEvents(record);
+        this.terminals.set(id, record);
+        const info = toInfo(record);
+        this.activitySink?.updateTerminal(info);
+        return info;
+    }
+    attachPtyEvents(record) {
+        record.pty.onData((data) => {
+            record.buffer = trimReplayBuffer(record.buffer + data);
+            record.events.emit("output", data);
+        });
+        record.pty.onExit(({ exitCode }) => {
+            record.exited = true;
+            record.exitCode = exitCode;
+            this.completeCommandRun(record.commandRunId, exitCode, record.failureNotice, record.cancellationRequested === true);
+            record.events.emit("exit", exitCode);
+            const info = toInfo(record);
+            this.activitySink?.updateTerminal(info);
+        });
+    }
+    completeCommandRun(runId, exitCode, failureNotice, cancelled) {
+        if (runId === undefined)
+            return;
+        const run = this.commandRuns.get(runId);
+        if (run === undefined || isTerminalCommandRunFinal(run.status))
+            return;
+        const completed = {
+            ...run,
+            status: exitCode === 0 && !cancelled ? "succeeded" : "failed",
+            ...(exitCode === undefined ? {} : { exitCode }),
+            completedAt: new Date().toISOString(),
+        };
+        this.commandRuns.set(runId, completed);
+        if (!this.disposed && !cancelled && completed.status === "failed" && failureNotice !== undefined) {
+            this.recordNotice?.({
+                severity: "error",
+                message: failureNotice.message,
+                scope: { projectId: completed.projectId },
+                context: { ...failureNotice.context, commandRunId: completed.id },
+            });
+        }
+    }
+    requireScoped(scope, id) {
+        validateScope(scope);
+        const terminal = this.terminals.get(id);
+        if (terminal === undefined || !matchesScope(terminal, scope)) {
+            throw new Error(t("ui.main.002ca07f2de5", "Terminal not found in this workspace"));
+        }
+        return terminal;
+    }
+    requireCommandRun(runId) {
+        const run = this.commandRuns.get(runId);
+        if (run === undefined)
+            throw new Error(t("ui.shared.ca71fd855ae2", "Terminal command run not found"));
+        return run;
+    }
+    cancelCommandRunRecord(run) {
+        if (isTerminalCommandRunFinal(run.status))
+            return copyCommandRun(run);
+        const terminal = this.terminals.get(run.terminalId);
+        if (terminal === undefined)
+            throw new Error(t("ui.main.970ebf253e68", "Terminal not found"));
+        if (!terminal.exited && terminal.cancellationRequested !== true) {
+            terminal.cancellationRequested = true;
+            try {
+                terminal.pty.write("\x03");
+            }
+            catch (error) {
+                terminal.cancellationRequested = false;
+                throw error;
+            }
+        }
+        return copyCommandRun(run);
+    }
+    closeRecord(terminal) {
+        if (!this.terminals.delete(terminal.id))
+            return;
+        terminal.events.emit("closed");
+        terminal.events.removeAllListeners();
+        this.activitySink?.removeTerminal(terminal.id, terminal.cwd);
+        if (!terminal.exited)
+            terminal.pty.kill();
+    }
+    requireAvailable() {
+        if (this.disposed)
+            throw new Error(t("ui.main.ee0fa7cb477f", "Terminal service is stopped"));
+    }
+}
+function toInfo(record) {
+    return {
+        id: record.id,
+        cwd: record.cwd,
+        name: record.name,
+        createdAt: record.createdAt,
+        exited: record.exited,
+        ...(record.exitCode === undefined ? {} : { exitCode: record.exitCode }),
+        ...(record.commandRunId === undefined ? {} : { commandRunId: record.commandRunId }),
+    };
+}
+function trimReplayBuffer(buffer) {
+    if (buffer.length <= MAX_REPLAY_BUFFER)
+        return buffer;
+    return buffer.slice(buffer.length - MAX_REPLAY_BUFFER);
+}
+export function interactiveShellArgs(shell) {
+    const executable = shell.split(/[\\/]/).at(-1)?.toLowerCase().replace(/^-/, "").replace(/\.exe$/, "");
+    // Preserve the existing invocation for arbitrary SHELL values rather than guessing at an unsupported login flag.
+    return executable === "bash" || executable === "zsh" || executable === "fish" ? ["-l"] : [];
+}
+function terminalEnvironment() {
+    return { ...process.env, TERM: "xterm-256color", PI_WEB_TERMINAL: "1" };
+}
+function interactiveShell(env = process.env) {
+    const shell = env["SHELL"]?.trim();
+    if (shell !== undefined && shell !== "")
+        return shell;
+    return process.platform === "win32" ? "powershell.exe" : "/bin/bash";
+}
+function commandRunShell(env = process.env) {
+    const configured = env["PI_WEB_COMMAND_SHELL"]?.trim();
+    if (configured !== undefined && configured !== "")
+        return configured;
+    const shell = env["SHELL"]?.trim();
+    if (shell !== undefined && shell !== "" && shell.toLowerCase().includes("bash"))
+        return shell;
+    if (process.platform === "win32") {
+        const gitBash = "D:\\Program Files\\Git\\bin\\bash.exe";
+        if (existsSync(gitBash))
+            return gitBash;
+        return "bash";
+    }
+    return shell !== undefined && shell !== "" ? shell : "/bin/bash";
+}
+function commandRunShellScript(command) {
+    return `printf '%s\\n' ${shellQuote(`$ ${command}`)}\n${command}`;
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function validateScope(scope) {
+    if (scope.projectId.trim() === "")
+        throw new Error(t("ui.main.c785a1f6204e", "projectId is required"));
+    if (scope.workspaceId.trim() === "")
+        throw new Error(t("ui.main.9850b858e3ba", "workspaceId is required"));
+    if (scope.cwd.trim() === "")
+        throw new Error(t("ui.main.3554e67956ef", "cwd is required"));
+}
+function matchesScope(record, scope) {
+    return record.projectId === scope.projectId
+        && record.workspaceId === scope.workspaceId
+        && record.cwd === scope.cwd;
+}
+function validateCommandRunOptions(options) {
+    validateScope(options);
+    if (options.origin.trim() === "")
+        throw new Error(t("ui.main.0b08e0eda1a4", "origin is required"));
+    if (options.title.trim() === "")
+        throw new Error(t("ui.main.394f110fbd2e", "title is required"));
+    if (options.command.trim() === "")
+        throw new Error(t("ui.main.f3029405fa76", "command is required"));
+    parseMetadata(options.metadata);
+}
+function parseMetadata(value) {
+    if (value === undefined || value === null)
+        return {};
+    if (!isRecord(value))
+        throw new Error(t("ui.main.8aaf09278346", "metadata must be an object"));
+    return Object.fromEntries(Object.entries(value).map(([key, metadataValue]) => {
+        if (key.trim() === "")
+            throw new Error(t("ui.main.32968c7e6565", "metadata keys must not be empty"));
+        if (typeof metadataValue !== "string")
+            throw new Error(t("ui.main.ca6186d140b2", "metadata values must be strings"));
+        return [key, metadataValue];
+    }));
+}
+function parseFailureNotice(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value.message !== "string" || value.message.trim() === "") {
+        throw new Error(t("ui.main.b63294884798", "failureNotice message must be a non-empty string"));
+    }
+    if (!isRecord(value.context) || !Object.values(value.context).every((item) => typeof item === "string")) {
+        throw new Error(t("ui.main.a38dcafc6669", "failureNotice context must contain only strings"));
+    }
+    return Object.freeze({ message: value.message, context: Object.freeze({ ...value.context }) });
+}
+function matchesCommandRunFilter(run, filter) {
+    if (filter.projectId !== undefined && run.projectId !== filter.projectId)
+        return false;
+    if (filter.workspaceId !== undefined && run.workspaceId !== filter.workspaceId)
+        return false;
+    if (filter.terminalId !== undefined && run.terminalId !== filter.terminalId)
+        return false;
+    if (filter.statuses !== undefined && filter.statuses.length > 0 && !filter.statuses.includes(run.status))
+        return false;
+    for (const [key, value] of Object.entries(filter.metadata ?? {})) {
+        if (run.metadata[key] !== value)
+            return false;
+    }
+    return true;
+}
+function isTerminalCommandRunFinal(status) {
+    return status === "succeeded" || status === "failed";
+}
+function copyCommandRun(run) {
+    return { ...run, metadata: { ...run.metadata } };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/pi-web-plugins/updates/i18n.js

@@ -0,0 +1,7 @@
+// Generated from pi-web-plugins/updates/i18n.ts. Do not edit directly.
+let translate;
+export function setTranslator(value) {
+    translate = value;
+}
+export const t = (key, fallback, params) => translate?.(key, fallback, params)
+    ?? fallback.replace(/\{([A-Za-z0-9_]+)\}/g, (match, name) => String(params?.[name] ?? match));

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

@@ -3,7 +3,7 @@
   "private": true,
   "piWeb": {
     "plugins": [
-      { "id": "updates", "module": "pi-web-plugin.js", "machineSpecific": true }
+      { "id": "updates", "browserRoot": ".", "module": "pi-web-plugin.js", "machineSpecific": true }
     ]
   }
 }