pi-remote-control 1.0.0

package/src/transcript-message.ts

@@ -0,0 +1,76 @@
+import type { TranscriptContentBlock, TranscriptMessage } from "./types.js";
+
+export function transcriptMessageFromPiMessage(input: {
+  id?: unknown;
+  timestamp?: unknown;
+  message?: unknown;
+  isStreaming?: boolean;
+}): TranscriptMessage[] {
+  const message = asRecord(input.message);
+  const role = messageRole(message.role);
+  if (!role) return [];
+  const content = transcriptContent(message.content);
+  const result: TranscriptMessage = {
+    id: readString(input.id) ?? readString(message.id) ?? `msg_${Math.random().toString(36).slice(2, 10)}`,
+    role,
+    content,
+    text: transcriptText(content),
+    createdAt: readTimestamp(input.timestamp) ?? readTimestamp(message.timestamp) ?? new Date().toISOString(),
+    isStreaming: input.isStreaming ?? false,
+  };
+  const toolCallId = readString(message.toolCallId);
+  if (toolCallId) result.toolCallId = toolCallId;
+  const toolName = readString(message.toolName);
+  if (toolName) result.toolName = toolName;
+  if (typeof message.isError === "boolean") result.isError = message.isError;
+  return [result];
+}
+
+export function transcriptContent(content: unknown): TranscriptContentBlock[] {
+  if (typeof content === "string") return [{ type: "text", text: content }];
+  if (!Array.isArray(content)) return [];
+  return content.flatMap<TranscriptContentBlock>((item) => {
+    const record = asRecord(item);
+    if (record.type === "text") {
+      const text = readString(record.text);
+      return text === undefined ? [] : [{ type: "text", text } satisfies TranscriptContentBlock];
+    }
+    if (record.type === "thinking") {
+      const thinking = readString(record.thinking);
+      return thinking === undefined ? [] : [{ type: "thinking", thinking } satisfies TranscriptContentBlock];
+    }
+    if (record.type === "toolCall") {
+      const id = readString(record.id);
+      const name = readString(record.name);
+      return id && name ? [{ type: "toolCall", id, name, arguments: record.arguments } satisfies TranscriptContentBlock] : [];
+    }
+    if (record.type === "image") {
+      const data = readString(record.data);
+      const mimeType = readString(record.mimeType);
+      return data && mimeType ? [{ type: "image", data, mimeType } satisfies TranscriptContentBlock] : [];
+    }
+    return [];
+  });
+}
+
+export function transcriptText(content: TranscriptContentBlock[]): string {
+  return content.flatMap((block) => block.type === "text" ? [block.text] : []).join("");
+}
+
+export function asRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" ? (value as Record<string, unknown>) : {};
+}
+
+export function readString(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}
+
+export function readTimestamp(value: unknown): string | undefined {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return new Date(value).toISOString();
+  return undefined;
+}
+
+function messageRole(value: unknown): TranscriptMessage["role"] | undefined {
+  return value === "user" || value === "assistant" || value === "toolResult" || value === "system" ? value : undefined;
+}

package/src/transcript-pagination.ts

