cld-pi 0.0.0-stage → 0.0.2

package/js/session.js

@@ -0,0 +1,186 @@
+// What the Ctrl+P panel reads about the running CC session: cost and name
+// from the transcript JSONL, model / effort / permission mode off the
+// screen, Bash output blocks for the hide toggle. Pure functions.
+
+import { closeSync, openSync, readSync, statSync } from 'node:fs'
+
+// $ per million tokens. From the Claude API reference bundled with Claude
+// Code (model table cached 2026-10-06). cacheRead: models whose cache reads
+// aren't the usual 0.1x of input. Cache writes: 1.25x input (5-minute TTL),
+// 2x (1-hour). Haiku 5.5 is billed higher above 100K-token prompts; the
+// base rate is used here.
+const prices = {
+  'claude-fable-5-1': { input: 10, output: 50, cacheRead: 0.25 },
+  'claude-mythos-5-1': { input: 10, output: 50, cacheRead: 0.25 },
+  'claude-fable-5': { input: 10, output: 50, cacheRead: 1 },
+  'claude-opus-5-5': { input: 4, output: 20, cacheRead: 0.2, fast: { input: 8, output: 40 } },
+  'claude-opus-5': { input: 5, output: 25, fast: { input: 10, output: 50 } },
+  'claude-opus-4-8': { input: 5, output: 25 },
+  'claude-opus-4-7': { input: 5, output: 25 },
+  'claude-opus-4-6': { input: 5, output: 25 },
+  'claude-sonnet-5-5': { input: 2, output: 10, cacheRead: 0.2 },
+  'claude-sonnet-5': { input: 2, output: 10 },
+  'claude-sonnet-4-6': { input: 3, output: 15 },
+  'claude-haiku-5-5': { input: 0.1, output: 0.5 },
+  'claude-haiku-4-5': { input: 1, output: 5 },
+}
+
+/** "a/anthropic/claude-opus-5.5[1m]" → "claude-opus-5-5" (gateway prefixes, dots, context tags). */
+export function normalizeModel(m) {
+  return String(m ?? '')
+    .split('/')
+    .pop()
+    .replace(/\[.*\]$/, '')
+    .replace(/\./g, '-')
+    .replace(/-\d{8}$/, '')
+}
+
+/** Cost in $ of one assistant message's usage on `model`, or null if unpriced. */
+export function usageCost(model, u) {
+  const p = prices[normalizeModel(model)]
+  if (!p || !u) return null
+  const rate = u.speed === 'fast' && p.fast ? { ...p, ...p.fast } : p
+  const w5 = u.cache_creation?.ephemeral_5m_input_tokens ?? u.cache_creation_input_tokens ?? 0
+  const w1 = u.cache_creation?.ephemeral_1h_input_tokens ?? 0
+  const read = p.cacheRead ?? rate.input * 0.1
+  return (
+    ((u.input_tokens ?? 0) * rate.input +
+      (u.output_tokens ?? 0) * rate.output +
+      w5 * rate.input * 1.25 +
+      w1 * rate.input * 2 +
+      (u.cache_read_input_tokens ?? 0) * read) /
+    1e6
+  )
+}
+
+/** Entries of a JSONL text; lines that don't parse are skipped. */
+export function parseEntries(text) {
+  const out = []
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue
+    try {
+      out.push(JSON.parse(line))
+    } catch {}
+  }
+  return out
+}
+
+/**
+ * An entry's cost the first time its assistant message shows up, else
+ * undefined. A message is logged once per content block with the same
+ * usage, so `seen` (message ids) makes it count once. null: unpriced model.
+ */
+export function messageCost(d, seen) {
+  const m = d.message
+  if (d.type !== 'assistant' || !m?.usage) return undefined
+  const id = m.id ?? d.uuid
+  if (seen.has(id)) return undefined
+  seen.add(id)
+  return usageCost(m.model, m.usage)
+}
+
+/** Summarize a transcript (JSONL text): total cost, session name, last model. */
+export function summarizeTranscript(text) {
+  const seen = new Set()
+  let cost = 0
+  let unpriced = 0
+  let title = null
+  let aiTitle = null
+  let model = null
+  for (const d of parseEntries(text)) {
+    if (d.type === 'custom-title' && d.customTitle) title = d.customTitle
+    if (d.type === 'ai-title' && d.aiTitle) aiTitle = d.aiTitle
+    if (d.type === 'assistant' && d.message?.usage && d.message.model) model = d.message.model
+    const c = messageCost(d, seen)
+    if (c === null) unpriced++
+    else if (c !== undefined) cost += c
+  }
+  return { cost, unpriced, name: title ?? aiTitle, model }
+}
+
+/**
+ * Follow a growing JSONL file: each call returns the entries appended since
+ * the last one (a partial last line waits for its newline). Starts over
+ * when the path changes or the file shrinks.
+ */
+export function tailEntries(read = readFrom) {
+  let path = null
+  let offset = 0
+  let partial = Buffer.alloc(0)
+  return p => {
+    if (p !== path) [path, offset, partial] = [p, 0, Buffer.alloc(0)]
+    if (!p) return []
+    const r = read(p, offset)
+    if (!r) return []
+    if (r.from < offset) partial = Buffer.alloc(0)
+    offset = r.from + r.buf.length
+    const buf = Buffer.concat([partial, r.buf])
+    const nl = buf.lastIndexOf(10)
+    partial = buf.subarray(nl + 1)
+    return nl < 0 ? [] : parseEntries(buf.subarray(0, nl + 1).toString('utf8'))
+  }
+}
+
+/** Bytes of `path` from `offset` on (from 0 if it shrank): { buf, from }. */
+function readFrom(path, offset) {
+  try {
+    const size = statSync(path).size
+    const from = size < offset ? 0 : offset
+    const buf = Buffer.alloc(size - from)
+    if (buf.length) {
+      const fd = openSync(path, 'r')
+      try {
+        readSync(fd, buf, 0, buf.length, from)
+      } finally {
+        closeSync(fd)
+      }
+    }
+    return { buf, from }
+  } catch {
+    return null
+  }
+}
+
+// ---- reading CC's status line ----
+
+export const efforts = ['low', 'medium', 'high', 'xhigh', 'max']
+export const modes = ['plan', 'acc', 'auto']
+export const models = ['haiku', 'sonnet', 'opus', 'fable']
+
+/** "◐ medium · /effort" → "medium". */
+export function effortOf(text) {
+  return text.match(/\b(low|medium|high|xhigh|max)\s*·\s*\/effort/)?.[1] ?? null
+}
+
+/** Permission mode from the status line: plan / norm (manual) / auto / acc (accept edits). */
+export function modeOf(text) {
+  if (/plan mode on/.test(text)) return 'plan'
+  if (/auto mode on/.test(text)) return 'auto'
+  if (/accept edits on/.test(text)) return 'acc'
+  if (/manual mode on/.test(text)) return 'norm'
+  return null
+}
+
+/** Which of `models` a model id / display name is. */
+export function modelFamily(m) {
+  const s = String(m ?? '').toLowerCase()
+  return models.find(f => s.includes(f)) ?? null
+}
+
+/**
+ * Rows of Bash tool output: after a "● Bash(…)" header, the "⎿" row and
+ * the indented continuation rows below it.
+ */
+export function bashOutputRows(rows) {
+  const out = new Set()
+  let inBlock = false
+  rows.forEach((r, i) => {
+    if (/^[●⏺] Bash\(/.test(r)) {
+      inBlock = true
+      return
+    }
+    if (inBlock && (/^\s{2}⎿/.test(r) || /^\s{5}\S/.test(r))) out.add(i)
+    else inBlock = false
+  })
+  return out
+}

package/js/stubs.js

@@ -0,0 +1,72 @@
+// pi.command names must also show up in CC's `/` autocomplete. CC discovers
+// command files in the project / user `.claude/commands` dirs (which we must
+// not write to) or in a plugin passed with `--plugin-dir`. Plugin commands
+// are namespaced (`cldp-pi:ad`), but a frontmatter `name:` registers the bare
+// name as an alias, so typing `/ad` matches `cldp-pi:ad (ad)` in the menu.
+// The plugin dir lives in claude-p's per-run temp dir and is filled before
+// claude starts (src/pi/main.zig waits for host.js's `ready`). The wrapper
+// intercepts the line, so a stub body never runs.
+import { mkdirSync, readFileSync, rmSync, rmdirSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+/** A plugin command stub: bare alias, with a description CC shows as empty. */
+export const stub = name => `---\nname: ${name}\ndescription: "​"\n---\n`
+
+/**
+ * Sync CC command stubs to `names` in the plugin dir `dir`. Returns a
+ * function; `.cleanup()` removes every file it made. Without a dir (no
+ * sidecar plugin), it does nothing.
+ */
+export function commandStubs(dir, log = () => {}) {
+  const ours = new Map() // name -> path
+  if (!dir) {
+    const noop = () => {}
+    noop.cleanup = () => {}
+    return noop
+  }
+  const commands = join(dir, 'commands')
+  const want = names => {
+    const keep = new Set(names.filter(n => /^[A-Za-z0-9_-]{1,64}$/.test(n)))
+    for (const [name, path] of ours) {
+      if (keep.has(name)) continue
+      try {
+        rmSync(path)
+      } catch {}
+      ours.delete(name)
+    }
+    for (const name of keep) {
+      if (ours.has(name)) continue
+      const path = join(commands, name + '.md')
+      let old = null
+      try {
+        old = readFileSync(path, 'utf8')
+      } catch {}
+      if (old != null && old !== stub(name)) continue // someone else's file
+      try {
+        mkdirSync(commands, { recursive: true })
+        if (old == null) writeFileSync(path, stub(name))
+        ours.set(name, path)
+      } catch (e) {
+        log('command stub', name, e)
+      }
+    }
+    // Once every stub is gone, take the (now empty) dir with it.
+    if (!ours.size) {
+      try {
+        rmdirSync(commands) // only succeeds while empty
+      } catch {}
+    }
+  }
+  want.cleanup = () => {
+    for (const path of ours.values()) {
+      try {
+        rmSync(path)
+      } catch {}
+    }
+    ours.clear()
+    try {
+      rmdirSync(commands) // never take anyone else's files with it
+    } catch {}
+  }
+  return want
+}

package/js/tab.js

@@ -0,0 +1,94 @@
+// Tab titles for terminals that name tabs themselves (pi.tui.title):
+// Yakuake, Konsole and Guake over D-Bus. Others use the window title (OSC 2).
+import { execFile } from 'node:child_process'
+
+const run = (cmd, args) =>
+  new Promise(resolve => execFile(cmd, args, { timeout: 2000 }, (err, out) => resolve(err ? null : String(out).trim())))
+
+const gdbus = (dest, path, method, ...args) =>
+  run('gdbus', ['call', '--session', '--dest', dest, '--object-path', path, '--method', method, ...args])
+
+// gdbus prints GVariant tuples: ('text',) or (3,)
+const unwrap = r => r?.match(/^\((?:'((?:[^'\\]|\\.)*)'|(-?\d+)),?\)$/s)?.slice(1).find(x => x != null)
+const gstr = s => `'${s.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`
+
+async function qdbusBin() {
+  for (const b of ['qdbus6', 'qdbus']) if ((await run(b, ['--version'])) != null) return b
+  return null
+}
+
+// Yakuake: Konsole session /Sessions/N is Yakuake terminal N-1 (Konsole
+// counts sessions from 1, Yakuake terminals from 0, one each per terminal).
+async function yakuake(env, q) {
+  const owner = unwrap(await gdbus('org.freedesktop.DBus', '/org/freedesktop/DBus', 'org.freedesktop.DBus.GetNameOwner', 'org.kde.yakuake'))
+  if (!owner || owner !== env.KONSOLE_DBUS_SERVICE) return null
+  const n = Number(env.KONSOLE_DBUS_SESSION?.split('/').pop())
+  if (!n) return null
+  const id = await run(q, ['org.kde.yakuake', '/yakuake/sessions', 'org.kde.yakuake.sessionIdForTerminalId', String(n - 1)])
+  if (id == null || Number(id) < 0) return null
+  return {
+    get: () => run(q, ['org.kde.yakuake', '/yakuake/tabs', 'org.kde.yakuake.tabTitle', id]),
+    set: t => run(q, ['org.kde.yakuake', '/yakuake/tabs', 'org.kde.yakuake.setTabTitle', id, t]),
+  }
+}
+
+// Konsole: the tab shows the session's displayed title (role 1).
+function konsole(env, q) {
+  const call = (...a) => run(q, [env.KONSOLE_DBUS_SERVICE, env.KONSOLE_DBUS_SESSION, ...a])
+  return {
+    get: () => call('org.kde.konsole.Session.title', '1'),
+    set: t => call('org.kde.konsole.Session.setTitle', '1', t),
+  }
+}
+
+// Guake: every tab's shell has GUAKE_TAB_UUID.
+function guake(env) {
+  const call = (m, ...a) => gdbus('org.guake3.RemoteControl', '/org/guake3/RemoteControl', `org.guake3.RemoteControl.${m}`, ...a)
+  const uuid = gstr(env.GUAKE_TAB_UUID)
+  return {
+    get: async () => {
+      const i = unwrap(await call('get_index_from_uuid', uuid))
+      return i == null ? null : unwrap(await call('get_tab_name', i))
+    },
+    set: t => call('rename_tab_uuid', uuid, gstr(t)),
+  }
+}
+
+/** The tab-title backend for this terminal ({ get, set }), or null. */
+export async function pickTab(env = process.env) {
+  if (env.GUAKE_TAB_UUID) return guake(env)
+  if (env.KONSOLE_DBUS_SERVICE && env.KONSOLE_DBUS_SESSION) {
+    const q = await qdbusBin()
+    if (q) return (await yakuake(env, q)) ?? konsole(env, q)
+  }
+  return null
+}
+
+/**
+ * Open a new tab in a dropdown terminal and run `command` there. Only
+ * Yakuake and Guake have a D-Bus call that does this (Konsole's terminals
+ * can't add a tab over D-Bus). Returns true once the command was handed
+ * over; false means the caller should fall back to "paste this".
+ */
+export async function openTab(command, env = process.env) {
+  if (env.GUAKE_TAB_UUID) {
+    const call = (m, ...a) => gdbus('org.guake3.RemoteControl', '/org/guake3/RemoteControl', `org.guake3.RemoteControl.${m}`, ...a)
+    // execute_command() opens and focuses the new tab itself (guake's
+    // dbusiface.py calls guake.add_tab()), so calling add_tab here too
+    // would leave an empty extra tab behind.
+    return (await call('execute_command', gstr(command))) != null
+  }
+  if (env.KONSOLE_DBUS_SERVICE && env.KONSOLE_DBUS_SESSION) {
+    const q = await qdbusBin()
+    if (!q) return false
+    // Konsole sets the same env vars; only act when the owner is Yakuake.
+    const owner = unwrap(await gdbus('org.freedesktop.DBus', '/org/freedesktop/DBus', 'org.freedesktop.DBus.GetNameOwner', 'org.kde.yakuake'))
+    if (!owner || owner !== env.KONSOLE_DBUS_SERVICE) return false
+    // addSession() creates and focuses a tab and returns its session id;
+    // runCommandInTerminal() types the line into that session's shell.
+    const sid = await run(q, ['org.kde.yakuake', '/yakuake/sessions', 'org.kde.yakuake.addSession'])
+    if (sid == null || Number(sid) < 0) return false
+    return (await run(q, ['org.kde.yakuake', '/yakuake/sessions', 'org.kde.yakuake.runCommandInTerminal', String(sid), command])) != null
+  }
+  return false
+}

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "cld-pi",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.2",
+  "description": "claude-p fork: `claude -p` drop-in plus an interactive TUI shell around Claude Code (fullscreen), with prefix completion, overlays and JS plugins.",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "cli",
+    "tui",
+    "zig",
+    "pty",
+    "zmux",
+    "ghostty"
+  ],
+  "license": "MIT",
+  "bin": {
+    "cld-pi": "bin/claude-p.js",
+    "claude-p": "bin/claude-p.js"
+  },
+  "files": [
+    "bin/claude-p.js",
+    "scripts/install.js",
+    "js/",
+    "!js/test/",
+    "README.md",
+    "README.zh-CN.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/install.js",
+    "test": "zig build test && node --test js/test/*.test.js",
+    "build": "zig build -Doptimize=ReleaseSafe",
+    "release": "node scripts/publish.mjs",
+    "release:dry-run": "node scripts/publish.mjs --dry-run",
+    "release:local": "node scripts/publish.mjs --local-only"
+  },
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/duangsuse/claude-pi.git"
+  },
+  "bugs": {
+    "url": "https://github.com/duangsuse/claude-pi/issues"
+  },
+  "homepage": "https://github.com/duangsuse/claude-pi#readme"
+}

