pi-export-notool 0.1.1 → 0.2.0

package/README.md

@@ -10,9 +10,21 @@ Start Pi with this extension, then run:
 /export-notool [output.html]
 ```
 
-Pi's built-in `/export` remains unchanged. `/export-notool` creates an HTML variant without tool or thinking blocks.
+Pi's built-in `/export` remains unchanged. `/export-notool` creates an HTML variant without visible tool or thinking blocks.
 
-If no path is supplied, it writes `pi-no-tools-<session-id>.html` in the current working directory. The output is created with Pi's built-in HTML exporter, then gets an idempotent stylesheet that hides `.tool-execution` and `.thinking-block` elements. The sidebar remains unchanged, so Pi's built-in **No-tools** toggle continues to work. Session data remains embedded in the file; this is display-only hiding.
+If no path is supplied, it writes `pi-no-tools-<session-id>.html` in the current working directory. The output is created with Pi's built-in HTML exporter, then gets an idempotent stylesheet that hides `.tool-execution` and `.thinking-block` elements. The sidebar remains unchanged, so Pi's built-in **No-tools** toggle continues to work. Session data remains embedded in the file; the default command is display-only hiding.
+
+### Publish mode
+
+For an HTML file intended to be shared, put `--publish` before the optional path:
+
+```text
+/export-notool --publish [output.html]
+```
+
+Publish mode writes `pi-no-tools-publish-<session-id>.html` by default. It physically removes tool calls, tool results, shell executions, thinking blocks, hidden extension state, system prompts, tool schemas, rendered tool data, and path-bearing session header metadata from the embedded payload. Unknown entry and content-block types are omitted rather than assumed safe, and retained entries are re-parented so Pi's session tree still works. Pi's unsanitized intermediate export is created only in a temporary directory and deleted before the command returns.
+
+The remaining visible textual conversation is scanned before it is written. Credential detection uses the MIT-licensed [`@sanity-labs/secret-scan`](https://github.com/sanity-labs/secret-scan) package; its distributed license attributes the incorporated detection rules to the MIT-licensed [Gitleaks](https://github.com/gitleaks/gitleaks) project. The extension also checks for POSIX, Windows, and UNC absolute paths. If it finds potential sensitive information, it shows grouped finding types without echoing matched values and requires confirmation. In a mode that cannot prompt, the publish export fails closed. Findings are warnings, not automatic redaction, and no pattern-based scanner can guarantee that content is safe to share.
 
 ## Development
 
@@ -27,3 +39,9 @@ Run its regression tests:
 ```bash
 npm test
 ```
+
+Publish a tested public release:
+
+```bash
+npm run publish:npm
+```

package/extensions/pi-export-notool/command-args.js

@@ -0,0 +1,8 @@
+/** Parse /export-notool arguments while preserving spaces in the output path. */
+export function parseExportArguments(args) {
+  const trimmed = args.trim();
+  const publishMatch = trimmed.match(/^--publish(?:\s+([\s\S]*))?$/);
+  return publishMatch
+    ? { publish: true, requestedPath: publishMatch[1]?.trim() ?? "" }
+    : { publish: false, requestedPath: trimmed };
+}

package/extensions/pi-export-notool/export-command.js

@@ -0,0 +1,118 @@
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { parseExportArguments } from "./command-args.js";
+import { injectNoToolCss } from "./html-injection.js";
+import { createPublishHtml } from "./publish-export.js";
+import { findSensitiveInfo, formatSensitiveWarning } from "./sensitive-info.js";
+
+const EXPORT_TIMEOUT_MS = 60_000;
+
+function outputPathFor(options, cwd, sessionFile) {
+  const sessionId = basename(sessionFile, ".jsonl");
+  const defaultName = options.publish
+    ? `pi-no-tools-publish-${sessionId}.html`
+    : `pi-no-tools-${sessionId}.html`;
+  const outputPath = resolve(cwd, options.requestedPath || defaultName);
+
+  if (extname(outputPath).toLowerCase() !== ".html") {
+    throw new Error("Output path must use the .html extension.");
+  }
+
+  return outputPath;
+}
+
+async function runPiExport(pi, sessionFile, outputPath, cwd) {
+  // Use Pi's own exporter so the output keeps the installed export template and theme.
+  const result = await pi.exec(
+    "pi",
+    ["--no-extensions", "--export", sessionFile, outputPath],
+    { cwd, timeout: EXPORT_TIMEOUT_MS },
+  );
+  if (result.killed || result.code !== 0) {
+    const stderr = typeof result.stderr === "string" ? result.stderr.trim() : "";
+    const stdout = typeof result.stdout === "string" ? result.stdout.trim() : "";
+    throw new Error(stderr || stdout || "Pi HTML export failed.");
+  }
+}
+
+async function writePublishExport(pi, ctx, sessionFile, outputPath) {
+  const temporaryDirectory = await mkdtemp(join(tmpdir(), "pi-export-notool-"));
+  const temporaryOutput = join(temporaryDirectory, "export.html");
+
+  let published;
+  try {
+    // Never place Pi's unsanitized export at the requested publish path, even briefly.
+    await runPiExport(pi, sessionFile, temporaryOutput, ctx.cwd);
+    const sourceHtml = await readFile(temporaryOutput, "utf8");
+    published = createPublishHtml(sourceHtml);
+  } finally {
+    // Delete the unsanitized file before prompting or writing the requested output.
+    await rm(temporaryDirectory, { recursive: true, force: true });
+  }
+
+  const findings = findSensitiveInfo(published.sessionData);
+  if (findings.length > 0) {
+    if (!ctx.hasUI) {
+      throw new Error(
+        `Publish export found ${findings.length} potential sensitive item(s), but this mode cannot request confirmation.`,
+      );
+    }
+
+    const confirmed = await ctx.ui.confirm(
+      "Sensitive information detected",
+      formatSensitiveWarning(findings),
+    );
+    if (!confirmed) {
+      ctx.ui.notify("Publish export cancelled; no file was written.", "info");
+      return undefined;
+    }
+  }
+
+  await mkdir(dirname(outputPath), { recursive: true });
+  await writeFile(outputPath, injectNoToolCss(published.html), "utf8");
+
+  return {
+    removedItems: Object.values(published.stats).reduce((total, count) => total + count, 0),
+    sensitiveItems: findings.length,
+  };
+}
+
+/** Create the /export-notool handler. Exported separately for command-level tests. */
+export function createExportNoToolHandler(pi) {
+  return async (args, ctx) => {
+    const sessionFile = ctx.sessionManager.getSessionFile();
+    if (!sessionFile) {
+      ctx.ui.notify("No saved session is available to export yet.", "error");
+      return;
+    }
+
+    try {
+      const options = parseExportArguments(args);
+      const outputPath = outputPathFor(options, ctx.cwd, sessionFile);
+
+      if (options.publish) {
+        const result = await writePublishExport(pi, ctx, sessionFile, outputPath);
+        if (!result) return;
+
+        const warningSuffix = result.sensitiveItems > 0
+          ? ` after confirming ${result.sensitiveItems} sensitive finding(s)`
+          : "";
+        ctx.ui.notify(
+          `Publish HTML export written to ${outputPath} (${result.removedItems} internal item(s) removed${warningSuffix})`,
+          "info",
+        );
+        return;
+      }
+
+      await mkdir(dirname(outputPath), { recursive: true });
+      await runPiExport(pi, sessionFile, outputPath, ctx.cwd);
+      const html = await readFile(outputPath, "utf8");
+      await writeFile(outputPath, injectNoToolCss(html), "utf8");
+      ctx.ui.notify(`No-tool HTML export written to ${outputPath}`, "info");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      ctx.ui.notify(`No-tool export failed: ${message}`, "error");
+    }
+  };
+}

package/extensions/pi-export-notool/index.ts

@@ -1,57 +1,11 @@
-import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { basename, dirname, extname, resolve } from "node:path";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { injectNoToolCss } from "./html-injection.js";
-
-const EXPORT_TIMEOUT_MS = 60_000;
-
-function outputPathFor(args: string, cwd: string, sessionFile: string): string {
-  const requestedPath = args.trim();
-  const defaultName = `pi-no-tools-${basename(sessionFile, ".jsonl")}.html`;
-  const outputPath = resolve(cwd, requestedPath || defaultName);
-
-  if (extname(outputPath).toLowerCase() !== ".html") {
-    throw new Error("Output path must use the .html extension.");
-  }
-
-  return outputPath;
-}
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createExportNoToolHandler } from "./export-command.js";
 
 export default function (pi: ExtensionAPI) {
-  const exportNoTool = async (args: string, ctx: ExtensionCommandContext) => {
-      const sessionFile = ctx.sessionManager.getSessionFile();
-      if (!sessionFile) {
-        ctx.ui.notify("No saved session is available to export yet.", "error");
-        return;
-      }
-
-      try {
-        const outputPath = outputPathFor(args, ctx.cwd, sessionFile);
-        await mkdir(dirname(outputPath), { recursive: true });
-
-        // Use Pi's own exporter so the output keeps the active export template and theme.
-        const result = await pi.exec(
-          "pi",
-          ["--no-extensions", "--export", sessionFile, outputPath],
-          { cwd: ctx.cwd, timeout: EXPORT_TIMEOUT_MS },
-        );
-        if (result.killed || result.code !== 0) {
-          throw new Error(result.stderr.trim() || result.stdout.trim() || "Pi HTML export failed.");
-        }
-
-        const html = await readFile(outputPath, "utf8");
-        await writeFile(outputPath, injectNoToolCss(html), "utf8");
-        ctx.ui.notify(`No-tool HTML export written to ${outputPath}`, "info");
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        ctx.ui.notify(`No-tool export failed: ${message}`, "error");
-      }
-  };
-
   // Interactive TUI handles Pi's built-in /export before extension commands,
   // so /export-notool is the explicit no-tool export command.
   pi.registerCommand("export-notool", {
-    description: "Export the current session to HTML with tool-call blocks hidden",
-    handler: exportNoTool,
+    description: "Export with tool blocks hidden; use --publish to physically remove them",
+    handler: createExportNoToolHandler(pi),
   });
 }

package/extensions/pi-export-notool/publish-export.js

@@ -0,0 +1,348 @@
+import { Buffer } from "node:buffer";
+
+const SESSION_DATA_SCRIPT = /(<script\b[^>]*\bid=(["'])session-data\2[^>]*>)([\s\S]*?)(<\/script\s*>)/gi;
+
+function copyString(target, source, key) {
+  if (typeof source[key] === "string") target[key] = source[key];
+}
+
+function copyFiniteNumber(target, source, key) {
+  if (typeof source[key] === "number" && Number.isFinite(source[key])) target[key] = source[key];
+}
+
+function sanitizeUsage(usage) {
+  if (!usage || typeof usage !== "object" || Array.isArray(usage)) return undefined;
+
+  const sanitized = {};
+  for (const key of ["input", "output", "cacheRead", "cacheWrite", "totalTokens"]) {
+    copyFiniteNumber(sanitized, usage, key);
+  }
+
+  if (usage.cost && typeof usage.cost === "object" && !Array.isArray(usage.cost)) {
+    const cost = {};
+    for (const key of ["input", "output", "cacheRead", "cacheWrite", "total"]) {
+      copyFiniteNumber(cost, usage.cost, key);
+    }
+    if (Object.keys(cost).length > 0) sanitized.cost = cost;
+  }
+
+  return Object.keys(sanitized).length > 0 ? sanitized : undefined;
+}
+
+function sanitizeVisibleContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return undefined;
+
+  const sanitized = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object" || Array.isArray(block)) continue;
+    if (block.type === "text" && typeof block.text === "string") {
+      sanitized.push({ type: "text", text: block.text });
+    } else if (
+      block.type === "image" &&
+      typeof block.data === "string" &&
+      typeof block.mimeType === "string"
+    ) {
+      sanitized.push({ type: "image", data: block.data, mimeType: block.mimeType });
+    }
+  }
+  return sanitized;
+}
+
+function sanitizeHeader(header) {
+  if (!header || typeof header !== "object" || Array.isArray(header)) {
+    throw new Error("The exported session header is missing or invalid.");
+  }
+
+  const sanitized = {};
+  if (header.type === "session") sanitized.type = "session";
+  copyFiniteNumber(sanitized, header, "version");
+  copyString(sanitized, header, "id");
+  copyString(sanitized, header, "timestamp");
+  return sanitized;
+}
+
+function baseEntry(entry) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry) || typeof entry.id !== "string") {
+    return undefined;
+  }
+
+  const sanitized = { type: entry.type, id: entry.id, parentId: null };
+  if (typeof entry.parentId === "string") sanitized.parentId = entry.parentId;
+  if (typeof entry.timestamp === "string" || typeof entry.timestamp === "number") {
+    sanitized.timestamp = entry.timestamp;
+  }
+  return sanitized;
+}
+
+function sanitizeMessageEntry(entry, stats) {
+  const base = baseEntry(entry);
+  const message = entry?.message;
+  if (!base || !message || typeof message !== "object" || Array.isArray(message)) {
+    stats.removedOpaqueEntries++;
+    return undefined;
+  }
+
+  if (message.role === "toolResult") {
+    stats.removedToolResults++;
+    return undefined;
+  }
+  if (message.role === "bashExecution") {
+    stats.removedBashExecutions++;
+    return undefined;
+  }
+
+  if (message.role === "user") {
+    const content = sanitizeVisibleContent(message.content);
+    if (content === undefined) {
+      stats.removedOpaqueEntries++;
+      return undefined;
+    }
+
+    const sanitizedMessage = { role: "user", content };
+    copyFiniteNumber(sanitizedMessage, message, "timestamp");
+    return { ...base, message: sanitizedMessage };
+  }
+
+  if (message.role === "assistant") {
+    if (!Array.isArray(message.content)) {
+      stats.removedOpaqueEntries++;
+      return undefined;
+    }
+
+    const content = [];
+    for (const block of message.content) {
+      if (!block || typeof block !== "object" || Array.isArray(block)) {
+        stats.removedOpaqueBlocks++;
+        continue;
+      }
+      if (block.type === "text" && typeof block.text === "string") {
+        content.push({ type: "text", text: block.text });
+      } else if (block.type === "thinking" || String(block.type).toLowerCase().includes("thinking")) {
+        stats.removedThinkingBlocks++;
+      } else if (block.type === "toolCall") {
+        stats.removedToolCalls++;
+      } else {
+        stats.removedOpaqueBlocks++;
+      }
+    }
+
+    const hasVisibleText = content.some((block) => block.text.trim().length > 0);
+    const hasVisibleError = message.stopReason === "error" || message.stopReason === "aborted";
+    if (!hasVisibleText && !hasVisibleError) {
+      stats.removedAssistantMessages++;
+      return undefined;
+    }
+
+    const sanitizedMessage = { role: "assistant", content };
+    for (const key of ["api", "provider", "model", "stopReason", "errorMessage"]) {
+      copyString(sanitizedMessage, message, key);
+    }
+    copyFiniteNumber(sanitizedMessage, message, "timestamp");
+    const usage = sanitizeUsage(message.usage);
+    if (usage) sanitizedMessage.usage = usage;
+    return { ...base, message: sanitizedMessage };
+  }
+
+  stats.removedOpaqueEntries++;
+  return undefined;
+}
+
+function sanitizeEntry(entry, stats) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+    stats.removedOpaqueEntries++;
+    return undefined;
+  }
+
+  if (entry.type === "message") return sanitizeMessageEntry(entry, stats);
+
+  const base = baseEntry(entry);
+  if (!base) {
+    stats.removedOpaqueEntries++;
+    return undefined;
+  }
+
+  if (
+    entry.type === "compaction" &&
+    typeof entry.summary === "string" &&
+    typeof entry.tokensBefore === "number" &&
+    Number.isFinite(entry.tokensBefore)
+  ) {
+    return { ...base, summary: entry.summary, tokensBefore: entry.tokensBefore };
+  }
+
+  if (entry.type === "branch_summary" && typeof entry.summary === "string") {
+    const sanitized = { ...base, summary: entry.summary };
+    copyString(sanitized, entry, "fromId");
+    return sanitized;
+  }
+
+  if (entry.type === "custom_message" && entry.display === true) {
+    const content = sanitizeVisibleContent(entry.content);
+    if (content === undefined) {
+      stats.removedOpaqueEntries++;
+      return undefined;
+    }
+    const sanitized = { ...base, customType: "extension", content, display: true };
+    copyString(sanitized, entry, "customType");
+    return sanitized;
+  }
+
+  if (entry.type === "model_change") {
+    const sanitized = { ...base };
+    copyString(sanitized, entry, "provider");
+    copyString(sanitized, entry, "modelId");
+    return sanitized;
+  }
+
+  if (entry.type === "thinking_level_change") {
+    const sanitized = { ...base };
+    copyString(sanitized, entry, "thinkingLevel");
+    return sanitized;
+  }
+
+  if (entry.type === "label" && typeof entry.targetId === "string" && typeof entry.label === "string") {
+    return { ...base, targetId: entry.targetId, label: entry.label };
+  }
+
+  stats.removedOpaqueEntries++;
+  return undefined;
+}
+
+function nearestRetainedId(startId, originalById, retainedIds) {
+  let currentId = typeof startId === "string" ? startId : undefined;
+  const visited = new Set();
+
+  while (currentId && !visited.has(currentId)) {
+    if (retainedIds.has(currentId)) return currentId;
+    visited.add(currentId);
+    const current = originalById.get(currentId);
+    currentId = typeof current?.parentId === "string" ? current.parentId : undefined;
+  }
+
+  return null;
+}
+
+function validateRetainedTree(entries) {
+  const byId = new Map(entries.map((entry) => [entry.id, entry]));
+  for (const entry of entries) {
+    const visited = new Set();
+    let current = entry;
+
+    while (current) {
+      if (visited.has(current.id)) {
+        throw new Error(`Cycle in published session tree at entry: ${current.id}`);
+      }
+      visited.add(current.id);
+
+      if (current.parentId === null || current.parentId === current.id) break;
+      current = byId.get(current.parentId);
+      if (!current) throw new Error(`Missing parent in published session tree for entry: ${entry.id}`);
+    }
+  }
+}
+
+/**
+ * Reduce Pi's embedded session data to fields needed to render shareable content.
+ * Tool results, shell executions, thinking/tool-call blocks, hidden custom state,
+ * tool definitions, rendered tool HTML, system prompts, and path-bearing header
+ * metadata are deliberately not copied.
+ */
+export function sanitizeSessionData(sessionData) {
+  if (!sessionData || typeof sessionData !== "object" || Array.isArray(sessionData)) {
+    throw new Error("The exported session data is invalid.");
+  }
+  if (!Array.isArray(sessionData.entries)) {
+    throw new Error("The exported session does not contain an entries array.");
+  }
+
+  const stats = {
+    removedToolCalls: 0,
+    removedToolResults: 0,
+    removedThinkingBlocks: 0,
+    removedBashExecutions: 0,
+    removedAssistantMessages: 0,
+    removedOpaqueEntries: 0,
+    removedOpaqueBlocks: 0,
+  };
+
+  const originalById = new Map();
+  for (const entry of sessionData.entries) {
+    if (entry && typeof entry === "object" && typeof entry.id === "string") {
+      if (originalById.has(entry.id)) throw new Error(`Duplicate session entry id: ${entry.id}`);
+      originalById.set(entry.id, entry);
+    }
+  }
+
+  let entries = sessionData.entries.map((entry) => sanitizeEntry(entry, stats)).filter(Boolean);
+  let retainedIds = new Set(entries.map((entry) => entry.id));
+
+  // A label for removed content is itself hidden metadata, so omit it too.
+  entries = entries.filter((entry) => {
+    if (entry.type !== "label" || retainedIds.has(entry.targetId)) return true;
+    stats.removedOpaqueEntries++;
+    return false;
+  });
+  retainedIds = new Set(entries.map((entry) => entry.id));
+
+  for (const entry of entries) {
+    entry.parentId = nearestRetainedId(entry.parentId, originalById, retainedIds);
+    if (entry.type === "branch_summary" && entry.fromId && !retainedIds.has(entry.fromId)) {
+      const fromId = nearestRetainedId(entry.fromId, originalById, retainedIds);
+      if (fromId) entry.fromId = fromId;
+      else delete entry.fromId;
+    }
+  }
+
+  validateRetainedTree(entries);
+
+  const leafId = nearestRetainedId(sessionData.leafId, originalById, retainedIds)
+    ?? entries.at(-1)?.id
+    ?? null;
+
+  return {
+    sessionData: {
+      header: sanitizeHeader(sessionData.header),
+      entries,
+      leafId,
+    },
+    stats,
+  };
+}
+
+/** Extract and decode the single session-data script from a Pi HTML export. */
+export function extractSessionData(html) {
+  const matches = [...html.matchAll(SESSION_DATA_SCRIPT)];
+  if (matches.length !== 1) {
+    throw new Error("Expected exactly one Pi session-data script in the exported HTML.");
+  }
+
+  const encoded = matches[0][3].trim();
+  if (!encoded || !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded)) {
+    throw new Error("The Pi session-data script is not valid base64.");
+  }
+
+  try {
+    return JSON.parse(Buffer.from(encoded, "base64").toString("utf8"));
+  } catch {
+    throw new Error("The Pi session-data script could not be decoded.");
+  }
+}
+
+/** Replace Pi's embedded session payload with a physically sanitized payload. */
+export function createPublishHtml(html) {
+  const matches = [...html.matchAll(SESSION_DATA_SCRIPT)];
+  if (matches.length !== 1) {
+    throw new Error("Expected exactly one Pi session-data script in the exported HTML.");
+  }
+
+  const originalData = extractSessionData(html);
+  const { sessionData, stats } = sanitizeSessionData(originalData);
+  const encoded = Buffer.from(JSON.stringify(sessionData), "utf8").toString("base64");
+  const match = matches[0];
+  const replacement = `${match[1]}${encoded}${match[4]}`;
+  const start = match.index;
+  const publishedHtml = html.slice(0, start) + replacement + html.slice(start + match[0].length);
+
+  return { html: publishedHtml, sessionData, stats };
+}

package/extensions/pi-export-notool/sensitive-info.js

@@ -0,0 +1,111 @@
+import { scan } from "@sanity-labs/secret-scan";
+
+// Avoid URL pathnames by requiring a boundary that cannot be the host or URL scheme.
+const POSIX_ABSOLUTE_PATH = /(^|[\s("'`=\[])((?:\/(?!\/)[^\s"'`<>/]+)+)/gm;
+const WINDOWS_ABSOLUTE_PATH = /(^|[\s("'`=\[])(([A-Za-z]:[\\/])[^\\/\s"'`<>]+(?:[\\/][^\\/\s"'`<>]+)*)/gm;
+const UNC_ABSOLUTE_PATH = /(^|[\s("'`=\[])(\\\\[^\\/\s"'`<>]+[\\/][^\\/\s"'`<>]+(?:[\\/][^\\/\s"'`<>]+)*)/gm;
+
+const COMMON_POSIX_ROOTS = new Set([
+  "Applications", "Library", "Users", "Volumes", "bin", "dev", "etc", "home", "mnt",
+  "opt", "private", "proc", "root", "sbin", "srv", "sys", "tmp", "usr", "var", "workspace", "workspaces",
+]);
+
+function collectStrings(value, location, output) {
+  if (typeof value === "string") {
+    output.push({ value, location });
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => collectStrings(item, `${location}[${index}]`, output));
+    return;
+  }
+
+  for (const [key, child] of Object.entries(value)) {
+    // Image bytes are opaque, high-entropy data and are not meaningful text to scan.
+    if (value.type === "image" && key === "data") continue;
+    collectStrings(child, `${location}.${key}`, output);
+  }
+}
+
+function isLikelyPosixPath(candidate) {
+  const components = candidate.slice(1).split("/");
+  if (components.length > 1) return true;
+
+  const component = components[0];
+  // One-segment slash commands are ambiguous. Still catch dotfiles, filenames,
+  // and standard filesystem roots while leaving commands such as /export-notool alone.
+  return component.startsWith(".") || component.includes(".") || COMMON_POSIX_ROOTS.has(component);
+}
+
+function findPaths(text, regex, label, location) {
+  regex.lastIndex = 0;
+  const findings = [];
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    const candidate = match[2].replace(/[),.;:!?]+$/, "");
+    const shouldReport = label !== "Absolute POSIX path" || isLikelyPosixPath(candidate);
+    if (candidate.length > 0 && shouldReport) {
+      findings.push({
+        kind: "absolute-path",
+        label,
+        confidence: "medium",
+        location,
+      });
+    }
+    if (match[0].length === 0) regex.lastIndex++;
+  }
+  return findings;
+}
+
+/**
+ * Find likely credentials and absolute paths without returning matched values.
+ * Secret patterns come from the MIT-licensed @sanity-labs/secret-scan package.
+ */
+export function findSensitiveInfo(value) {
+  const strings = [];
+  collectStrings(value, "$", strings);
+
+  const findings = [];
+  for (const item of strings) {
+    for (const secret of scan(item.value)) {
+      findings.push({
+        kind: "secret",
+        label: secret.label,
+        confidence: secret.confidence,
+        location: item.location,
+      });
+    }
+
+    findings.push(...findPaths(item.value, POSIX_ABSOLUTE_PATH, "Absolute POSIX path", item.location));
+    findings.push(...findPaths(item.value, WINDOWS_ABSOLUTE_PATH, "Absolute Windows path", item.location));
+    findings.push(...findPaths(item.value, UNC_ABSOLUTE_PATH, "Absolute UNC path", item.location));
+  }
+
+  return findings;
+}
+
+/** Build a bounded warning for Pi's confirm dialog without echoing secret values. */
+export function formatSensitiveWarning(findings) {
+  const groups = new Map();
+  for (const finding of findings) {
+    const key = `${finding.label}\u0000${finding.confidence}`;
+    const current = groups.get(key) ?? { label: finding.label, confidence: finding.confidence, count: 0 };
+    current.count++;
+    groups.set(key, current);
+  }
+
+  const grouped = [...groups.values()].sort((a, b) => b.count - a.count || a.label.localeCompare(b.label));
+  const visible = grouped.slice(0, 8);
+  const lines = visible.map((group) => `• ${group.label} (${group.confidence}): ${group.count}`);
+  if (grouped.length > visible.length) lines.push(`• ${grouped.length - visible.length} more finding type(s)`);
+
+  return [
+    `The published conversation still contains ${findings.length} potential sensitive item(s):`,
+    "",
+    ...lines,
+    "",
+    "Matched values are not shown. Continue writing the file?",
+  ].join("\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-export-notool",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Export Pi sessions to HTML without visible tool-call blocks",
   "type": "module",
   "keywords": [
@@ -8,8 +8,15 @@
     "pi-extension"
   ],
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hyein-cbio/pi-export-notool.git"
+  },
+  "homepage": "https://github.com/hyein-cbio/pi-export-notool#readme",
   "scripts": {
-    "test": "node --test test/*.test.mjs"
+    "test": "node --test test/*.test.mjs",
+    "prepublishOnly": "npm test",
+    "publish:npm": "npm publish --access public"
   },
   "files": [
     "extensions",
@@ -23,5 +30,8 @@
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*"
+  },
+  "dependencies": {
+    "@sanity-labs/secret-scan": "1.1.0"
   }
 }