chainlesschain 0.47.6 → 0.47.8

package/src/lib/session-core-singletons.js

@@ -8,12 +8,15 @@
  */
 
 import { join } from "node:path";
+import { promises as fsp, existsSync, mkdirSync } from "node:fs";
 import { getHomeDir } from "./paths.js";
 import {
   MemoryStore,
   BetaFlags,
   ApprovalGate,
   APPROVAL_POLICY,
+  SessionManager,
+  StreamRouter,
   createMemoryFileAdapter,
   createBetaFlagsFileAdapter,
   createApprovalGateFileAdapter,
@@ -23,6 +26,7 @@ import {
 let _memoryStore = null;
 let _betaFlags = null;
 let _approvalGate = null;
+let _sessionManager = null;
 
 export function getMemoryStorePath() {
   return join(getHomeDir(), "memory-store.json");
@@ -63,8 +67,60 @@ export async function getApprovalGate() {
   return _approvalGate;
 }
 
+export function getParkedSessionsPath() {
+  return join(getHomeDir(), "parked-sessions.json");
+}
+
+function createParkedSessionsStore(filePath) {
+  async function readAll() {
+    try {
+      const raw = await fsp.readFile(filePath, "utf8");
+      return JSON.parse(raw || "{}");
+    } catch {
+      return {};
+    }
+  }
+  async function writeAll(map) {
+    const dir = join(filePath, "..");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    await fsp.writeFile(filePath, JSON.stringify(map, null, 2), "utf8");
+  }
+  return {
+    async save(json) {
+      const map = await readAll();
+      map[json.sessionId] = json;
+      await writeAll(map);
+    },
+    async load(sessionId) {
+      const map = await readAll();
+      return map[sessionId] || null;
+    },
+    async remove(sessionId) {
+      const map = await readAll();
+      delete map[sessionId];
+      await writeAll(map);
+    },
+    async list() {
+      return Object.values(await readAll());
+    },
+  };
+}
+
+export function getSessionManager() {
+  if (_sessionManager) return _sessionManager;
+  const store = createParkedSessionsStore(getParkedSessionsPath());
+  _sessionManager = new SessionManager({ store });
+  _sessionManager._parkedStore = store;
+  return _sessionManager;
+}
+
+export function createStreamRouter() {
+  return new StreamRouter();
+}
+
 export function resetSessionCoreSingletonsForTests() {
   _memoryStore = null;
   _betaFlags = null;
   _approvalGate = null;
+  _sessionManager = null;
 }

package/src/lib/session-tail.js

@@ -0,0 +1,128 @@
+/**
+ * Session tail — Phase I of Managed Agents parity plan.
+ *
+ * Follows a JSONL session file and yields new events as an async iterable.
+ * Uses offset-polling so it works cross-platform (fs.watch on Windows is
+ * unreliable for appended-to files).
+ *
+ * Pure generator + helper; the CLI command just wires output.
+ */
+
+import { promises as fsp } from "node:fs";
+import { existsSync, statSync } from "node:fs";
+import { sessionPath } from "../harness/jsonl-session-store.js";
+
+function parseLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Parse a contiguous chunk of buffered text into events. Returns {events, rest}
+ * where `rest` is the unterminated trailing partial line to keep for the next
+ * read.
+ */
+export function parseChunk(buffer) {
+  const events = [];
+  let rest = buffer;
+  let nl = rest.indexOf("\n");
+  while (nl !== -1) {
+    const line = rest.slice(0, nl);
+    rest = rest.slice(nl + 1);
+    const evt = parseLine(line);
+    if (evt) events.push(evt);
+    nl = rest.indexOf("\n");
+  }
+  return { events, rest };
+}
+
+function matchesFilter(event, { types, sinceMs }) {
+  if (types && types.length > 0 && !types.includes(event.type)) return false;
+  if (sinceMs && event.timestamp && event.timestamp < sinceMs) return false;
+  return true;
+}
+
+/**
+ * Get the initial offset for a session:
+ *   - fromStart: 0
+ *   - fromEnd (default): current EOF, so only new events are yielded
+ */
+export function initialOffset(sessionId, { fromStart = false } = {}) {
+  const p = sessionPath(sessionId);
+  if (!existsSync(p)) return 0;
+  if (fromStart) return 0;
+  return statSync(p).size;
+}
+
+/**
+ * Follow a session file. Yields {event, offset} objects as new JSONL lines
+ * are appended. Caller passes an AbortSignal (or the generator runs forever).
+ *
+ * Options:
+ *   - signal       AbortSignal — stops the loop
+ *   - pollMs       polling interval (default 200)
+ *   - fromStart    start from byte 0 (default false — tail from EOF)
+ *   - fromOffset   explicit starting byte offset (overrides fromStart)
+ *   - types        string[] of event.type to include (null = all)
+ *   - sinceMs      only yield events with timestamp >= sinceMs
+ *   - once         if true, stop once file is drained (no polling)
+ */
+export async function* followSession(sessionId, options = {}) {
+  const {
+    signal,
+    pollMs = 200,
+    fromStart = false,
+    fromOffset,
+    types = null,
+    sinceMs = null,
+    once = false,
+  } = options;
+
+  const filePath = sessionPath(sessionId);
+  let offset =
+    typeof fromOffset === "number"
+      ? fromOffset
+      : initialOffset(sessionId, { fromStart });
+  let buffer = "";
+
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    if (signal?.aborted) return;
+
+    if (existsSync(filePath)) {
+      const stat = await fsp.stat(filePath);
+      if (stat.size < offset) {
+        // File was truncated / rotated — restart from beginning
+        offset = 0;
+        buffer = "";
+      }
+      if (stat.size > offset) {
+        const fd = await fsp.open(filePath, "r");
+        try {
+          const length = stat.size - offset;
+          const buf = Buffer.alloc(length);
+          await fd.read(buf, 0, length, offset);
+          offset = stat.size;
+          buffer += buf.toString("utf-8");
+        } finally {
+          await fd.close();
+        }
+        const { events, rest } = parseChunk(buffer);
+        buffer = rest;
+        for (const evt of events) {
+          if (matchesFilter(evt, { types, sinceMs })) {
+            yield { event: evt, offset };
+          }
+        }
+      }
+    }
+
+    if (once) return;
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+}

package/src/lib/session-usage.js

@@ -0,0 +1,166 @@
+/**
+ * Session usage aggregation — Phase I of Managed Agents parity plan.
+ *
+ * Scans JSONL session events for token usage (emitted either as explicit
+ * `token_usage` events or embedded under `event.data.usage` on
+ * `assistant_message` / `llm_call` events) and produces roll-ups by model.
+ *
+ * Purely functional aggregation + file-reading helpers. No state.
+ */
+
+import {
+  readEvents,
+  listJsonlSessions,
+} from "../harness/jsonl-session-store.js";
+
+const USAGE_EVENT_TYPES = new Set([
+  "token_usage",
+  "assistant_message",
+  "llm_call",
+  "llm_response",
+]);
+
+function toNumber(v) {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : 0;
+}
+
+/**
+ * Extract a normalized usage record from a single event, or null if none.
+ * Accepts both snake_case (OpenAI/Anthropic) and camelCase variants.
+ */
+export function extractUsage(event) {
+  if (!event || typeof event !== "object") return null;
+  if (!USAGE_EVENT_TYPES.has(event.type)) return null;
+
+  const d = event.data || {};
+  const raw =
+    event.type === "token_usage"
+      ? d.usage || d
+      : d.usage || d.tokenUsage || null;
+  if (!raw || typeof raw !== "object") return null;
+
+  const inputTokens = toNumber(
+    raw.input_tokens ?? raw.prompt_tokens ?? raw.inputTokens ?? 0,
+  );
+  const outputTokens = toNumber(
+    raw.output_tokens ?? raw.completion_tokens ?? raw.outputTokens ?? 0,
+  );
+  const totalTokens = toNumber(
+    raw.total_tokens ?? raw.totalTokens ?? inputTokens + outputTokens,
+  );
+
+  if (inputTokens === 0 && outputTokens === 0 && totalTokens === 0) {
+    return null;
+  }
+
+  return {
+    provider: d.provider || raw.provider || null,
+    model: d.model || raw.model || null,
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    timestamp: event.timestamp || null,
+  };
+}
+
+/**
+ * Aggregate a list of events into { total, byModel[] }.
+ */
+export function aggregateUsage(events) {
+  const byKey = new Map();
+  const total = {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    calls: 0,
+  };
+
+  for (const evt of events || []) {
+    const u = extractUsage(evt);
+    if (!u) continue;
+
+    total.inputTokens += u.inputTokens;
+    total.outputTokens += u.outputTokens;
+    total.totalTokens += u.totalTokens;
+    total.calls += 1;
+
+    const key = `${u.provider || "?"}/${u.model || "?"}`;
+    const entry = byKey.get(key) || {
+      provider: u.provider,
+      model: u.model,
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      calls: 0,
+    };
+    entry.inputTokens += u.inputTokens;
+    entry.outputTokens += u.outputTokens;
+    entry.totalTokens += u.totalTokens;
+    entry.calls += 1;
+    byKey.set(key, entry);
+  }
+
+  return {
+    total,
+    byModel: Array.from(byKey.values()).sort(
+      (a, b) => b.totalTokens - a.totalTokens,
+    ),
+  };
+}
+
+/**
+ * Roll up usage for a single JSONL session.
+ */
+export function sessionUsage(sessionId) {
+  const events = readEvents(sessionId);
+  const agg = aggregateUsage(events);
+  return { sessionId, ...agg };
+}
+
+/**
+ * Roll up usage across every JSONL session on disk.
+ */
+export function allSessionsUsage({ limit = 1000 } = {}) {
+  const sessions = listJsonlSessions({ limit });
+  const perSession = sessions.map((s) => sessionUsage(s.id));
+
+  const total = {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    calls: 0,
+  };
+  const byKey = new Map();
+
+  for (const s of perSession) {
+    total.inputTokens += s.total.inputTokens;
+    total.outputTokens += s.total.outputTokens;
+    total.totalTokens += s.total.totalTokens;
+    total.calls += s.total.calls;
+    for (const row of s.byModel) {
+      const key = `${row.provider || "?"}/${row.model || "?"}`;
+      const entry = byKey.get(key) || {
+        provider: row.provider,
+        model: row.model,
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        calls: 0,
+      };
+      entry.inputTokens += row.inputTokens;
+      entry.outputTokens += row.outputTokens;
+      entry.totalTokens += row.totalTokens;
+      entry.calls += row.calls;
+      byKey.set(key, entry);
+    }
+  }
+
+  return {
+    sessions: perSession,
+    total,
+    byModel: Array.from(byKey.values()).sort(
+      (a, b) => b.totalTokens - a.totalTokens,
+    ),
+  };
+}

package/src/lib/shell-approval.js

@@ -0,0 +1,96 @@
+/**
+ * shell-approval — compose the existing shell policy ruleset with session-core
+ * ApprovalGate.
+ *
+ * Managed Agents parity Phase G item #3: `evaluateShellCommandPolicy` returns a
+ * hard allow/deny/warn on rule patterns, but we also want per-session policy
+ * tiers (strict / trusted / autopilot) and a confirm() hook before medium/high
+ * risk commands actually run.
+ *
+ * Mapping:
+ *   shell decision DENY  → risk HIGH  (still rejected outright even before
+ *                                      policy — hard-denied rules are always
+ *                                      unsafe)
+ *   shell decision WARN  → risk MEDIUM
+ *   shell decision ALLOW → risk LOW
+ *   shell decision REROUTE → risk HIGH (rerouted, never actually executed)
+ *
+ * Returns a uniform shape `{ allowed, decision, via, reason, shellPolicy,
+ * riskLevel, policy }` so callers don't have to juggle two decision types.
+ */
+
+const sharedShellPolicy = require("../runtime/coding-agent-shell-policy.cjs");
+const {
+  APPROVAL_RISK: RISK,
+  APPROVAL_DECISION: DECISION,
+} = require("@chainlesschain/session-core");
+
+const SHELL_TO_RISK = {
+  allow: RISK.LOW,
+  warn: RISK.MEDIUM,
+  deny: RISK.HIGH,
+  reroute: RISK.HIGH,
+};
+
+async function evaluateShellCommandWithApproval({
+  command,
+  sessionId = null,
+  approvalGate = null,
+  shellPolicyOptions = {},
+} = {}) {
+  const shellPolicy = sharedShellPolicy.evaluateShellCommandPolicy(
+    command,
+    shellPolicyOptions,
+  );
+
+  const riskLevel = SHELL_TO_RISK[shellPolicy.decision] || RISK.MEDIUM;
+
+  // Hard-blocked rules bypass the gate entirely — the gate tier cannot
+  // up-authorize them.
+  if (!shellPolicy.allowed) {
+    return {
+      allowed: false,
+      decision: DECISION.DENY,
+      via: "shell-policy",
+      reason: shellPolicy.reason,
+      shellPolicy,
+      riskLevel,
+      policy: null,
+    };
+  }
+
+  // No ApprovalGate wired? Preserve legacy behavior (shell policy decides).
+  if (!approvalGate || typeof approvalGate.decide !== "function") {
+    return {
+      allowed: true,
+      decision: DECISION.ALLOW,
+      via: "shell-policy",
+      reason: shellPolicy.reason,
+      shellPolicy,
+      riskLevel,
+      policy: null,
+    };
+  }
+
+  const gateResult = await approvalGate.decide({
+    sessionId,
+    riskLevel,
+    tool: "run_shell",
+    args: { command },
+  });
+
+  return {
+    allowed: gateResult.decision === DECISION.ALLOW,
+    decision: gateResult.decision,
+    via: gateResult.via,
+    reason: shellPolicy.reason,
+    shellPolicy,
+    riskLevel,
+    policy: gateResult.policy,
+  };
+}
+
+module.exports = {
+  evaluateShellCommandWithApproval,
+  SHELL_TO_RISK,
+};

package/src/lib/ws-chat-handler.js

@@ -46,6 +46,9 @@ export class WSChatHandler {
         model: session.model,
         baseUrl: session.baseUrl || "http://localhost:11434",
         apiKey: session.apiKey,
+        // Phase J — pipe WS session id so chat-core records token_usage
+        // into the JSONL session store; visible via `cc session usage`.
+        sessionId: session.sessionId || session.id,
       };
 
       const fullContent = await chatWithStreaming(