@inferhub/usage 0.1.8 → 0.1.10

package/bin/statusline.mjs

@@ -1,48 +1,71 @@
 #!/usr/bin/env node
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-
-const root = dirname(fileURLToPath(import.meta.url));
-const client = await import(pathToFileURL(join(root, "../dist/index.js")).href);
-
-function readStdin() {
-  try {
-    return readFileSync(0, "utf8");
-  } catch {
-    return "{}";
-  }
-}
-
-let session = {};
-try {
-  session = JSON.parse(readStdin() || "{}");
-} catch {
-  session = {};
-}
-
-try {
-  // Do NOT pass Claude's session_id through: InferHub derives its own conversation
-  // key server-side (hash of system+first user message / X-Session-Id). Claude's
-  // UUID almost never matches, which produced "sess 0r/0". Default API path uses
-  // the user's latest InferHub session.
-  const { usage } = await client.fetchAccountUsageAuto({
-    window: "day",
-    force: false,
-  });
-  const contextPct =
-    typeof session?.context_window?.used_percentage === "number"
-      ? session.context_window.used_percentage
-      : null;
-  const model = session?.model?.display_name || session?.model?.id || null;
-  process.stdout.write(
-    client.formatStatusLine(usage, {
-      contextPct,
-      model,
-    }) + "\n",
-  );
-} catch (e) {
-  const msg = e instanceof Error ? e.message : String(e);
-  process.stdout.write("InferHub · offline (" + msg.slice(0, 48) + ")\n");
-  process.exitCode = 0;
-}
+/**
+ * Claude Code statusline — one compact line.
+ *
+ * Session id strategy:
+ *  - Prefer conversation-prefix hash from transcript (matches proxy sessionid.Derive)
+ *  - Also try Claude's session_id (if proxy stored user/metadata session)
+ *  - Never fall back to "latest account session" (that jumps between chats)
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const root = dirname(fileURLToPath(import.meta.url));
+const client = await import(pathToFileURL(join(root, "../dist/index.js")).href);
+
+function readStdin() {
+  try {
+    return readFileSync(0, "utf8");
+  } catch {
+    return "{}";
+  }
+}
+
+let input = {};
+try {
+  input = JSON.parse(readStdin() || "{}");
+} catch {
+  input = {};
+}
+
+try {
+  const sessionId = client.sessionIdFromClaudeStatuslineInput({
+    session_id: input.session_id,
+    transcript_path: input.transcript_path,
+  });
+
+  // Fetch with explicit session when known; otherwise omit session block rather
+  // than showing the account's latest unrelated conversation.
+  const { usage } = await client.fetchAccountUsageAuto({
+    window: "day",
+    sessionId: sessionId || undefined,
+  });
+
+  // If we couldn't derive a session id, strip session so we don't show wrong data.
+  // Accept exact id or legacy JSON blob that contains this session UUID.
+  if (!sessionId) {
+    usage.session = null;
+  } else if (usage.session) {
+    const got = String(usage.session.id || "");
+    if (got !== sessionId && !got.includes(sessionId)) {
+      usage.session = null;
+    } else {
+      usage.session.id = sessionId; // normalize display/id for formatters
+    }
+  }
+
+  const contextPct =
+    typeof input?.context_window?.used_percentage === "number"
+      ? input.context_window.used_percentage
+      : null;
+  const model = input?.model?.display_name || input?.model?.id || null;
+
+  process.stdout.write(
+    client.formatStatusLine(usage, { contextPct, model }) + "\n",
+  );
+} catch (e) {
+  const msg = e instanceof Error ? e.message : String(e);
+  process.stdout.write("InferHub · offline (" + msg.slice(0, 40) + ")\n");
+  process.exitCode = 0;
+}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export type { AccountUsage, FetchUsageOptions, ResolvedAuth, UsageWindowKind, } from "./types.js";
 export { DEFAULT_BASE_URL, fetchAccountUsage, fetchAccountUsageAuto, normalizeBaseUrl, resolveAuth, usageUrl, } from "./client.js";
 export { formatReport, formatStatusLine, money, shortModel, tokens } from "./format.js";
+export { deriveConversationSessionId, messagesFromTranscript, sessionIdFromClaudeStatuslineInput, } from "./session-id.js";

package/dist/index.js

@@ -1,2 +1,3 @@
 export { DEFAULT_BASE_URL, fetchAccountUsage, fetchAccountUsageAuto, normalizeBaseUrl, resolveAuth, usageUrl, } from "./client.js";
 export { formatReport, formatStatusLine, money, shortModel, tokens } from "./format.js";
+export { deriveConversationSessionId, messagesFromTranscript, sessionIdFromClaudeStatuslineInput, } from "./session-id.js";

package/dist/session-id.d.ts

@@ -0,0 +1,19 @@
+/** Same algorithm as proxy sessionid.conversationPrefix + sha256[:16]. */
+export declare function deriveConversationSessionId(messages: Array<{
+    role?: string;
+    content?: unknown;
+    type?: string;
+}>): string | null;
+/**
+ * Best-effort extract ordered messages from a Claude transcript jsonl.
+ * Handles common shapes: {type:"user"|"assistant", message:{role,content}} etc.
+ */
+export declare function messagesFromTranscript(transcriptPath: string): Array<{
+    role?: string;
+    content?: unknown;
+    type?: string;
+}>;
+export declare function sessionIdFromClaudeStatuslineInput(input: {
+    session_id?: string;
+    transcript_path?: string;
+}): string | null;

