@chainingintention/pi-web-cn 2.202610.4 → 2.202611.1

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

@@ -1,20 +1,63 @@
 // 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";
+import { mkdirSync, existsSync } from "node:fs";
+import { t } from "./i18n.js";
+import { isAbsolute } from "node:path";
 const MAX_REPLAY_BUFFER = 200_000;
+/** Validate the private host boundary without interpreting host configuration. */
+export function snapshotMaintenanceExecutionContext(value) {
+    if (typeof value !== "object" || value === null)
+        throw new Error("Terminal maintenance execution context is required");
+    const cwd = Reflect.get(value, "cwd");
+    const env = Reflect.get(value, "env");
+    if (typeof cwd !== "string" || !isAbsolute(cwd))
+        throw new Error("Terminal maintenance cwd must be absolute");
+    if (!isRecord(env))
+        throw new Error("Terminal maintenance env is required");
+    const snapshot = {};
+    for (const [key, entry] of Object.entries(env)) {
+        if (entry !== undefined && typeof entry !== "string")
+            throw new Error("Terminal maintenance env must contain only strings or undefined");
+        Object.defineProperty(snapshot, key, { value: entry, enumerable: true });
+    }
+    return Object.freeze({ cwd, env: Object.freeze(snapshot) });
+}
 export class TerminalService {
+    provider;
     recordNotice;
-    spawnPty;
     terminals = new Map();
     commandRuns = new Map();
     activitySink;
     disposed = false;
-    constructor(recordNotice, spawnPty = pty.spawn) {
+    maintenanceExecutionContext;
+    constructor(provider, recordNotice) {
+        this.provider = provider;
         this.recordNotice = recordNotice;
-        this.spawnPty = spawnPty;
+    }
+    bindMaintenanceExecutionContext(context) {
+        if (this.maintenanceExecutionContext !== undefined)
+            throw new Error("Terminal maintenance execution context is already bound");
+        this.maintenanceExecutionContext = snapshotMaintenanceExecutionContext(context);
+    }
+    maintenanceScope() {
+        return { scope: "maintenance", cwd: this.requireMaintenanceExecutionContext().cwd };
+    }
+    requireMaintenanceExecutionContext() {
+        if (this.maintenanceExecutionContext === undefined)
+            throw new Error("Terminal maintenance directory is unavailable");
+        return this.maintenanceExecutionContext;
+    }
+    executionEnvironment(scope) {
+        const env = scope.scope === "maintenance" ? this.requireMaintenanceExecutionContext().env : process.env;
+        return { ...env, TERM: "xterm-256color", PI_WEB_TERMINAL: "1" };
+    }
+    prepareCwd(scope) {
+        if (scope.scope !== "maintenance")
+            return;
+        if (scope.cwd !== this.requireMaintenanceExecutionContext().cwd)
+            throw new Error("Invalid Terminal maintenance directory");
+        mkdirSync(scope.cwd, { recursive: true });
     }
     bindActivitySink(sink) {
         if (this.activitySink !== undefined)
@@ -36,7 +79,7 @@ export class TerminalService {
     }
     create(options) {
         validateScope(options);
-        const shell = interactiveShell();
+        const shell = interactiveShell(this.executionEnvironment(options));
         return this.createTerminal({ ...options, shell, shellArgs: interactiveShellArgs(shell) });
     }
     runCommand(options) {
@@ -53,10 +96,10 @@ export class TerminalService {
         const queued = {
             id: commandRunId,
             origin: options.origin,
-            projectId: options.projectId,
-            workspaceId: options.workspaceId,
+            ...terminalIdentity(options),
             terminalId,
             title: options.title,
+            ...terminalTitlePresentationField(options.titlePresentation),
             command: options.command,
             status: "queued",
             createdAt,
@@ -67,14 +110,14 @@ export class TerminalService {
         try {
             this.createTerminal({
                 id: terminalId,
-                projectId: options.projectId,
-                workspaceId: options.workspaceId,
+                ...terminalIdentity(options),
                 cwd: options.cwd,
                 name: options.title,
+                ...terminalTitlePresentationField(options.titlePresentation),
                 ...(options.cols === undefined ? {} : { cols: options.cols }),
                 ...(options.rows === undefined ? {} : { rows: options.rows }),
                 shellArgs: ["-lc", commandRunShellScript(options.command)],
-                shell: commandRunShell(),
+                shell: commandRunShell(this.executionEnvironment(options)),
                 commandRunId,
                 ...(failureNotice === undefined ? {} : { failureNotice }),
             });
@@ -92,7 +135,7 @@ export class TerminalService {
     }
     listCommandRunsForScope(scope, filter = {}) {
         validateScope(scope);
-        return this.listCommandRuns({ ...filter, projectId: scope.projectId, workspaceId: scope.workspaceId });
+        return this.listCommandRuns(filter).filter((run) => matchesIdentity(run, scope));
     }
     getCommandRun(runId) {
         const run = this.commandRuns.get(runId);
@@ -101,7 +144,7 @@ export class TerminalService {
     getCommandRunForScope(scope, runId) {
         validateScope(scope);
         const run = this.commandRuns.get(runId);
-        return run?.projectId === scope.projectId && run.workspaceId === scope.workspaceId
+        return run !== undefined && matchesIdentity(run, scope)
             ? copyCommandRun(run)
             : undefined;
     }
@@ -143,33 +186,48 @@ export class TerminalService {
     write(scope, id, data) {
         const terminal = this.requireScoped(scope, id);
         if (!terminal.exited)
-            terminal.pty.write(data);
+            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));
+            terminal.pty?.resize(Math.floor(cols), Math.floor(rows));
         }
     }
     continue(scope, id) {
+        this.requireAvailable();
         const record = this.requireScoped(scope, id);
+        this.prepareCwd(record);
         if (!record.exited)
             return toInfo(record);
+        const previousExitCode = record.exitCode;
+        const previousCommandRunId = record.commandRunId;
+        const previousFailureNotice = record.failureNotice;
         delete record.exitCode;
         delete record.commandRunId;
+        delete record.failureNotice;
         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 shell = interactiveShell(this.executionEnvironment(record));
+        const previousShell = record.shell;
+        record.shell = shell;
+        delete record.cancellationRequested;
+        try {
+            this.spawnPty(record, interactiveShellArgs(shell), 100, 30, "\r\n[continued in interactive shell]\r\n");
+        }
+        catch (error) {
+            record.exited = true;
+            if (previousExitCode !== undefined)
+                record.exitCode = previousExitCode;
+            if (previousCommandRunId !== undefined)
+                record.commandRunId = previousCommandRunId;
+            if (previousFailureNotice !== undefined)
+                record.failureNotice = previousFailureNotice;
+            if (previousShell === undefined)
+                delete record.shell;
+            else
+                record.shell = previousShell;
+            throw error;
+        }
         const info = toInfo(record);
         this.activitySink?.updateTerminal(info);
         return info;
@@ -193,58 +251,104 @@ export class TerminalService {
         if (this.disposed)
             return;
         this.disposed = true;
-        for (const terminal of [...this.terminals.values()])
-            this.closeRecord(terminal);
+        const errors = [];
+        for (const terminal of [...this.terminals.values()]) {
+            try {
+                this.closeRecord(terminal);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (errors.length > 0)
+            throw new AggregateError(errors, "Failed to dispose terminal PTYs");
     }
     createTerminal(options) {
         this.requireAvailable();
         validateScope(options);
+        this.prepareCwd(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 defaultShellNumber = requestedName === undefined || requestedName === "" ? this.list(options).length + 1 : undefined;
         const record = {
             id,
-            projectId: options.projectId,
-            workspaceId: options.workspaceId,
+            ...terminalIdentity(options),
             cwd: options.cwd,
-            name: requestedName !== undefined && requestedName !== "" ? requestedName : `Shell ${String(this.list(options).length + 1)}`,
+            ...(options.shell === undefined ? {} : { shell: options.shell }),
+            name: defaultShellNumber === undefined ? requestedName ?? "" : `Shell ${String(defaultShellNumber)}`,
+            ...(defaultShellNumber === undefined ? {} : { defaultShellNumber }),
+            ...terminalTitlePresentationField(options.titlePresentation),
             createdAt,
             exited: false,
-            pty: terminal,
+            generation: 0,
             buffer: "",
             events: new EventEmitter(),
             ...(options.commandRunId === undefined ? {} : { commandRunId: options.commandRunId }),
             ...(options.failureNotice === undefined ? {} : { failureNotice: options.failureNotice }),
         };
-        this.attachPtyEvents(record);
         this.terminals.set(id, record);
+        try {
+            this.spawnPty(record, options.shellArgs, options.cols ?? 100, options.rows ?? 30);
+        }
+        catch (error) {
+            this.terminals.delete(id);
+            throw error;
+        }
         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);
+    spawnPty(record, args, cols, rows, marker = "") {
+        const generation = ++record.generation;
+        // Stage synchronous spawn callbacks until the handle and continuation marker are installed.
+        const pending = [];
+        let ready = false;
+        const deliver = (callback) => {
+            if (!ready)
+                pending.push(callback);
+            else
+                callback();
+        };
+        const current = () => this.terminals.get(record.id) === record
+            && record.generation === generation && !record.exited;
+        const env = this.executionEnvironment(record);
+        const handle = this.provider.spawn({
+            shell: record.shell ?? interactiveShell(env), args, cwd: record.cwd, cols, rows, env,
+        }, {
+            output: (data) => {
+                deliver(() => {
+                    if (!current())
+                        return;
+                    record.buffer = trimReplayBuffer(record.buffer + data);
+                    record.events.emit("output", data);
+                });
+            },
+            exit: (exitCode) => {
+                deliver(() => {
+                    if (!current())
+                        return;
+                    record.exited = true;
+                    if (exitCode !== undefined)
+                        record.exitCode = exitCode;
+                    record.pty?.dispose();
+                    delete record.pty;
+                    this.completeCommandRun(record.commandRunId, exitCode, record.failureNotice, record.cancellationRequested === true);
+                    record.events.emit("exit", exitCode);
+                    this.activitySink?.updateTerminal(toInfo(record));
+                });
+            },
         });
+        record.pty = handle;
+        if (marker !== "") {
+            record.buffer = trimReplayBuffer(record.buffer + marker);
+            record.events.emit("output", marker);
+        }
+        ready = true;
+        for (const callback of pending)
+            callback();
     }
-    completeCommandRun(runId, exitCode, failureNotice, cancelled) {
+    completeCommandRun(runId, exitCode, failureNotice, cancelled = false) {
         if (runId === undefined)
             return;
         const run = this.commandRuns.get(runId);
@@ -261,7 +365,8 @@ export class TerminalService {
             this.recordNotice?.({
                 severity: "error",
                 message: failureNotice.message,
-                scope: { projectId: completed.projectId },
+                ...(failureNotice.presentation === undefined ? {} : { presentation: failureNotice.presentation }),
+                ...(completed.scope === "maintenance" ? {} : { scope: { projectId: completed.projectId } }),
                 context: { ...failureNotice.context, commandRunId: completed.id },
             });
         }
@@ -289,7 +394,7 @@ export class TerminalService {
         if (!terminal.exited && terminal.cancellationRequested !== true) {
             terminal.cancellationRequested = true;
             try {
-                terminal.pty.write("\x03");
+                terminal.pty?.write("\x03");
             }
             catch (error) {
                 terminal.cancellationRequested = false;
@@ -301,11 +406,18 @@ export class TerminalService {
     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();
+        // Closing is final even if a provider never publishes an exit after disposal.
+        terminal.generation += 1;
+        this.completeCommandRun(terminal.commandRunId, undefined, undefined);
+        try {
+            terminal.pty?.dispose();
+        }
+        finally {
+            delete terminal.pty;
+            terminal.events.emit("closed");
+            terminal.events.removeAllListeners();
+            this.activitySink?.removeTerminal(terminal.id, terminal.cwd);
+        }
     }
     requireAvailable() {
         if (this.disposed)
@@ -315,9 +427,11 @@ export class TerminalService {
 function toInfo(record) {
     return {
         id: record.id,
+        ...terminalIdentity(record),
         cwd: record.cwd,
         name: record.name,
-        createdAt: record.createdAt,
+        ...terminalTitlePresentationField(record.titlePresentation),
+        ...(record.defaultShellNumber === undefined ? {} : { defaultShellNumber: record.defaultShellNumber }), createdAt: record.createdAt,
         exited: record.exited,
         ...(record.exitCode === undefined ? {} : { exitCode: record.exitCode }),
         ...(record.commandRunId === undefined ? {} : { commandRunId: record.commandRunId }),
@@ -333,9 +447,6 @@ export function interactiveShellArgs(shell) {
     // 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 !== "")
@@ -364,17 +475,33 @@ 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.scope === "maintenance") {
+        if (scope.projectId !== undefined || scope.workspaceId !== undefined)
+            throw new Error("Maintenance scope cannot include workspace ids");
+    }
+    else {
+        if (scope.scope !== undefined && scope.scope !== "workspace")
+            throw new Error("Invalid Terminal scope");
+        if (typeof scope.projectId !== "string" || scope.projectId.trim() === "")
+            throw new Error("projectId is required");
+        if (typeof scope.workspaceId !== "string" || scope.workspaceId.trim() === "")
+            throw new Error("workspaceId is required");
+    }
     if (scope.cwd.trim() === "")
-        throw new Error(t("ui.main.3554e67956ef", "cwd is required"));
+        throw new Error("cwd is required");
+}
+function terminalIdentity(scope) {
+    return scope.scope === "maintenance"
+        ? { scope: "maintenance" }
+        : { ...(scope.scope === undefined ? {} : { scope: "workspace" }), projectId: scope.projectId, workspaceId: scope.workspaceId };
+}
+function matchesIdentity(record, scope) {
+    if (record.scope === "maintenance" || scope.scope === "maintenance")
+        return record.scope === scope.scope;
+    return record.projectId === scope.projectId && record.workspaceId === scope.workspaceId;
 }
 function matchesScope(record, scope) {
-    return record.projectId === scope.projectId
-        && record.workspaceId === scope.workspaceId
-        && record.cwd === scope.cwd;
+    return matchesIdentity(record, scope) && record.cwd === scope.cwd;
 }
 function validateCommandRunOptions(options) {
     validateScope(options);
@@ -408,7 +535,12 @@ function parseFailureNotice(value) {
     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 }) });
+    return Object.freeze({
+        message: value.message,
+        context: Object.freeze({ ...value.context }),
+        ...(value.presentation?.kind === "workspaceRemovalCommandFailed"
+            ? { presentation: Object.freeze({ kind: "workspaceRemovalCommandFailed" }) } : {}),
+    });
 }
 function matchesCommandRunFilter(run, filter) {
     if (filter.projectId !== undefined && run.projectId !== filter.projectId)
@@ -428,6 +560,16 @@ function matchesCommandRunFilter(run, filter) {
 function isTerminalCommandRunFinal(status) {
     return status === "succeeded" || status === "failed";
 }
+// This server entry is shipped as a self-contained transpiled graph, not bundled
+// with core. Validate its private input locally; only the public type is imported.
+function terminalTitlePresentationField(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return {};
+    const kind = Reflect.get(value, "kind");
+    const label = Reflect.get(value, "label");
+    return kind === "workspaceRemoval" && typeof label === "string" && label.length <= 4096
+        ? { titlePresentation: Object.freeze({ kind, label }) } : {};
+}
 function copyCommandRun(run) {
     return { ...run, metadata: { ...run.metadata } };
 }

package/dist/pi-web-plugins/themes/assets/graphite.css

@@ -0,0 +1,56 @@
+:root {
+  --codex-sidebar-bg: #1d2120;
+  --codex-sidebar-hover: #303432;
+  --pi-font: system-ui, sans-serif;
+  --pi-mono: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  --pi-thinking: var(--pi-muted);
+  --pi-tool: var(--pi-muted);
+  --pi-syntax-comment: var(--pi-muted);
+  --pi-syntax-keyword: var(--pi-text);
+  --pi-syntax-string: var(--pi-text-secondary);
+  --pi-syntax-number: var(--pi-text-secondary);
+  --pi-syntax-title: var(--pi-text);
+  --pi-syntax-deletion: var(--pi-danger);
+  --pi-chat-conversation-bg: var(--pi-bg);
+  --pi-chat-conversation-border: var(--pi-border-muted);
+  --pi-chat-user-bg: var(--pi-surface);
+  --pi-chat-user-border: var(--pi-muted);
+  --pi-chat-system-bg: var(--pi-surface);
+  --pi-chat-activity-bg: var(--pi-surface);
+  --pi-chat-compacting-bg: var(--pi-surface);
+  --pi-bg: #191b1a;
+  --pi-surface: #222222;
+  --pi-surface-hover: #303030;
+  --pi-terminal-bg: #181818;
+  --pi-terminal-text: #e8e8e8;
+  --pi-border: #555555;
+  --pi-border-muted: #343936;
+  --pi-text: #e8e8e8;
+  --pi-text-secondary: #bcbcbc;
+  --pi-text-bright: #ffffff;
+  --pi-muted: #aaaaaa;
+  --pi-dim: #929292;
+  --pi-accent: #dedede;
+  --pi-accent-border: #aaaaaa;
+  --pi-selection-bg: #303030;
+  --pi-success: #8cbd9b;
+  --pi-success-border: #8cbd9b;
+  --pi-success-bg: #1c241e;
+  --pi-success-surface: #242e26;
+  --pi-success-ring: #8cbd9b55;
+  --pi-warning: #d1b571;
+  --pi-warning-border: #d1b571;
+  --pi-warning-surface: #2d281e;
+  --pi-danger: #e58f8f;
+  --pi-purple: var(--pi-text-secondary);
+  --pi-purple-border: var(--pi-border);
+  --pi-purple-surface: var(--pi-surface);
+  --pi-overlay: #00000088;
+  --pi-shadow-soft: #00000044;
+  --pi-shadow: #00000066;
+  --pi-shadow-strong: #00000088;
+  --pi-bg-overlay-soft: #181818dd;
+  --pi-bg-overlay: #181818e6;
+  --pi-success-bg-overlay: #1c241eee;
+  --pi-terminal-selection: #484848;
+}

package/dist/pi-web-plugins/themes/assets/paper.css

@@ -0,0 +1,56 @@
+:root {
+  --codex-sidebar-bg: #eef7f5;
+  --codex-sidebar-hover: #dfe8e5;
+  --pi-font: system-ui, sans-serif;
+  --pi-mono: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  --pi-thinking: var(--pi-muted);
+  --pi-tool: var(--pi-muted);
+  --pi-syntax-comment: var(--pi-muted);
+  --pi-syntax-keyword: var(--pi-text);
+  --pi-syntax-string: var(--pi-text-secondary);
+  --pi-syntax-number: var(--pi-text-secondary);
+  --pi-syntax-title: var(--pi-text);
+  --pi-syntax-deletion: var(--pi-danger);
+  --pi-chat-conversation-bg: var(--pi-bg);
+  --pi-chat-conversation-border: var(--pi-border-muted);
+  --pi-chat-user-bg: var(--pi-surface);
+  --pi-chat-user-border: var(--pi-muted);
+  --pi-chat-system-bg: var(--pi-surface);
+  --pi-chat-activity-bg: var(--pi-surface);
+  --pi-chat-compacting-bg: var(--pi-surface);
+  --pi-bg: #ffffff;
+  --pi-surface: #f5f5f5;
+  --pi-surface-hover: #eaeaea;
+  --pi-terminal-bg: #ffffff;
+  --pi-terminal-text: #202020;
+  --pi-border: #cbd0ce;
+  --pi-border-muted: #e3e8e6;
+  --pi-text: #272b2a;
+  --pi-text-secondary: #4e5253;
+  --pi-text-bright: #101010;
+  --pi-muted: #626262;
+  --pi-dim: #707070;
+  --pi-accent: #303030;
+  --pi-accent-border: #626262;
+  --pi-selection-bg: #e2eeea;
+  --pi-success: #287044;
+  --pi-success-border: #287044;
+  --pi-success-bg: #f1f6f2;
+  --pi-success-surface: #eaf2ec;
+  --pi-success-ring: #28704455;
+  --pi-warning: #865900;
+  --pi-warning-border: #865900;
+  --pi-warning-surface: #faf5e9;
+  --pi-danger: #b03030;
+  --pi-purple: var(--pi-text-secondary);
+  --pi-purple-border: var(--pi-border);
+  --pi-purple-surface: var(--pi-surface);
+  --pi-overlay: #00000066;
+  --pi-shadow-soft: #00000014;
+  --pi-shadow: #00000022;
+  --pi-shadow-strong: #00000033;
+  --pi-bg-overlay-soft: #ffffffdd;
+  --pi-bg-overlay: #ffffffe6;
+  --pi-success-bg-overlay: #f1f6f2ee;
+  --pi-terminal-selection: #d4d4d4;
+}

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

@@ -0,0 +1,21 @@
+{
+  "name": "@pi-web/themes-plugin",
+  "private": true,
+  "piWeb": {
+    "plugins": [{
+      "id": "themes",
+      "browserRoot": "assets",
+      "themes": [
+        { "id": "pi-web-dark", "name": "PI WEB Dark", "description": "Dark PI WEB palette.", "order": 10, "colorScheme": "dark", "stylesheets": [{ "id": "palette", "path": "pi-web-dark.css" }] },
+        { "id": "pi-web-light", "name": "PI WEB Light", "description": "Light PI WEB palette.", "order": 20, "colorScheme": "light", "stylesheets": [{ "id": "palette", "path": "pi-web-light.css" }] },
+        { "id": "classic", "name": "PI WEB Classic", "description": "The original PI WEB dark palette.", "order": 30, "colorScheme": "dark", "stylesheets": [{ "id": "palette", "path": "classic.css" }] },
+        { "id": "paper", "name": "Paper", "description": "White and neutral grays with restrained status colors.", "order": 40, "colorScheme": "light", "stylesheets": [{ "id": "palette", "path": "paper.css" }] },
+        { "id": "graphite", "name": "Graphite", "description": "Charcoal and neutral grays with restrained status colors.", "order": 50, "colorScheme": "dark", "stylesheets": [{ "id": "palette", "path": "graphite.css" }] }
+      ],
+      "themePairs": [
+        { "id": "pi-web", "name": "PI WEB", "order": 10, "light": "pi-web-light", "dark": "pi-web-dark" },
+        { "id": "paper-graphite", "name": "Paper / Graphite", "order": 20, "light": "paper", "dark": "graphite" }
+      ]
+    }]
+  }
+}