@@ -0,0 +1,68 @@
+import type { TranscriptMessage } from "./types.js";
+
+export const DEFAULT_TRANSCRIPT_PAGE_LIMIT = 100;
+export const MAX_TRANSCRIPT_PAGE_LIMIT = 200;
+
+export type TranscriptPage = {
+  messages: TranscriptMessage[];
+  olderMessagesCursor: string | null;
+  hasOlderMessages: boolean;
+};
+
+export class InvalidTranscriptCursorError extends Error {
+  constructor() {
+    super("invalid_cursor");
+  }
+}
+
+export function encodeTranscriptCursor(createdAt: string): string {
+  return Buffer.from(createdAt, "utf8").toString("base64url");
+}
+
+export function decodeTranscriptCursor(cursor: string): string {
+  try {
+    if (!/^[A-Za-z0-9_-]+$/.test(cursor)) throw new InvalidTranscriptCursorError();
+    const decoded = Buffer.from(cursor, "base64url").toString("utf8");
+    if (!decoded || Number.isNaN(Date.parse(decoded)) || encodeTranscriptCursor(decoded) !== cursor) throw new InvalidTranscriptCursorError();
+    return decoded;
+  } catch (error) {
+    if (error instanceof InvalidTranscriptCursorError) throw error;
+    throw new InvalidTranscriptCursorError();
+  }
+}
+
+export function recentTranscriptWindow(messages: TranscriptMessage[], limit: number): TranscriptPage {
+  return pageFromCandidates(normalizeMessages(messages), limit);
+}
+
+export function olderTranscriptPage(messages: TranscriptMessage[], beforeCursor: string, limit: number): TranscriptPage {
+  const beforeCreatedAt = decodeTranscriptCursor(beforeCursor);
+  const normalizedMessages = normalizeMessages(messages);
+  if (!normalizedMessages.some((message) => message.createdAt === beforeCreatedAt)) throw new InvalidTranscriptCursorError();
+  return pageFromCandidates(
+    normalizedMessages.filter((message) => message.createdAt < beforeCreatedAt),
+    limit,
+  );
+}
+
+function pageFromCandidates(candidates: TranscriptMessage[], limit: number): TranscriptPage {
+  const start = Math.max(0, candidates.length - limit);
+  const pageMessages = candidates.slice(start);
+  const hasOlderMessages = start > 0;
+  return {
+    messages: pageMessages,
+    olderMessagesCursor: hasOlderMessages && pageMessages[0] ? encodeTranscriptCursor(pageMessages[0].createdAt) : null,
+    hasOlderMessages,
+  };
+}
+
+function normalizeMessages(messages: TranscriptMessage[]): TranscriptMessage[] {
+  const byId = new Map<string, TranscriptMessage>();
+  for (const message of messages) {
+    if (!byId.has(message.id)) byId.set(message.id, message);
+  }
+  return [...byId.values()].sort((left, right) => {
+    const byCreatedAt = left.createdAt.localeCompare(right.createdAt);
+    return byCreatedAt === 0 ? left.id.localeCompare(right.id) : byCreatedAt;
+  });
+}

package/src/transcript-preview.ts

