ocuclaw 1.2.4 → 1.3.0

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-update-service.js

@@ -0,0 +1,216 @@
+import { PLUGIN_VERSION, REQUIRES_CLIENT_VERSION } from "../version.js";
+
+/**
+ * Plugin update service.
+ *
+ * Exposes the current plugin version (from build-time constant) and two
+ * single-flight executors that shell out to the openclaw CLI:
+ *   - runPluginUpdate: `openclaw plugins update ocuclaw`
+ *   - runGatewayRestart: `openclaw gateway restart` (detached)
+ *
+ * Injects child_process.spawn so tests can mock process behaviour.
+ */
+function createPluginUpdateService(deps) {
+  const spawn = deps.spawn;
+  const logger = deps.logger;
+  const nowMs = deps.nowMs;
+  const setTimeoutFn = deps.setTimeout;
+  const clearTimeoutFn = deps.clearTimeout;
+  const updateTimeoutMs = Number.isFinite(deps.updateTimeoutMs)
+    ? Math.max(1, Math.floor(deps.updateTimeoutMs))
+    : 5 * 60 * 1000;
+  const killGraceMs = Number.isFinite(deps.killGraceMs)
+    ? Math.max(1, Math.floor(deps.killGraceMs))
+    : 5 * 1000;
+
+  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;
+  }
+
+  function captureStderrTail(stream, maxBytes) {
+    const chunks = [];
+    let totalBytes = 0;
+    let drained = false;
+    const drainCallbacks = [];
+    stream.on("data", (chunk) => {
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+      chunks.push(buf);
+      totalBytes += buf.length;
+      while (totalBytes > maxBytes && chunks.length > 0) {
+        const head = chunks[0];
+        if (totalBytes - head.length >= maxBytes) {
+          // Dropping head still leaves more than maxBytes; drop it entirely.
+          chunks.shift();
+          totalBytes -= head.length;
+        } else {
+          // Partial drop: slice head so the total becomes exactly maxBytes.
+          const drop = totalBytes - maxBytes;
+          chunks[0] = head.subarray(drop);
+          totalBytes = maxBytes;
+          break;
+        }
+      }
+    });
+    const onDrained = () => {
+      if (drained) return;
+      drained = true;
+      for (const cb of drainCallbacks) cb();
+    };
+    stream.on("end", onDrained);
+    stream.on("close", onDrained);
+    stream.on("error", onDrained);
+    return {
+      readTail() {
+        return Buffer.concat(chunks).toString("utf8");
+      },
+      whenDrained(cb) {
+        if (drained) { cb(); } else { drainCallbacks.push(cb); }
+      },
+    };
+  }
+
+  let updateInFlight = false;
+  let restartStarted = false;
+
+  async function runPluginUpdate() {
+    if (updateInFlight) {
+      return { ok: false, reason: "in_progress" };
+    }
+    updateInFlight = true;
+    try {
+      return await doRunPluginUpdate();
+    } finally {
+      updateInFlight = false;
+    }
+  }
+
+  async function doRunPluginUpdate() {
+    return await new Promise((resolve) => {
+      const STDERR_MAX_BYTES = 8 * 1024;
+      let settled = false;
+      let timedOut = false;
+      let timeoutTimer = null;
+      let killTimer = null;
+      let safetyTimer = null;
+      const settle = (result) => {
+        if (settled) return;
+        settled = true;
+        if (timeoutTimer !== null) {
+          clearTimeoutFn(timeoutTimer);
+          timeoutTimer = null;
+        }
+        if (killTimer !== null) {
+          clearTimeoutFn(killTimer);
+          killTimer = null;
+        }
+        if (safetyTimer !== null) {
+          clearTimeoutFn(safetyTimer);
+          safetyTimer = null;
+        }
+        resolve(result);
+      };
+
+      let child;
+      try {
+        child = spawn(
+          "openclaw",
+          ["plugins", "update", "ocuclaw"],
+          { env: process.env, stdio: ["ignore", "pipe", "pipe"] },
+        );
+      } catch (_err) {
+        settle({ ok: false, reason: "spawn_failed" });
+        return;
+      }
+
+      const stderrBuf = child.stderr
+        ? captureStderrTail(child.stderr, STDERR_MAX_BYTES)
+        : { readTail: () => "", whenDrained: (cb) => cb() };
+
+      child.on("error", (err) => {
+        const code = err && err.code;
+        if (code === "ENOENT") {
+          settle({ ok: false, reason: "cli_not_found" });
+        } else {
+          settle({ ok: false, reason: "spawn_failed" });
+        }
+      });
+      child.on("exit", (code) => {
+        if (timedOut) {
+          settle({ ok: false, reason: "timeout" });
+          return;
+        }
+        if (code === 0) {
+          settle({ ok: true });
+          return;
+        }
+        const exitCode = typeof code === "number" ? code : null;
+        stderrBuf.whenDrained(() => {
+          const tail = stderrBuf.readTail();
+          settle({
+            ok: false,
+            reason: "nonzero_exit",
+            exitCode,
+            stderrTail: tail.length > 0 ? tail : undefined,
+          });
+        });
+      });
+
+      timeoutTimer = setTimeoutFn(() => {
+        timeoutTimer = null;
+        timedOut = true;
+        try { child.kill("SIGTERM"); } catch (_) {}
+        killTimer = setTimeoutFn(() => {
+          killTimer = null;
+          try { child.kill("SIGKILL"); } catch (_) {}
+        }, killGraceMs);
+        // Safety net: if child never emits exit, settle after kill grace + buffer.
+        safetyTimer = setTimeoutFn(() => {
+          safetyTimer = null;
+          settle({ ok: false, reason: "timeout" });
+        }, killGraceMs + 50);
+      }, updateTimeoutMs);
+    });
+  }
+
+  async function runGatewayRestart() {
+    if (restartStarted) {
+      return { ok: false, started: false, reason: "in_progress" };
+    }
+    let child;
+    try {
+      child = spawn(
+        "openclaw",
+        ["gateway", "restart"],
+        { detached: true, stdio: "ignore", env: process.env },
+      );
+    } catch (err) {
+      const code = err && err.code;
+      if (code === "ENOENT") {
+        return { ok: false, started: false, reason: "cli_not_found" };
+      }
+      return { ok: false, started: false, reason: "spawn_failed" };
+    }
+    try {
+      if (typeof child.unref === "function") child.unref();
+    } catch (_) {}
+    restartStarted = true;
+    return { ok: true, started: true };
+  }
+
+  return {
+    getPluginVersion,
+    getRequiresClientVersion,
+    runPluginUpdate,
+    runGatewayRestart,
+  };
+}
+
+export { createPluginUpdateService };

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,
+  };
+}