@baique/pi-web-sky 0.1.35 → 0.1.36

package/lib/turn-written-files.ts

@@ -0,0 +1,60 @@
+import type { AssistantContentBlock, ToolResultMessage } from "./types";
+import { resolveLocalFilePath } from "./file-links";
+import { isEditToolName, isWriteToolName } from "./tool-names";
+
+export interface WrittenFile {
+  /** Resolved absolute path of a file this turn wrote. */
+  filePath: string;
+}
+
+function isFileWritingToolName(toolName: string): boolean {
+  return isWriteToolName(toolName) || isEditToolName(toolName);
+}
+
+function readToolPath(input: Record<string, unknown> | undefined): string | null {
+  if (!input) return null;
+  const value = input.file_path ?? input.path;
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+
+/**
+ * Collect the distinct files a single assistant turn actually wrote.
+ *
+ * Every entry is derived from a `write`/`edit` tool call whose result arrived
+ * and did not error — never from the reply text. A path the assistant merely
+ * mentions in prose is not evidence that any file was touched, so it is not a
+ * source here; the tool call is the record of what happened.
+ *
+ * Paths are resolved against `cwd`, deduped, and kept in first-seen order.
+ */
+export function extractTurnWrittenFiles(
+  content: AssistantContentBlock[],
+  toolResults: Map<string, ToolResultMessage> | undefined,
+  cwd?: string,
+): WrittenFile[] {
+  const seen = new Set<string>();
+  const writtenFiles: WrittenFile[] = [];
+
+  for (const block of content) {
+    if (block.type !== "toolCall") continue;
+    if (!isFileWritingToolName(block.toolName)) continue;
+
+    // No result yet (still streaming) or the call failed — nothing was written.
+    const result = toolResults?.get(block.toolCallId);
+    if (!result || result.isError) continue;
+
+    const rawPath = readToolPath(block.input);
+    if (!rawPath) continue;
+
+    // Tool arguments are filesystem paths, not hrefs: preserve characters such
+    // as #, ?, and :digits that have special meaning in links and source refs.
+    const filePath = resolveLocalFilePath(rawPath, cwd);
+    if (!filePath) continue;
+
+    if (seen.has(filePath)) continue;
+    seen.add(filePath);
+    writtenFiles.push({ filePath });
+  }
+
+  return writtenFiles;
+}

package/lib/types.ts

@@ -0,0 +1,349 @@
+// Types mirrored from pi-mono coding-agent session-manager
+
+export interface SessionHeader {
+  type: "session";
+  version?: number;
+  id: string;
+  timestamp: string;
+  cwd: string;
+  parentSession?: string;
+}
+
+export interface SessionEntryBase {
+  type: string;
+  id: string;
+  parentId: string | null;
+  timestamp: string;
+}
+
+export interface TextContent {
+  type: "text";
+  text: string;
+}
+
+export interface ImageContent {
+  type: "image";
+  source: {
+    type: "base64" | "url";
+    media_type?: string;
+    data?: string;
+    url?: string;
+  };
+}
+
+export interface ThinkingContent {
+  type: "thinking";
+  thinking: string;
+  /** Historical content omitted from the initial response and loaded on demand. */
+  deferred?: boolean;
+}
+
+export interface ToolCallContent {
+  type: "toolCall";
+  toolCallId: string;
+  toolName: string;
+  input: Record<string, unknown>;
+  /** Client-only buffer for streamed tool input. Never persisted to session files. */
+  rawInput?: string;
+}
+
+export type AssistantContentBlock = TextContent | ImageContent | ThinkingContent | ToolCallContent;
+
+export interface UserMessage {
+  role: "user";
+  content: string | (TextContent | ImageContent)[];
+  timestamp?: number;
+}
+
+export interface AssistantMessage {
+  role: "assistant";
+  content: AssistantContentBlock[];
+  model: string;
+  provider: string;
+  stopReason?: string;
+  errorMessage?: string;
+  timestamp?: number;
+  usage?: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    cost: {
+      input: number;
+      output: number;
+      cacheRead: number;
+      cacheWrite: number;
+      total: number;
+    };
+  };
+}
+
+export interface ToolResultMessage {
+  role: "toolResult";
+  toolCallId: string;
+  toolName?: string;
+  content: (TextContent | ImageContent)[];
+  isError?: boolean;
+  details?: unknown;
+  timestamp?: number;
+}
+
+export interface CustomMessage {
+  role: "custom";
+  customType: string;
+  content: string | (TextContent | ImageContent)[];
+  display: boolean;
+  details?: unknown;
+  timestamp?: number;
+}
+
+export interface BashExecutionMessage {
+  role: "bashExecution";
+  command: string;
+  output: string;
+  exitCode?: number;
+  cancelled?: boolean;
+  truncated?: boolean;
+  fullOutputPath?: string;
+  excludeFromContext?: boolean;
+  timestamp?: number;
+}
+
+export type AgentMessage = UserMessage | AssistantMessage | ToolResultMessage | CustomMessage | BashExecutionMessage;
+
+export type ExtensionUiRequest =
+  | {
+      type: "extension_ui_request";
+      id: string;
+      method: "select";
+      title: string;
+      options: string[];
+      timeout?: number;
+      expiresAt?: number;
+    }
+  | {
+      type: "extension_ui_request";
+      id: string;
+      method: "confirm";
+      title: string;
+      message: string;
+      timeout?: number;
+      expiresAt?: number;
+    }
+  | {
+      type: "extension_ui_request";
+      id: string;
+      method: "input";
+      title: string;
+      placeholder?: string;
+      timeout?: number;
+      expiresAt?: number;
+    }
+  | {
+      type: "extension_ui_request";
+      id: string;
+      method: "editor";
+      title: string;
+      prefill?: string;
+      timeout?: number;
+      expiresAt?: number;
+    }
+  | {
+      type: "extension_ui_request";
+      id: string;
+      method: "notify";
+      message: string;
+      notifyType?: "info" | "warning" | "error";
+    }
+  | {
+      type: "extension_ui_request";
+      id: string;
+      method: "setStatus";
+      statusKey: string;
+      statusText?: string;
+    }
+  | {
+      type: "extension_ui_request";
+      id: string;
+      method: "setWidget";
+      widgetKey: string;
+      widgetLines?: string[];
+      widgetPlacement?: "aboveEditor" | "belowEditor";
+    }
+  | {
+      type: "extension_ui_request";
+      id: string;
+      method: "setTitle";
+      title: string;
+    }
+  | {
+      type: "extension_ui_request";
+      id: string;
+      method: "set_editor_text";
+      text: string;
+    }
+  | {
+      type: "extension_ui_request";
+      id: string;
+      method: "custom";
+      lines: string[];
+      closed?: boolean;
+    };
+
+export type BlockingExtensionUiRequest = Extract<
+  ExtensionUiRequest,
+  { method: "select" | "confirm" | "input" | "editor" | "custom" }
+>;
+
+export type ExtensionUiResponse =
+  | { type: "extension_ui_response"; id: string; value: string }
+  | { type: "extension_ui_response"; id: string; confirmed: boolean }
+  | { type: "extension_ui_response"; id: string; cancelled: true };
+
+export interface ExtensionStatusItem {
+  key: string;
+  text: string;
+}
+
+export interface ExtensionWidgetItem {
+  key: string;
+  lines: string[];
+  placement: "aboveEditor" | "belowEditor";
+}
+
+export interface SessionMessageEntry extends SessionEntryBase {
+  type: "message";
+  message: AgentMessage;
+}
+
+export interface ThinkingLevelChangeEntry extends SessionEntryBase {
+  type: "thinking_level_change";
+  thinkingLevel: string;
+}
+
+export interface ModelChangeEntry extends SessionEntryBase {
+  type: "model_change";
+  provider: string;
+  modelId: string;
+}
+
+export interface CompactionEntry extends SessionEntryBase {
+  type: "compaction";
+  summary: string;
+  firstKeptEntryId: string;
+  tokensBefore: number;
+  details?: unknown;
+  fromHook?: boolean;
+}
+
+export interface BranchSummaryEntry extends SessionEntryBase {
+  type: "branch_summary";
+  fromId: string;
+  summary: string;
+  details?: unknown;
+  fromHook?: boolean;
+}
+
+export interface CustomEntry extends SessionEntryBase {
+  type: "custom";
+  customType: string;
+  data?: unknown;
+}
+
+export interface CustomMessageEntry extends SessionEntryBase {
+  type: "custom_message";
+  customType: string;
+  content: string | (TextContent | ImageContent)[];
+  details?: unknown;
+  display: boolean;
+}
+
+export interface LabelEntry extends SessionEntryBase {
+  type: "label";
+  targetId: string;
+  label: string | undefined;
+}
+
+export interface SessionInfoEntry extends SessionEntryBase {
+  type: "session_info";
+  name?: string;
+}
+
+export type SessionEntry =
+  | SessionMessageEntry
+  | ThinkingLevelChangeEntry
+  | ModelChangeEntry
+  | CompactionEntry
+  | BranchSummaryEntry
+  | CustomEntry
+  | CustomMessageEntry
+  | LabelEntry
+  | SessionInfoEntry;
+
+export type FileEntry = SessionHeader | SessionEntry;
+
+export interface BranchPreview {
+  role?: "user" | "assistant";
+  text: string;
+}
+
+export interface SessionTreeNode {
+  entry: SessionEntry;
+  children: SessionTreeNode[];
+  label?: string;
+  compressedEntryIds?: string[];
+  branchPreview?: BranchPreview;
+}
+
+export interface SessionInfo {
+  path: string;
+  id: string;
+  cwd: string;
+  name?: string;
+  created: string;
+  modified: string;
+  messageCount: number;
+  firstMessage: string;
+  /** 最后一条 assistant 回复文本（看板卡片中间区展示用，截断），无则为空串 */
+  lastReply?: string;
+  parentSessionId?: string; // set if this session was forked from another
+  /** Main repo root shared by all worktrees of this cwd (cwd itself for non-git dirs).
+   *  Always set by the server; optional because the client builds transient
+   *  SessionInfo objects before the first refresh. Fall back to cwd. */
+  projectRoot?: string;
+  /** Stable server-computed project identity for grouping and comparison.
+   *  Unlike projectRoot, Windows keys are case- and separator-insensitive.
+   *  Internal only: use projectRoot/cwd for display and filesystem operations. */
+  projectKey?: string;
+  /** Branch name when cwd is a linked git worktree (not the main checkout) */
+  worktreeBranch?: string;
+  /** Git branch of the session's project root (any git repo, not only worktrees). */
+  branch?: string;
+  /** True when cwd is a linked git worktree (not the main checkout). */
+  isWorktree?: boolean;
+  /** True while the runtime session exists only in memory and its JSONL file
+   *  has not been created yet. Disk-backed actions must wait until this clears. */
+  transient?: boolean;
+  /** Pinned by the user; sorts first inside its own region (task group or chat). */
+  pinned?: boolean;
+  /** Live task ownership (sessionInfo panel reads it realtime to avoid stale snapshots). */
+  taskName?: string;
+}
+
+export interface TodoItem {
+  id?: string;
+  content: string;
+  status?: string;
+  priority?: string;
+}
+
+export interface SessionContext {
+  messages: AgentMessage[];
+  entryIds: string[]; // parallel to messages — the session entry id for each message
+  /** Parallel to entryIds — the parent entry id of each message's session entry (null = root). */
+  parentIds: (string | null)[];
+  thinkingLevel: string;
+  model: { provider: string; modelId: string } | null;
+  // Latest todo list published by pi (pi-todo.state custom entries), empty when none.
+  todos: TodoItem[];
+}