@@ -0,0 +1,102 @@
+import type { TranscriptContentBlock, TranscriptMessage } from "./types.js";
+
+export const INITIAL_WEBSOCKET_SESSION_MESSAGE_LIMIT = 20;
+export const INITIAL_WEBSOCKET_STRING_PREVIEW_BYTES = 10 * 1024;
+
+type SessionStateWithMessages = {
+  messages?: TranscriptMessage[];
+  hasOlderMessages?: boolean;
+};
+
+export function previewInitialSessionState<T>(state: T): T {
+  if (!isRecord(state) || !Array.isArray((state as SessionStateWithMessages).messages)) return state;
+  const messages = (state as SessionStateWithMessages).messages ?? [];
+  const start = Math.max(0, messages.length - INITIAL_WEBSOCKET_SESSION_MESSAGE_LIMIT);
+  return {
+    ...state,
+    messages: messages.slice(start).map(previewTranscriptMessage),
+    hasOlderMessages: (state as SessionStateWithMessages).hasOlderMessages || start > 0,
+  };
+}
+
+function previewTranscriptMessage(message: TranscriptMessage): TranscriptMessage {
+  const text = previewString(message.text);
+  return {
+    ...message,
+    content: message.content.map(previewContentBlock),
+    text: text.value,
+    ...(text.truncated ? { textTruncated: true, textOriginalBytes: text.originalBytes } : {}),
+  };
+}
+
+function previewContentBlock(block: TranscriptContentBlock): TranscriptContentBlock {
+  if (block.type === "text") {
+    const text = previewString(block.text);
+    return text.truncated ? { ...block, text: text.value, truncated: true, originalBytes: text.originalBytes } : { ...block };
+  }
+  if (block.type === "thinking") {
+    const thinking = previewString(block.thinking);
+    return thinking.truncated ? { ...block, thinking: thinking.value, truncated: true, originalBytes: thinking.originalBytes } : { ...block };
+  }
+  if (block.type === "image") {
+    const data = previewString(block.data);
+    return data.truncated ? { ...block, data: data.value, truncated: true, originalBytes: data.originalBytes } : { ...block };
+  }
+  const originalBytes = jsonByteLength(block.arguments);
+  const { value, truncated } = previewUnknownStrings(block.arguments);
+  return truncated ? { ...block, arguments: value, argumentsTruncated: true, argumentsOriginalBytes: originalBytes } : { ...block, arguments: value };
+}
+
+function previewUnknownStrings(value: unknown): { value: unknown; truncated: boolean } {
+  if (typeof value === "string") {
+    const preview = previewString(value);
+    return { value: preview.value, truncated: preview.truncated };
+  }
+  if (Array.isArray(value)) {
+    let truncated = false;
+    const items = value.map((item) => {
+      const preview = previewUnknownStrings(item);
+      truncated ||= preview.truncated;
+      return preview.value;
+    });
+    return { value: items, truncated };
+  }
+  if (isRecord(value)) {
+    let truncated = false;
+    const result: Record<string, unknown> = {};
+    for (const [key, item] of Object.entries(value)) {
+      const preview = previewUnknownStrings(item);
+      truncated ||= preview.truncated;
+      result[key] = preview.value;
+    }
+    return { value: result, truncated };
+  }
+  return { value, truncated: false };
+}
+
+function previewString(value: string): { value: string; truncated: false } | { value: string; truncated: true; originalBytes: number } {
+  const originalBytes = Buffer.byteLength(value, "utf8");
+  if (originalBytes <= INITIAL_WEBSOCKET_STRING_PREVIEW_BYTES) return { value, truncated: false };
+  return { value: truncateUtf8(value, INITIAL_WEBSOCKET_STRING_PREVIEW_BYTES), truncated: true, originalBytes };
+}
+
+function truncateUtf8(value: string, maxBytes: number): string {
+  const bytes = Buffer.from(value, "utf8");
+  for (let end = maxBytes; end >= 0; end -= 1) {
+    try {
+      return new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, end));
+    } catch {
+      // Try a smaller prefix when maxBytes cuts through a multi-byte sequence.
+    }
+  }
+  return "";
+}
+
+function jsonByteLength(value: unknown): number {
+  const serialized = JSON.stringify(value);
+  return serialized === undefined ? 0 : Buffer.byteLength(serialized, "utf8");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object";
+}

package/src/transcript-stream.ts