package/dist/session-id.js

@@ -0,0 +1,103 @@
+/**
+ * Match proxy/internal/sessionid.Derive conversation-prefix hashing so the
+ * Claude statusline can query the same session_id that request_logs stores.
+ *
+ * Priority mirrors the proxy:
+ *  1. Explicit session id (Claude stdin session_id) if we ever store it server-side
+ *  2. sha256(system + first user message)[:16] hex — same as proxy
+ */
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+function flattenContent(content) {
+    if (content == null)
+        return "";
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content.map(flattenContent).join("");
+    }
+    if (typeof content === "object") {
+        const o = content;
+        if (typeof o.text === "string")
+            return o.text;
+        if (o.content != null)
+            return flattenContent(o.content);
+    }
+    return "";
+}
+/** Same algorithm as proxy sessionid.conversationPrefix + sha256[:16]. */
+export function deriveConversationSessionId(messages) {
+    let system = "";
+    let firstUser = "";
+    for (const m of messages) {
+        const role = (m.role || m.type || "").toLowerCase();
+        if (role === "system") {
+            const t = flattenContent(m.content);
+            if (t)
+                system += t + "\n";
+        }
+        else if (role === "user" || role === "human") {
+            firstUser = flattenContent(m.content);
+            break;
+        }
+    }
+    if (!firstUser)
+        return null;
+    const prefix = system + firstUser;
+    const sum = createHash("sha256").update(prefix, "utf8").digest("hex");
+    return sum.slice(0, 32); // 16 bytes = 32 hex chars (proxy uses sum[:16] bytes)
+}
+/**
+ * Best-effort extract ordered messages from a Claude transcript jsonl.
+ * Handles common shapes: {type:"user"|"assistant", message:{role,content}} etc.
+ */
+export function messagesFromTranscript(transcriptPath) {
+    if (!transcriptPath || !existsSync(transcriptPath))
+        return [];
+    let text;
+    try {
+        text = readFileSync(transcriptPath, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of text.split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        try {
+            const row = JSON.parse(line);
+            // Claude Code transcript variants
+            if (row.type === "user" || row.type === "assistant" || row.type === "system") {
+                const msg = row.message || row;
+                out.push({
+                    role: String(msg.role || row.type),
+                    content: msg.content ?? row.content,
+                });
+                continue;
+            }
+            if (typeof row.role === "string" && row.content != null) {
+                out.push({ role: row.role, content: row.content });
+            }
+        }
+        catch {
+            /* skip bad lines */
+        }
+    }
+    return out;
+}
+export function sessionIdFromClaudeStatuslineInput(input) {
+    // Prefer Claude UUID — proxy now stores metadata.user_id / session_id when
+    // present, so each Claude conversation keeps its own counter.
+    if (input.session_id && input.session_id.length > 8)
+        return input.session_id;
+    // Fallback: conversation-prefix hash (matches proxy sessionid.Derive when no
+    // explicit session was sent).
+    if (input.transcript_path) {
+        const msgs = messagesFromTranscript(input.transcript_path);
+        const derived = deriveConversationSessionId(msgs);
+        if (derived)
+            return derived;
+    }
+    return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inferhub/usage",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Shared InferHub account usage client for coding-agent plugins",
   "type": "module",
   "main": "./dist/index.js",

package/src/index.ts

@@ -13,3 +13,8 @@ export {
   usageUrl,
 } from "./client.js";
 export { formatReport, formatStatusLine, money, shortModel, tokens } from "./format.js";
+export {
+  deriveConversationSessionId,
+  messagesFromTranscript,
+  sessionIdFromClaudeStatuslineInput,
+} from "./session-id.js";

package/src/session-id.ts

@@ -0,0 +1,106 @@
+/**
+ * Match proxy/internal/sessionid.Derive conversation-prefix hashing so the
+ * Claude statusline can query the same session_id that request_logs stores.
+ *
+ * Priority mirrors the proxy:
+ *  1. Explicit session id (Claude stdin session_id) if we ever store it server-side
+ *  2. sha256(system + first user message)[:16] hex — same as proxy
+ */
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+
+function flattenContent(content: unknown): string {
+  if (content == null) return "";
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map(flattenContent).join("");
+  }
+  if (typeof content === "object") {
+    const o = content as { text?: unknown; content?: unknown };
+    if (typeof o.text === "string") return o.text;
+    if (o.content != null) return flattenContent(o.content);
+  }
+  return "";
+}
+
+/** Same algorithm as proxy sessionid.conversationPrefix + sha256[:16]. */
+export function deriveConversationSessionId(messages: Array<{
+  role?: string;
+  content?: unknown;
+  type?: string;
+}>): string | null {
+  let system = "";
+  let firstUser = "";
+  for (const m of messages) {
+    const role = (m.role || m.type || "").toLowerCase();
+    if (role === "system") {
+      const t = flattenContent(m.content);
+      if (t) system += t + "\n";
+    } else if (role === "user" || role === "human") {
+      firstUser = flattenContent(m.content);
+      break;
+    }
+  }
+  if (!firstUser) return null;
+  const prefix = system + firstUser;
+  const sum = createHash("sha256").update(prefix, "utf8").digest("hex");
+  return sum.slice(0, 32); // 16 bytes = 32 hex chars (proxy uses sum[:16] bytes)
+}
+
+/**
+ * Best-effort extract ordered messages from a Claude transcript jsonl.
+ * Handles common shapes: {type:"user"|"assistant", message:{role,content}} etc.
+ */
+export function messagesFromTranscript(transcriptPath: string): Array<{
+  role?: string;
+  content?: unknown;
+  type?: string;
+}> {
+  if (!transcriptPath || !existsSync(transcriptPath)) return [];
+  let text: string;
+  try {
+    text = readFileSync(transcriptPath, "utf8");
+  } catch {
+    return [];
+  }
+  const out: Array<{ role?: string; content?: unknown; type?: string }> = [];
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const row = JSON.parse(line) as Record<string, unknown>;
+      // Claude Code transcript variants
+      if (row.type === "user" || row.type === "assistant" || row.type === "system") {
+        const msg = (row.message as Record<string, unknown>) || row;
+        out.push({
+          role: String(msg.role || row.type),
+          content: msg.content ?? row.content,
+        });
+        continue;
+      }
+      if (typeof row.role === "string" && row.content != null) {
+        out.push({ role: row.role, content: row.content });
+      }
+    } catch {
+      /* skip bad lines */
+    }
+  }
+  return out;
+}
+
+export function sessionIdFromClaudeStatuslineInput(input: {
+  session_id?: string;
+  transcript_path?: string;
+}): string | null {
+  // Prefer Claude UUID — proxy now stores metadata.user_id / session_id when
+  // present, so each Claude conversation keeps its own counter.
+  if (input.session_id && input.session_id.length > 8) return input.session_id;
+
+  // Fallback: conversation-prefix hash (matches proxy sessionid.Derive when no
+  // explicit session was sent).
+  if (input.transcript_path) {
+    const msgs = messagesFromTranscript(input.transcript_path);
+    const derived = deriveConversationSessionId(msgs);
+    if (derived) return derived;
+  }
+  return null;
+}