@pi-harness/pi-harness 0.1.2 → 0.1.4

package/packages/core/src/plugins/skill-guard.ts

@@ -0,0 +1,152 @@
+import { readFile } from "node:fs/promises";
+import type { Context } from "@deepseek-ai/cordis";
+import { Type } from "@earendil-works/pi-ai";
+import { defineTool, type AgentToolResult } from "@earendil-works/pi-coding-agent";
+
+const maxSkillBytes = 128 * 1024;
+const maxSkills = 50;
+
+export type SkillGuardRisk = "safe" | "review" | "blocked";
+export type SkillGuardFinding = { code: string; severity: "medium" | "high"; message: string };
+export type SkillGuardReport = { name: string; risk: SkillGuardRisk; score: number; findings: SkillGuardFinding[] };
+export type ScannedSkillReport = SkillGuardReport & { path: string; source: string; scannedBytes: number };
+
+type Pattern = { code: string; severity: SkillGuardFinding["severity"]; score: number; message: string; pattern: RegExp };
+
+const patterns: readonly Pattern[] = [
+  {
+    code: "instruction_override",
+    severity: "high",
+    score: 5,
+    message: "检测到试图覆盖已有指令的文本。",
+    pattern: /\bignore\s+(?:all\s+)?(?:previous|earlier|above)\s+instructions\b/iu,
+  },
+  {
+    code: "secret_exfiltration",
+    severity: "high",
+    score: 6,
+    message: "检测到可能要求外传 API key、token 或密码的文本。",
+    pattern: /\b(?:api[\s_-]?key|token|password|secret)\b.{0,120}\b(?:send|upload|post|share|curl|wget)\b/iu,
+  },
+  {
+    code: "remote_exfiltration",
+    severity: "high",
+    score: 6,
+    message: "检测到通过远程命令外传敏感值的文本。",
+    pattern: /\b(?:curl|wget)\b.{0,180}\b(?:api[\s_-]?key|token|password|secret)\b/iu,
+  },
+  {
+    code: "remote_payload",
+    severity: "medium",
+    score: 2,
+    message: "检测到从远程地址加载或执行内容的文本。",
+    pattern: /\b(?:curl|wget)\s+https?:\/\//iu,
+  },
+  {
+    code: "destructive_command",
+    severity: "high",
+    score: 6,
+    message: "检测到可能破坏工作区或磁盘的命令。",
+    pattern: /\b(?:rm\s+-rf|git\s+reset\s+--hard|git\s+clean\s+-f|mkfs(?:\.[a-z0-9]+)?|dd\s+if=)\b/iu,
+  },
+  {
+    code: "obfuscated_payload",
+    severity: "medium",
+    score: 3,
+    message: "检测到可能用于隐藏执行内容的编码或动态执行。",
+    pattern: /\b(?:eval|base64\s+-d|fromcharcode)\b/iu,
+  },
+];
+
+function skillName(name: string): string {
+  return name.trim().slice(0, 64) || "unknown";
+}
+
+export function inspectSkillText(text: string, name: string): SkillGuardReport {
+  if (Buffer.byteLength(text, "utf8") > maxSkillBytes) throw new Error(`Skill guard input must be at most ${maxSkillBytes} bytes`);
+  const findings = patterns.filter((item) => item.pattern.test(text)).map(({ code, severity, message }) => ({ code, severity, message }));
+  const score = findings.reduce((total, finding) => total + (patterns.find((item) => item.code === finding.code)?.score ?? 0), 0);
+  const risk: SkillGuardRisk = findings.some((finding) => finding.severity === "high") ? "blocked" : findings.length > 0 ? "review" : "safe";
+  return { name: skillName(name), risk, score, findings };
+}
+
+async function scanLoadedSkills(context: Context): Promise<ScannedSkillReport[]> {
+  const loaded = context.piResources.resourceLoader.getSkills();
+  const reports: ScannedSkillReport[] = [];
+  for (const skill of loaded.skills.slice(0, maxSkills)) {
+    try {
+      const content = await readFile(skill.filePath, "utf8");
+      const report = inspectSkillText(content, skill.name);
+      reports.push({ ...report, path: skill.filePath, source: skill.sourceInfo.source, scannedBytes: Buffer.byteLength(content, "utf8") });
+    } catch {
+      reports.push({
+        name: skillName(skill.name),
+        risk: "review",
+        score: 2,
+        findings: [{ code: "read_error", severity: "medium", message: "Skill 文件无法读取，已标记为需要复核。" }],
+        path: skill.filePath,
+        source: skill.sourceInfo.source,
+        scannedBytes: 0,
+      });
+    }
+  }
+  return reports;
+}
+
+export default {
+  name: "pi-skill-guard",
+  inject: ["piResources", "piPluginUi", "piTools"],
+  apply(context: Context) {
+    let reports: ScannedSkillReport[] = [];
+    let scans = 0;
+    const unregister = context.piTools.register(
+      defineTool({
+        name: "skill_guard_scan",
+        label: "Skill guard scan",
+        description:
+          "Audit loaded Agent Skills for instruction override, secret exfiltration, destructive commands, and obfuscation without retaining skill source text.",
+        promptSnippet: "audit loaded skills for prompt injection and unsafe command risks",
+        parameters: Type.Object({ query: Type.Optional(Type.String()) }),
+        async execute(_toolCallId, params): Promise<AgentToolResult<{ total: number; blocked: number; review: number; reports: ScannedSkillReport[] }>> {
+          const query = (params.query ?? "").trim().toLocaleLowerCase();
+          if (query.length > 120) throw new Error("Skill guard query must contain 0-120 characters");
+          reports = await scanLoadedSkills(context);
+          scans += 1;
+          const filtered = reports.filter((report) => query === "" || `${report.name} ${report.source}`.toLocaleLowerCase().includes(query));
+          const result = {
+            total: filtered.length,
+            blocked: filtered.filter((report) => report.risk === "blocked").length,
+            review: filtered.filter((report) => report.risk === "review").length,
+            reports: filtered,
+          };
+          return {
+            content: [{ type: "text", text: `${result.total} skill(s) scanned: ${result.blocked} blocked, ${result.review} review.` }],
+            details: result,
+          };
+        },
+      }),
+    );
+    const disposePanel = context.piPluginUi.register({
+      id: "skill-guard-panel",
+      pluginId: "@pi-harness/core/plugins/skill-guard",
+      title: "Skill Guard",
+      description: "审计已加载 Skill 的提示词覆盖、秘密外传和危险命令，只保存风险摘要。",
+      icon: "◇",
+      read: () => ({
+        scans,
+        total: reports.length,
+        blocked: reports.filter((report) => report.risk === "blocked").length,
+        review: reports.filter((report) => report.risk === "review").length,
+        reports,
+      }),
+    });
+    void scanLoadedSkills(context).then((nextReports) => {
+      reports = nextReports;
+      scans = 1;
+    });
+    context.effect(() => () => {
+      unregister();
+      disposePanel();
+    });
+  },
+};

