ocuclaw 1.3.0 → 1.3.2

package/dist/runtime/channel-two-hook.js

@@ -0,0 +1,36 @@
+import { composeChannelTwoFragment } from "../domain/prompt-channel-fragments.js";
+
+/**
+ * Build a before_prompt_build hook that injects the Channel-2 fragment.
+ * @param {{getDisplayStartStates:Function, getDisplayCurrentStates:Function,
+ *          hasConnectedAppClient:Function}} service
+ */
+export function createChannelTwoHook(service, opts = {}) {
+  const emitDebug = typeof opts.emitDebug === "function" ? opts.emitDebug : () => {};
+  return function channelTwoBeforePromptBuild(_event, ctx) {
+    const sessionKey =
+      ctx && typeof ctx.sessionKey === "string" && ctx.sessionKey.trim()
+        ? ctx.sessionKey
+        : null;
+    if (!sessionKey) return undefined;
+    try {
+      const fragment = composeChannelTwoFragment({
+        startEnabled: service.getDisplayStartStates(sessionKey),
+        currentEnabled: service.getDisplayCurrentStates(sessionKey),
+        glassesConnected:
+          typeof service.hasConnectedAppClient === "function"
+            ? service.hasConnectedAppClient()
+            : true,
+      });
+      if (!fragment) return undefined;
+      emitDebug("relay.session", "channel_two_fragment_injected", "debug",
+        { sessionKey }, () => ({ chars: fragment.length }));
+      return { appendSystemContext: fragment };
+    } catch (_err) {
+      // Defensive: any state-read failure yields no injection.
+      return undefined;
+    }
+  };
+}
+
+export default createChannelTwoHook;

package/dist/runtime/container-env.js

@@ -0,0 +1,41 @@
+import fs from "node:fs";
+
+// Marker files written by the container runtimes themselves: Docker creates
+// /.dockerenv, Podman creates /run/.containerenv. Kubernetes-style runtimes
+// leave neither — detection there would need heuristics too fragile to ship.
+const CONTAINER_MARKER_PATHS = ["/.dockerenv", "/run/.containerenv"];
+
+export function isLoopbackBindAddress(address) {
+  const normalized = typeof address === "string" ? address.trim().toLowerCase() : "";
+  if (!normalized) return false;
+  return (
+    normalized === "localhost" ||
+    normalized === "::1" ||
+    normalized.startsWith("127.")
+  );
+}
+
+export function isContainerEnvironment(deps = {}) {
+  const existsSync = typeof deps.existsSync === "function" ? deps.existsSync : fs.existsSync;
+  const markerPaths = Array.isArray(deps.markerPaths) ? deps.markerPaths : CONTAINER_MARKER_PATHS;
+  for (const markerPath of markerPaths) {
+    try {
+      if (existsSync(markerPath)) return true;
+    } catch {
+      // No filesystem signal beats a startup failure: treat unreadable markers
+      // as "not a container" and keep the relay booting.
+    }
+  }
+  return false;
+}
+
+export function composeContainerLoopbackWarning(wsBind, wsPort) {
+  return (
+    `[ocuclaw] relay is bound to ${wsBind} inside a container — if the OcuClaw app cannot connect, this is likely why. ` +
+    `Connections from outside the container arrive via its network interface, which a loopback bind does not listen on, ` +
+    `so the relay is unreachable even though it reports healthy. ` +
+    `(Containers run with --network host are unaffected and can ignore this warning.) ` +
+    `Fix: openclaw config set plugins.entries.ocuclaw.config.wsBind "0.0.0.0" ` +
+    `and publish the relay port to the host loopback only (-p 127.0.0.1:${wsPort}:${wsPort}), then restart the gateway.`
+  );
+}

package/dist/runtime/display-toggle-states.js

