pi-kanban 0.3.1 → 2.0.0

package/lib/inline-assets.js

@@ -0,0 +1,238 @@
+// Inlines an HTML file's local assets so it renders standalone inside the preview's
+// `srcdoc` iframe. An `about:srcdoc` document has no URL of its own, so every relative
+// href resolves against the app origin and 404s — the only way a sibling stylesheet,
+// script or image can reach the frame is embedded in the document text.
+//
+// Remote refs (https:, //cdn, data:) are left untouched: they already resolve.
+
+const path = require('node:path');
+const fs = require('node:fs').promises;
+
+// Individually large assets are the ones that blow up as base64 (+33%), and the total
+// guards the modal: the whole document is handed to the client in one JSON response.
+// Both count bytes on disk, charged once per unique file — the delivered document is
+// larger than the total whenever an asset is base64'd or referenced twice.
+const MAX_ASSET_BYTES = 4 * 1024 * 1024;
+const MAX_TOTAL_BYTES = 16 * 1024 * 1024;
+// @import chains are followed, so a cycle needs both a depth stop and a seen-set.
+const MAX_IMPORT_DEPTH = 5;
+
+const MIME_BY_EXT = {
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.avif': 'image/avif',
+  '.svg': 'image/svg+xml',
+  '.ico': 'image/x-icon',
+  '.bmp': 'image/bmp',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf',
+  '.otf': 'font/otf',
+  '.eot': 'application/vnd.ms-fontobject',
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+  '.ogv': 'video/ogg',
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+  '.ogg': 'audio/ogg',
+  '.json': 'application/json',
+  '.css': 'text/css',
+  '.js': 'text/javascript'
+};
+
+function isRemoteRef(ref) {
+  return !ref || /^[a-z][a-z0-9+.-]*:/i.test(ref) || ref.startsWith('//') || ref.startsWith('#');
+}
+
+function mimeFor(file) {
+  return MIME_BY_EXT[path.extname(file).toLowerCase()] || 'application/octet-stream';
+}
+
+// Reads an attribute out of a tag, quoted or bare. Returns undefined when absent.
+function attrOf(tag, name) {
+  const q = new RegExp(`${name.replace(':', '\\:')}\\s*=\\s*(['"])(.*?)\\1`, 'i');
+  return tag.match(q)?.[2] ?? tag.match(new RegExp(`${name.replace(':', '\\:')}\\s*=\\s*([^\\s>]+)`, 'i'))?.[1];
+}
+
+// Rewrites every match of `re` in one pass: `fn` receives the match array and returns
+// the replacement, or null to leave that match alone. Replacements are resolved
+// concurrently (each reads its own asset) and spliced by offset, so the string is
+// rebuilt once instead of once per match.
+async function replaceMatches(text, re, fn) {
+  const matches = [...text.matchAll(re)];
+  if (!matches.length) return text;
+  const replacements = await Promise.all(matches.map(m => fn(m)));
+  const out = [];
+  let cursor = 0;
+  matches.forEach((m, i) => {
+    if (replacements[i] == null) return;
+    out.push(text.slice(cursor, m.index), replacements[i]);
+    cursor = m.index + m[0].length;
+  });
+  out.push(text.slice(cursor));
+  return out.join('');
+}
+
+// One context threads through a whole document: the cache means an asset referenced by
+// twenty rules is read, size-checked and charged exactly once, and nested @import/url()
+// chains can't each spend the full allowance.
+async function loadAsset(absPath, ctx) {
+  if (!ctx.cache.has(absPath)) {
+    ctx.cache.set(
+      absPath,
+      (async () => {
+        const stat = await fs.stat(absPath);
+        if (!stat.isFile()) throw new Error('not a file');
+        if (stat.size > MAX_ASSET_BYTES || ctx.spent + stat.size > MAX_TOTAL_BYTES) {
+          ctx.skipped.push({ path: absPath, size: stat.size, reason: 'too large' });
+          return null;
+        }
+        ctx.spent += stat.size;
+        return fs.readFile(absPath);
+      })()
+    );
+  }
+  return ctx.cache.get(absPath);
+}
+
+async function loadText(absPath, ctx) {
+  return (await loadAsset(absPath, ctx))?.toString('utf8') ?? null;
+}
+
+async function toDataUri(absPath, ctx) {
+  const buf = await loadAsset(absPath, ctx);
+  return buf === null ? null : `data:${mimeFor(absPath)};base64,${buf.toString('base64')}`;
+}
+
+// Resolves a ref against `baseDir` and hands the loaded asset to `use`. Remote refs and
+// unreadable files yield null, which every caller treats as "leave the markup as
+// authored" so the frame degrades to the pre-inlining behaviour.
+async function withAsset(ref, baseDir, use) {
+  if (isRemoteRef(ref)) return null;
+  try {
+    return await use(path.resolve(baseDir, ref));
+  } catch {
+    return null;
+  }
+}
+
+const CSS_IMPORT = /@import\s+(?:url\(\s*)?(['"]?)([^'")\s;]+)\1\s*\)?\s*([^;]*);/gi;
+const CSS_URL = /url\(\s*(['"]?)([^'")]+)\1\s*\)/gi;
+
+// Rewrites url(...) targets and follows @import into the imported sheet's own directory —
+// a nested sheet's relative refs are relative to *it*, not to the document.
+async function inlineCss(css, baseDir, ctx, depth = 0, seen = new Set()) {
+  let out = css;
+
+  if (depth < MAX_IMPORT_DEPTH) {
+    out = await replaceMatches(out, CSS_IMPORT, ([, , ref, media]) =>
+      withAsset(ref, baseDir, async abs => {
+        if (seen.has(abs)) return null;
+        const text = await loadText(abs, ctx);
+        if (text === null) return null;
+        const nested = await inlineCss(text, path.dirname(abs), ctx, depth + 1, new Set([...seen, abs]));
+        // A media query on the @import has to survive as a wrapper or the rules leak.
+        return media.trim() ? `@media ${media.trim()}{\n${nested}\n}` : nested;
+      })
+    );
+  }
+
+  return replaceMatches(out, CSS_URL, ([, , ref]) =>
+    withAsset(ref, baseDir, async abs => {
+      const uri = await toDataUri(abs, ctx);
+      return uri && `url("${uri}")`;
+    })
+  );
+}
+
+// `</script>` anywhere in inlined JS (a string, a regex, a template) would close the tag
+// early and dump the rest as markup.
+function escapeScript(js) {
+  return js.replace(/<\/script/gi, '<\\/script');
+}
+
+function inlineStylesheets(html, baseDir, ctx) {
+  return replaceMatches(html, /<link\b[^>]*>/gi, async ([tag]) => {
+    if (!/rel\s*=\s*(['"]?)[^'">]*\bstylesheet\b/i.test(tag)) return null;
+    return withAsset(attrOf(tag, 'href'), baseDir, async abs => {
+      const css = await loadText(abs, ctx);
+      if (css === null) return null;
+      const inlined = await inlineCss(css, path.dirname(abs), ctx, 0, new Set([abs]));
+      const media = attrOf(tag, 'media');
+      return `<style${media ? ` media="${media}"` : ''}>\n${inlined}\n</style>`;
+    });
+  });
+}
+
+function inlineStyleElements(html, baseDir, ctx) {
+  return replaceMatches(html, /<style\b[^>]*>([\s\S]*?)<\/style>/gi, async ([tag, css]) => {
+    if (!/url\(|@import/i.test(css)) return null;
+    const inlined = await inlineCss(css, baseDir, ctx);
+    return inlined === css ? null : tag.replace(css, inlined);
+  });
+}
+
+function inlineScripts(html, baseDir, ctx) {
+  return replaceMatches(html, /<script\b[^>]*\bsrc\s*=[^>]*>\s*<\/script>/gi, ([tag]) =>
+    withAsset(attrOf(tag, 'src'), baseDir, async abs => {
+      const js = await loadText(abs, ctx);
+      if (js === null) return null;
+      // Keep type= (module vs classic changes semantics); drop src/defer/async, which
+      // mean nothing once the body is inline.
+      const type = attrOf(tag, 'type');
+      return `<script${type ? ` type="${type}"` : ''}>\n${escapeScript(js)}\n</script>`;
+    })
+  );
+}
+
+// src/poster/href on media and image tags. `<use href>` covers sprite sheets, which are
+// the one SVG case that silently renders nothing when unresolved.
+const SRC_ATTR_TAGS = /<(img|source|video|audio|use)\b[^>]*>/gi;
+const SRC_ATTR = /\b(src|poster|href|xlink:href)\s*=\s*(['"])(.*?)\2/gi;
+
+function inlineElementSrcs(html, baseDir, ctx) {
+  return replaceMatches(html, SRC_ATTR_TAGS, async ([tag]) => {
+    let out = await replaceMatches(tag, SRC_ATTR, ([, name, , ref]) =>
+      withAsset(ref, baseDir, async abs => {
+        const uri = await toDataUri(abs, ctx);
+        return uri && `${name}="${uri}"`;
+      })
+    );
+    // srcset is a comma-separated candidate list, each entry `url [descriptor]`.
+    const srcset = out.match(/srcset\s*=\s*(['"])(.*?)\1/i);
+    if (srcset) {
+      const parts = await Promise.all(
+        srcset[2].split(',').map(async entry => {
+          const [ref, ...rest] = entry.trim().split(/\s+/);
+          const uri = await withAsset(ref, baseDir, abs => toDataUri(abs, ctx));
+          return uri ? [uri, ...rest].join(' ') : entry.trim();
+        })
+      );
+      out = out.replace(srcset[0], `srcset="${parts.join(', ')}"`);
+    }
+    return out === tag ? null : out;
+  });
+}
+
+/**
+ * Embeds every resolvable local asset an HTML document references.
+ *
+ * @returns {Promise<{ html: string, bytes: number, skipped: Array<{path:string,size:number,reason:string}> }>}
+ */
+async function inlineHtmlAssets(html, absHtmlPath) {
+  const baseDir = path.dirname(absHtmlPath);
+  const ctx = { spent: 0, skipped: [], cache: new Map() };
+  // Author-written <style> blocks first: after inlineStylesheets a <link> has become a
+  // <style> whose refs are already resolved, and re-walking megabytes of data URIs to
+  // find nothing is the one pass worth ordering around.
+  let out = await inlineStyleElements(html, baseDir, ctx);
+  out = await inlineStylesheets(out, baseDir, ctx);
+  out = await inlineScripts(out, baseDir, ctx);
+  out = await inlineElementSrcs(out, baseDir, ctx);
+  return { html: out, bytes: ctx.spent, skipped: ctx.skipped };
+}
+
+module.exports = { inlineHtmlAssets, MIME_BY_EXT, MAX_ASSET_BYTES };

package/lib/linked-docs.js

@@ -0,0 +1,56 @@
+// Server copy of each session's linked docs: file paths and http(s) URLs. The browser keeps its own list in localStorage
+// and merges this one in when it connects, so a `doc link` sent while no tab is open is not lost.
+// Newest first, capped like the browser list.
+
+const { linkUrl, MAX_LINKED_DOCS } = require('../public/link-url');
+
+// Same rule as `canonicalPath` in public/app.js: one Windows file is reached as `C:\a` and `c:/a`.
+function canonicalPath(p) {
+  const slashed = String(p).replace(/\\/g, '/');
+  return /^[A-Za-z]:/.test(slashed) ? slashed.toLowerCase() : slashed;
+}
+
+/**
+ * @param {object} o
+ * @param {() => object|null} o.load returns `{sessions: {[id]: string[]}}` or null
+ * @param {(data: object) => void} o.save
+ */
+function createLinkedDocStore({ load, save }) {
+  const bySession = new Map();
+  const saved = load()?.sessions;
+  if (saved && typeof saved === 'object') {
+    for (const [id, paths] of Object.entries(saved)) {
+      const clean = Array.isArray(paths) ? paths.filter((p) => typeof p === 'string' && p) : [];
+      if (clean.length) bySession.set(id, clean.slice(0, MAX_LINKED_DOCS));
+    }
+  }
+
+  const persist = () => save({ version: 1, sessions: Object.fromEntries(bySession) });
+
+  function link(sessionId, filePath) {
+    const key = canonicalPath(filePath);
+    const rest = (bySession.get(sessionId) || []).filter((p) => canonicalPath(p) !== key);
+    bySession.set(sessionId, [filePath, ...rest].slice(0, MAX_LINKED_DOCS));
+    persist();
+  }
+
+  // With no path, forgets every doc of the session. Returns whether anything was removed.
+  function unlink(sessionId, filePath) {
+    const paths = bySession.get(sessionId);
+    if (!paths) return false;
+    const key = filePath == null ? null : canonicalPath(filePath);
+    const rest = key === null ? [] : paths.filter((p) => canonicalPath(p) !== key);
+    if (rest.length === paths.length) return false;
+    if (rest.length) bySession.set(sessionId, rest);
+    else bySession.delete(sessionId);
+    persist();
+    return true;
+  }
+
+  const get = (sessionId) => [...(bySession.get(sessionId) || [])];
+  const all = () => Object.fromEntries([...bySession].map(([id, paths]) => [id, [...paths]]));
+
+  return { link, unlink, get, all };
+}
+
+module.exports = { createLinkedDocStore, canonicalPath, linkUrl, MAX_LINKED_DOCS };

package/lib/live-sessions.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { writeJsonAtomic } = require('./atomic-write');
+
+// The live-session registry the pi extension writes: one <pid>.json per interactive pi process.
+function readLiveSessions(sessionsDir) {
+  const sessions = [];
+  let files;
+  try {
+    files = fs.readdirSync(sessionsDir).filter((f) => f.endsWith('.json'));
+  } catch {
+    return sessions;
+  }
+  for (const file of files) {
+    try {
+      const s = JSON.parse(fs.readFileSync(path.join(sessionsDir, file), 'utf8'));
+      if (s?.sessionId && s.kind === 'interactive') {
+        sessions.push({ sessionId: s.sessionId, pid: s.pid || null, cwd: s.cwd || null, sessionDir: s.sessionDir || null, startedAt: s.startedAt || 0, status: s.status || null, statusUpdatedAt: s.statusUpdatedAt || null, name: s.name || null });
+      }
+    } catch { /* skip invalid */ }
+  }
+  return sessions;
+}
+
+// EPERM means the process exists but belongs to someone else.
+function isPidAlive(pid) {
+  try { process.kill(pid, 0); return true; } catch (e) { return e.code === 'EPERM'; }
+}
+
+// A registry file outlives a crashed pi, so the pid is probed rather than trusted.
+function isSessionLive(sessions, sessionId, exceptPid = null) {
+  return sessions.some((s) => {
+    if (s.sessionId !== sessionId || !s.pid || s.pid === exceptPid) return false;
+    return isPidAlive(s.pid);
+  });
+}
+
+// /new and /resume keep pi's process and registry file and swap its sessionId, so the id
+// that pid held before is finished even though its transcript was written moments ago. `replaced`
+// maps that id to when the swap was seen; an id that shows up live again leaves it.
+function noteReplacedSessions(prev, next, replaced, now, ttlMs) {
+  for (const [id, at] of replaced) if (now - at > ttlMs) replaced.delete(id);
+  if (prev) {
+    const byPid = new Map(next.filter((s) => s.pid).map((s) => [s.pid, s.sessionId]));
+    for (const s of prev) {
+      const id = s.pid && byPid.get(s.pid);
+      if (id && id !== s.sessionId) replaced.set(s.sessionId, now);
+    }
+  }
+  for (const s of next) replaced.delete(s.sessionId);
+}
+
+const liveFile = (dir, pid) => path.join(dir, `${pid}.json`);
+
+// The pi extension writes the registry that readLiveSessions reads: one file per pi process,
+// rewritten in place when /new, /resume or /fork swaps the session that process runs.
+async function writeLiveSession(dir, entry) {
+  await writeJsonAtomic(liveFile(dir, entry.pid), { kind: 'interactive', ...entry });
+}
+
+async function removeLiveSession(dir, pid) {
+  await fs.promises.rm(liveFile(dir, pid), { force: true });
+}
+
+// For a process 'exit' handler, where async work never runs.
+function removeLiveSessionSync(dir, pid) {
+  fs.rmSync(liveFile(dir, pid), { force: true });
+}
+
+// A pi that was killed never removes its file.
+async function sweepDeadLiveSessions(dir) {
+  let files;
+  try {
+    files = await fs.promises.readdir(dir);
+  } catch {
+    return;
+  }
+  for (const file of files) {
+    const pid = /^(\d+)\.json$/.exec(file)?.[1];
+    if (pid && !isPidAlive(Number(pid))) await fs.promises.rm(path.join(dir, file), { force: true });
+  }
+}
+
+module.exports = { readLiveSessions, isPidAlive, isSessionLive, noteReplacedSessions, writeLiveSession, removeLiveSession, removeLiveSessionSync, sweepDeadLiveSessions };

package/lib/model-windows.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const fs = require('node:fs');
+const { writeJsonAtomic } = require('./atomic-write');
+
+// A session file names the model of each reply but not its context window, and `pi --list-models`
+// rounds the window. The pi extension copies the exact windows of the models pi has auth for from
+// its model registry into this file, keyed "<provider>/<model id>".
+const MODEL_WINDOWS_FILE = 'model-windows.json';
+
+const modelKey = (provider, id) => `${provider}/${id}`;
+
+function readModelWindows(file) {
+  try {
+    const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return data && typeof data === 'object' && !Array.isArray(data) ? data : {};
+  } catch {
+    return {};
+  }
+}
+
+// Each pi process adds its registry and keeps the entries it does not know, so an old session
+// whose model another pi registered still finds its window.
+async function recordModelWindows(file, models) {
+  const windows = readModelWindows(file);
+  let changed = false;
+  for (const m of models) {
+    if (!m?.provider || !m.id || !(m.contextWindow > 0)) continue;
+    const key = modelKey(m.provider, m.id);
+    if (windows[key] === m.contextWindow) continue;
+    windows[key] = m.contextWindow;
+    changed = true;
+  }
+  if (changed) await writeJsonAtomic(file, windows);
+  return changed;
+}
+
+// The context of the last reply as pi counts it (calculateContextTokens in its compaction module).
+// Null when the reply has no usage or its model's window is unknown.
+function contextOf(reply, windows) {
+  const u = reply?.usage;
+  const window = reply?.provider && reply.model ? windows[modelKey(reply.provider, reply.model)] : null;
+  if (!u || !(window > 0)) return null;
+  const tokens = u.input_tokens + u.cache_read_input_tokens + u.cache_creation_input_tokens + u.output_tokens;
+  return tokens > 0 ? { tokens, window } : null;
+}
+
+module.exports = { MODEL_WINDOWS_FILE, readModelWindows, recordModelWindows, contextOf };