package/packages/core/src/plugins/sql-lens.ts

@@ -0,0 +1,92 @@
+import { DatabaseSync } from "node:sqlite";
+import { realpath, stat } from "node:fs/promises";
+import { relative, resolve } from "node:path";
+import type { Context } from "@deepseek-ai/cordis";
+import { Type } from "@earendil-works/pi-ai";
+import { defineTool, type AgentToolResult } from "@earendil-works/pi-coding-agent";
+
+type SqlReport = { database: string; query: string; columns: string[]; rows: Record<string, unknown>[]; truncated: boolean };
+
+function databasePath(workspace: string, requested: string): { absolute: string; relative: string } {
+  const root = resolve(workspace);
+  const absolute = resolve(root, requested);
+  const path = relative(root, absolute);
+  if (path.startsWith("..") || path.includes("/..")) throw new Error("Database path must stay inside the current workspace");
+  return { absolute, relative: path || "." };
+}
+
+function assertReadOnlyQuery(query: string): string {
+  const normalized = query.trim().replace(/;+$/g, "");
+  if (!/^(select|pragma|with)\b/i.test(normalized)) throw new Error("SQL Lens only allows SELECT, WITH, and PRAGMA queries");
+  if (/^pragma\b/i.test(normalized)) {
+    if (
+      !/^pragma\s+(table_info|table_xinfo|index_list|index_info|foreign_key_list|database_list|user_version|schema_version|compile_options|encoding|page_count|page_size|freelist_count|application_id|auto_vacuum)\b/i.test(
+        normalized,
+      )
+    )
+      throw new Error("SQL Lens rejected a non-read-only PRAGMA");
+  }
+  if (/[;=]|\b(insert|update|delete|drop|alter|create|attach|detach|vacuum|reindex|replace)\b/i.test(normalized))
+    throw new Error("SQL Lens rejected a mutating or multi-statement query");
+  return normalized;
+}
+
+export default {
+  name: "pi-sql-lens",
+  inject: ["piHarnessLaunch", "piPluginUi", "piTools"],
+  apply(context: Context) {
+    let latest: SqlReport | undefined;
+    const run = async (database = "data.db", query = "SELECT name, type FROM sqlite_master ORDER BY type, name"): Promise<SqlReport> => {
+      const workspace = await realpath(context.piHarnessLaunch.cwd);
+      const requested = databasePath(workspace, database);
+      const canonical = databasePath(workspace, await realpath(requested.absolute));
+      const location = canonical;
+      const metadata = await stat(location.absolute);
+      if (!metadata.isFile()) throw new Error("Database path is not a file");
+      const safeQuery = assertReadOnlyQuery(query);
+      const db = new DatabaseSync(location.absolute, { readOnly: true });
+      try {
+        const rows = db.prepare(safeQuery).all() as Record<string, unknown>[];
+        const limited = rows.slice(0, 100);
+        latest = {
+          database: location.relative,
+          query: safeQuery,
+          columns: limited.length ? Object.keys(limited[0] ?? {}) : [],
+          rows: limited,
+          truncated: rows.length > limited.length,
+        };
+        return latest;
+      } finally {
+        db.close();
+      }
+    };
+    const unregisterTool = context.piTools.register(
+      defineTool({
+        name: "sql_readonly",
+        label: "SQL read-only",
+        description: "Inspect a SQLite database with a bounded read-only SELECT, WITH, or PRAGMA query.",
+        promptSnippet: "inspect a local SQLite database without writes",
+        parameters: Type.Object({
+          database: Type.Optional(Type.String({ description: "SQLite path relative to workspace" })),
+          query: Type.Optional(Type.String({ description: "Read-only SELECT, WITH, or PRAGMA query" })),
+        }),
+        async execute(_toolCallId, params): Promise<AgentToolResult<SqlReport>> {
+          const report = await run(params.database, params.query);
+          return { content: [{ type: "text", text: `${report.database}: ${report.rows.length} row(s).` }], details: report };
+        },
+      }),
+    );
+    const disposePanel = context.piPluginUi.register({
+      id: "sql-lens-panel",
+      pluginId: "@pi-harness/core/plugins/sql-lens",
+      title: "SQL Lens",
+      description: "以只读模式浏览 SQLite 数据库 Schema 和查询结果。",
+      icon: "⌗",
+      read: () => ({ latest: latest ?? null }),
+    });
+    context.effect(() => () => {
+      unregisterTool();
+      disposePanel();
+    });
+  },
+};

