ocuclaw 1.2.4 → 1.3.1

package/dist/runtime/ocuclaw-settings-store.js

@@ -3,6 +3,7 @@ import * as path from "node:path";
 
 const STORE_VERSION = 1;
 const STORE_FILENAME = "ocuclaw-settings.json";
+const PERSIST_DEBOUNCE_MS = 250;
 
 function normalizeLogger(logger) {
   if (!logger || typeof logger !== "object") {
@@ -48,6 +49,10 @@ export function normalizeOcuClawDefaultThinking(value) {
   return "";
 }
 
+export function normalizeOcuClawDefaultFastMode(value) {
+  return value === true;
+}
+
 function isStoredSnapshotCanonical(value, snapshot) {
   if (!value || typeof value !== "object") {
     return false;
@@ -55,7 +60,8 @@ function isStoredSnapshotCanonical(value, snapshot) {
   return (
     normalizeTrimmedString(value.systemPrompt) === snapshot.systemPrompt &&
     normalizeTrimmedString(value.defaultModel) === snapshot.defaultModel &&
-    normalizeOcuClawDefaultThinking(value.defaultThinking) === snapshot.defaultThinking
+    normalizeOcuClawDefaultThinking(value.defaultThinking) === snapshot.defaultThinking &&
+    normalizeOcuClawDefaultFastMode(value.defaultFastMode) === snapshot.defaultFastMode
   );
 }
 
@@ -64,6 +70,7 @@ export function normalizeOcuClawSettingsSnapshot(value = {}) {
     systemPrompt: normalizeOcuClawSystemPrompt(value.systemPrompt),
     defaultModel: normalizeOcuClawDefaultModel(value.defaultModel),
     defaultThinking: normalizeOcuClawDefaultThinking(value.defaultThinking),
+    defaultFastMode: normalizeOcuClawDefaultFastMode(value.defaultFastMode),
   };
 }
 
@@ -83,37 +90,26 @@ export function createOcuClawSettingsStore(opts = {}) {
         ? path.join(opts.stateDir.trim(), STORE_FILENAME)
         : null;
 
-  function persistSnapshot(snapshot, reason) {
-    if (!statePath) {
-      emitDebug(
-        "settings.loadsave",
-        "ocuclaw_settings_persist_skipped",
-        "debug",
-        null,
-        () => ({
-          reason,
-          systemPromptChars: snapshot.systemPrompt.length,
-          defaultModel: snapshot.defaultModel,
-          defaultThinking: snapshot.defaultThinking,
-        }),
-      );
-      return;
-    }
+  let pendingWrite = null;
+  let pendingWriteTimer = null;
+  let writeInFlight = false;
 
+  async function writeSnapshotToDisk(snapshot, reason) {
+    const payload =
+      JSON.stringify(
+        {
+          version: STORE_VERSION,
+          updatedAtMs: now(),
+          settings: snapshot,
+        },
+        null,
+        2,
+      ) + "\n";
+    const tmpPath = `${statePath}.tmp`;
     try {
-      fs.mkdirSync(path.dirname(statePath), { recursive: true });
-      fs.writeFileSync(
-        statePath,
-        JSON.stringify(
-          {
-            version: STORE_VERSION,
-            updatedAtMs: now(),
-            settings: snapshot,
-          },
-          null,
-          2,
-        ) + "\n",
-      );
+      await fs.promises.mkdir(path.dirname(statePath), { recursive: true });
+      await fs.promises.writeFile(tmpPath, payload);
+      await fs.promises.rename(tmpPath, statePath);
       emitDebug(
         "settings.loadsave",
         "ocuclaw_settings_persisted",
@@ -125,6 +121,7 @@ export function createOcuClawSettingsStore(opts = {}) {
           systemPromptChars: snapshot.systemPrompt.length,
           defaultModel: snapshot.defaultModel,
           defaultThinking: snapshot.defaultThinking,
+          defaultFastMode: snapshot.defaultFastMode,
         }),
       );
     } catch (err) {
@@ -142,10 +139,52 @@ export function createOcuClawSettingsStore(opts = {}) {
           message: err && err.message ? err.message : String(err),
         }),
       );
-      throw err;
     }
   }
 
+  function flushPendingWrite() {
+    if (writeInFlight || !pendingWrite) {
+      return;
+    }
+    const { snapshot, reason } = pendingWrite;
+    pendingWrite = null;
+    writeInFlight = true;
+    writeSnapshotToDisk(snapshot, reason).finally(() => {
+      writeInFlight = false;
+      if (pendingWrite) {
+        flushPendingWrite();
+      }
+    });
+  }
+
+  function persistSnapshot(snapshot, reason) {
+    if (!statePath) {
+      emitDebug(
+        "settings.loadsave",
+        "ocuclaw_settings_persist_skipped",
+        "debug",
+        null,
+        () => ({
+          reason,
+          systemPromptChars: snapshot.systemPrompt.length,
+          defaultModel: snapshot.defaultModel,
+          defaultThinking: snapshot.defaultThinking,
+          defaultFastMode: snapshot.defaultFastMode,
+        }),
+      );
+      return;
+    }
+
+    pendingWrite = { snapshot, reason };
+    if (pendingWriteTimer) {
+      clearTimeout(pendingWriteTimer);
+    }
+    pendingWriteTimer = setTimeout(() => {
+      pendingWriteTimer = null;
+      flushPendingWrite();
+    }, PERSIST_DEBOUNCE_MS);
+  }
+
   function loadInitialSnapshot() {
     if (!statePath || !fs.existsSync(statePath)) {
       persistSnapshot(defaults, "seed_defaults");
@@ -173,6 +212,7 @@ export function createOcuClawSettingsStore(opts = {}) {
           systemPromptChars: loaded.systemPrompt.length,
           defaultModel: loaded.defaultModel,
           defaultThinking: loaded.defaultThinking,
+          defaultFastMode: loaded.defaultFastMode,
         }),
       );
       if (
@@ -223,6 +263,9 @@ export function createOcuClawSettingsStore(opts = {}) {
         defaultThinking: hasOwn(patch, "defaultThinking")
           ? normalizeOcuClawDefaultThinking(patch.defaultThinking)
           : snapshot.defaultThinking,
+        defaultFastMode: hasOwn(patch, "defaultFastMode")
+          ? normalizeOcuClawDefaultFastMode(patch.defaultFastMode)
+          : snapshot.defaultFastMode,
       };
       snapshot = next;
       persistSnapshot(snapshot, "set_settings");

package/dist/runtime/plugin-version-service.js

@@ -0,0 +1,23 @@
+import { PLUGIN_VERSION, REQUIRES_CLIENT_VERSION } from "../version.js";
+
+/**
+ * Plugin version provider. Exposes the build-time version constants used by the
+ * relay handshake. No process execution.
+ */
+function createPluginVersionService() {
+  function getPluginVersion() {
+    return typeof PLUGIN_VERSION === "string" && PLUGIN_VERSION.length > 0
+      ? PLUGIN_VERSION
+      : null;
+  }
+
+  function getRequiresClientVersion() {
+    return typeof REQUIRES_CLIENT_VERSION === "string" && REQUIRES_CLIENT_VERSION.length > 0
+      ? REQUIRES_CLIENT_VERSION
+      : null;
+  }
+
+  return { getPluginVersion, getRequiresClientVersion };
+}
+
+export { createPluginVersionService };

package/dist/runtime/protocol-adapter.js

@@ -4,8 +4,11 @@ const V1_TO_INTERNAL = {
   switchSession: "ocuclaw.session.switch",
   newChat: "ocuclaw.session.reset",
   getSessions: "ocuclaw.session.list",
+  deleteSessions: "ocuclaw.session.delete",
+  setSessionPinned: "ocuclaw.session.pinned.set",
   getStatus: "ocuclaw.runtime.status.get",
   getModelsCatalog: "ocuclaw.model.catalog.get",
+  getProviderUsageSnapshot: "ocuclaw.provider.usage.get",
   getSkills: "ocuclaw.skills.catalog.get",
   getSonioxModels: "ocuclaw.voice.soniox.models.get",
   getSessionModelConfig: "ocuclaw.session.config.get",
@@ -22,6 +25,7 @@ const V1_TO_INTERNAL = {
   "debug-set": "ocuclaw.debug.config.set",
   "debug-dump": "ocuclaw.debug.events.query",
   resume: "ocuclaw.sync.resume",
+  compactSession: "ocuclaw.session.compact",
 };
 
 const RESULT_TO_V1 = {
@@ -36,15 +40,18 @@ const RESULT_TO_V1 = {
   "ocuclaw.settings.snapshot": "ocuClawSettings",
   "ocuclaw.settings.set.ack": "ocuClawSettingsAck",
   "ocuclaw.model.catalog.snapshot": "modelsCatalog",
+  "ocuclaw.provider.usage.snapshot": "providerUsageSnapshot",
   "ocuclaw.skills.catalog.snapshot": "skillsCatalog",
   "ocuclaw.voice.soniox.models.snapshot": "sonioxModels",
   "ocuclaw.approval.resolve.ack": "approvalResponseAck",
+  "ocuclaw.session.compact.ack": "compactSessionAck",
 };
 
 const EVENT_TO_V1 = {
   "ocuclaw.view.pages.snapshot": "pages",
   "ocuclaw.runtime.status": "status",
   "ocuclaw.activity.update": "activity",
+  "ocuclaw.typing.update": "typing",
   "ocuclaw.message.stream.delta": "streaming",
   "ocuclaw.session.switch.applied": "sessionSwitched",
   "ocuclaw.sync.resume.ack": "resume-ack",
@@ -52,6 +59,8 @@ const EVENT_TO_V1 = {
   "ocuclaw.approval.resolved": "approvalResolved",
   "ocuclaw.remote.control": "remote-control",
   "ocuclaw.protocol.tap.frame": "protocol",
+  "ocuclaw.provider.usage.snapshot": "providerUsageSnapshot",
+  "ocuclaw.session.context.snapshot": "sessionContextSnapshot",
 };
 
 const INTERNAL_TO_V1 = Object.fromEntries(

package/dist/runtime/provider-usage-select.js

@@ -0,0 +1,168 @@
+function normalizeWindowKey(label, index) {
+  const normalized = typeof label === "string" ? label.trim().toLowerCase() : "";
+
+  if (normalized === "week" || normalized === "weekly") {
+    return { key: "week", sortOrder: 20 };
+  }
+
+  if (/^5\s*(h|hr|hrs|hour|hours)?$/.test(normalized)) {
+    return { key: "5h", sortOrder: 10 };
+  }
+
+  const key = normalized.replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  return {
+    key: key || `window_${index}`,
+    sortOrder: 100 + index,
+  };
+}
+
+function toFiniteNumber(value, fallback) {
+  if (value === null || value === undefined || value === "") {
+    return fallback;
+  }
+  const number = Number(value);
+  return Number.isFinite(number) ? number : fallback;
+}
+
+function normalizeWindow(window, index) {
+  const normalizedKey = normalizeWindowKey(window && window.label, index);
+  const label =
+    typeof window?.label === "string" && window.label.trim()
+      ? window.label.trim()
+      : normalizedKey.key;
+
+  return {
+    key: normalizedKey.key,
+    label,
+    usedPercent: toFiniteNumber(window && window.usedPercent, 0),
+    resetAtMs: toFiniteNumber(window && window.resetAt, null),
+    sortOrder: normalizedKey.sortOrder,
+  };
+}
+
+function isStrongerWindow(candidate, current) {
+  if (candidate.usedPercent !== current.usedPercent) {
+    return candidate.usedPercent > current.usedPercent;
+  }
+  return candidate.sortOrder > current.sortOrder;
+}
+
+export function selectLimitingWindow(windows) {
+  if (!Array.isArray(windows) || windows.length === 0) {
+    return null;
+  }
+
+  return windows.slice().sort((left, right) => {
+    const leftExhausted = left.usedPercent >= 100;
+    const rightExhausted = right.usedPercent >= 100;
+
+    if (leftExhausted !== rightExhausted) {
+      return leftExhausted ? -1 : 1;
+    }
+
+    if (left.usedPercent !== right.usedPercent) {
+      return right.usedPercent - left.usedPercent;
+    }
+
+    return right.sortOrder - left.sortOrder;
+  })[0];
+}
+
+export function selectProviderUsageSnapshot(summary, opts = {}) {
+  const providers = Array.isArray(summary && summary.providers) ? summary.providers : [];
+  const activeProvider =
+    typeof opts.provider === "string" ? opts.provider.trim().toLowerCase() : "";
+
+  if (!activeProvider) {
+    return null;
+  }
+
+  const namedEntries = providers.filter(
+    (entry) => typeof entry?.provider === "string",
+  );
+
+  let match = namedEntries.find(
+    (entry) => entry.provider.trim().toLowerCase() === activeProvider,
+  );
+
+  // Family fallback: the session model config reports the base provider id
+  // (e.g. "openai") while the usage summary keys the same usage by its
+  // sub-provider source (e.g. "openai-codex"). When there is no exact match
+  // but exactly ONE summary entry belongs to the active provider's family
+  // ("${activeProvider}-…"), resolve it. Restricted to a single family member
+  // to avoid ambiguous attribution when multiple sub-providers exist.
+  if (!match) {
+    const familyMatches = namedEntries.filter((entry) =>
+      entry.provider.trim().toLowerCase().startsWith(`${activeProvider}-`),
+    );
+    if (familyMatches.length === 1) {
+      match = familyMatches[0];
+    }
+  }
+
+  if (!match) {
+    return null;
+  }
+
+  const windows = (Array.isArray(match.windows) ? match.windows : []).map(normalizeWindow);
+  const limitingWindow = selectLimitingWindow(windows);
+  const dedupedWindows = [];
+  const keyToIndex = new Map();
+
+  for (const window of windows) {
+    if (!keyToIndex.has(window.key)) {
+      keyToIndex.set(window.key, dedupedWindows.length);
+      dedupedWindows.push(window);
+      continue;
+    }
+
+    const existingIndex = keyToIndex.get(window.key);
+    const existingWindow = dedupedWindows[existingIndex];
+    if (isStrongerWindow(window, existingWindow)) {
+      dedupedWindows[existingIndex] = window;
+    }
+  }
+
+  const provider = typeof match.provider === "string" ? match.provider.trim() : match.provider;
+
+  return {
+    sessionKey: typeof opts.sessionKey === "string" ? opts.sessionKey : null,
+    provider,
+    displayName:
+      typeof match.displayName === "string" && match.displayName.trim()
+        ? match.displayName.trim()
+        : provider,
+    fetchedAtMs: toFiniteNumber(summary && summary.updatedAt, null),
+    stale: opts.stale === true,
+    limitingWindowKey: limitingWindow ? limitingWindow.key : null,
+    windows: dedupedWindows,
+  };
+}
+
+export function buildRateLimitInfoFromSnapshot(snapshot) {
+  if (!snapshot || snapshot.stale === true || !snapshot.limitingWindowKey) {
+    return null;
+  }
+  if (snapshot.poolStatus === "ready") {
+    return null;
+  }
+
+  const limitingWindow = Array.isArray(snapshot.windows)
+    ? snapshot.windows.find((window) => window.key === snapshot.limitingWindowKey) || null
+    : null;
+
+  if (!limitingWindow) {
+    return null;
+  }
+
+  return {
+    sessionKey: snapshot.sessionKey || null,
+    provider: snapshot.provider || null,
+    windowKey: limitingWindow.key,
+    windowLabel: limitingWindow.label,
+    usedPercent: limitingWindow.usedPercent,
+    resetAtMs: limitingWindow.resetAtMs,
+    fetchedAtMs: snapshot.fetchedAtMs,
+    stale: false,
+  };
+}