@@ -0,0 +1,98 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const DEFAULTS = { emoji: false, pace: false };
+const STORE_FILENAME = "ocuclaw-display-toggles.json";
+
+/**
+ * Tracks, per session, the display-feature toggle state at session start
+ * (frozen on first record) and the latest reported state.
+ *
+ * The FROZEN start-state is persisted to stateDir so it survives a relay/plugin
+ * restart — the Channel-1 prompt snapshot is also persisted, so without this the
+ * Channel-2 disable stop-notice would be lost after a restart (a session that
+ * started with a feature ON would re-freeze start=OFF from the first post-restart
+ * send and never notice the disable). The CURRENT state is NOT persisted: it
+ * re-derives from the next send, so persisting it would mean a write per turn.
+ */
+export function createDisplayToggleTracker(opts = {}) {
+  const limit = Number.isFinite(opts.limit) ? opts.limit : 200;
+  const statePath =
+    typeof opts.stateDir === "string" && opts.stateDir.trim()
+      ? path.join(opts.stateDir.trim(), STORE_FILENAME)
+      : null;
+  /** @type {Map<string,{start:{emoji,pace},current:{emoji,pace}}>} */
+  const byKey = new Map();
+
+  function norm(v) {
+    return { emoji: !!(v && v.emoji), pace: !!(v && v.pace) };
+  }
+
+  function load() {
+    if (!statePath) return;
+    try {
+      const parsed = JSON.parse(fs.readFileSync(statePath, "utf8"));
+      if (parsed && parsed.entries && typeof parsed.entries === "object") {
+        for (const [k, v] of Object.entries(parsed.entries)) {
+          if (v && v.start) {
+            const start = norm(v.start);
+            // current re-derives on the next send; seed it from start until then.
+            byKey.set(k, { start, current: { ...start } });
+          }
+        }
+      }
+    } catch (_e) {
+      // Missing/corrupt store is non-fatal: start empty.
+    }
+  }
+
+  function persist() {
+    if (!statePath) return;
+    try {
+      const entries = {};
+      for (const [k, v] of byKey.entries()) entries[k] = { start: v.start };
+      const tmp = `${statePath}.tmp`;
+      fs.writeFileSync(tmp, JSON.stringify({ version: 1, entries }), { mode: 0o600 });
+      fs.renameSync(tmp, statePath);
+    } catch (_e) {
+      // Best-effort persistence.
+    }
+  }
+
+  function evictIfNeeded() {
+    while (byKey.size > limit) {
+      const oldest = byKey.keys().next().value;
+      if (oldest === undefined) break;
+      byKey.delete(oldest);
+    }
+  }
+
+  load();
+
+  return {
+    record(sessionKey, states) {
+      const cur = norm(states);
+      const existing = byKey.get(sessionKey);
+      if (!existing) {
+        byKey.set(sessionKey, { start: cur, current: cur });
+        evictIfNeeded();
+        persist(); // a new frozen start-state was recorded
+        return;
+      }
+      existing.current = cur; // start stays frozen; no persist (start unchanged)
+    },
+    getStart(sessionKey) {
+      const e = byKey.get(sessionKey);
+      return e ? { ...e.start } : { ...DEFAULTS };
+    },
+    getCurrent(sessionKey) {
+      const e = byKey.get(sessionKey);
+      return e ? { ...e.current } : { ...DEFAULTS };
+    },
+    clear(sessionKey) {
+      if (byKey.delete(sessionKey)) persist();
+    },
+  };
+}
+
+export default createDisplayToggleTracker;

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/register-session-title-distiller.js