package/lib/wallpaper-settings.ts

@@ -0,0 +1,191 @@
+"use client";
+
+import { useCallback, useEffect, useState } from "react";
+
+/**
+ * Wallpaper display settings:
+ * - repeat   : tile horizontally (`background-repeat: repeat-x`)
+ * - offsetX  : horizontal drag offset in px, applied as `calc(50% + Npx)`
+ * - fill     : fill leftover side gaps with colours sampled from the
+ *              wallpaper's left/right edges (only meaningful when not tiling)
+ * - bubbleOpacity : chat-bubble glass opacity in percent (0–100), written to
+ *              `--bubble-alpha` on <html>
+ * - bubbleBlur    : frosted blur radius in px (0–30), written to
+ *              `--glass-blur-bubble` on <html>
+ * - scrimAlpha    : board-canvas scrim opacity in percent (0–100), written to
+ *              `--board-scrim-alpha` on <html> (independent of bubble alpha)
+ * - scrimBlur     : board-canvas scrim blur radius in px (0–30), written to
+ *              `--board-scrim-blur` on <html>
+ *
+ * 看板 scrim：透明度滑块暂注释（微调即对背景影响过大），透明度固定保持 0，
+ * 只向用户开放磨砂滑块；scrimAlpha 字段保留以备后续恢复。
+ *
+ * Settings persist in localStorage and are applied to <html> as CSS custom
+ * properties consumed by the wallpaper layer on `body` in app/globals.css.
+ */
+
+export type WallpaperSettings = {
+  repeat: boolean;
+  offsetX: number;
+  fill: boolean;
+  fillColorLeft: string;
+  fillColorRight: string;
+  bubbleOpacity: number;
+  bubbleBlur: number;
+  scrimAlpha: number;
+  scrimBlur: number;
+};
+
+const DEFAULTS: WallpaperSettings = {
+  repeat: false,
+  offsetX: 0,
+  fill: false,
+  fillColorLeft: "#000000",
+  fillColorRight: "#000000",
+  bubbleOpacity: 44,
+  bubbleBlur: 8,
+  scrimAlpha: 0,
+  // 默认无磨砂（0）。打开画布时先按默认渲染，再从存储恢复——
+  // 若默认非 0，首帧会先闪一下 2px 再跳变成存储值（见 useWallpaperSettings 惰性初始化注释）
+  scrimBlur: 0,
+};
+
+const LS_KEY = "wallpaper-settings";
+
+export function loadWallpaperSettings(): WallpaperSettings {
+  try {
+    const raw = localStorage.getItem(LS_KEY);
+    if (!raw) return { ...DEFAULTS };
+    return { ...DEFAULTS, ...(JSON.parse(raw) as Partial<WallpaperSettings>) };
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+
+export function saveWallpaperSettings(s: WallpaperSettings): void {
+  try {
+    localStorage.setItem(LS_KEY, JSON.stringify(s));
+  } catch {
+    // localStorage unavailable — settings stay session-only.
+  }
+}
+
+/** Push the current settings into CSS custom properties on <html>. */
+export function applyWallpaperCss(s: WallpaperSettings, hasImage: boolean): void {
+  const el = document.documentElement.style;
+  el.setProperty("--app-bg-repeat", s.repeat ? "repeat-x" : "no-repeat");
+  // The wallpaper always keeps its fitted `cover` size. Repeat/fill merely
+  // cover the side gaps that open up after a horizontal drag offset — they
+  // must never rescale the image itself.
+  el.setProperty("--app-bg-size", "cover");
+  el.setProperty("--app-bg-pos-x", `calc(50% + ${Math.round(s.offsetX)}px)`);
+  el.setProperty("--bubble-alpha", String(s.bubbleOpacity / 100));
+  el.setProperty("--glass-blur-bubble", `${Math.round(s.bubbleBlur)}px`);
+  // scrim 透明度固定保持 0（透明度滑块暂注释，微调即对背景影响过大），
+  // 只写磨砂强度。
+  // scrim 磨砂只用 blur、不动饱和度——磨砂本质就是模糊，去饱和/增饱和
+  // 都会让壁纸颜色失真，且会受 --glass-saturate（浅 80% / 深 140%）的
+  // 主题差异影响。只 blur 则深浅色效果完全一致。
+  // 关键：磨砂强度为 0 时把整个 backdrop-filter 置为 none，背景原样。
+  el.setProperty("--board-scrim-alpha", String(s.scrimAlpha / 100));
+  el.setProperty("--board-scrim-blur", `${Math.round(s.scrimBlur)}px`);
+  el.setProperty(
+    "--board-scrim-filter",
+    s.scrimBlur > 0 ? `blur(${Math.round(s.scrimBlur)}px)` : "none",
+  );
+  if (s.fill && !s.repeat && hasImage) {
+    el.setProperty(
+      "--app-bg-fill",
+      `linear-gradient(90deg, ${s.fillColorLeft}, ${s.fillColorLeft} 50%, ${s.fillColorRight} 50%, ${s.fillColorRight})`,
+    );
+  } else {
+    el.removeProperty("--app-bg-fill");
+  }
+}
+
+/**
+ * Sample the leftmost/rightmost pixel column of an image blob into two CSS colours.
+ * Only samples the top 8 rows — a short vertical slice keeps colours true to the
+ * wallpaper edge and avoids the "washed out" result that happens when averaging
+ * highlights, shadows and midtones over a taller strip.
+ */
+export async function sampleEdgeColors(
+  blob: Blob,
+): Promise<{ left: string; right: string } | null> {
+  try {
+    const bmp = await createImageBitmap(blob);
+    const sampleH = 8;
+    const w = Math.max(1, Math.round((bmp.width * sampleH) / bmp.height));
+    const canvas = document.createElement("canvas");
+    canvas.width = w;
+    canvas.height = sampleH;
+    const ctx = canvas.getContext("2d", { willReadFrequently: true });
+    if (!ctx) return null;
+    ctx.drawImage(bmp, 0, 0, w, sampleH);
+    const avg = (x: number): string => {
+      const d = ctx.getImageData(x, 0, 1, sampleH).data;
+      let r = 0, g = 0, b = 0;
+      for (let i = 0; i < sampleH; i++) {
+        r += d[i * 4];
+        g += d[i * 4 + 1];
+        b += d[i * 4 + 2];
+      }
+      return `rgb(${Math.round(r / sampleH)}, ${Math.round(g / sampleH)}, ${Math.round(b / sampleH)})`;
+    };
+    const result = { left: avg(0), right: avg(w - 1) };
+    bmp.close();
+    return result;
+  } catch {
+    return null;
+  }
+}
+
+export type WallpaperDims = { width: number; height: number };
+
+/** Natural dimensions of an image or video URL (video reads metadata only). */
+export function loadMediaDims(
+  url: string,
+  isVideo: boolean,
+): Promise<WallpaperDims | null> {
+  if (isVideo) {
+    return new Promise((resolve) => {
+      const v = document.createElement("video");
+      v.preload = "metadata";
+      v.onloadedmetadata = () =>
+        resolve({ width: v.videoWidth, height: v.videoHeight });
+      v.onerror = () => resolve(null);
+      v.src = url;
+    });
+  }
+  return new Promise((resolve) => {
+    const img = new Image();
+    img.onload = () => resolve({ width: img.naturalWidth, height: img.naturalHeight });
+    img.onerror = () => resolve(null);
+    img.src = url;
+  });
+}
+
+/** Load, persist and live-apply wallpaper display settings. */
+export function useWallpaperSettings(hasImage: boolean) {
+  // 惰性初始化直接读 localStorage：首帧即存储值（无存储时为默认）。
+  // 不要用 DEFAULTS 起步再挂载后 setSettings 恢复——那会让首帧先应用默认值
+  // （如 scrimBlur 2px）再跳变到存储值，打开画布时磨砂强度闪烁一下。
+  // SSR 阶段 localStorage 不存在，loadWallpaperSettings 内部 try/catch 返回默认，安全。
+  const [settings, setSettings] = useState<WallpaperSettings>(() => loadWallpaperSettings());
+
+  useEffect(() => {
+    applyWallpaperCss(settings, hasImage);
+  }, [settings, hasImage]);
+
+  const update = useCallback(
+    (patch: Partial<WallpaperSettings>) =>
+      setSettings((prev) => {
+        const next = { ...prev, ...patch };
+        saveWallpaperSettings(next);
+        return next;
+      }),
+    [],
+  );
+
+  return { settings, update };
+}

package/lib/web-auth.test.mjs

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+async function loadSubject() {
+  return import("./web-auth.ts");
+}
+
+function authorization(username, password) {
+  return `Basic ${Buffer.from(`${username}:${password}`, "utf8").toString("base64")}`;
+}
+
+test("enables password authentication only for a non-empty configured password", async () => {
+  const { isWebPasswordEnabled } = await loadSubject();
+  assert.equal(isWebPasswordEnabled(undefined), false);
+  assert.equal(isWebPasswordEnabled(""), false);
+  assert.equal(isWebPasswordEnabled("secret"), true);
+});
+
+test("accepts only the fixed pi username and configured password", async () => {
+  const { isValidBasicAuthorization } = await loadSubject();
+  assert.equal(isValidBasicAuthorization(authorization("pi", "secret"), "secret"), true);
+  assert.equal(isValidBasicAuthorization(authorization("admin", "secret"), "secret"), false);
+  assert.equal(isValidBasicAuthorization(authorization("pi", "wrong"), "secret"), false);
+});
+
+test("supports UTF-8 passwords and colons in the password", async () => {
+  const { isValidBasicAuthorization } = await loadSubject();
+  const password = "口令:with:colons";
+  assert.equal(isValidBasicAuthorization(authorization("pi", password), password), true);
+});
+
+test("rejects missing, malformed, and non-canonical authorization values", async () => {
+  const { isValidBasicAuthorization } = await loadSubject();
+  const valid = authorization("pi", "secret");
+
+  assert.equal(isValidBasicAuthorization(null, "secret"), false);
+  assert.equal(isValidBasicAuthorization("Bearer token", "secret"), false);
+  assert.equal(isValidBasicAuthorization("Basic !!!", "secret"), false);
+  assert.equal(isValidBasicAuthorization(`${valid}!`, "secret"), false);
+  assert.equal(isValidBasicAuthorization(
+    `Basic ${Buffer.from("missing-separator", "utf8").toString("base64")}`,
+    "secret",
+  ), false);
+});
+
+test("does not authenticate when password protection is disabled", async () => {
+  const { isValidBasicAuthorization } = await loadSubject();
+  assert.equal(isValidBasicAuthorization(authorization("pi", ""), ""), false);
+  assert.equal(isValidBasicAuthorization(authorization("pi", "secret"), undefined), false);
+});

package/lib/web-auth.ts

@@ -0,0 +1,45 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+
+export const PI_WEB_AUTH_USERNAME = "pi";
+
+function hashSecret(value: string): Buffer {
+  return createHash("sha256").update(value, "utf8").digest();
+}
+
+function secretsEqual(actual: string, expected: string): boolean {
+  return timingSafeEqual(hashSecret(actual), hashSecret(expected));
+}
+
+export function isWebPasswordEnabled(
+  password: string | undefined = process.env.PI_WEB_PASSWORD,
+): password is string {
+  return typeof password === "string" && password.length > 0;
+}
+
+export function isValidBasicAuthorization(
+  authorization: string | null,
+  password = process.env.PI_WEB_PASSWORD,
+): boolean {
+  if (!isWebPasswordEnabled(password) || !authorization) return false;
+
+  const match = /^Basic\s+(\S+)$/i.exec(authorization);
+  if (!match) return false;
+
+  let credentials: string;
+  try {
+    const decoded = Buffer.from(match[1], "base64");
+    if (decoded.toString("base64") !== match[1]) return false;
+    credentials = new TextDecoder("utf-8", { fatal: true }).decode(decoded);
+  } catch {
+    return false;
+  }
+
+  const separator = credentials.indexOf(":");
+  if (separator === -1) return false;
+
+  const username = credentials.slice(0, separator);
+  const suppliedPassword = credentials.slice(separator + 1);
+  const usernameMatches = secretsEqual(username, PI_WEB_AUTH_USERNAME);
+  const passwordMatches = secretsEqual(suppliedPassword, password);
+  return usernameMatches && passwordMatches;
+}