@@ -0,0 +1,89 @@
+import { asRecord, readString, readTimestamp, transcriptMessageFromPiMessage } from "./transcript-message.js";
+import type { TranscriptContentBlock, TranscriptStreamEvent } from "./types.js";
+
+export function normalizeTuiEvent(event: unknown): TranscriptStreamEvent[] {
+  const record = asRecord(event);
+  switch (record.type) {
+    case "turn_start": {
+      const turnIndex = readTurnIndex(record.turnIndex);
+      if (turnIndex === undefined) return [];
+      const createdAt = readTimestamp(record.timestamp);
+      return createdAt ? [{ type: "turn_start", turnIndex, createdAt }] : [{ type: "turn_start", turnIndex }];
+    }
+    case "turn_end": {
+      const turnIndex = readTurnIndex(record.turnIndex);
+      return turnIndex === undefined ? [] : [{ type: "turn_end", turnIndex }];
+    }
+    case "message_start":
+      if (asRecord(record.message).role !== "assistant") return [];
+      return transcriptMessageFromPiMessage({ id: messageId(record), timestamp: record.timestamp, message: record.message, isStreaming: true })
+        .map((message) => ({ type: "transcript_message_start", message }));
+    case "message_end":
+      return transcriptMessageFromPiMessage({ id: messageId(record), timestamp: record.timestamp, message: record.message, isStreaming: false })
+        .map((message) => ({ type: "transcript_message_end", message }));
+    case "message_update":
+      return normalizeMessageUpdate(record);
+    case "tool_execution_start": {
+      const toolCallId = readString(record.toolCallId);
+      const toolName = readString(record.toolName);
+      return toolCallId && toolName ? [{ type: "tool_execution_start", toolCallId, toolName, args: record.args }] : [];
+    }
+    case "tool_execution_update": {
+      const toolCallId = readString(record.toolCallId);
+      const toolName = readString(record.toolName);
+      return toolCallId && toolName ? [{ type: "tool_execution_update", toolCallId, toolName, partialResult: record.partialResult }] : [];
+    }
+    case "tool_execution_end": {
+      const toolCallId = readString(record.toolCallId);
+      const toolName = readString(record.toolName);
+      if (!toolCallId || !toolName) return [];
+      return [{ type: "tool_execution_end", toolCallId, toolName, result: record.result, isError: record.isError === true }];
+    }
+    default:
+      return [];
+  }
+}
+
+function normalizeMessageUpdate(record: Record<string, unknown>): TranscriptStreamEvent[] {
+  const id = messageId(record);
+  if (!id) return [];
+  const assistantMessageEvent = asRecord(record.assistantMessageEvent);
+  const contentIndex = readContentIndex(assistantMessageEvent.contentIndex);
+  if (assistantMessageEvent.type === "text_delta") {
+    const delta = readString(assistantMessageEvent.delta) ?? readString(assistantMessageEvent.text);
+    return delta === undefined ? [] : [{ type: "transcript_message_patch", messageId: id, contentIndex, patch: { type: "text_delta", delta } }];
+  }
+  if (assistantMessageEvent.type === "thinking_delta") {
+    const delta = readString(assistantMessageEvent.delta) ?? readString(assistantMessageEvent.thinking);
+    return delta === undefined ? [] : [{ type: "transcript_message_patch", messageId: id, contentIndex, patch: { type: "thinking_delta", delta } }];
+  }
+  if (assistantMessageEvent.type === "toolcall_end") {
+    const toolCall = normalizeToolCall(assistantMessageEvent.toolCall);
+    return toolCall ? [{ type: "transcript_message_patch", messageId: id, contentIndex, patch: { type: "toolCall", toolCall } }] : [];
+  }
+  if (assistantMessageEvent.type === "done" || assistantMessageEvent.type === "error") {
+    return transcriptMessageFromPiMessage({ id, timestamp: record.timestamp, message: record.message, isStreaming: false })
+      .map((message) => ({ type: "transcript_message_end", message }));
+  }
+  return [];
+}
+
+function messageId(record: Record<string, unknown>): string | undefined {
+  return readString(record.id) ?? readString(asRecord(record.message).id);
+}
+
+function readContentIndex(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : undefined;
+}
+
+function readTurnIndex(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : undefined;
+}
+
+function normalizeToolCall(value: unknown): Extract<TranscriptContentBlock, { type: "toolCall" }> | undefined {
+  const record = asRecord(value);
+  if (record.type !== "toolCall") return undefined;
+  const id = readString(record.id);
+  const name = readString(record.name);
+  return id && name ? { type: "toolCall", id, name, arguments: record.arguments } : undefined;
+}

package/src/types.ts