@@ -0,0 +1,100 @@
+import * as fs from "node:fs/promises";
+import { createSessionTitleDistiller } from "./session-title-distiller.js";
+import { stripAgentSessionPrefix } from "./session-title-distiller-helpers.js";
+
+function genRunId() {
+  const c = globalThis && globalThis.crypto;
+  if (c && typeof c.randomUUID === "function") return `ocuclaw-title-${c.randomUUID()}`;
+  return `ocuclaw-title-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+export function registerSessionTitleDistiller(api, service) {
+  if (!api || typeof api.on !== "function") return () => {};
+  // The budget lives in sessionService (so a logical reset clears it with the
+  // title record + toggle state). Resolve it lazily per call: at registration
+  // the live relay may not exist yet, and a sibling context resolves the shared
+  // relay's budget.
+  const budget = {
+    canRun: (k) => {
+      const b = service.getDistillerBudget();
+      return b ? b.canRun(k) : true;
+    },
+    recordTurn: (k) => {
+      const b = service.getDistillerBudget();
+      if (b) b.recordTurn(k);
+    },
+    recordOutcome: (k, o) => {
+      const b = service.getDistillerBudget();
+      if (b) b.recordOutcome(k, o);
+    },
+  };
+  const distiller = createSessionTitleDistiller({
+    // Lazy getter: the real state dir only arrives at service.start(), after
+    // this distiller is constructed during registration.
+    getStateDir: () => (service.getStateDir ? service.getStateDir() : undefined),
+    nowMs: () => Date.now(),
+    genId: genRunId,
+    emitDebug: (...a) => (service.emitDebug ? service.emitDebug(...a) : undefined),
+    getSessionTitleModel: () => service.getRuntimeConfig().sessionTitleModel || "",
+    conversationState: { getRawMessages: () => service.getRawMessages() },
+    sessionService: {
+      getSessionTitleRecord: (k) => service.getSessionTitleRecord(k),
+      isNeuralSessionNamesEnabled: (k) => service.isNeuralSessionNamesEnabled(k),
+      isSessionUserLocked: (k) => service.isSessionUserLocked(k),
+      hasRecordedUserMessage: (k) => service.hasRecordedUserMessage(k),
+      setSessionTitle: (k, t, o) => service.setSessionTitle(k, t, o),
+    },
+    isEvenAiSessionKey: (k) => service.isEvenAiSessionKey(k),
+    cleanupDistillerSession: (k) =>
+      typeof service.deleteDistillerSession === "function"
+        ? service.deleteDistillerSession(k)
+        : Promise.resolve(null),
+    subagentRuntime: (() => {
+      const sa = api && api.runtime && api.runtime.subagent;
+      if (
+        !sa ||
+        typeof sa.run !== "function" ||
+        typeof sa.waitForRun !== "function" ||
+        typeof sa.getSessionMessages !== "function" ||
+        typeof sa.deleteSession !== "function"
+      ) {
+        return null;
+      }
+      return {
+        run: (p) => sa.run(p),
+        waitForRun: (p) => sa.waitForRun(p),
+        getSessionMessages: (p) => sa.getSessionMessages(p),
+        deleteSession: (p) => sa.deleteSession(p),
+      };
+    })(),
+    gatewayBridge: {
+      request: (m, p, o) => service.gatewayRequest(m, p, o),
+      on: (evt, cb) => service.onGatewayEvent(evt, cb),
+    },
+    fs,
+    budget,
+  });
+
+  return api.on("agent_end", (event, ctx) => {
+    // 2026.6.x delivers the canonical `agent:<id>:<key>` form; relay state is
+    // keyed by the bare relay key — normalize at the boundary.
+    const rawSessionKey = ctx && typeof ctx.sessionKey === "string" ? ctx.sessionKey : null;
+    const sessionKey = stripAgentSessionPrefix(rawSessionKey);
+    if (!sessionKey) return;
+    // Capture the completed run's messages NOW, before the fire-and-forget run
+    // defers: agent_end carries the run's final messages (the authoritative
+    // source for THIS session). Fall back to a synchronous snapshot of the live
+    // conversation state. Either way the messages are pinned here so a later
+    // session switch / clear can't make the distiller title from another
+    // session's transcript.
+    const eventMessages = event && Array.isArray(event.messages) ? event.messages : null;
+    const messages =
+      eventMessages && eventMessages.length
+        ? eventMessages
+        : service.getRawMessages();
+    // Fire-and-forget; never block run teardown.
+    Promise.resolve(distiller.maybeRun(sessionKey, { messages })).catch(() => {});
+  });
+}
+
+export default registerSessionTitleDistiller;