@oversk7/pi-web-dsh-style 1.0.1 → 1.1.1

package/README.md

@@ -1,5 +1,7 @@
 # @oversk7/pi-web-dsh-style
 
+[GitHub 源码](https://github.com/oversk7/pi-web-dsh-style) · [问题与建议](https://github.com/oversk7/pi-web-dsh-style/issues) · [npm](https://www.npmjs.com/package/@oversk7/pi-web-dsh-style) · [Pi 扩展目录](https://pi.dev/packages/@oversk7/pi-web-dsh-style)
+
 采用 DeepSeek Harness（DSH）视觉风格、面向 Windows 的非官方 Pi Coding Agent 本地浏览器界面扩展。后端使用 Pi 的公开 RPC 模式，每个会话对应独立的 RPC 进程；历史会话可直接从 Pi 会话文件恢复和渲染。
 
 > 仅承诺 Windows 10/11。首次启动只监听 `127.0.0.1`；电脑网页的“设置 → 手机访问”可配置仅本机、局域网和服务器中转。之后 `pi --web` 使用已保存的模式。
@@ -40,6 +42,19 @@ pi --web
 /web --stop
 ```
 
+### 网页会话中的斜杠命令
+
+输入 `/` 可查看当前可用命令。Web 内置命令包括 `/settings`、`/model`、`/thinking`、`/export`、`/copy`、`/name`、`/session`、`/new`、`/resume`、`/rewind`、`/tree`、`/compact` 和 `/reload`。
+
+- `/model provider/model` 精确匹配时切换模型；未唯一匹配时打开带搜索词的模型选择器。`/thinking high` 切换当前模型支持的思考强度，两者不带参数时打开选择器。
+- `/compact 压缩要求` 会将要求传给 Pi；`/name 名称` 修改会话名称，不带参数时显示当前名称。
+- `/resume` 打开侧栏会话搜索；`/export` 下载 HTML 到浏览器下载目录，暂不接受导出路径或 JSONL 格式参数。
+- 网页会话中的 `/reload` 只重载当前会话的扩展与配置。要重载整个 Web 服务，请使用设置中的“重新加载”或在宿主 Pi 终端执行 `/reload`。
+
+扩展命令、提示词模板和 `/skill:名称` 由当前会话的 Pi RPC 进程执行。未知命令会报错并保留草稿，不会作为普通消息发送给模型；普通消息需要避免以 `/` 开头。
+
+`/scoped-models`、`/import`、`/share`、`/fork`、`/clone`、`/trust`、`/changelog`、`/hotkeys`、`/login`、`/logout` 和 `/quit` 尚未提供对应的 Web 操作，输入时会显示说明。需要这些 Pi 功能时请使用终端。
+
 ### 手机通过局域网访问
 
 电脑和手机连接同一 Wi-Fi，在电脑本机网页“设置 → 手机访问”中选择“局域网”并保存。也可以执行 `/web --lan`，或直接以 `pi --web-lan` 启动。首次使用时，在同一设置中设置固定密码；之后手机打开显示的地址，输入该密码即可登录。界面只显示一个手机访问地址，优先使用 Wi-Fi，并过滤 WSL、Hyper-V 等虚拟网卡。
@@ -130,6 +145,12 @@ npm login --registry=https://registry.npmjs.org
 npm publish --access public --tag latest
 ```
 
+## 反馈与相关扩展
+
+欢迎通过 [GitHub Issues](https://github.com/oversk7/pi-web-dsh-style/issues) 反馈问题、提出建议，或分享使用场景。报告问题时，请附上扩展版本、Pi 版本、Windows 版本和复现步骤；涉及手机访问时，请说明使用的是局域网还是服务器中转。
+
+同一作者的 [pi-pwsh-notify](https://github.com/oversk7/pi-pwsh-notify) 为 Pi 提供 Windows PowerShell 7 工具，以及后台任务完成自动通知功能。
+
 ## 许可证
 
 原创代码使用 MIT License。Web UI 的部分样式和设计 token 改编自 DeepSeek Harness，字体资源来自 KaTeX，代码高亮使用 highlight.js。完整归属与许可证见 [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md)。

package/THIRD_PARTY_NOTICES.md

@@ -3,6 +3,10 @@
 This package contains adapted web UI styles and bundled font assets from the
 projects below. Their licenses are reproduced here as required.
 
+The browser Markdown renderer also bundles markdown-it and highlight.js with
+their dependencies. Their license texts are included in
+`web/assets/markdown.LICENSE.txt`, next to the bundled renderer.
+
 ## DeepSeek Harness
 
 Source: https://github.com/deepseek-ai/deepseek-harness

package/attachment-parser.ts

@@ -0,0 +1,210 @@
+import { extname, posix } from "node:path";
+import { fileURLToPath } from "node:url";
+import { unzipSync } from "fflate";
+import { XMLParser, XMLValidator } from "fast-xml-parser";
+
+const MAX_TEXT = 200_000;
+const MAX_XML_BYTES = 32 * 1024 * 1024;
+const OFFICE_MIME: Record<string, string> = {
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+};
+
+type XmlNode = { [key: string]: XmlNode[] | Record<string, string> | string };
+const parser = new XMLParser({ preserveOrder: true, ignoreAttributes: false, attributeNamePrefix: "", parseTagValue: false, parseAttributeValue: false, trimValues: false });
+
+function tag(node: XmlNode): string {
+  return Object.keys(node).find((key) => key !== ":@") ?? "";
+}
+function children(node: XmlNode): XmlNode[] {
+  const value = node[tag(node)];
+  return Array.isArray(value) ? value : [];
+}
+function attr(node: XmlNode, name: string): string {
+  return (node[":@"] as Record<string, string> | undefined)?.[name] ?? "";
+}
+function find(nodes: XmlNode[], name: string): XmlNode[] {
+  const found: XmlNode[] = [];
+  for (const node of nodes) {
+    if (tag(node).split(":").at(-1) === name) found.push(node);
+    else found.push(...find(children(node), name));
+  }
+  return found;
+}
+function value(nodes: XmlNode[]): string {
+  return nodes.map((node) => tag(node) === "#text" ? String(node["#text"]) : value(children(node))).join("");
+}
+function runs(nodes: XmlNode[]): string {
+  return nodes.map((node) => {
+    const name = tag(node).split(":").at(-1);
+    if (name === "t") return value(children(node));
+    if (name === "tab") return "\t";
+    if (name === "br" || name === "cr") return "\n";
+    return runs(children(node));
+  }).join("");
+}
+function checked(text: string): string {
+  if (text.length > MAX_TEXT) throw new Error("解析文本超过 200000 字符，请拆分文件后上传");
+  return text;
+}
+function decode(bytes: Uint8Array): string {
+  const encoding = bytes[0] === 0xff && bytes[1] === 0xfe ? "utf-16le"
+    : bytes[0] === 0xfe && bytes[1] === 0xff ? "utf-16be" : "utf-8";
+  try {
+    return new TextDecoder(encoding, { fatal: true }).decode(bytes);
+  } catch {
+    throw new Error("文件编码无效，仅支持 UTF-8 或带 BOM 的 UTF-16 文本");
+  }
+}
+
+function officeFiles(bytes: Uint8Array): Record<string, Uint8Array> {
+  let total = 0;
+  try {
+    const files = unzipSync(bytes, { filter(entry) {
+      if (!/\.(xml|rels)$/i.test(entry.name)) return false;
+      total += entry.originalSize;
+      if (total > MAX_XML_BYTES) throw new Error("Office XML 解压总量超过 32MB");
+      return true;
+    } });
+    if (Object.values(files).reduce((sum, file) => sum + file.length, 0) > MAX_XML_BYTES) throw new Error("Office XML 解压总量超过 32MB");
+    return files;
+  } catch (error) {
+    throw new Error(`无法解析 Office 压缩包：${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function xml(files: Record<string, Uint8Array>, path: string): XmlNode[] {
+  if (!files[path]) throw new Error(`Office 文件缺少 ${path}`);
+  const text = decode(files[path]);
+  if (/<!\s*(DOCTYPE|ENTITY)\b/i.test(text)) throw new Error("不支持含 DTD 或实体声明的 Office XML");
+  if (XMLValidator.validate(text) !== true) throw new Error(`Office XML 格式无效：${path}`);
+  return parser.parse(text) as XmlNode[];
+}
+function relationships(files: Record<string, Uint8Array>, source: string): Map<string, { path: string; type: string }> {
+  const relPath = posix.join(posix.dirname(source), "_rels", `${posix.basename(source)}.rels`);
+  const result = new Map<string, { path: string; type: string }>();
+  if (!files[relPath]) return result;
+  for (const rel of find(xml(files, relPath), "Relationship")) {
+    if (attr(rel, "TargetMode") === "External") continue;
+    const target = attr(rel, "Target");
+    const path = posix.normalize(target.startsWith("/") ? target.slice(1) : posix.join(posix.dirname(source), target));
+    if (path.startsWith("../") || path.includes("\\")) throw new Error("Office 关系路径无效");
+    result.set(attr(rel, "Id"), { path, type: attr(rel, "Type") });
+  }
+  return result;
+}
+function related(rels: ReturnType<typeof relationships>, id: string): string {
+  const rel = rels.get(id);
+  if (!rel) throw new Error(`Office 文件缺少内部关系：${id}`);
+  return rel.path;
+}
+function word(nodes: XmlNode[]): string {
+  return nodes.map((node) => {
+    const name = tag(node).split(":").at(-1);
+    if (name === "p") return `${runs(children(node))}\n`;
+    if (name === "tr") return `${find(children(node), "tc").map((cell) => word(children(cell)).trimEnd()).join("\t")}\n`;
+    return word(children(node));
+  }).join("");
+}
+function excel(files: Record<string, Uint8Array>): string {
+  const source = "xl/workbook.xml";
+  const rels = relationships(files, source);
+  const sharedPath = [...rels.values()].find((rel) => rel.type.endsWith("/sharedStrings"))?.path;
+  const shared = sharedPath ? find(xml(files, sharedPath), "si").map((node) => runs(children(node))) : [];
+  let text = "";
+  for (const sheet of find(xml(files, source), "sheet")) {
+    text = checked(`${text}工作表：${attr(sheet, "name")}\n`);
+    const root = xml(files, related(rels, attr(sheet, "r:id")));
+    for (const cell of find(root, "c")) {
+      const address = attr(cell, "r");
+      if (!/^[A-Z]+[1-9]\d*$/.test(address)) throw new Error("工作表单元格缺少有效坐标");
+      const type = attr(cell, "t");
+      let content = value(find(children(cell), "v"));
+      if (type === "s") {
+        if (!/^\d+$/.test(content) || shared[Number(content)] === undefined) throw new Error("工作表共享字符串索引无效");
+        content = shared[Number(content)];
+      } else if (type === "inlineStr") content = runs(children(cell));
+      else if (type === "b" && content) content = content === "1" ? "TRUE" : "FALSE";
+      text = checked(`${text}${address}: ${content}\n`);
+    }
+    text = checked(`${text}\n`);
+  }
+  return text.trimEnd();
+}
+function powerpoint(files: Record<string, Uint8Array>): string {
+  const source = "ppt/presentation.xml";
+  const rels = relationships(files, source);
+  let text = "";
+  let index = 0;
+  for (const slide of find(xml(files, source), "sldId")) {
+    const path = related(rels, attr(slide, "r:id"));
+    const content = find(xml(files, path), "p").map((node) => runs(children(node))).join("\n");
+    text = checked(`${text}幻灯片 ${++index}\n${content}\n`);
+    for (const rel of relationships(files, path).values()) {
+      if (rel.type.endsWith("/notesSlide")) {
+        const notes = find(xml(files, rel.path), "p").map((node) => runs(children(node))).join("\n");
+        text = checked(`${text}备注：\n${notes}\n`);
+      }
+    }
+    text = checked(`${text}\n`);
+  }
+  return text.trimEnd();
+}
+async function pdf(bytes: Uint8Array): Promise<string> {
+  const { getDocument } = await import("pdfjs-dist/legacy/build/pdf.mjs");
+  const packageUrl = import.meta.resolve("pdfjs-dist/package.json");
+  const task = getDocument({
+    data: Uint8Array.from(bytes),
+    useSystemFonts: true,
+    cMapUrl: fileURLToPath(new URL("./cmaps/", packageUrl)).replace(/\\/g, "/"),
+    cMapPacked: true,
+    standardFontDataUrl: fileURLToPath(new URL("./standard_fonts/", packageUrl)).replace(/\\/g, "/"),
+  });
+  try {
+    const document = await task.promise;
+    let text = "";
+    for (let index = 1; index <= document.numPages; index++) {
+      const page = await document.getPage(index);
+      try {
+        const content = await page.getTextContent();
+        for (const item of content.items) {
+          if ("str" in item) text = checked(text + item.str + (item.hasEOL ? "\n" : " "));
+        }
+        text = checked(`${text}\n`);
+      } finally {
+        page.cleanup();
+      }
+    }
+    if (!text.trim()) throw new Error("PDF 无可提取文本，可能是扫描件；当前不支持 OCR");
+    return text.trim();
+  } catch (error) {
+    if (error instanceof Error && error.name === "PasswordException") throw new Error("PDF 受密码保护，无法提取文本");
+    throw error;
+  } finally {
+    await task.destroy();
+  }
+}
+
+export async function parseDocument(bytes: Uint8Array, filename: string): Promise<{ text: string; mimeType: string }> {
+  const extension = extname(filename).toLowerCase();
+  if (/^\.(doc|xls|ppt|zip|rar|7z|gz|tar|mp3|mp4|wav|ogg|flac|aac|m4a|m4v|mov|avi|webm|mkv|wma|wmv|exe|dll|png|jpg|jpeg|gif|webp)$/.test(extension)) {
+    throw new Error("不支持此文件类型，请上传文本、PDF、DOCX、XLSX 或 PPTX");
+  }
+  if (Buffer.from(bytes.subarray(0, 8)).equals(Buffer.from([0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1]))) {
+    throw new Error("不支持旧版二进制 Office 或加密 Office 文件");
+  }
+  if (extension === ".pdf" || Buffer.from(bytes.subarray(0, 5)).toString("ascii") === "%PDF-") {
+    return { text: checked(await pdf(bytes)), mimeType: "application/pdf" };
+  }
+  if (OFFICE_MIME[extension]) {
+    const files = officeFiles(bytes);
+    const text = extension === ".docx" ? word(xml(files, "word/document.xml")).trimEnd()
+      : extension === ".xlsx" ? excel(files) : powerpoint(files);
+    return { text: checked(text), mimeType: OFFICE_MIME[extension] };
+  }
+  if (bytes[0] === 0x50 && bytes[1] === 0x4b) throw new Error("不支持 ZIP 压缩文件，请上传 DOCX、XLSX 或 PPTX");
+  const text = decode(bytes);
+  if (/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/.test(text)) throw new Error("文件包含二进制控制符，无法作为文本解析");
+  const mimeType = ({ ".json": "application/json", ".csv": "text/csv", ".md": "text/markdown", ".markdown": "text/markdown" } as Record<string, string>)[extension] ?? "text/plain";
+  return { text: checked(text), mimeType };
+}

package/attachment-store.ts

@@ -2,17 +2,22 @@ import { randomUUID } from "node:crypto";
 import { readFile, unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { parseDocument } from "./attachment-parser.ts";
 
-export interface ImageAttachmentMeta {
+export interface AttachmentMeta {
   id: string;
+  kind: "image" | "document";
+  name: string;
+  textLength?: number;
   mimeType: string;
   size: number;
   createdAt: number;
   expiresAt: number;
 }
 
-interface StoredImageAttachment extends ImageAttachmentMeta {
+interface StoredAttachment extends AttachmentMeta {
   path: string;
+  text?: string;
   timer: ReturnType<typeof setTimeout>;
 }
 
@@ -43,53 +48,62 @@ function fallbackImageMimeType(bytes: Uint8Array): string | null {
   return null;
 }
 
-async function detectImageMimeType(path: string, bytes: Uint8Array): Promise<string | null> {
+export async function detectImageMimeType(path: string, bytes: Uint8Array): Promise<string | null> {
   const detector = await resolvePublicMimeDetector();
   return detector ? detector(path) : fallbackImageMimeType(bytes);
 }
 
-export interface ImageAttachmentStoreOptions {
+export interface AttachmentStoreOptions {
   directory?: string;
   ttlMs?: number;
   maxBytes?: number;
   maxPromptImages?: number;
+  maxPromptAttachments?: number;
 }
 
-export class ImageAttachmentStore {
+export class AttachmentStore {
   readonly maxPromptImages: number;
+  readonly maxPromptAttachments: number;
   private readonly directory: string;
   private readonly ttlMs: number;
   private readonly maxBytes: number;
-  private readonly entries = new Map<string, StoredImageAttachment>();
+  private readonly entries = new Map<string, StoredAttachment>();
 
-  constructor(options: ImageAttachmentStoreOptions = {}) {
+  constructor(options: AttachmentStoreOptions = {}) {
     this.directory = options.directory ?? tmpdir();
     this.ttlMs = options.ttlMs ?? 24 * 60 * 60 * 1000;
     this.maxBytes = options.maxBytes ?? 15 * 1024 * 1024;
     this.maxPromptImages = options.maxPromptImages ?? 4;
+    this.maxPromptAttachments = options.maxPromptAttachments ?? 8;
   }
 
-  async create(bytes: Uint8Array): Promise<ImageAttachmentMeta> {
-    if (bytes.byteLength === 0) throw new Error("图片内容为空");
+  async create(bytes: Uint8Array, filename?: string): Promise<AttachmentMeta> {
+    if (bytes.byteLength === 0) throw new Error("文件内容为空");
     if (bytes.byteLength > this.maxBytes) {
-      throw new Error(`图片不能超过 ${Math.floor(this.maxBytes / 1024 / 1024)} MB`);
+      throw new Error(`文件不能超过 ${Math.floor(this.maxBytes / 1024 / 1024)} MB`);
     }
 
     const id = randomUUID();
-    const path = join(this.directory, `pi-web-attachment-${id}.img`);
+    const path = join(this.directory, `pi-web-attachment-${id}.upload`);
+    const name = filename?.split(/[\\/]/).pop()?.replace(/[\x00-\x1f\x7f]/g, "").slice(0, 255) || "";
     await writeFile(path, bytes);
     try {
-      const mimeType = await detectImageMimeType(path, bytes);
-      if (!mimeType) throw new Error("不支持的图片格式");
+      const imageMimeType = await detectImageMimeType(path, bytes);
+      if (!imageMimeType && !name) throw new Error("不支持的图片格式");
+      const document = imageMimeType ? undefined : await parseDocument(bytes, name);
+      const mimeType = imageMimeType || document!.mimeType;
       const createdAt = Date.now();
       const expiresAt = createdAt + this.ttlMs;
       const timer = setTimeout(() => {
         void this.remove(id);
       }, this.ttlMs);
       timer.unref();
-      const stored: StoredImageAttachment = {
+      const stored: StoredAttachment = {
         id,
         path,
+        kind: imageMimeType ? "image" : "document",
+        name: name || `图片.${mimeType.split("/")[1]}`,
+        ...(document ? { text: document.text, textLength: document.text.length } : {}),
         mimeType,
         size: bytes.byteLength,
         createdAt,
@@ -104,7 +118,7 @@ export class ImageAttachmentStore {
     }
   }
 
-  get(id: string): ImageAttachmentMeta | undefined {
+  get(id: string): AttachmentMeta | undefined {
     const stored = this.entries.get(id);
     if (!stored) return undefined;
     if (stored.expiresAt <= Date.now()) {
@@ -114,26 +128,52 @@ export class ImageAttachmentStore {
     return this.meta(stored);
   }
 
-  async read(id: string): Promise<{ meta: ImageAttachmentMeta; bytes: Buffer }> {
+  async read(id: string): Promise<{ meta: AttachmentMeta; bytes: Buffer }> {
     const stored = this.entries.get(id);
     if (!stored || stored.expiresAt <= Date.now()) {
       if (stored) await this.remove(id);
-      throw new Error("图片附件不存在或已过期");
+      throw new Error("附件不存在或已过期");
     }
     return { meta: this.meta(stored), bytes: await readFile(stored.path) };
   }
 
-  async imagesForRpc(ids: string[]): Promise<Array<{ type: "image"; data: string; mimeType: string }>> {
+  async promptForRpc(ids: string[], message: string): Promise<{
+    message: string;
+    images: Array<{ type: "image"; data: string; mimeType: string }>;
+  }> {
     const uniqueIds = [...new Set(ids)];
-    if (uniqueIds.length > this.maxPromptImages) {
+    if (uniqueIds.length > this.maxPromptAttachments) {
+      throw new Error(`每条消息最多附加 ${this.maxPromptAttachments} 个文件`);
+    }
+    const attachments = uniqueIds.map((id) => {
+      const stored = this.entries.get(id);
+      if (!stored || !this.get(id)) throw new Error("附件不存在或已过期，请重新上传");
+      return stored;
+    });
+    if (attachments.filter((entry) => entry.kind === "image").length > this.maxPromptImages) {
       throw new Error(`每条消息最多附加 ${this.maxPromptImages} 张图片`);
     }
+    if (attachments.reduce((length, entry) => length + (entry.textLength || 0), 0) > 200_000) {
+      throw new Error("附件文本总量不能超过 200000 字符，请拆分发送");
+    }
     const images = [];
-    for (const id of uniqueIds) {
-      const { meta, bytes } = await this.read(id);
-      images.push({ type: "image" as const, data: bytes.toString("base64"), mimeType: meta.mimeType });
+    const documents = [];
+    for (const attachment of attachments) {
+      if (attachment.kind === "image") {
+        const { meta, bytes } = await this.read(attachment.id);
+        images.push({ type: "image" as const, data: bytes.toString("base64"), mimeType: meta.mimeType });
+      } else {
+        const text = attachment.text!;
+        let fenceLength = 3;
+        for (const match of text.matchAll(/`+/g)) fenceLength = Math.max(fenceLength, match[0].length + 1);
+        const fence = "`".repeat(fenceLength);
+        documents.push(`附件：${JSON.stringify(attachment.name)}\n${fence}text\n${text}\n${fence}`);
+      }
     }
-    return images;
+    return {
+      message: [message.trim() || (documents.length ? "请分析附加文件。" : "请分析附加图片。"), ...documents].join("\n\n"),
+      images,
+    };
   }
 
   async remove(id: string): Promise<boolean> {
@@ -149,9 +189,12 @@ export class ImageAttachmentStore {
     await Promise.all([...this.entries.keys()].map((id) => this.remove(id)));
   }
 
-  private meta(stored: StoredImageAttachment): ImageAttachmentMeta {
+  private meta(stored: StoredAttachment): AttachmentMeta {
     return {
       id: stored.id,
+      kind: stored.kind,
+      name: stored.name,
+      ...(stored.textLength !== undefined ? { textLength: stored.textLength } : {}),
       mimeType: stored.mimeType,
       size: stored.size,
       createdAt: stored.createdAt,

package/background-jobs.ts

@@ -0,0 +1,52 @@
+import { open } from "node:fs/promises";
+import { basename, dirname } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+import { stripAnsi, type RenderedMessage } from "./transcript.ts";
+
+export interface BackgroundJob {
+  id: string;
+  jobId: string;
+  name?: string;
+  command: string;
+  logPath: string;
+}
+
+export function collectBackgroundJobs(messages: RenderedMessage[]): BackgroundJob[] {
+  const jobs = new Map<string, BackgroundJob>();
+  for (const message of messages) {
+    for (const block of message.blocks ?? []) {
+      if (block.type !== "toolCall" || block.name !== "pwsh" || !block.id || block.result?.isError) continue;
+      const text = block.result?.content ?? "";
+      const started = /^Started background job (bg-\d+)\b/.exec(text);
+      const logPath = /Full log: ([^\r\n]+)$/.exec(text)?.[1].trim();
+      if (!started || !logPath || basename(logPath) !== `${started[1]}.log` || !basename(dirname(logPath)).startsWith("pi-pwsh-notify-")) continue;
+      const args = block.arguments && typeof block.arguments === "object" ? block.arguments as Record<string, unknown> : {};
+      // Job numbers restart with each extension instance; tool call IDs remain session-scoped.
+      jobs.set(block.id, {
+        id: block.id,
+        jobId: started[1],
+        name: typeof args.name === "string" ? args.name : undefined,
+        command: typeof args.command === "string" ? args.command : block.argumentsText ?? "",
+        logPath,
+      });
+    }
+  }
+  return [...jobs.values()].reverse();
+}
+
+export async function readBackgroundJobLog(logPath: string): Promise<{ output: string; truncated: boolean }> {
+  const file = await open(logPath, "r");
+  try {
+    const { size } = await file.stat();
+    const start = Math.max(0, size - 128 * 1024);
+    const buffer = Buffer.alloc(Math.min(size, 128 * 1024));
+    const { bytesRead } = await file.read(buffer, 0, buffer.length, start);
+    let offset = 0;
+    if (start > 0) while (offset < bytesRead && (buffer[offset] & 0xc0) === 0x80) offset++;
+    const text = new StringDecoder("utf8").write(buffer.subarray(offset, bytesRead));
+    const lines = text.split("\n");
+    return { output: stripAnsi(lines.slice(-1000).join("\n")), truncated: start > 0 || lines.length > 1000 };
+  } finally {
+    await file.close();
+  }
+}

package/extension-settings.ts

@@ -0,0 +1,50 @@
+import { getAgentDir, SettingsManager } from "@earendil-works/pi-coding-agent";
+
+type PackageEntry = ReturnType<SettingsManager["getPackages"]>[number];
+type ManagedPackage = Exclude<PackageEntry, string> & { piWebExtensionFilter?: string[] };
+
+export function togglePackage(entry: PackageEntry, enabled: boolean): PackageEntry {
+  const next: ManagedPackage = typeof entry === "string" ? { source: entry } : { ...entry };
+  const disabled = Array.isArray(next.extensions) && next.extensions.length === 0;
+  if (enabled === !disabled) return entry;
+  if (enabled) {
+    if (next.piWebExtensionFilter) next.extensions = next.piWebExtensionFilter;
+    else delete next.extensions;
+    delete next.piWebExtensionFilter;
+  } else {
+    if (next.extensions) next.piWebExtensionFilter = next.extensions;
+    next.extensions = [];
+  }
+  return next;
+}
+
+export async function extensionSettings(cwd: string, change?: { scope: "global" | "project"; source: string; enabled: boolean }, agentDir = getAgentDir()) {
+  const manager = SettingsManager.create(cwd, agentDir, { projectTrusted: true });
+  const checkErrors = () => {
+    const errors = manager.drainErrors();
+    if (errors.length) throw new Error(errors.map((item) => item.error.message).join("\n"));
+  };
+  checkErrors();
+  if (change) {
+    const settings = change.scope === "global" ? manager.getGlobalSettings() : manager.getProjectSettings();
+    const packages = settings.packages ?? [];
+    if (!packages.some((entry) => (typeof entry === "string" ? entry : entry.source) === change.source)) throw new Error("扩展包配置已变化，请刷新列表");
+    const next = packages.map((entry) => (typeof entry === "string" ? entry : entry.source) === change.source ? togglePackage(entry, change.enabled) : entry);
+    if (change.scope === "global") manager.setPackages(next);
+    else manager.setProjectPackages(next);
+    await manager.flush();
+    checkErrors();
+  }
+  return {
+    cwd,
+    packages: (["global", "project"] as const).flatMap((scope) => {
+      const settings = scope === "global" ? manager.getGlobalSettings() : manager.getProjectSettings();
+      return (settings.packages ?? []).map((entry) => ({
+        scope,
+        source: typeof entry === "string" ? entry : entry.source,
+        enabled: typeof entry === "string" || entry.extensions?.length !== 0,
+        filtered: typeof entry !== "string" && Boolean(entry.extensions?.length),
+      }));
+    }),
+  };
+}

package/file-preview.ts

@@ -55,6 +55,8 @@ export interface FilePreviewData {
   path: string;
   name: string;
   language: string;
+  kind: "code" | "markdown" | "html";
+  content?: string;
   highlighted: boolean;
   highlightedHtml: string;
   lineCount: number;
@@ -68,7 +70,9 @@ function escapeHtml(value: string): string {
 export function buildFilePreview(filePath: string, data: Buffer): FilePreviewData {
   const name = basename(filePath);
   const text = data.toString("utf8").replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n");
-  const language = LANGUAGES_BY_FILENAME[name.toLowerCase()] ?? LANGUAGES_BY_EXTENSION[extname(name).toLowerCase()] ?? "plaintext";
+  const extension = extname(name).toLowerCase();
+  const language = LANGUAGES_BY_FILENAME[name.toLowerCase()] ?? LANGUAGES_BY_EXTENSION[extension] ?? "plaintext";
+  const kind = language === "markdown" ? "markdown" : [".html", ".htm"].includes(extension) ? "html" : "code";
   const canHighlight = data.byteLength <= MAX_HIGHLIGHT_BYTES && Boolean(hljs.getLanguage(language));
   let highlightedHtml = escapeHtml(text);
   let highlighted = false;
@@ -86,6 +90,8 @@ export function buildFilePreview(filePath: string, data: Buffer): FilePreviewDat
     path: filePath,
     name,
     language,
+    kind,
+    ...(kind !== "code" ? { content: text } : {}),
     highlighted,
     highlightedHtml,
     lineCount: text.split("\n").length,

package/package.json

@@ -1,10 +1,18 @@
 {
   "name": "@oversk7/pi-web-dsh-style",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "An unofficial DSH-styled Windows browser UI for pi coding agent with configurable LAN and native frp relay access",
   "type": "module",
   "license": "MIT",
   "author": "oversk7",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oversk7/pi-web-dsh-style.git"
+  },
+  "homepage": "https://github.com/oversk7/pi-web-dsh-style#readme",
+  "bugs": {
+    "url": "https://github.com/oversk7/pi-web-dsh-style/issues"
+  },
   "keywords": [
     "pi-package",
     "pi-coding-agent",
@@ -21,12 +29,16 @@
   },
   "files": [
     "abort-session.ts",
+    "background-jobs.ts",
     "attachment-store.ts",
+    "attachment-parser.ts",
     "file-preview.ts",
+    "extension-settings.ts",
     "index.ts",
     "local-session.ts",
     "network-access.ts",
     "network-settings.ts",
+    "terminal-proxy.ts",
     "frp-process.ts",
     "pi-rpc.ts",
     "sse-channel.ts",
@@ -41,11 +53,12 @@
     "THIRD_PARTY_NOTICES.md"
   ],
   "scripts": {
+    "build:markdown": "node scripts/build-markdown.mjs",
     "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"
+    "prepack": "npm run build:markdown && npm run verify"
   },
   "pi": {
     "extensions": [
@@ -61,6 +74,7 @@
     "@earendil-works/pi-coding-agent": "0.85.0",
     "@earendil-works/pi-server": "0.85.0",
     "@types/node": "^22.19.19",
+    "esbuild": "^0.28.2",
     "typescript": "^5.9.3"
   },
   "publishConfig": {
@@ -69,6 +83,10 @@
     "tag": "latest"
   },
   "dependencies": {
-    "highlight.js": "^11.12.0"
+    "fast-xml-parser": "^5.11.1",
+    "fflate": "^0.8.3",
+    "highlight.js": "^11.12.0",
+    "markdown-it": "^15.0.2",
+    "pdfjs-dist": "^6.3.289"
   }
 }