@somewhatintelligent/cc-ws-client 0.1.0

package/src/permissions.ts

@@ -0,0 +1,105 @@
+// can_use_tool gate. The binary sends INBOUND control_request frames with
+// subtype:"can_use_tool" when --permission-prompt-tool=stdio is set. We must
+// reply with a CanUseToolResponseFrame (nested envelope) carrying either an
+// allow or a deny.
+//
+// Two consumer surfaces share the same machinery:
+//   1. promise callback — pass `onCanUseTool` to createCcSession; we resolve
+//      it for each request and dispatch the result.
+//   2. queue + respondToPermission — subscribe to the `pendingPermissions`
+//      atom, render UI, call respondToPermission(id, decision).
+// If `onCanUseTool` is provided it wins; the queue is then transient and
+// callers should not consume it from UI.
+
+import { atom, type WritableAtom } from "nanostores";
+import {
+  isControlRequest,
+  type CanUseToolRequest,
+  type InboundFrame,
+} from "./protocol";
+import type { WsClient } from "./ws";
+
+export type PermissionDecision =
+  | { behavior: "allow"; updatedInput?: unknown }
+  | { behavior: "deny"; message?: string };
+
+export type PendingPermission = {
+  id: string;          // request_id we'll reply to
+  toolName: string;
+  input: unknown;
+  raw: CanUseToolRequest;
+};
+
+export type OnCanUseTool = (
+  req: PendingPermission,
+) => Promise<PermissionDecision> | PermissionDecision;
+
+export type PermissionsController = {
+  pendingPermissions: WritableAtom<PendingPermission[]>;
+  ingest: (frame: InboundFrame) => boolean;
+  respond: (id: string, decision: PermissionDecision) => void;
+  // Drop every queued can_use_tool request without replying. Called by
+  // session respawn/disconnect — the issuing claude is dead, so any reply
+  // would go nowhere; the queue is stale UI clutter.
+  clearQueue: () => void;
+};
+
+export function createPermissionsController(opts: {
+  ws: WsClient;
+  onCanUseTool?: OnCanUseTool;
+}): PermissionsController {
+  const pendingPermissions = atom<PendingPermission[]>([]);
+
+  function reply(id: string, decision: PermissionDecision, originalInput: unknown) {
+    const inner =
+      decision.behavior === "allow"
+        ? { behavior: "allow" as const, updatedInput: decision.updatedInput ?? originalInput ?? {} }
+        : { behavior: "deny" as const, message: decision.message ?? "Denied by user" };
+    opts.ws.send({
+      type: "control_response",
+      response: {
+        subtype: "success",
+        request_id: id,
+        response: inner,
+      },
+    });
+  }
+
+  function respond(id: string, decision: PermissionDecision) {
+    const queue = pendingPermissions.get();
+    const entry = queue.find((p) => p.id === id);
+    if (!entry) return;
+    pendingPermissions.set(queue.filter((p) => p.id !== id));
+    reply(id, decision, entry.input);
+  }
+
+  function ingest(frame: InboundFrame): boolean {
+    if (!isControlRequest(frame) || frame.request.subtype !== "can_use_tool") return false;
+    const cr = frame as CanUseToolRequest;
+    const entry: PendingPermission = {
+      id: cr.request_id,
+      toolName: cr.request.tool_name ?? "?",
+      input: cr.request.input ?? {},
+      raw: cr,
+    };
+    if (opts.onCanUseTool) {
+      // Promise-style: resolve immediately, never enqueue.
+      Promise.resolve(opts.onCanUseTool(entry))
+        .then((decision) => reply(entry.id, decision, entry.input))
+        .catch((err) => {
+          console.error("[permissions] onCanUseTool threw", err);
+          reply(entry.id, { behavior: "deny", message: "handler error" }, entry.input);
+        });
+    } else {
+      // Queue-style: append for the consumer to handle via respond().
+      pendingPermissions.set([...pendingPermissions.get(), entry]);
+    }
+    return true;
+  }
+
+  function clearQueue() {
+    pendingPermissions.set([]);
+  }
+
+  return { pendingPermissions, ingest, respond, clearQueue };
+}

package/src/persistence.ts

