@codeoid/core 0.1.0

package/README.md

@@ -0,0 +1,39 @@
+# @codeoid/core
+
+Framework-agnostic client core for the [Codeoid](https://github.com/saucam/codeoid)
+daemon — everything a frontend needs except the pixels:
+
+- **`CodeoidClient`** — the WebSocket transport: auth handshake (token +
+  protocol version + capability declaration), request/response correlation,
+  liveness heartbeat, exponential-backoff reconnect with full jitter. Needs
+  only a WHATWG `WebSocket` global (browsers, React Native, Bun, Node ≥ 22).
+  All timing is injectable. Native hosts call `reconnectNow()` from their own
+  resume signal (e.g. React Native `AppState`).
+- **`MessageStore`** + kernels (`mergeDeltaInto`, `dedupeReplay`) — the
+  single source of truth for transcript accumulation: upsert-by-messageId,
+  streaming delta merges, snapshot vs chunked vs incremental replay routing
+  (`ingest()`), per-message versions and per-session epochs.
+- **`ResumeCursors`** — `replay.resume` cursor tracking so reconnects fetch
+  only the tail mutated since, not the whole scrollback.
+- Display helpers shared across frontends: usage formatters (`formatTokens`,
+  `formatCostUsd`, …), identity/provenance labels (`shortSub`,
+  `identityLabel`, …), approval scanning, slash-command parsing.
+
+```ts
+import { CodeoidClient, MessageStore, ResumeCursors } from "@codeoid/core";
+import { CAPABILITIES } from "@codeoid/protocol";
+
+const store = new MessageStore();
+const cursors = new ResumeCursors();
+const client = new CodeoidClient({
+  url: "ws://localhost:7400",
+  token,
+  capabilities: [CAPABILITIES.PARTS, CAPABILITIES.CHUNKED_REPLAY, CAPABILITIES.SEQ_RESUME],
+  clientName: "my-frontend/1.0",
+});
+client.onMessage((msg) => store.ingest(msg, cursors));
+await client.connect();
+```
+
+Ships TypeScript source (every consumer transpiles TS — Bun, Vite, Metro).
+`@codeoid/protocol` is a peer dependency.

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@codeoid/core",
+  "version": "0.1.0",
+  "description": "Framework-agnostic Codeoid client core — WebSocket transport (auth handshake, reconnect, heartbeat), message store semantics, resume cursors, and display helpers. Shared by the web UI and the mobile client.",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/saucam/codeoid.git",
+    "directory": "packages/core"
+  },
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
+  },
+  "sideEffects": false,
+  "files": ["src", "!src/**/*.test.ts", "README.md"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@codeoid/protocol": "^0.1.0"
+  }
+}

package/src/approvals.ts

@@ -0,0 +1,60 @@
+/**
+ * Shared pending-approval lookup for ApprovalBar + desktop notifications.
+ *
+ * The naive version scanned the ENTIRE message array from index 0 on every
+ * streaming delta — O(N) per delta on a 5 000-message session. Two levers
+ * keep this cheap while preserving user-visible behavior:
+ *
+ *   1. Status gate. Approvals can only pend mid-turn, so when the session
+ *      is `idle` / `error` there is nothing to find and we skip the scan
+ *      entirely. We deliberately gate on "any active status" rather than
+ *      strictly `waiting_approval`: with parallel pending approvals (rare,
+ *      stream-input mode) the daemon flips status to `tool_running` /
+ *      `thinking` the moment the FIRST approval resolves even though a
+ *      second is still waiting (session.ts resolves each canUseTool with
+ *      `setStatus(approved ? "tool_running" : "thinking")`), and a strict
+ *      gate would hide that second approval bar forever — deadlocking the
+ *      turn from the user's point of view.
+ *
+ *   2. Turn-bounded backward scan. Pending approvals live in the CURRENT
+ *      turn — every earlier turn's tool calls were finalized (executing /
+ *      cancelled) before the next user message could be accepted. So scan
+ *      backward from the tail and stop at the first `user` message. Within
+ *      that window the OLDEST pending match wins, matching the previous
+ *      forward-scan semantics (the daemon serializes approvals oldest
+ *      first).
+ */
+
+import type { SessionMessage, SessionStatus } from "@codeoid/protocol";
+
+const APPROVAL_POSSIBLE: ReadonlySet<SessionStatus> = new Set<SessionStatus>([
+  "waiting_approval",
+  "thinking",
+  "tool_running",
+]);
+
+/**
+ * Find the oldest tool_call in `waiting_confirmation` within the current
+ * turn, or null. `status` is the session's current status (undefined when
+ * the session record is missing).
+ */
+export function findPendingApproval(
+  messages: readonly SessionMessage[],
+  status: SessionStatus | undefined,
+): SessionMessage | null {
+  if (!status || !APPROVAL_POSSIBLE.has(status)) return null;
+  let oldest: SessionMessage | null = null;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (!m) continue;
+    if (m.role === "user") break; // turn boundary — nothing pends earlier
+    if (
+      m.role === "tool_call" &&
+      m.tool &&
+      m.tool.state.phase === "waiting_confirmation"
+    ) {
+      oldest = m; // keep walking — an earlier pending in this turn wins
+    }
+  }
+  return oldest;
+}