@@ -0,0 +1,116 @@
+export type IsoTimestamp = string;
+
+export type DaemonConfig = {
+  bindAddress: string;
+  advertisedBaseUrl?: string;
+};
+
+export type DaemonState = {
+  pid: number;
+  startedAt: IsoTimestamp;
+  version: string;
+  piVersion: string;
+  bindAddress: string;
+  stateDir: string;
+};
+
+export type PairedDevice = {
+  id: string;
+  name: string;
+  tokenHash: string;
+  createdAt: IsoTimestamp;
+  lastSeenAt?: IsoTimestamp;
+  revokedAt?: IsoTimestamp;
+};
+
+export type PairingCode = {
+  id: string;
+  codeHash: string;
+  createdAt: IsoTimestamp;
+  expiresAt: IsoTimestamp;
+  consumedAt?: IsoTimestamp;
+};
+
+export type TranscriptContentBlock =
+  | { type: "text"; text: string; truncated?: boolean; originalBytes?: number }
+  | { type: "thinking"; thinking: string; truncated?: boolean; originalBytes?: number }
+  | { type: "toolCall"; id: string; name: string; arguments: unknown; argumentsTruncated?: boolean; argumentsOriginalBytes?: number }
+  | { type: "image"; data: string; mimeType: string; truncated?: boolean; originalBytes?: number };
+
+export type TranscriptMessage = {
+  id: string;
+  role: "user" | "assistant" | "toolResult" | "system";
+  content: TranscriptContentBlock[];
+  text: string;
+  textTruncated?: boolean;
+  textOriginalBytes?: number;
+  createdAt: IsoTimestamp;
+  toolCallId?: string;
+  toolName?: string;
+  isError?: boolean;
+  isStreaming: boolean;
+};
+
+export type TranscriptMessagePatch =
+  | { type: "text_delta"; delta: string }
+  | { type: "thinking_delta"; delta: string }
+  | { type: "toolCall"; toolCall: Extract<TranscriptContentBlock, { type: "toolCall" }> }
+  | { type: "replace"; message: TranscriptMessage };
+
+export type RuntimeStatus = {
+  model: null | {
+    provider: string;
+    id: string;
+    name?: string;
+    contextWindow?: number;
+    maxTokens?: number;
+    reasoning?: boolean;
+  };
+  thinkingLevel: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | null;
+  usage: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    cost: {
+      input: number;
+      output: number;
+      cacheRead: number;
+      cacheWrite: number;
+      total: number;
+    };
+  };
+  context: null | {
+    tokens: number | null;
+    contextWindow: number;
+    percent: number | null;
+  };
+  updatedAt: IsoTimestamp;
+};
+
+export type RemoteCompactResultEvent =
+  | { type: "remote_compact_result"; requestId: string; ok: true; summary: string; firstKeptEntryId: string; tokensBefore: number }
+  | { type: "remote_compact_result"; requestId: string; ok: false; message: string };
+
+export type TranscriptStreamEvent =
+  | { type: "session_state"; state: unknown }
+  | { type: "runtime_status"; status: RuntimeStatus }
+  | RemoteCompactResultEvent
+  | { type: "turn_start"; turnIndex: number; createdAt?: IsoTimestamp }
+  | { type: "turn_end"; turnIndex: number }
+  | { type: "transcript_message_start"; message: TranscriptMessage }
+  | { type: "transcript_message_patch"; messageId: string; contentIndex?: number; patch: TranscriptMessagePatch }
+  | { type: "transcript_message_end"; message: TranscriptMessage }
+  | { type: "tool_execution_start"; toolCallId: string; toolName: string; args: unknown }
+  | { type: "tool_execution_update"; toolCallId: string; toolName: string; partialResult: unknown }
+  | { type: "tool_execution_end"; toolCallId: string; toolName: string; result?: unknown; isError: boolean }
+  | { type: "session_closed" }
+  | { type: "error"; error: string };
+
+export type ToolCallStatus = {
+  id: string;
+  name: string;
+  status: "pending" | "running" | "succeeded" | "failed" | "aborted";
+  summary?: string;
+  updatedAt: IsoTimestamp;
+};

package/tests/active-session-registry.test.ts