@@ -0,0 +1,121 @@
+// Local-storage persistence: sessionId + visible message timeline + active
+// mode/model/effort. Without this, --continue restores claude's internal
+// context but doesn't restream prior turns over stream-json — refresh would
+// land on an empty bubble list.
+
+import type { MessagesController, MessageEntry } from "./messages";
+import type { Effort, PermissionMode } from "./modes";
+import type { ReadableAtom } from "nanostores";
+
+export type StorageLike = {
+  getItem: (key: string) => string | null;
+  setItem: (key: string, value: string) => void;
+  removeItem: (key: string) => void;
+};
+
+export type CcPersistenceOptions = {
+  enabled?: boolean;
+  storage?: StorageLike;
+  key?: string;
+  // Cap on serialized message entries. Streaming entries are never
+  // persisted (transient by definition).
+  maxMessages?: number;
+};
+
+export type PersistenceConfig = {
+  storage: StorageLike;
+  key: string;
+  maxMessages: number;
+};
+
+export type PersistedShape = {
+  sessionId: string | null;
+  messages?: MessageEntry[];
+  permissionMode?: PermissionMode;
+  model?: string;
+  effort?: Effort;
+};
+
+export function resolvePersistence(
+  opt: CcPersistenceOptions | false | undefined,
+): PersistenceConfig | null {
+  if (opt === false) return null;
+  // Default to localStorage in browsers; null on the server so SSR doesn't
+  // crash on missing globals.
+  const g = globalThis as { localStorage?: StorageLike };
+  const defaultStorage: StorageLike | null = g.localStorage ?? null;
+  const storage = opt?.storage ?? defaultStorage;
+  if (!storage) return null;
+  if (opt && opt.enabled === false) return null;
+  return {
+    storage,
+    key: opt?.key ?? "cc-ws-session",
+    maxMessages: opt?.maxMessages ?? 200,
+  };
+}
+
+export function loadPersisted(cfg: PersistenceConfig): PersistedShape | null {
+  try {
+    const raw = cfg.storage.getItem(cfg.key);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    return parsed as PersistedShape;
+  } catch {
+    return null;
+  }
+}
+
+export function savePersisted(cfg: PersistenceConfig, payload: PersistedShape): void {
+  try {
+    // Streaming entries are transient; serializing would resurrect a
+    // half-decoded message on reload. Keep frame + local_user only.
+    const trimmed: PersistedShape = { ...payload };
+    if (Array.isArray(payload.messages)) {
+      const filtered = payload.messages.filter(
+        (m) => m.kind === "frame" || m.kind === "local_user",
+      );
+      trimmed.messages = filtered.slice(-cfg.maxMessages);
+    }
+    cfg.storage.setItem(cfg.key, JSON.stringify(trimmed));
+  } catch {
+    // Persistence is best-effort UX, not a correctness requirement.
+  }
+}
+
+// Wires up debounced save-on-change for the relevant atoms. We subscribe
+// to messagesCtrl.revision (only bumps on non-streaming changes) rather
+// than `messages` directly — otherwise every streaming token kicks the
+// 250ms timer and we serialize the entire timeline every 250ms during a
+// turn for changes that are about to be discarded by the streaming-entry
+// filter in savePersisted anyway.
+export function installPersistenceWriter(args: {
+  persistence: PersistenceConfig;
+  init: ReadableAtom<{ sessionId: string | null }>;
+  messagesCtrl: MessagesController;
+  activeMode: ReadableAtom<PermissionMode>;
+  activeModel: ReadableAtom<string>;
+  activeEffort: ReadableAtom<Effort | "">;
+}) {
+  const { persistence, init, messagesCtrl, activeMode, activeModel, activeEffort } = args;
+  let saveTimer: ReturnType<typeof setTimeout> | null = null;
+  const flush = () => {
+    saveTimer = null;
+    savePersisted(persistence, {
+      sessionId: init.get().sessionId,
+      messages: messagesCtrl.messages.get(),
+      permissionMode: activeMode.get(),
+      model: activeModel.get() || undefined,
+      effort: activeEffort.get() || undefined,
+    });
+  };
+  const schedule = () => {
+    if (saveTimer != null) return;
+    saveTimer = setTimeout(flush, 250);
+  };
+  init.subscribe(schedule);
+  messagesCtrl.revision.subscribe(schedule);
+  activeMode.subscribe(schedule);
+  activeModel.subscribe(schedule);
+  activeEffort.subscribe(schedule);
+}