package/packages/core/src/plugins/stdio.ts

@@ -1,10 +1,12 @@
 import type { Context } from "@deepseek-ai/cordis";
 import { StdioApplication } from "../stdio.js";
+import { assertKnownConfigKeys } from "../config.js";
 
 export default {
   name: "pi-stdio",
   inject: ["piRuntime", "piResources", "piHarnessStdio", "piHarnessLaunch"],
-  apply(context: Context) {
+  apply(context: Context, config: unknown) {
+    assertKnownConfigKeys("pi-stdio", config, []);
     const application = new StdioApplication(context.piRuntime, context.piHarnessLaunch, context.piHarnessStdio);
     for (const diagnostic of context.piResources.diagnostics) {
       if (diagnostic.type !== "error") context.piHarnessStdio.writeError(`Resource ${diagnostic.type}: ${diagnostic.message}\n`);

package/packages/core/src/plugins/synapse.ts

@@ -0,0 +1,130 @@
+import type { Context } from "@deepseek-ai/cordis";
+import z from "@deepseek-ai/schemastery";
+import { Type } from "@earendil-works/pi-ai";
+import { defineTool, SessionManager, type AgentToolResult, type SessionInfo } from "@earendil-works/pi-coding-agent";
+import { assertKnownConfigKeys } from "../config.js";
+
+const defaultMaxSessions = 500;
+const maxAllowedSessions = 2_000;
+const maxLabelLength = 120;
+
+export interface SynapsePluginConfig {
+  maxSessions?: number;
+}
+
+export const Config: z<SynapsePluginConfig> = z.object({
+  maxSessions: z.number().default(defaultMaxSessions),
+});
+
+export interface SynapseNode {
+  id: string;
+  sessionId: string;
+  label: string;
+  cwd: string;
+  parentSessionId?: string;
+  messageCount: number;
+  modified: string;
+  active: boolean;
+  branchCount: number;
+}
+
+export interface SynapseEdge {
+  from: string;
+  to: string;
+  kind: "fork";
+}
+
+export interface SynapseGraph {
+  nodes: SynapseNode[];
+  edges: SynapseEdge[];
+  activeSessionId?: string;
+  orphanCount: number;
+}
+
+function sessionLabel(session: SessionInfo): string {
+  const value = session.name?.trim() || session.firstMessage.trim() || session.id;
+  return value.length > maxLabelLength ? `${value.slice(0, maxLabelLength - 1)}…` : value;
+}
+
+export function buildSynapseGraph(sessions: readonly SessionInfo[], activePath?: string): SynapseGraph {
+  const byPath = new Map(sessions.map((session) => [session.path, session]));
+  const children = new Map<string, number>();
+  const edges: SynapseEdge[] = [];
+  let orphanCount = 0;
+  for (const session of sessions) {
+    const parentPath = session.parentSessionPath;
+    if (parentPath === undefined) continue;
+    const parent = byPath.get(parentPath);
+    if (parent === undefined) {
+      orphanCount += 1;
+      continue;
+    }
+    children.set(parent.id, (children.get(parent.id) ?? 0) + 1);
+    edges.push({ from: parent.id, to: session.id, kind: "fork" });
+  }
+  const activeSessionId = sessions.find((session) => session.path === activePath)?.id;
+  return {
+    nodes: sessions.map((session) => {
+      const parent = session.parentSessionPath === undefined ? undefined : byPath.get(session.parentSessionPath);
+      return {
+        id: session.id,
+        sessionId: session.id,
+        label: sessionLabel(session),
+        cwd: session.cwd,
+        ...(parent === undefined ? {} : { parentSessionId: parent.id }),
+        messageCount: session.messageCount,
+        modified: session.modified.toISOString(),
+        active: session.path === activePath,
+        branchCount: children.get(session.id) ?? 0,
+      };
+    }),
+    edges,
+    ...(activeSessionId === undefined ? {} : { activeSessionId }),
+    orphanCount,
+  };
+}
+
+export default {
+  name: "pi-synapse",
+  inject: ["piHarnessLaunch", "piSession", "piPluginUi", "piTools"],
+  Config,
+  apply(context: Context, config: SynapsePluginConfig) {
+    assertKnownConfigKeys("pi-synapse", config, ["maxSessions"]);
+    const maxSessions = Math.max(1, Math.min(maxAllowedSessions, Math.trunc(config.maxSessions ?? defaultMaxSessions)));
+    let graph: SynapseGraph = { nodes: [], edges: [], orphanCount: 0 };
+    let refreshes = 0;
+
+    const refresh = async (): Promise<SynapseGraph> => {
+      const sessions = await SessionManager.list(context.piHarnessLaunch.cwd, context.piSession.manager.getSessionDir());
+      graph = buildSynapseGraph(sessions.slice(0, maxSessions), context.piSession.manager.getSessionFile());
+      refreshes += 1;
+      return graph;
+    };
+
+    const refreshTool = context.piTools.register(
+      defineTool({
+        name: "synapse_session_map",
+        label: "Refresh session map",
+        description: "Refresh the Synapse view from Pi's native session files and return fork relationships for the current workspace.",
+        promptSnippet: "inspect the native Pi session map and fork lineage",
+        parameters: Type.Object({}),
+        async execute(): Promise<AgentToolResult<SynapseGraph>> {
+          const next = await refresh();
+          return { content: [{ type: "text", text: `Synapse mapped ${next.nodes.length} session(s) and ${next.edges.length} fork edge(s).` }], details: next };
+        },
+      }),
+    );
+    const disposePanel = context.piPluginUi.register({
+      id: "synapse-panel",
+      pluginId: "@pi-harness/core/plugins/synapse",
+      title: "Synapse",
+      description: "将当前工作区的原生 Pi 会话与 fork 关系投影成可浏览地图。",
+      icon: "⌘",
+      read: async () => ({ ...(await refresh()), refreshes }),
+    });
+    context.effect(() => () => {
+      refreshTool();
+      disposePanel();
+    });
+  },
+};

package/packages/core/src/plugins/tab-manager.ts

@@ -0,0 +1,135 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { Context } from "@deepseek-ai/cordis";
+import { Type } from "@earendil-works/pi-ai";
+import { defineTool, type AgentToolResult } from "@earendil-works/pi-coding-agent";
+
+const storageFile = "session-tabs.json";
+const maxTabs = 24;
+type Tab = { id: string; label: string; sessionPath: string; pinned: boolean; updatedAt: string };
+type TabState = { tabs: Tab[]; activeId: string | null };
+
+function emptyState(): TabState {
+  return { tabs: [], activeId: null };
+}
+
+async function readState(path: string): Promise<TabState> {
+  try {
+    const parsed: unknown = JSON.parse(await readFile(path, "utf8"));
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return emptyState();
+    const value = parsed as { tabs?: unknown; activeId?: unknown };
+    const tabs = Array.isArray(value.tabs)
+      ? value.tabs.filter(
+          (tab): tab is Tab =>
+            tab !== null &&
+            typeof tab === "object" &&
+            typeof (tab as { id?: unknown }).id === "string" &&
+            typeof (tab as { label?: unknown }).label === "string" &&
+            typeof (tab as { sessionPath?: unknown }).sessionPath === "string" &&
+            typeof (tab as { pinned?: unknown }).pinned === "boolean" &&
+            typeof (tab as { updatedAt?: unknown }).updatedAt === "string",
+        )
+      : [];
+    return { tabs: tabs.slice(0, maxTabs), activeId: typeof value.activeId === "string" ? value.activeId : null };
+  } catch {
+    return emptyState();
+  }
+}
+
+async function persist(path: string, state: TabState): Promise<void> {
+  await writeFile(path, JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+
+export default {
+  name: "pi-tab-manager",
+  inject: ["piHarnessLaunch", "piSession", "piPluginUi", "piTools"],
+  async apply(context: Context) {
+    const path = join(context.piHarnessLaunch.agentDir, storageFile);
+    const state = await readState(path);
+    let writes = 0;
+    const activeSession = (): { id: string; sessionPath: string } => ({
+      id: context.piSession.manager.getSessionId(),
+      sessionPath: context.piSession.manager.getSessionFile() ?? join(context.piHarnessLaunch.agentDir, `${context.piSession.manager.getSessionId()}.jsonl`),
+    });
+    const upsert = (id: string, sessionPath: string, label: string | undefined, pinned: boolean): Tab => {
+      const now = new Date().toISOString();
+      const existing = state.tabs.find((tab) => tab.id === id || tab.sessionPath === sessionPath);
+      if (existing !== undefined) {
+        existing.label = label?.trim() || existing.label;
+        existing.pinned = pinned;
+        existing.updatedAt = now;
+        state.activeId = existing.id;
+        return existing;
+      }
+      if (state.tabs.length >= maxTabs) throw new Error(`A maximum of ${maxTabs} session tabs is supported`);
+      const tab = { id, label: label?.trim() || id, sessionPath, pinned, updatedAt: now };
+      state.tabs = [tab, ...state.tabs];
+      state.activeId = tab.id;
+      return tab;
+    };
+    const unregisterTool = context.piTools.register(
+      defineTool({
+        name: "session_tab_manage",
+        label: "Session tabs",
+        description: "Pin, rename, activate, remove, or list lightweight session tabs without deleting session files.",
+        promptSnippet: "organize open Pi sessions as named tabs",
+        parameters: Type.Object({
+          action: Type.Union(["pin", "unpin", "rename", "activate", "remove", "list"]),
+          sessionPath: Type.Optional(Type.String()),
+          label: Type.Optional(Type.String()),
+        }),
+        async execute(_toolCallId, params): Promise<AgentToolResult<TabState | Tab>> {
+          const active = activeSession();
+          const targetPath = params.sessionPath?.trim() || active.sessionPath;
+          const target = state.tabs.find((tab) => tab.sessionPath === targetPath);
+          if (params.action === "list") return { content: [{ type: "text", text: `${state.tabs.length} session tab(s).` }], details: state };
+          if (params.action === "activate") {
+            if (target === undefined) throw new Error("Session tab not found");
+            state.activeId = target.id;
+            target.updatedAt = new Date().toISOString();
+            await persist(path, state);
+            writes += 1;
+            return { content: [{ type: "text", text: `Active session tab: ${target.label}` }], details: state };
+          }
+          if (params.action === "remove") {
+            if (target === undefined) throw new Error("Session tab not found");
+            state.tabs = state.tabs.filter((tab) => tab !== target);
+            state.activeId = state.tabs[0]?.id ?? null;
+          } else if (params.action === "rename") {
+            if (target === undefined) throw new Error("Session tab not found");
+            const label = params.label?.trim() ?? "";
+            if (label.length === 0 || label.length > 120) throw new Error("Tab label must be 1 to 120 characters");
+            target.label = label;
+            target.updatedAt = new Date().toISOString();
+            state.activeId = target.id;
+          } else if (params.action === "pin") {
+            const tab = upsert(active.id, targetPath, params.label, params.action === "pin");
+            await persist(path, state);
+            writes += 1;
+            return { content: [{ type: "text", text: `Pinned session tab: ${tab.label}` }], details: tab };
+          } else {
+            if (target === undefined) throw new Error("Session tab not found");
+            target.pinned = false;
+            target.updatedAt = new Date().toISOString();
+            state.activeId = target.id;
+          }
+          await persist(path, state);
+          writes += 1;
+          return { content: [{ type: "text", text: `Session tabs: ${state.tabs.length}.` }], details: state };
+        },
+      }),
+    );
+    const disposePanel = context.piPluginUi.register({
+      id: "tab-manager-panel",
+      pluginId: "@pi-harness/core/plugins/tab-manager",
+      title: "Session Tabs",
+      description: "管理命名会话标签；移除标签不会删除会话文件。",
+      icon: "▣",
+      read: () => ({ activeId: state.activeId, tabs: state.tabs, writes }),
+    });
+    context.effect(() => () => {
+      unregisterTool();
+      disposePanel();
+    });
+  },
+};