@threadcrumbs/common 0.1.10 → 0.1.11

package/lib/claude-transcript.mjs

@@ -2,6 +2,7 @@ import fsp from 'node:fs/promises'
 import { requestCost } from './anthropic-prices.mjs'
 import { FIXED_PARTS, emptyFixed, emptySizes, setFixed, sizeCall, sizeCompaction, sizePrompt, sizeReply, sizeRequest, sizeResult, sizeResumed } from './context-breakdown.mjs'
 import { listFiles, parseJsonLine, readNewLines } from './fsutil.mjs'
+import { reusedPids } from './proc-start.mjs'
 import {
   DETAIL_LIMITS,
   activityDetail,
@@ -60,8 +61,9 @@ const pidAlive = (pid) => {
   }
 }
 
-export async function readLiveSessions(dir, isAlive = pidAlive) {
-  const live = new Map()
+export async function readLiveSessions(dir, isAlive = pidAlive, reused = reusedPids) {
+  const records = []
+  const dead = []
   for (const file of await listFiles(dir, (n) => n.endsWith('.json'))) {
     let record
     try {
@@ -69,7 +71,19 @@ export async function readLiveSessions(dir, isAlive = pidAlive) {
     } catch {
       continue
     }
-    if (!record?.sessionId || !record.pid || !isAlive(record.pid)) continue
+    if (!record?.sessionId || !record.pid) continue
+    if (isAlive(record.pid)) records.push(record)
+    else dead.push(record.pid)
+  }
+  try {
+    reused?.forget?.(dead)
+  } catch {}
+  const recycled = await Promise.resolve()
+    .then(() => reused(records))
+    .catch(() => null)
+  const live = new Map()
+  for (const record of records) {
+    if (recycled instanceof Set && recycled.has(record.pid)) continue
     live.set(record.sessionId, { pid: record.pid, status: text(record.status), name: text(record.name), socket: text(record.messagingSocketPath) })
   }
   return live

package/lib/proc-start.mjs

@@ -0,0 +1,157 @@
+import { execFile } from 'node:child_process'
+import fsp from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+
+const WAIT_MS = 1000
+const QUERY_MS = 10_000
+const KEPT = 1024
+const USER_HZ = 100
+const LSTART_SLACK_S = 60
+const FILETIME_MAX = 300_000_000_000_000_000n
+const TICKS_BEFORE_1601 = 504_911_232_000_000_000n
+const QUARTER_HOUR = 9_000_000_000n
+const TICK_SLACK = 10n
+const PS = '/bin/ps'
+
+const powershell = () => path.win32.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe')
+
+const getProcess = (pids) =>
+  `$ErrorActionPreference='SilentlyContinue';foreach($p in Get-Process -Id ${pids.join(',')}){try{'{0} {1}' -f $p.Id,$p.StartTime.ToFileTimeUtc()}catch{}}`
+
+function query(file, args, env = {}) {
+  return new Promise((resolve) => {
+    execFile(file, args, { env: { ...process.env, ...env }, timeout: QUERY_MS, windowsHide: true }, (err, stdout) => resolve(typeof stdout === 'string' ? stdout : ''))
+  })
+}
+
+function startLines(stdout, line) {
+  const found = new Map()
+  for (const row of stdout.slice(0, stdout.lastIndexOf('\n') + 1).split('\n')) {
+    const m = line.exec(row)
+    if (m) found.set(Number(m[1]), m[2])
+  }
+  return found
+}
+
+const lstartSeconds = (value) => Date.parse(`${value} UTC`) / 1000
+
+const statTicks = (stat) => stat.slice(stat.lastIndexOf(')') + 2).split(' ')[19]
+
+async function linuxStarts(pids, read) {
+  const boot = Number(/^btime (\d+)$/m.exec(await read('/proc/stat', 'utf8').catch(() => ''))?.[1])
+  const found = new Map()
+  for (const pid of pids) {
+    const ticks = statTicks((await read(`/proc/${pid}/stat`, 'utf8').catch(() => '')) || '')
+    if (!/^\d+$/.test(ticks || '')) continue
+    found.set(pid, { ticks, seconds: boot > 0 ? boot + Math.floor(Number(ticks) / USER_HZ) : NaN })
+  }
+  return found
+}
+
+export async function processStarts(pids, { platform = process.platform, run = query, read = fsp.readFile } = {}) {
+  const asked = [...new Set(pids)].filter((pid) => Number.isSafeInteger(pid) && pid > 0)
+  if (!asked.length) return new Map()
+  if (platform === 'linux') return linuxStarts(asked, read)
+  if (platform === 'win32') {
+    const found = startLines(await run(powershell(), ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', getProcess(asked)]), /^\s*(\d+)\s+(\d+)\s*$/)
+    return new Map([...found].map(([pid, filetime]) => [pid, { filetime }]))
+  }
+  if (platform === 'darwin') {
+    const found = startLines(await run(PS, ['-o', 'pid=', '-o', 'lstart=', '-p', asked.join(',')], { LC_ALL: 'C', TZ: 'UTC' }), /^\s*(\d+)\s+(\S.*?)\s*$/)
+    return new Map([...found].map(([pid, lstart]) => [pid, { seconds: lstartSeconds(lstart) }]))
+  }
+  return new Map()
+}
+
+function sameFiletime(recorded, actual) {
+  if (recorded <= FILETIME_MAX) return recorded === actual
+  const offset = (((recorded - TICKS_BEFORE_1601 - actual) % QUARTER_HOUR) + QUARTER_HOUR) % QUARTER_HOUR
+  return offset <= TICK_SLACK || QUARTER_HOUR - offset <= TICK_SLACK
+}
+
+export function sameStart(recorded, found) {
+  if (typeof recorded !== 'string' || !found || typeof found !== 'object') return null
+  const value = recorded.trim()
+  if (/^\d+$/.test(value)) {
+    if (/^\d+$/.test(found.filetime ?? '')) return sameFiletime(BigInt(value), BigInt(found.filetime))
+    if (/^\d+$/.test(found.ticks ?? '')) return BigInt(value) === BigInt(found.ticks)
+    return null
+  }
+  const at = lstartSeconds(value)
+  if (!Number.isFinite(at) || !Number.isFinite(found.seconds)) return null
+  return Math.abs(at - found.seconds) <= LSTART_SLACK_S
+}
+
+async function domainOf(platform) {
+  if (platform === 'win32') return `win32:${os.hostname().toLowerCase()}`
+  if (platform === 'darwin') return 'darwin'
+  if (platform !== 'linux') return null
+  const [id, ns] = await Promise.all([
+    fsp.readFile('/etc/machine-id', 'utf8').then((t) => t.trim(), () => ''),
+    fsp.readlink('/proc/self/ns/pid').catch(() => ''),
+  ])
+  return `linux:${id}:${ns}`
+}
+
+const domains = new Map()
+
+export function ownPidDomain(platform = process.platform) {
+  if (!domains.has(platform)) domains.set(platform, domainOf(platform).catch(() => null))
+  return domains.get(platform)
+}
+
+const recordedStart = (record) => [record?.procStartFt, record?.procStart].find((v) => typeof v === 'string' && v.trim())?.trim() || ''
+
+function within(promise, ms) {
+  let timer
+  const late = new Promise((resolve) => {
+    timer = setTimeout(resolve, ms)
+  })
+  return Promise.race([promise, late]).finally(() => clearTimeout(timer))
+}
+
+export function reusedPidCheck({ lookup = processStarts, domain = ownPidDomain, waitMs = WAIT_MS } = {}) {
+  const known = new Map()
+  const forget = (pids) => {
+    const gone = new Set(pids)
+    if (!gone.size) return
+    for (const key of [...known.keys()]) if (gone.has(Number(key.slice(0, key.indexOf(':'))))) known.delete(key)
+  }
+  return Object.assign(reusedPids, { forget })
+  async function reusedPids(records) {
+    const own = await Promise.resolve()
+      .then(() => domain())
+      .catch(() => null)
+    if (!own) return new Set()
+    const asked = []
+    for (const record of records) {
+      const start = recordedStart(record)
+      const local = record?.pidDomain === undefined || record.pidDomain === own
+      if (start && local && Number.isSafeInteger(record.pid) && record.pid > 0) asked.push({ pid: record.pid, start, key: `${record.pid}:${start}` })
+    }
+    const fresh = asked.filter((a) => !known.has(a.key))
+    if (fresh.length) {
+      const found = Promise.resolve()
+        .then(() => lookup(fresh.map((a) => a.pid)))
+        .catch(() => null)
+      for (const a of fresh) {
+        const entry = { same: null, ready: null }
+        entry.ready = found
+          .then((starts) => sameStart(a.start, starts instanceof Map ? starts.get(a.pid) : undefined))
+          .catch(() => null)
+          .then((same) => {
+            entry.same = same
+            entry.ready = null
+          })
+        known.set(a.key, entry)
+        if (known.size > KEPT) known.delete(known.keys().next().value)
+      }
+    }
+    const waiting = asked.map((a) => known.get(a.key)?.ready).filter(Boolean)
+    if (waiting.length) await within(Promise.all(waiting), waitMs)
+    return new Set(asked.filter((a) => known.get(a.key)?.same === false).map((a) => a.pid))
+  }
+}
+
+export const reusedPids = reusedPidCheck()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@threadcrumbs/common",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "type": "module",
   "description": "Code the Threadcrumbs apps share, starting with the readers for each coding-agent harness.",
   "license": "SEE LICENSE IN LICENSE.md",

package/telemetry/claude-code.mjs

@@ -24,6 +24,7 @@ export function claudeCode({
   desktop = claudeDesktopStores(),
   now = Date.now,
   isAlive,
+  reusedPids,
 } = {}) {
   const projectsDir = path.join(home, 'projects')
   const liveDir = path.join(home, 'sessions')
@@ -155,7 +156,7 @@ export function claudeCode({
   }
 
   async function scanSessions() {
-    const [live, limits, marks] = await Promise.all([readLiveSessions(liveDir, isAlive), contextLimits(), desktopRecords(desktop).then(desktopMarks)])
+    const [live, limits, marks] = await Promise.all([readLiveSessions(liveDir, isAlive, reusedPids), contextLimits(), desktopRecords(desktop).then(desktopMarks)])
     const found = []
     const files = new Map()
     const states = new Map()
@@ -238,7 +239,7 @@ export function claudeCode({
     const stat = file ? await fsp.stat(file).catch(() => null) : null
     if (!stat) return null
     const state = await (known.get(id) === file ? transcripts : olderReader(file)).read(file, stat)
-    const [live, limits, marks] = await Promise.all([readLiveSessions(liveDir, isAlive), contextLimits(), desktopRecords(desktop).then(desktopMarks)])
+    const [live, limits, marks] = await Promise.all([readLiveSessions(liveDir, isAlive, reusedPids), contextLimits(), desktopRecords(desktop).then(desktopMarks)])
     const said = await opened(file, stat, state, limits)
     if (marks.get(id)?.archived) return null
     const running = live.get(id)