pi-cost 0.1.0

package/README.md

@@ -0,0 +1,46 @@
+# pi-cost
+
+Cost dashboard for the [pi coding agent](https://pi.dev) — overview → project → session → message, with actual and estimated spend.
+
+[![pi-cost demo](./assets/session-light.png)](https://github.com/user-attachments/assets/f9383f3f-4379-4ca6-b920-badb35f5eea8)
+
+## Documentation
+
+**[→ See the documentation](https://nikiforovall.github.io/pi-cost/)**
+
+User guide, cost-source model, keyboard shortcuts, and theme authoring all live there.
+
+## Installation
+
+```sh
+pi install npm:pi-cost
+```
+
+Then use `/cost start | stop | restart | status | open` from inside pi.
+
+Or run standalone:
+
+```sh
+npx pi-cost
+```
+
+Open `http://localhost:5461` — `npm run dev` auto-opens the browser.
+
+### From source
+
+```sh
+git clone https://github.com/NikiforovAll/pi-cost
+cd pi-cost
+npm install
+npm start              # http://localhost:5461
+pi --add ./extensions  # register as a pi extension
+```
+
+## Screenshots
+
+| View            | Preview                                      |
+| --------------- | -------------------------------------------- |
+| Overview        | ![Overview](./assets/overview.png)           |
+| Project         | ![Project](./assets/project.png)             |
+| Session         | ![Session](./assets/session.png)             |
+| Session (light) | ![Session light](./assets/session-light.png) |

package/extensions/cost.ts

@@ -0,0 +1,181 @@
+import { spawn, spawnSync, type ChildProcess } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { createConnection } from "node:net";
+import { homedir } from "node:os";
+import { join as joinPath, resolve as resolvePath } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const extDir = fileURLToPath(new URL('.', import.meta.url));
+
+let child: ChildProcess | null = null;
+let lastStderr = "";
+const port = 5461;
+
+const COST_DIR = joinPath(homedir(), ".pi", "agent", "cost");
+const SETTINGS_PATH = joinPath(COST_DIR, "settings.json");
+const DEFAULT_THEME_DIR = joinPath(COST_DIR, "themes");
+
+type CostSettings = {
+	themes?: { light?: string; dark?: string; dir?: string };
+};
+
+function readSettings(): CostSettings {
+	try {
+		return JSON.parse(readFileSync(SETTINGS_PATH, "utf8")) as CostSettings;
+	} catch (e: any) {
+		if (e?.code !== "ENOENT") console.warn(`pi-cost: cannot read ${SETTINGS_PATH}: ${e.message}`);
+		return {};
+	}
+}
+
+function buildServerEnv(): NodeJS.ProcessEnv {
+	const settings = readSettings();
+	const t = settings.themes ?? {};
+	const env: NodeJS.ProcessEnv = { ...process.env, PORT: String(port) };
+	env.COST_THEME_DIR = process.env.COST_THEME_DIR ?? t.dir ?? DEFAULT_THEME_DIR;
+	if (process.env.COST_LIGHT_THEME ?? t.light) {
+		env.COST_LIGHT_THEME = process.env.COST_LIGHT_THEME ?? t.light;
+	}
+	if (process.env.COST_DARK_THEME ?? t.dark) {
+		env.COST_DARK_THEME = process.env.COST_DARK_THEME ?? t.dark;
+	}
+	return env;
+}
+
+const SUBCOMMANDS = ["start", "stop", "restart", "status", "open"] as const;
+type Sub = (typeof SUBCOMMANDS)[number];
+
+function probePort(p: number, timeoutMs = 250): Promise<boolean> {
+	return new Promise((resolve) => {
+		const sock = createConnection({ port: p, host: "127.0.0.1" });
+		const done = (ok: boolean) => { sock.destroy(); resolve(ok); };
+		sock.setTimeout(timeoutMs);
+		sock.once("connect", () => done(true));
+		sock.once("timeout", () => done(false));
+		sock.once("error", () => done(false));
+	});
+}
+
+async function waitForPort(p: number, totalMs = 5000): Promise<boolean> {
+	const start = Date.now();
+	while (Date.now() - start < totalMs) {
+		if (await probePort(p)) return true;
+		await new Promise((r) => setTimeout(r, 150));
+	}
+	return false;
+}
+
+function splitArgs(args: string): string[] {
+	return args.trim().split(/\s+/).filter(Boolean);
+}
+
+function findPidsOnPort(p: number): number[] {
+	if (process.platform === "win32") {
+		const r = spawnSync("netstat", ["-ano", "-p", "tcp"], { encoding: "utf8" });
+		if (r.status !== 0) return [];
+		const pids = new Set<number>();
+		for (const line of r.stdout.split(/\r?\n/)) {
+			const m = line.match(/^\s*TCP\s+\S+:(\d+)\s+\S+\s+LISTENING\s+(\d+)/i);
+			if (m && Number(m[1]) === p) pids.add(Number(m[2]));
+		}
+		return [...pids];
+	}
+	const r = spawnSync("lsof", ["-tiTCP:" + p, "-sTCP:LISTEN"], { encoding: "utf8" });
+	if (r.status !== 0) return [];
+	return r.stdout.split(/\s+/).map((s) => Number(s)).filter((n) => Number.isFinite(n) && n > 0);
+}
+
+function killPid(pid: number): void {
+	if (process.platform === "win32") {
+		spawnSync("taskkill", ["/F", "/PID", String(pid)], { stdio: "ignore" });
+	} else {
+		try { process.kill(pid, "SIGKILL"); } catch {}
+	}
+}
+
+export default function costExtension(pi: ExtensionAPI) {
+	const serverPath = resolvePath(extDir, "..", "server.js");
+	const url = `http://localhost:${port}`;
+
+	type Notify = (m: string, l?: "info" | "error") => void;
+
+	async function startServer(notify: Notify, opts: { silentSuccess?: boolean } = {}): Promise<boolean> {
+		if (await probePort(port)) {
+			notify(`pi-cost already listening on ${url} — run /cost open to launch it`);
+			return true;
+		}
+		lastStderr = "";
+		child = spawn(process.execPath, [serverPath], {
+			env: buildServerEnv(),
+			stdio: ["ignore", "ignore", "pipe"],
+			detached: true,
+			windowsHide: true,
+		});
+		child.stderr?.on("data", (b) => { lastStderr += b.toString(); });
+		child.on("exit", () => { child = null; });
+
+		if (!(await waitForPort(port))) {
+			notify(`pi-cost failed to start.\n${lastStderr.slice(-500) || "(no stderr)"}`, "error");
+			return false;
+		}
+		child.stderr?.removeAllListeners("data");
+		child.stderr?.resume();
+		child.unref();
+		if (!opts.silentSuccess) notify(`pi-cost started → ${url} — run /cost open to launch it`);
+		return true;
+	}
+
+	async function stopServer(notify: Notify, opts: { silentSuccess?: boolean } = {}): Promise<boolean> {
+		if (child) child.kill("SIGINT");
+		child = null;
+
+		if (await probePort(port)) {
+			const pids = findPidsOnPort(port);
+			for (const pid of pids) killPid(pid);
+			await new Promise((r) => setTimeout(r, 300));
+			if (await probePort(port)) {
+				notify(`port ${port} still in use after killing pids ${pids.join(",") || "?"}`, "error");
+				return false;
+			}
+			if (!opts.silentSuccess) {
+				notify(`pi-cost stopped (killed orphan pid${pids.length > 1 ? "s" : ""} ${pids.join(",")})`);
+			}
+			return true;
+		}
+		if (!opts.silentSuccess) notify("pi-cost stopped");
+		return true;
+	}
+
+	pi.registerCommand("cost", {
+		description: "pi-cost dashboard: start | stop | restart | status | open",
+		getArgumentCompletions: (prefix) =>
+			SUBCOMMANDS.filter((s) => s.startsWith(prefix)).map((s) => ({ value: s, label: s })),
+		handler: async (args, ctx) => {
+			const tokens = splitArgs(args);
+			const sub = (tokens[0] || "start") as Sub;
+			const notify = (m: string, l: "info" | "error" = "info") => ctx.ui.notify(m, l);
+
+			if (sub === "start") { await startServer(notify); return; }
+			if (sub === "stop") { await stopServer(notify); return; }
+			if (sub === "restart") {
+				if (!(await stopServer(notify, { silentSuccess: true }))) return;
+				if (!(await startServer(notify, { silentSuccess: true }))) return;
+				notify(`pi-cost restarted → ${url}`);
+				return;
+			}
+			if (sub === "status") {
+				const up = await probePort(port);
+				const owned = child ? ` (pid ${child.pid})` : " (external)";
+				notify(up ? `running on ${url}${owned}` : "not running");
+				return;
+			}
+			if (sub === "open") {
+				const { default: open } = await import("open");
+				await open(url);
+				return;
+			}
+			notify(`Usage: /cost ${SUBCOMMANDS.join("|")}`, "error");
+		},
+	});
+}

package/extensions/package.json

@@ -0,0 +1 @@
+{ "type": "module" }

package/extensions/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2024",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "lib": ["es2024"],
+    "types": ["node"]
+  },
+  "include": ["./**/*.ts"]
+}

package/lib/pi-parsers-cost.js

@@ -0,0 +1,297 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const readline = require('node:readline');
+
+const PI_DIR = process.env.PI_DIR || path.join(os.homedir(), '.pi');
+const SESSIONS_DIR = path.join(PI_DIR, 'agent', 'sessions');
+
+function getPiDir() { return PI_DIR; }
+function getSessionsDir() { return SESSIONS_DIR; }
+
+// "--C--Users-nikiforovall-dev-pi--" -> "C:\Users\nikiforovall\dev\pi"
+function decodeProjectDir(name) {
+  let s = name;
+  if (s.startsWith('--')) s = s.slice(2);
+  if (s.endsWith('--')) s = s.slice(0, -2);
+  const m = s.match(/^([A-Za-z])--(.+)$/);
+  if (m) return `${m[1]}:\\${m[2].replace(/-/g, '\\')}`;
+  return s.replace(/-/g, path.sep);
+}
+
+async function listSessionFiles() {
+  let projDirs;
+  try { projDirs = await fs.promises.readdir(SESSIONS_DIR, { withFileTypes: true }); }
+  catch { return []; }
+  const projects = projDirs.filter((d) => d.isDirectory());
+  const perProject = await Promise.all(projects.map(async (d) => {
+    const projDir = d.name;
+    const projPath = path.join(SESSIONS_DIR, projDir);
+    let files;
+    try { files = await fs.promises.readdir(projPath, { withFileTypes: true }); }
+    catch { return []; }
+    const jsonls = files.filter((f) => f.isFile() && f.name.endsWith('.jsonl'));
+    const stats = await Promise.all(jsonls.map(async (f) => {
+      const full = path.join(projPath, f.name);
+      try {
+        const s = await fs.promises.stat(full);
+        return { file: full, projectDir: projDir, cwd: decodeProjectDir(projDir), mtime: s.mtime, mtimeMs: s.mtimeMs, size: s.size };
+      } catch { return null; }
+    }));
+    return stats.filter(Boolean);
+  }));
+  return perProject.flat();
+}
+
+// Nested subagent JSONLs live under <projectDir>/<parentSessionId>/<runId>/run-N/session.jsonl.
+// Cost is already accounted for inline in the parent's `subagent` toolResult; we list
+// them separately so the UI can drill into a specific run.
+async function listNestedSubagentFiles() {
+  let projDirs;
+  try { projDirs = await fs.promises.readdir(SESSIONS_DIR, { withFileTypes: true }); }
+  catch { return []; }
+  const out = [];
+  await Promise.all(projDirs.filter((d) => d.isDirectory()).map(async (proj) => {
+    const projPath = path.join(SESSIONS_DIR, proj.name);
+    let parentDirs;
+    try { parentDirs = await fs.promises.readdir(projPath, { withFileTypes: true }); }
+    catch { return; }
+    await Promise.all(parentDirs.filter((d) => d.isDirectory()).map(async (parent) => {
+      const parentPath = path.join(projPath, parent.name);
+      let runDirs;
+      try { runDirs = await fs.promises.readdir(parentPath, { withFileTypes: true }); }
+      catch { return; }
+      await Promise.all(runDirs.filter((d) => d.isDirectory()).map(async (run) => {
+        const runPath = path.join(parentPath, run.name);
+        let attempts;
+        try { attempts = await fs.promises.readdir(runPath, { withFileTypes: true }); }
+        catch { return; }
+        await Promise.all(attempts.filter((d) => d.isDirectory()).map(async (attempt) => {
+          const file = path.join(runPath, attempt.name, 'session.jsonl');
+          try {
+            const s = await fs.promises.stat(file);
+            out.push({
+              file,
+              projectDir: proj.name,
+              parentDirName: parent.name,
+              runId: run.name,
+              attempt: attempt.name,
+              mtime: s.mtime, mtimeMs: s.mtimeMs, size: s.size,
+            });
+          } catch {}
+        }));
+      }));
+    }));
+  }));
+  return out;
+}
+
+async function readJsonlLines(file) {
+  return new Promise((resolve, reject) => {
+    const lines = [];
+    const stream = fs.createReadStream(file, { encoding: 'utf8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    rl.on('line', (l) => { if (l.trim()) lines.push(l); });
+    rl.on('close', () => resolve(lines));
+    rl.on('error', reject);
+  });
+}
+
+function parseLine(line) {
+  try { return JSON.parse(line); } catch { return null; }
+}
+
+async function readSessionEntriesUncached(file) {
+  const lines = await readJsonlLines(file);
+  const entries = [];
+  for (const l of lines) {
+    const e = parseLine(l);
+    if (e) entries.push(e);
+  }
+  return entries;
+}
+
+const SESSION_CACHE_MAX = 200;
+const sessionCache = new Map();
+
+function cachePut(file, entry) {
+  if (sessionCache.has(file)) sessionCache.delete(file);
+  sessionCache.set(file, entry);
+  while (sessionCache.size > SESSION_CACHE_MAX) {
+    sessionCache.delete(sessionCache.keys().next().value);
+  }
+}
+
+function basenameWithoutExt(file) { return path.basename(file, '.jsonl'); }
+
+function slugFromFile(file) {
+  const base = basenameWithoutExt(file);
+  const idx = base.indexOf('_');
+  return idx >= 0 ? base.slice(idx + 1) : base;
+}
+
+// Aggregate per-session totals. Mirrors pi-kanban's summarize() but trimmed to
+// the fields we need for cost reporting.
+function summarize(entries) {
+  let sessionEntry = null;
+  let lastTimestamp = null;
+  let firstTimestamp = null;
+  let totalCost = 0;
+  let totalInput = 0;
+  let totalOutput = 0;
+  let totalCacheRead = 0;
+  let totalCacheWrite = 0;
+  let userCount = 0;
+  let assistantCount = 0;
+  let messageCount = 0;
+  let provider = null;
+  let model = null;
+  let customTitle = null;
+  let firstUserText = null;
+  let parentSession = null;
+
+  for (const e of entries) {
+    if (e.type === 'session') {
+      sessionEntry = e;
+      if (e.parentSession) parentSession = e.parentSession;
+      if (!firstTimestamp) firstTimestamp = e.timestamp || null;
+    } else if (e.type === 'session_info') {
+      if (typeof e.name === 'string' && e.name.trim()) customTitle = e.name.trim();
+    } else if (e.type === 'model_change') {
+      provider = e.provider || provider;
+      model = e.modelId || model;
+    } else if (e.type === 'message') {
+      messageCount++;
+      if (!firstTimestamp) firstTimestamp = e.timestamp || null;
+      lastTimestamp = e.timestamp || lastTimestamp;
+      const m = e.message || {};
+      if (m.role === 'user') {
+        userCount++;
+        if (!firstUserText) {
+          const c = m.content;
+          const txt = Array.isArray(c) ? c.find((x) => x && x.type === 'text')?.text : null;
+          if (txt) firstUserText = txt;
+        }
+      } else if (m.role === 'assistant') {
+        assistantCount++;
+        const u = m.usage;
+        if (u) {
+          totalInput += u.input || 0;
+          totalOutput += u.output || 0;
+          totalCacheRead += u.cacheRead || 0;
+          totalCacheWrite += u.cacheWrite || 0;
+          totalCost += (u.cost && u.cost.total) || 0;
+        }
+        if (m.provider) provider = m.provider;
+        if (m.model) model = m.model;
+      }
+    }
+  }
+
+  return {
+    sessionEntry,
+    firstTimestamp,
+    lastTimestamp,
+    totalCost,
+    totalInput,
+    totalOutput,
+    totalCacheRead,
+    totalCacheWrite,
+    totalTokens: totalInput + totalOutput + totalCacheRead + totalCacheWrite,
+    userCount,
+    assistantCount,
+    messageCount,
+    provider,
+    model,
+    customTitle,
+    firstUserText,
+    parentSession,
+  };
+}
+
+async function getCachedSession(file, knownStat = null) {
+  const stat = knownStat || await fs.promises.stat(file);
+  const cached = sessionCache.get(file);
+  if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+    cachePut(file, cached);
+    return cached;
+  }
+  const entries = await readSessionEntriesUncached(file);
+  const summary = summarize(entries);
+  const entry = { mtimeMs: stat.mtimeMs, size: stat.size, entries, summary };
+  cachePut(file, entry);
+  return entry;
+}
+
+function invalidateSessionCache(file) {
+  if (file) sessionCache.delete(file);
+  else sessionCache.clear();
+}
+
+// Yields { ts, provider, model, usage, messageId } per assistant message with usage.
+function* enumerateMessageUsages(entries) {
+  let provider = null;
+  let model = null;
+  for (const e of entries) {
+    if (e.type === 'model_change') {
+      provider = e.provider || provider;
+      model = e.modelId || model;
+      continue;
+    }
+    if (e.type !== 'message') continue;
+    const m = e.message || {};
+    if (m.role !== 'assistant') continue;
+    const u = m.usage;
+    if (!u) continue;
+    yield {
+      ts: e.timestamp || null,
+      provider: m.provider || provider,
+      model: m.model || model,
+      usage: u,
+      messageId: e.id || null,
+    };
+  }
+}
+
+// Yields { ts, agent, task, model, usage, runId, jsonlPath } per subagent run.
+// pi records subagent invocations as `subagent` tool results in the parent's
+// JSONL; each `details.results[]` entry is one run with its own usage block.
+function* enumerateSubagentRuns(entries) {
+  for (const e of entries) {
+    if (e.type !== 'message') continue;
+    const m = e.message;
+    if (!m || m.role !== 'toolResult' || m.toolName !== 'subagent') continue;
+    const results = m.details && Array.isArray(m.details.results) ? m.details.results : [];
+    for (const r of results) {
+      if (!r || !r.usage) continue;
+      yield {
+        ts: e.timestamp || m.timestamp || null,
+        agent: r.agent || null,
+        task: r.task || null,
+        model: r.model || null,
+        usage: r.usage,
+        runId: m.details?.runId || null,
+        jsonlPath: r.sessionFile || r.artifactPaths?.jsonlPath || null,
+        turns: r.usage.turns || null,
+        exitCode: r.exitCode ?? null,
+      };
+    }
+  }
+}
+
+module.exports = {
+  getPiDir,
+  getSessionsDir,
+  decodeProjectDir,
+  listSessionFiles,
+  listNestedSubagentFiles,
+  readSessionEntriesUncached,
+  summarize,
+  getCachedSession,
+  invalidateSessionCache,
+  enumerateMessageUsages,
+  enumerateSubagentRuns,
+  slugFromFile,
+};