@oversk7/pi-web-dsh-style 0.1.0-alpha.1

package/index.ts

@@ -0,0 +1,177 @@
+import { readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { getPackageDir, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getSupportedThinkingLevels } from "@earendil-works/pi-ai/compat";
+
+interface MaintenanceCommandResult {
+  stdout: string;
+  stderr: string;
+  code: number;
+  killed: boolean;
+}
+
+interface WebServerModule {
+  startWebServer(options?: {
+    defaultCwd?: string;
+    port?: number;
+    open?: boolean;
+    initialModelInfo?: {
+      models: unknown[];
+      thinkingLevels: string[];
+      defaultModel?: unknown;
+      thinkingLevel?: string;
+    };
+    initialCommands?: unknown[];
+    updateExtensions?: () => Promise<MaintenanceCommandResult>;
+    reloadRuntime?: () => Promise<void>;
+  }): Promise<string>;
+  stopWebServer(): Promise<void>;
+  getWebUrl(): string | undefined;
+}
+
+interface ReloadState {
+  resumeWebAfterReload: boolean;
+}
+
+const RELOAD_STATE_KEY = Symbol.for("@oversk7/pi-web-dsh-style/reload-state");
+const processState = globalThis as typeof globalThis & { [key: symbol]: unknown };
+const reloadState = (processState[RELOAD_STATE_KEY] ??= { resumeWebAfterReload: false }) as ReloadState;
+
+let serverPromise: Promise<WebServerModule> | undefined;
+
+function piCliEntry(): string {
+  if (process.env.PI_WEB_PI_CLI) return resolve(process.env.PI_WEB_PI_CLI);
+  const packageDir = getPackageDir();
+  const manifest = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf8")) as {
+    bin?: string | Record<string, string>;
+  };
+  const target = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.pi;
+  if (!target) throw new Error("Pi package does not declare a CLI entry");
+  return resolve(packageDir, target);
+}
+
+function parseArgs(args?: string): Record<string, string | boolean> {
+  const out: Record<string, string | boolean> = {};
+  const tokens = (args ?? "").trim().split(/\s+/).filter(Boolean);
+  for (let i = 0; i < tokens.length; i += 1) {
+    const token = tokens[i];
+    if (token === "--stop") out.stop = true;
+    else if (token === "--no-open") out.open = "false";
+    else if (token === "--port" && tokens[i + 1]) {
+      out.port = tokens[++i];
+    }
+  }
+  return out;
+}
+
+async function startServer(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  options: Record<string, string | boolean> = {},
+): Promise<void> {
+  try {
+    serverPromise ??= import("./server.ts") as Promise<WebServerModule>;
+    const mod = await serverPromise;
+    const availableModels = ctx.modelRegistry.getAvailable();
+    const initialModels = availableModels.length > 0 ? availableModels : ctx.model ? [ctx.model] : [];
+    const url = await mod.startWebServer({
+      defaultCwd: ctx.cwd,
+      port: typeof options.port === "string" ? Number(options.port) : undefined,
+      open: options.open !== "false",
+      initialModelInfo: {
+        models: initialModels,
+        thinkingLevels: ctx.model ? getSupportedThinkingLevels(ctx.model) : [],
+        defaultModel: ctx.model,
+        thinkingLevel: ctx.thinkingLevel,
+      },
+      initialCommands: pi.getCommands(),
+      updateExtensions: () => pi.exec(process.execPath, [piCliEntry(), "update", "--extensions"], {
+        cwd: ctx.cwd,
+        timeout: 10 * 60_000,
+      }),
+      reloadRuntime: async () => {
+        reloadState.resumeWebAfterReload = true;
+        try {
+          pi.sendUserMessage("/pi-web-reload-runtime", {
+            deliverAs: "followUp",
+            expandPromptTemplates: true,
+          });
+        } catch (error) {
+          reloadState.resumeWebAfterReload = false;
+          throw error;
+        }
+      },
+    });
+    ctx.ui.notify(`pi-web: ${url}`, "info");
+  } catch (error) {
+    serverPromise = undefined;
+    ctx.ui.notify(`pi-web failed: ${String(error)}`, "error");
+  }
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.registerCommand("pi-web-reload-runtime", {
+    description: "Internal command used by pi-web to reload the Pi runtime",
+    handler: async (_args, ctx) => {
+      try {
+        await ctx.reload();
+      } catch (error) {
+        reloadState.resumeWebAfterReload = false;
+        throw error;
+      }
+    },
+  });
+
+  pi.registerCommand("pi-web-navigate-tree", {
+    description: "Internal command used by pi-web for same-session tree navigation",
+    handler: async (args, ctx) => {
+      const targetId = args.trim();
+      if (!targetId || !ctx.sessionManager.getEntry(targetId)) throw new Error("会话树节点不存在");
+      await ctx.waitForIdle();
+      const result = await ctx.navigateTree(targetId, { summarize: false });
+      if (result.cancelled) throw new Error("会话回溯已取消");
+      pi.appendEntry("pi-web-tree-navigation", { targetId });
+    },
+  });
+
+  pi.registerFlag("web", {
+    description: "Start the pi agent web UI and open it in the browser",
+    type: "boolean",
+    default: false,
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    const resumeAfterReload = reloadState.resumeWebAfterReload;
+    reloadState.resumeWebAfterReload = false;
+    if (pi.getFlag("web") === true || resumeAfterReload) {
+      await startServer(pi, ctx, resumeAfterReload ? { open: "false" } : {});
+    }
+  });
+
+  pi.on("session_shutdown", async () => {
+    if (!serverPromise) return;
+    const mod = await serverPromise;
+    await mod.stopWebServer();
+    serverPromise = undefined;
+  });
+
+  pi.registerCommand("web", {
+    description: "Open the pi agent web UI (DSH-style multi-workspace browser surface)",
+    handler: async (args, ctx) => {
+      const options = parseArgs(args);
+      if (options.stop) {
+        if (!serverPromise) {
+          ctx.ui.notify("pi-web: not running", "info");
+          return;
+        }
+        const mod = await serverPromise;
+        await mod.stopWebServer();
+        serverPromise = undefined;
+        ctx.ui.notify("pi-web: stopped", "info");
+        return;
+      }
+
+      await startServer(pi, ctx, options);
+    },
+  });
+}