package/scripts/install.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+// Download the prebuilt `claude-p` binary for the current platform/arch from
+// a GitHub release and drop it into prebuilt/<plat>-<arch>/.
+//
+// Used both as the npm `postinstall` script and from `bin/claude-p.js`, so
+// `npx cld-pi` still works when npm skips install scripts (npm 11.19+ gates
+// dependency scripts behind its allow-scripts allowlist and npx skips them
+// silently by default).
+//
+// Strategy:
+//   1. If a binary already exists at the expected path (e.g. installed from
+//      cache or a previous run), do nothing.
+//   2. Otherwise, try `prebuilt/<plat>-<arch>/claude-p` shipped in the
+//      package (publishers can pre-bundle for the most common targets).
+//   3. Failing that, download from
+//      https://github.com/<repository>/releases/download/v<version>/claude-p-<plat>-<arch>.gz
+//      (repo taken from package.json), gunzip, and chmod +x.
+//
+// Proxy: Node's https client ignores HTTPS_PROXY, so when a proxy is
+// configured (and curl is available) the download goes through curl, which
+// honours the standard proxy variables. A failed direct request also falls
+// back to curl.
+//
+// If `CLAUDE_P_SKIP_DOWNLOAD=1` is set, do nothing (useful for monorepo
+// bootstraps where the binary is provided out-of-band).
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const https = require("node:https");
+const zlib = require("node:zlib");
+const { spawnSync } = require("node:child_process");
+
+const pkg = require("../package.json");
+
+function log(msg) {
+  process.stderr.write(`claude-p (install): ${msg}\n`);
+}
+
+function platformDir() {
+  return `${process.platform}-${process.arch}`;
+}
+
+function exeName() {
+  return process.platform === "win32" ? "claude-p.exe" : "claude-p";
+}
+
+function targetPath() {
+  return path.join(__dirname, "..", "prebuilt", platformDir(), exeName());
+}
+
+function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true });
+}
+
+function alreadyInstalled() {
+  try {
+    const stat = fs.statSync(targetPath());
+    return stat.isFile() && stat.size > 0;
+  } catch {
+    return false;
+  }
+}
+
+function isSupported() {
+  const okPlatform = ["darwin", "linux"].includes(process.platform);
+  const okArch = ["x64", "arm64"].includes(process.arch);
+  return okPlatform && okArch;
+}
+
+function proxyConfigured() {
+  return Boolean(
+    process.env.HTTPS_PROXY ||
+      process.env.https_proxy ||
+      process.env.HTTP_PROXY ||
+      process.env.http_proxy ||
+      process.env.ALL_PROXY ||
+      process.env.all_proxy,
+  );
+}
+
+let curlChecked = null;
+function hasCurl() {
+  if (curlChecked === null) {
+    const r = spawnSync("curl", ["--version"], { stdio: "ignore" });
+    curlChecked = !r.error && r.status === 0;
+  }
+  return curlChecked;
+}
+
+function getHttps(url) {
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, { timeout: 30_000 }, (res) => {
+      if (
+        res.statusCode &&
+        res.statusCode >= 300 &&
+        res.statusCode < 400 &&
+        res.headers.location
+      ) {
+        // Follow redirect (GitHub release assets do this).
+        res.resume();
+        resolve(getHttps(res.headers.location));
+        return;
+      }
+      if (res.statusCode !== 200) {
+        res.resume();
+        reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+        return;
+      }
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => resolve(Buffer.concat(chunks)));
+      res.on("error", reject);
+    });
+    req.on("timeout", () => req.destroy(new Error(`timed out fetching ${url}`)));
+    req.on("error", reject);
+  });
+}
+
+function getCurl(url) {
+  const tmp = path.join(os.tmpdir(), `claude-p-${process.pid}-${Date.now()}.gz`);
+  try {
+    const r = spawnSync(
+      "curl",
+      [
+        "-fsSL",
+        "--retry",
+        "3",
+        "--connect-timeout",
+        "20",
+        "--max-time",
+        "300",
+        "-o",
+        tmp,
+        url,
+      ],
+      { stdio: ["ignore", "ignore", "inherit"] },
+    );
+    if (r.error) throw r.error;
+    if (r.status !== 0) throw new Error(`curl exited ${r.status} for ${url}`);
+    return fs.readFileSync(tmp);
+  } finally {
+    fs.rmSync(tmp, { force: true });
+  }
+}
+
+async function get(url) {
+  if (proxyConfigured() && hasCurl()) return getCurl(url);
+  try {
+    return await getHttps(url);
+  } catch (err) {
+    if (hasCurl()) {
+      log(`direct download failed (${err.message}); retrying with curl`);
+      return getCurl(url);
+    }
+    throw err;
+  }
+}
+
+// GitHub repo the release assets live on, from package.json `repository`.
+function releaseRepo() {
+  const url = typeof pkg.repository === "string" ? pkg.repository : pkg.repository?.url;
+  const m = url && url.match(/github\.com[/:]([^/]+\/[^/.]+)/);
+  return m ? m[1] : null;
+}
+
+async function download(say) {
+  const repo = releaseRepo();
+  if (!repo) throw new Error("package.json has no GitHub `repository`; no release to download from");
+  const url = `https://github.com/${repo}/releases/download/v${pkg.version}/claude-p-${platformDir()}.gz`;
+  say(`downloading ${url}`);
+  const gz = await get(url);
+  const bin = zlib.gunzipSync(gz);
+  const dest = targetPath();
+  ensureDir(path.dirname(dest));
+  fs.writeFileSync(dest, bin, { mode: 0o755 });
+  say(`installed ${dest} (${bin.length} bytes)`);
+}
+
+// Returns true when the binary is present afterwards. Never throws.
+async function ensureInstalled({ quiet = false } = {}) {
+  const say = quiet ? () => {} : log;
+  if (process.env.CLAUDE_P_SKIP_DOWNLOAD === "1") {
+    say("CLAUDE_P_SKIP_DOWNLOAD set; skipping");
+    return alreadyInstalled();
+  }
+  if (!isSupported()) {
+    say(`platform ${platformDir()} not supported; skipping`);
+    return false;
+  }
+  if (alreadyInstalled()) {
+    say(`already installed at ${targetPath()}`);
+    return true;
+  }
+  try {
+    await download(say);
+    return true;
+  } catch (err) {
+    say(`download failed: ${err.message}`);
+    say("you can build from source with: zig build -Doptimize=ReleaseSafe");
+    return false;
+  }
+}
+
+module.exports = { ensureInstalled, targetPath, platformDir, isSupported };
+
+if (require.main === module) {
+  ensureInstalled().catch((err) => {
+    log(`unexpected error: ${err.stack || err.message}`);
+    // Don't break the npm install; the shim reports the missing binary.
+  });
+}