@@ -0,0 +1,170 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { describe, expect, it } from "vitest";
+import { createActiveSessionRegistry } from "../src/active-session-registry.js";
+
+const runtimeStatus = {
+  model: { provider: "anthropic", id: "claude-sonnet-4-5", contextWindow: 200000 },
+  thinkingLevel: "medium" as const,
+  usage: { input: 12, output: 3, cacheRead: 50, cacheWrite: 10, cost: { input: 0.036, output: 0.045, cacheRead: 0.015, cacheWrite: 0.0375, total: 0.1335 } },
+  context: { tokens: 65000, contextWindow: 200000, percent: 32.5 },
+  updatedAt: "2026-05-09T09:47:00.000Z",
+};
+
+describe("active TUI session registry", () => {
+  it("groups active sessions by project and removes inactive sessions", () => {
+    const registry = createActiveSessionRegistry();
+    registry.registerSession({
+      id: "sess_1",
+      piSessionId: "pi_1",
+      project: { id: "proj_1", name: "Example", path: "/repo/example" },
+      sessionFile: "/tmp/session.jsonl",
+      name: "Fix bug",
+      pid: 1234,
+      messageCount: 2,
+      isStreaming: false,
+      updatedAt: "2026-05-09T00:00:00.000Z",
+    });
+
+    expect(registry.listProjects()).toEqual([{ id: "proj_1", name: "Example", path: "/repo/example" }]);
+    expect(registry.listProjectSessions("proj_1")).toEqual([
+      {
+        id: "sess_1",
+        piSessionId: "pi_1",
+        projectId: "proj_1",
+        name: "Fix bug",
+        path: "/tmp/session.jsonl",
+        updatedAt: "2026-05-09T00:00:00.000Z",
+        messageCount: 2,
+        isActive: true,
+      },
+    ]);
+
+    expect(registry.unregisterSession("sess_1")).toBe(true);
+    expect(registry.listProjects()).toEqual([]);
+    expect(registry.listProjectSessions("proj_1")).toEqual([]);
+  });
+
+  it("prunes active TUI sessions when heartbeats stop", () => {
+    let now = 1_000;
+    const registry = createActiveSessionRegistry({ now: () => now, staleSessionTimeoutMs: 5_000 });
+    registry.registerSession({
+      id: "sess_1",
+      piSessionId: "pi_1",
+      project: { id: "proj_1", name: "Example", path: "/repo/example" },
+      sessionFile: "/tmp/session.jsonl",
+      pid: 1234,
+      messageCount: 0,
+      isStreaming: false,
+      updatedAt: "2026-05-09T00:00:00.000Z",
+    });
+
+    now = 5_000;
+    expect(registry.touchSession("sess_1")).toBe(true);
+    now = 9_999;
+    expect(registry.pruneInactiveSessions()).toEqual([]);
+    expect(registry.listProjects()).toEqual([{ id: "proj_1", name: "Example", path: "/repo/example" }]);
+
+    now = 10_001;
+    expect(registry.pruneInactiveSessions()).toEqual(["sess_1"]);
+    expect(registry.listProjects()).toEqual([]);
+    expect(registry.touchSession("sess_1")).toBe(false);
+  });
+
+  it("prunes active TUI sessions when the owning TUI process exits", () => {
+    const registry = createActiveSessionRegistry({ isProcessRunning: (pid) => pid !== 1234, staleSessionTimeoutMs: 60_000 });
+    registry.registerSession({
+      id: "sess_1",
+      piSessionId: "pi_1",
+      project: { id: "proj_1", name: "Example", path: "/repo/example" },
+      sessionFile: "/tmp/session.jsonl",
+      pid: 1234,
+      messageCount: 0,
+      isStreaming: false,
+      updatedAt: "2026-05-09T00:00:00.000Z",
+    });
+
+    expect(registry.pruneInactiveSessions()).toEqual(["sess_1"]);
+    expect(registry.listProjects()).toEqual([]);
+  });
+
+  it("queues remote commands for active TUI sessions", () => {
+    const registry = createActiveSessionRegistry();
+    registry.registerSession({
+      id: "sess_1",
+      piSessionId: "pi_1",
+      project: { id: "proj_1", name: "Example", path: "/repo/example" },
+      sessionFile: "/tmp/session.jsonl",
+      pid: 1234,
+      messageCount: 0,
+      isStreaming: false,
+      updatedAt: "2026-05-09T00:00:00.000Z",
+    });
+
+    expect(registry.enqueueCommand("sess_1", { type: "remote_abort", requestId: "req_1" })).toBe(true);
+    expect(registry.enqueueCommand("missing", { type: "remote_abort", requestId: "req_2" })).toBe(false);
+    expect(registry.takeCommands("sess_1")).toEqual([{ type: "remote_abort", requestId: "req_1" }]);
+    expect(registry.takeCommands("sess_1")).toEqual([]);
+  });
+
+  it("returns snapshots for active sessions", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-remote-control-registry-"));
+    const sessionFile = join(root, "session.jsonl");
+    const registry = createActiveSessionRegistry();
+    try {
+      await writeFile(sessionFile, [
+        JSON.stringify({ type: "message", id: "msg_1", timestamp: "2026-05-09T00:00:00.000Z", message: { role: "user", content: "hello" } }),
+        JSON.stringify({ type: "message", id: "msg_2", timestamp: "2026-05-09T00:00:01.000Z", message: { role: "assistant", content: [{ type: "text", text: "hi" }] } }),
+      ].join("\n"));
+      registry.registerSession({
+        id: "sess_1",
+        piSessionId: "pi_1",
+        project: { id: "proj_1", name: "Example", path: "/repo/example" },
+        sessionFile,
+        pid: 1234,
+        messageCount: 0,
+        isStreaming: true,
+        updatedAt: "2026-05-09T00:00:00.000Z",
+      });
+
+      expect(registry.getSessionState("sess_1")).toMatchObject({
+      session: { id: "sess_1", projectId: "proj_1", isActive: true },
+      messages: [
+        { id: "msg_1", role: "user", text: "hello", createdAt: "2026-05-09T00:00:00.000Z", isStreaming: false },
+        { id: "msg_2", role: "assistant", text: "hi", createdAt: "2026-05-09T00:00:01.000Z", isStreaming: false },
+      ],
+      tools: [],
+      isStreaming: true,
+      pendingMessageCount: 0,
+      runtimeStatus: null,
+      });
+      expect(registry.getSessionState("missing")).toBeUndefined();
+    } finally {
+      await rm(root, { recursive: true, force: true });
+    }
+  });
+
+  it("stores and updates runtime status snapshots for active sessions", () => {
+    const registry = createActiveSessionRegistry();
+    registry.registerSession({
+      id: "sess_1",
+      piSessionId: "pi_1",
+      project: { id: "proj_1", name: "Example", path: "/repo/example" },
+      sessionFile: "/tmp/session.jsonl",
+      pid: 1234,
+      messageCount: 0,
+      isStreaming: false,
+      runtimeStatus,
+      updatedAt: "2026-05-09T00:00:00.000Z",
+    });
+
+    expect(registry.getSessionState("sess_1")?.runtimeStatus).toEqual(runtimeStatus);
+    expect(registry.updateRuntimeStatus("sess_1", runtimeStatus)).toBe(false);
+
+    const nextStatus = { ...runtimeStatus, thinkingLevel: "high" as const, updatedAt: "2026-05-09T09:48:00.000Z" };
+    expect(registry.updateRuntimeStatus("sess_1", nextStatus)).toBe(true);
+    expect(registry.getSessionState("sess_1")?.runtimeStatus).toEqual(nextStatus);
+    expect(registry.updateRuntimeStatus("missing", nextStatus)).toBe(false);
+  });
+});

package/tests/auth.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { hashDeviceToken, issueDeviceToken, verifyDeviceToken } from "../src/auth/tokens.js";
+
+describe("device tokens", () => {
+  it("issues a raw token and a persistable hash", () => {
+    const issued = issueDeviceToken();
+
+    expect(issued.rawToken).toMatch(/^prd_[A-Za-z0-9_-]{32,}$/);
+    expect(issued.tokenHash).not.toContain(issued.rawToken);
+  });
+
+  it("verifies the original token", async () => {
+    const hash = await hashDeviceToken("prd_test_token", "fixed-salt");
+
+    await expect(verifyDeviceToken("prd_test_token", hash)).resolves.toBe(true);
+    await expect(verifyDeviceToken("wrong", hash)).resolves.toBe(false);
+  });
+});