package/local-session.ts

@@ -0,0 +1,190 @@
+import { existsSync, statSync } from "node:fs";
+import { calculateContextTokens, estimateTokens, SessionManager } from "@earendil-works/pi-coding-agent";
+import { renderSessionEntries, type RenderedMessage } from "./transcript.ts";
+
+export type Json = Record<string, unknown>;
+
+export interface LocalSessionSnapshot {
+  messages: RenderedMessage[];
+  state: Json;
+  stats: Json | null;
+  title?: string;
+  sessionFile?: string;
+}
+
+interface SessionEntry {
+  type: string;
+  id?: string;
+  parentId?: string | null;
+  timestamp?: string;
+  message?: Json;
+  provider?: string;
+  modelId?: string;
+  thinkingLevel?: string;
+  name?: string;
+}
+
+function localContextTokens(manager: SessionManager): number | null {
+  const branch = manager.getBranch();
+  let latestCompactionIndex = -1;
+  for (let i = branch.length - 1; i >= 0; i -= 1) {
+    if (branch[i]?.type === "compaction") {
+      latestCompactionIndex = i;
+      break;
+    }
+  }
+  if (latestCompactionIndex >= 0) {
+    let hasPostCompactionUsage = false;
+    for (let i = branch.length - 1; i > latestCompactionIndex; i -= 1) {
+      const entry = branch[i];
+      if (entry?.type !== "message" || entry.message.role !== "assistant") continue;
+      if (entry.message.stopReason === "aborted" || entry.message.stopReason === "error" || !entry.message.usage) continue;
+      if (calculateContextTokens(entry.message.usage) > 0) {
+        hasPostCompactionUsage = true;
+        break;
+      }
+    }
+    if (!hasPostCompactionUsage) return null;
+  }
+
+  const messages = manager.buildSessionContext().messages;
+  let lastUsageIndex = -1;
+  let contextTokens = 0;
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const message = messages[i];
+    if (message.role !== "assistant") continue;
+    if (message.stopReason === "aborted" || message.stopReason === "error" || !message.usage) continue;
+    const tokens = calculateContextTokens(message.usage);
+    if (tokens <= 0) continue;
+    lastUsageIndex = i;
+    contextTokens = tokens;
+    break;
+  }
+  const trailingStart = lastUsageIndex >= 0 ? lastUsageIndex + 1 : 0;
+  for (let i = trailingStart; i < messages.length; i += 1) {
+    contextTokens += estimateTokens(messages[i]);
+  }
+  return contextTokens;
+}
+
+/**
+ * Read a Pi session JSONL file directly (no pi process) and produce the same
+ * shape the web UI uses for switching/display. This makes switching to a
+ * not-yet-opened session instant, like DSH's in-memory harness sessions.
+ */
+export function loadLocalSession(sessionFile: string, fallbackCwd?: string): LocalSessionSnapshot {
+  if (!existsSync(sessionFile) || statSync(sessionFile).size === 0) {
+    return {
+      messages: [],
+      state: { sessionFile, isStreaming: false },
+      stats: null,
+      sessionFile,
+    };
+  }
+
+  const manager = SessionManager.open(sessionFile, undefined, fallbackCwd);
+  const entries = manager.getEntries() as SessionEntry[];
+  const leafId = manager.getLeafId();
+
+  const byId = new Map<string, SessionEntry>();
+  for (const entry of entries) {
+    if (entry.id) byId.set(entry.id, entry);
+  }
+
+  // Walk from the current leaf to the root so forked branches only show the
+  // active path, mirroring what the pi session exposes to the UI.
+  let leaf = leafId ? byId.get(leafId) : undefined;
+  if (!leaf) leaf = entries[entries.length - 1];
+  const path: SessionEntry[] = [];
+  let current: SessionEntry | undefined = leaf;
+  const seen = new Set<string>();
+  while (current) {
+    if (current.id && seen.has(current.id)) break;
+    if (current.id) seen.add(current.id);
+    path.push(current);
+    current = current.parentId && current.id !== current.parentId ? byId.get(current.parentId) : undefined;
+  }
+  path.reverse();
+
+  const rawMessages: Json[] = [];
+  let model: Json | null = null;
+  let thinkingLevel = "off";
+  let sessionName = "";
+  for (const entry of path) {
+    if (entry.type === "message" && entry.message && typeof entry.message === "object") {
+      rawMessages.push(entry.message);
+      if (entry.message.role === "assistant") {
+        if (typeof entry.message.provider === "string" && typeof entry.message.model === "string") {
+          model = {
+            provider: entry.message.provider,
+            id: entry.message.model,
+            name: entry.message.model,
+          };
+        }
+      }
+    } else if (entry.type === "model_change") {
+      if (typeof entry.provider === "string" && typeof entry.modelId === "string") {
+        model = { provider: entry.provider, id: entry.modelId, name: entry.modelId };
+      }
+    } else if (entry.type === "thinking_level_change" && typeof entry.thinkingLevel === "string") {
+      thinkingLevel = entry.thinkingLevel;
+    } else if (entry.type === "session_info" && typeof entry.name === "string" && entry.name.trim()) {
+      sessionName = entry.name.trim();
+    }
+  }
+
+  const messages = renderSessionEntries(entries, leafId);
+  const contextTokens = localContextTokens(manager);
+
+  // Cheap local stats until a warm process can provide the authoritative ones.
+  let userMessages = 0;
+  let assistantMessages = 0;
+  let toolCalls = 0;
+  let input = 0;
+  let output = 0;
+  let cost = 0;
+  for (const raw of rawMessages) {
+    const message = raw as Json;
+    const role = message.role;
+    if (role === "user") userMessages += 1;
+    else if (role === "assistant") assistantMessages += 1;
+    if (role === "assistant" && Array.isArray(message.content)) {
+      for (const part of message.content as Json[]) {
+        if (part && part.type === "toolCall") toolCalls += 1;
+      }
+    }
+    if (message.usage && typeof message.usage === "object") {
+      const usage = message.usage as Json;
+      input += Number(usage.input ?? 0);
+      output += Number(usage.output ?? 0);
+    }
+    if (typeof message.cost === "number") cost += message.cost;
+  }
+
+  const state: Json = {
+    model,
+    thinkingLevel,
+    isStreaming: false,
+    isCompacting: false,
+    sessionFile: manager.getSessionFile(),
+    sessionId: manager.getSessionId(),
+    sessionName,
+    messageCount: rawMessages.length,
+    pendingMessageCount: 0,
+  };
+
+  return {
+    messages,
+    state,
+    stats: {
+      userMessages,
+      assistantMessages,
+      toolCalls,
+      tokens: { input, output },
+      contextUsage: { tokens: contextTokens },
+      cost: Number(cost.toFixed(6)),
+    },
+    title: sessionName || undefined,
+    sessionFile: manager.getSessionFile(),
+  };
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@oversk7/pi-web-dsh-style",
+  "version": "0.1.0-alpha.1",
+  "description": "An unofficial DSH-styled local Windows browser UI extension for pi coding agent",
+  "type": "module",
+  "license": "MIT",
+  "author": "oversk7",
+  "keywords": [
+    "pi-package",
+    "pi-coding-agent",
+    "web-ui",
+    "dsh",
+    "deepseek-harness",
+    "windows"
+  ],
+  "os": [
+    "win32"
+  ],
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "files": [
+    "abort-session.ts",
+    "attachment-store.ts",
+    "file-preview.ts",
+    "index.ts",
+    "local-session.ts",
+    "pi-rpc.ts",
+    "sse-channel.ts",
+    "server.ts",
+    "state-store.ts",
+    "transcript.ts",
+    "windows-clipboard.ts",
+    "web/",
+    "README.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "node --test tests/*.test.ts",
+    "check:package": "node scripts/check-package.mjs",
+    "verify": "npm run typecheck && npm test && npm run check:package",
+    "prepack": "npm run verify"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-ai": "0.85.0",
+    "@earendil-works/pi-coding-agent": "0.85.0",
+    "@earendil-works/pi-server": "0.85.0",
+    "@types/node": "^22.19.19",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org",
+    "tag": "alpha"
+  },
+  "dependencies": {
+    "highlight.js": "^11.12.0"
+  }
+}

package/pi-rpc.ts

@@ -0,0 +1,253 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { getPackageDir } from "@earendil-works/pi-coding-agent";
+
+export type Json = Record<string, any>;
+
+export interface PiRpc {
+  send<T = unknown>(command: Json, timeoutMs?: number): Promise<T>;
+  write(message: Json): void;
+  close(timeoutMs?: number): Promise<void>;
+  onEvent(handler: (event: Json) => void): () => void;
+}
+
+const REQUEST_TIMEOUT = 120_000;
+
+function safeJsonParse(line: string): Json | undefined {
+  try {
+    const value = JSON.parse(line);
+    return value && typeof value === "object" ? (value as Json) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+interface PiRpcLaunch {
+  entry: string;
+  argsPrefix: string[];
+}
+
+function exportedRpcEntry(packageDir: string): string {
+  const manifestPath = join(packageDir, "package.json");
+  const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as {
+    exports?: Record<string, string | { import?: string; default?: string }>;
+  };
+  const rpcExport = manifest.exports?.["./rpc-entry"];
+  const target = typeof rpcExport === "string" ? rpcExport : rpcExport?.import ?? rpcExport?.default;
+  if (!target) throw new Error("@earendil-works/pi-coding-agent does not export ./rpc-entry");
+  const entry = resolve(packageDir, target);
+  if (!existsSync(entry)) throw new Error(`pi rpc entry does not exist: ${entry}`);
+  return entry;
+}
+
+export function resolvePiRpcLaunch(): PiRpcLaunch {
+  const explicitRpcEntry = process.env.PI_WEB_RPC_ENTRY;
+  if (explicitRpcEntry) {
+    const entry = resolve(explicitRpcEntry);
+    if (!existsSync(entry)) throw new Error(`PI_WEB_RPC_ENTRY does not exist: ${entry}`);
+    return { entry, argsPrefix: [] };
+  }
+
+  const legacyCli = process.env.PI_WEB_PI_CLI;
+  if (legacyCli) {
+    const entry = resolve(legacyCli);
+    if (!existsSync(entry)) throw new Error(`PI_WEB_PI_CLI does not exist: ${entry}`);
+    return { entry, argsPrefix: ["--mode", "rpc"] };
+  }
+
+  return { entry: exportedRpcEntry(getPackageDir()), argsPrefix: [] };
+}
+
+export interface PiRpcSpawnOptions {
+  cwd: string;
+  sessionId?: string;
+  sessionFile?: string;
+  name?: string;
+  noSession?: boolean;
+}
+
+export function spawnPiRpc(options: PiRpcSpawnOptions): PiRpc {
+  const launch = resolvePiRpcLaunch();
+  const args = [...launch.argsPrefix];
+  if (options.noSession) {
+    args.push("--no-session");
+  } else if (options.sessionFile) {
+    args.push("--session", options.sessionFile);
+  } else if (options.sessionId) {
+    args.push("--session-id", options.sessionId);
+  }
+  if (options.name) args.push("--name", options.name);
+  const child = spawn(process.execPath, [launch.entry, ...args], {
+    cwd: options.cwd,
+    env: { ...process.env, NO_COLOR: "1", PI_TELEMETRY: "0" },
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true,
+  });
+
+  const handlers = new Set<(event: Json) => void>();
+  const pending = new Map<string, { resolve: (v: Json) => void; reject: (e: Error) => void; timer: ReturnType<typeof setTimeout> }>();
+  let buffer = "";
+  let closed = false;
+  let spawnError: Error | undefined;
+  let resolveExit: (() => void) | undefined;
+  const exitPromise = new Promise<void>((resolve) => {
+    resolveExit = resolve;
+  });
+
+  const forceClose = (reason: string): void => {
+    if (closed) return;
+    closed = true;
+    try {
+      child.kill();
+    } catch {
+      // ignore
+    }
+    const error = new Error(reason);
+    for (const [, p] of pending) {
+      clearTimeout(p.timer);
+      p.reject(error);
+    }
+    pending.clear();
+  };
+
+  child.on("error", (error) => {
+    spawnError = error;
+    closed = true;
+    resolveExit?.();
+    for (const [, p] of pending) {
+      clearTimeout(p.timer);
+      p.reject(error);
+    }
+    pending.clear();
+    for (const handler of handlers) handler({ type: "spawn_error", error: String(error) });
+  });
+
+  const expectedNewSessionWarning = options.sessionId
+    ? `Warning: No project session found with id '${options.sessionId}'; creating a new session with that id.`
+    : undefined;
+  let stderrBuffer = "";
+  const logStderrLine = (line: string) => {
+    const text = line.endsWith("\r") ? line.slice(0, -1) : line;
+    if (!text || text.includes("pi@") || text === expectedNewSessionWarning) return;
+    console.error(`[pi-web rpc stderr] ${text}`);
+  };
+
+  child.stderr?.on("data", (chunk: Buffer) => {
+    stderrBuffer += chunk.toString("utf8");
+    let idx: number;
+    while ((idx = stderrBuffer.indexOf("\n")) >= 0) {
+      logStderrLine(stderrBuffer.slice(0, idx));
+      stderrBuffer = stderrBuffer.slice(idx + 1);
+    }
+  });
+  child.stderr?.on("end", () => {
+    if (stderrBuffer) logStderrLine(stderrBuffer);
+    stderrBuffer = "";
+  });
+
+  child.stdout?.on("data", (chunk: Buffer) => {
+    buffer += chunk.toString("utf8");
+    let idx: number;
+    while ((idx = buffer.indexOf("\n")) >= 0) {
+      let line = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 1);
+      if (line.endsWith("\r")) line = line.slice(0, -1);
+      const event = safeJsonParse(line);
+      if (!event) continue;
+      if (event.type === "response" && typeof event.id === "string") {
+        const p = pending.get(event.id);
+        if (p) {
+          pending.delete(event.id);
+          clearTimeout(p.timer);
+          if (event.success === false) {
+            p.reject(new Error(typeof event.error === "string" ? event.error : JSON.stringify(event.error)));
+          } else {
+            p.resolve(event);
+          }
+        }
+        continue;
+      }
+      for (const handler of handlers) {
+        try {
+          handler(event);
+        } catch (error) {
+          console.error("[pi-web] event handler failed:", error);
+        }
+      }
+    }
+  });
+
+  child.on("exit", (code, signal) => {
+    closed = true;
+    resolveExit?.();
+    for (const [, p] of pending) {
+      clearTimeout(p.timer);
+      p.reject(new Error(`pi rpc exited (${code ?? signal ?? "unknown"})`));
+    }
+    pending.clear();
+    for (const handler of handlers) handler({ type: "process_exit", code: code ?? undefined, signal: signal ?? undefined });
+  });
+
+  return {
+    send<T = unknown>(command: Json, timeoutMs = REQUEST_TIMEOUT): Promise<T> {
+      if (spawnError) return Promise.reject(spawnError);
+      if (closed) return Promise.reject(new Error("pi rpc process is not running"));
+      const id = randomUUID();
+      const payload = { ...command, id };
+      return new Promise<T>((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pending.delete(id);
+          reject(new Error(`pi rpc command timed out: ${String(command.type)}`));
+        }, timeoutMs);
+        pending.set(id, { resolve: resolve as (v: Json) => void, reject, timer });
+        child.stdin.write(`${JSON.stringify(payload)}\n`, (error) => {
+          if (error) {
+            pending.delete(id);
+            clearTimeout(timer);
+            reject(error);
+          }
+        });
+      });
+    },
+    write(message: Json): void {
+      if (spawnError) throw spawnError;
+      if (closed) throw new Error("pi rpc process is not running");
+      child.stdin.write(`${JSON.stringify(message)}\n`);
+    },
+    onEvent(handler) {
+      handlers.add(handler);
+      return () => handlers.delete(handler);
+    },
+    async close(timeoutMs = 3000) {
+      if (closed) return exitPromise;
+      let timeout: ReturnType<typeof setTimeout> | undefined;
+      let forced = false;
+      const timeoutPromise = new Promise<void>((resolve) => {
+        timeout = setTimeout(() => {
+          forced = true;
+          forceClose("pi rpc close timed out");
+          resolve();
+        }, timeoutMs);
+        timeout.unref();
+      });
+      try {
+        child.stdin.end();
+      } catch {
+        // ignore
+      }
+      await Promise.race([exitPromise, timeoutPromise]);
+      if (timeout) clearTimeout(timeout);
+      if (forced) {
+        await Promise.race([
+          exitPromise,
+          new Promise<void>((resolve) => {
+            const timer = setTimeout(resolve, 1000);
+            timer.unref();
+          }),
+        ]);
+      }
+    },
+  };
+}