ocuclaw 0.1.0

package/dist/even-ai/even-ai-settings-store.js

@@ -0,0 +1,365 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export const DEFAULT_EVEN_AI_ROUTING_MODE = "active";
+export const SUPPORTED_EVEN_AI_ROUTING_MODES = Object.freeze([
+  "active",
+  "background",
+  "background_new",
+]);
+const ACCEPTED_EVEN_AI_ROUTING_MODES = Object.freeze([
+  ...SUPPORTED_EVEN_AI_ROUTING_MODES,
+  "dedicated",
+  "new",
+  "dedicated_shadow",
+  "new_shadow",
+]);
+
+const STORE_VERSION = 1;
+const STORE_FILENAME = "even-ai-settings.json";
+const MAX_TRACKED_THROWAWAY_KEYS = 20;
+
+function normalizeLogger(logger) {
+  if (!logger || typeof logger !== "object") {
+    return console;
+  }
+  return {
+    info: typeof logger.info === "function" ? logger.info.bind(logger) : console.log,
+    warn: typeof logger.warn === "function" ? logger.warn.bind(logger) : console.warn,
+    error: typeof logger.error === "function" ? logger.error.bind(logger) : console.error,
+    debug:
+      typeof logger.debug === "function" ? logger.debug.bind(logger) : console.debug,
+  };
+}
+
+function normalizeTrimmedString(value) {
+  if (typeof value !== "string") {
+    return "";
+  }
+  return value.trim();
+}
+
+export function normalizeEvenAiRoutingMode(value) {
+  const normalized = normalizeTrimmedString(value).toLowerCase();
+  if (SUPPORTED_EVEN_AI_ROUTING_MODES.includes(normalized)) {
+    return normalized;
+  }
+  if (normalized === "dedicated" || normalized === "dedicated_shadow") {
+    return "background";
+  }
+  if (normalized === "new" || normalized === "new_shadow") {
+    return "background_new";
+  }
+  return DEFAULT_EVEN_AI_ROUTING_MODE;
+}
+
+export function normalizeEvenAiSystemPrompt(value) {
+  return normalizeTrimmedString(value);
+}
+
+export function normalizeEvenAiDefaultModel(value) {
+  return normalizeTrimmedString(value);
+}
+
+export function normalizeEvenAiDefaultThinking(value) {
+  const normalized = normalizeTrimmedString(value).toLowerCase();
+  if (!normalized) {
+    return "";
+  }
+  if ([
+    "off",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+  ].includes(normalized)) {
+    return normalized;
+  }
+  return "";
+}
+
+export function normalizeEvenAiListenEnabled(value) {
+  return value === true;
+}
+
+function normalizeTrackedThrowawayKeys(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  const normalized = [];
+  const seen = new Set();
+  for (const rawKey of value) {
+    const sessionKey = normalizeTrimmedString(rawKey);
+    if (!sessionKey) continue;
+    const dedupeKey = sessionKey.toLowerCase();
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
+    normalized.push(sessionKey);
+    if (normalized.length >= MAX_TRACKED_THROWAWAY_KEYS) {
+      break;
+    }
+  }
+  return normalized;
+}
+
+function arraysEqual(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  for (let i = 0; i < left.length; i += 1) {
+    if (left[i] !== right[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function isStoredSnapshotCanonical(value, snapshot) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (normalizeTrimmedString(value.routingMode) !== snapshot.routingMode) {
+    return false;
+  }
+  if (normalizeTrimmedString(value.systemPrompt) !== snapshot.systemPrompt) {
+    return false;
+  }
+  if (normalizeTrimmedString(value.defaultModel) !== snapshot.defaultModel) {
+    return false;
+  }
+  if (normalizeEvenAiDefaultThinking(value.defaultThinking) !== snapshot.defaultThinking) {
+    return false;
+  }
+  if (normalizeEvenAiListenEnabled(value.listenEnabled) !== snapshot.listenEnabled) {
+    return false;
+  }
+  if (!Array.isArray(value.trackedThrowawayKeys)) {
+    return snapshot.trackedThrowawayKeys.length === 0;
+  }
+  return arraysEqual(value.trackedThrowawayKeys, snapshot.trackedThrowawayKeys);
+}
+
+export function normalizeEvenAiSettingsSnapshot(value = {}) {
+  return {
+    routingMode: normalizeEvenAiRoutingMode(value.routingMode),
+    systemPrompt: normalizeEvenAiSystemPrompt(value.systemPrompt),
+    defaultModel: normalizeEvenAiDefaultModel(value.defaultModel),
+    defaultThinking: normalizeEvenAiDefaultThinking(value.defaultThinking),
+    listenEnabled: normalizeEvenAiListenEnabled(value.listenEnabled),
+    trackedThrowawayKeys: normalizeTrackedThrowawayKeys(value.trackedThrowawayKeys),
+  };
+}
+
+function hasOwn(obj, key) {
+  return !!obj && Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+export function createEvenAiSettingsStore(opts = {}) {
+  const logger = normalizeLogger(opts.logger);
+  const emitDebug = typeof opts.emitDebug === "function" ? opts.emitDebug : () => {};
+  const now = typeof opts.now === "function" ? opts.now : () => Date.now();
+  const defaults = normalizeEvenAiSettingsSnapshot(opts.defaults || {});
+  const statePath =
+    typeof opts.statePath === "string" && opts.statePath.trim()
+      ? opts.statePath.trim()
+      : typeof opts.stateDir === "string" && opts.stateDir.trim()
+        ? path.join(opts.stateDir.trim(), STORE_FILENAME)
+        : null;
+
+  function persistSnapshot(snapshot, reason) {
+    if (!statePath) {
+      emitDebug(
+        "settings.loadsave",
+        "even_ai_settings_persist_skipped",
+        "debug",
+        null,
+        () => ({
+          reason,
+          routingMode: snapshot.routingMode,
+          systemPromptChars: snapshot.systemPrompt.length,
+          defaultModel: snapshot.defaultModel,
+          defaultThinking: snapshot.defaultThinking,
+          listenEnabled: snapshot.listenEnabled,
+          trackedThrowawayKeyCount: snapshot.trackedThrowawayKeys.length,
+        }),
+      );
+      return;
+    }
+
+    try {
+      fs.mkdirSync(path.dirname(statePath), { recursive: true });
+      fs.writeFileSync(
+        statePath,
+        JSON.stringify(
+          {
+            version: STORE_VERSION,
+            updatedAtMs: now(),
+            settings: snapshot,
+          },
+          null,
+          2,
+        ) + "\n",
+      );
+      emitDebug(
+        "settings.loadsave",
+        "even_ai_settings_persisted",
+        "info",
+        null,
+        () => ({
+          reason,
+          statePath,
+          routingMode: snapshot.routingMode,
+          systemPromptChars: snapshot.systemPrompt.length,
+          defaultModel: snapshot.defaultModel,
+          defaultThinking: snapshot.defaultThinking,
+          listenEnabled: snapshot.listenEnabled,
+          trackedThrowawayKeyCount: snapshot.trackedThrowawayKeys.length,
+        }),
+      );
+    } catch (err) {
+      logger.error(
+        `[evenai] failed to persist Even AI settings: ${err && err.message ? err.message : err}`,
+      );
+      emitDebug(
+        "settings.loadsave",
+        "even_ai_settings_persist_failed",
+        "warn",
+        null,
+        () => ({
+          reason,
+          statePath,
+          message: err && err.message ? err.message : String(err),
+        }),
+      );
+      throw err;
+    }
+  }
+
+  function loadInitialSnapshot() {
+    if (!statePath || !fs.existsSync(statePath)) {
+      persistSnapshot(defaults, "seed_defaults");
+      return { ...defaults };
+    }
+
+    try {
+      const raw = fs.readFileSync(statePath, "utf8");
+      const parsed = JSON.parse(raw);
+      const storedSettings =
+        parsed && parsed.settings && typeof parsed.settings === "object"
+          ? parsed.settings
+          : null;
+      const loaded =
+        parsed &&
+        parsed.version === STORE_VERSION &&
+        storedSettings
+          ? normalizeEvenAiSettingsSnapshot(storedSettings)
+          : defaults;
+      emitDebug(
+        "settings.loadsave",
+        "even_ai_settings_loaded",
+        "info",
+        null,
+        () => ({
+          statePath,
+          routingMode: loaded.routingMode,
+          systemPromptChars: loaded.systemPrompt.length,
+          defaultModel: loaded.defaultModel,
+          defaultThinking: loaded.defaultThinking,
+          listenEnabled: loaded.listenEnabled,
+          trackedThrowawayKeyCount: loaded.trackedThrowawayKeys.length,
+        }),
+      );
+      if (
+        parsed.version !== STORE_VERSION ||
+        !isStoredSnapshotCanonical(storedSettings, loaded)
+      ) {
+        persistSnapshot(loaded, "normalize_loaded_settings");
+      }
+      return loaded;
+    } catch (err) {
+      logger.warn(
+        `[evenai] failed to load Even AI settings, falling back to defaults: ${err && err.message ? err.message : err}`,
+      );
+      emitDebug(
+        "settings.loadsave",
+        "even_ai_settings_load_failed",
+        "warn",
+        null,
+        () => ({
+          statePath,
+          message: err && err.message ? err.message : String(err),
+        }),
+      );
+      persistSnapshot(defaults, "rewrite_after_load_failure");
+      return { ...defaults };
+    }
+  }
+
+  let snapshot = loadInitialSnapshot();
+
+  function updateTrackedThrowawayKeys(nextKeys, reason) {
+    snapshot = {
+      ...snapshot,
+      trackedThrowawayKeys: normalizeTrackedThrowawayKeys(nextKeys),
+    };
+    persistSnapshot(snapshot, reason);
+    return { ...snapshot };
+  }
+
+  return {
+    getStatePath() {
+      return statePath;
+    },
+
+    getSnapshot() {
+      return { ...snapshot };
+    },
+
+    getTrackedThrowawayKeys() {
+      return [...snapshot.trackedThrowawayKeys];
+    },
+
+    recordTrackedThrowawayKey(sessionKey) {
+      const normalizedKey = normalizeTrimmedString(sessionKey);
+      if (!normalizedKey) {
+        return { ...snapshot };
+      }
+      const dedupeKey = normalizedKey.toLowerCase();
+      const nextKeys = [
+        normalizedKey,
+        ...snapshot.trackedThrowawayKeys.filter((key) => key.toLowerCase() !== dedupeKey),
+      ];
+      return updateTrackedThrowawayKeys(nextKeys, "record_throwaway_session");
+    },
+
+    async setSettings(patch = {}) {
+      const next = {
+        routingMode: hasOwn(patch, "routingMode")
+          ? normalizeEvenAiRoutingMode(patch.routingMode)
+          : snapshot.routingMode,
+        systemPrompt: hasOwn(patch, "systemPrompt")
+          ? normalizeEvenAiSystemPrompt(patch.systemPrompt)
+          : snapshot.systemPrompt,
+        defaultModel: hasOwn(patch, "defaultModel")
+          ? normalizeEvenAiDefaultModel(patch.defaultModel)
+          : snapshot.defaultModel,
+        defaultThinking: hasOwn(patch, "defaultThinking")
+          ? normalizeEvenAiDefaultThinking(patch.defaultThinking)
+          : snapshot.defaultThinking,
+        listenEnabled: hasOwn(patch, "listenEnabled")
+          ? normalizeEvenAiListenEnabled(patch.listenEnabled)
+          : snapshot.listenEnabled,
+        trackedThrowawayKeys: [...snapshot.trackedThrowawayKeys],
+      };
+      snapshot = next;
+      persistSnapshot(snapshot, "set_settings");
+      return {
+        status: "accepted",
+        settings: { ...snapshot },
+      };
+    },
+  };
+}
+
+export default createEvenAiSettingsStore;

package/dist/gateway/gateway-bridge.js

@@ -0,0 +1,175 @@
+function removeListenerCompat(emitter, eventName, listener) {
+  if (typeof emitter.off === "function") {
+    emitter.off(eventName, listener);
+    return;
+  }
+  if (typeof emitter.removeListener === "function") {
+    emitter.removeListener(eventName, listener);
+  }
+}
+
+function defaultIdempotencyKey() {
+  const globalCrypto = globalThis && globalThis.crypto;
+  if (globalCrypto && typeof globalCrypto.randomUUID === "function") {
+    return globalCrypto.randomUUID();
+  }
+  return `ocuclaw-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+function callClientMethod(openclawClient, name, args) {
+  const fn = openclawClient && openclawClient[name];
+  if (typeof fn !== "function") {
+    throw new Error(`Gateway bridge requires openclawClient.${name}()`);
+  }
+  return fn.apply(openclawClient, args);
+}
+
+function callRequestMethod(openclawClient, method, params, requestOpts) {
+  const requestFn = openclawClient && openclawClient.request;
+  if (typeof requestFn !== "function") {
+    throw new Error("Plugin RPC bridge requires openclawClient.request()");
+  }
+  return requestFn.call(openclawClient, method, params, requestOpts);
+}
+
+function buildAgentRequestParams(
+  text,
+  sessionKey,
+  attachment,
+  createIdempotencyKey,
+  requestOptions,
+) {
+  const params = {
+    message: text,
+    sessionKey: sessionKey || "main",
+    idempotencyKey: createIdempotencyKey(),
+  };
+  const extraSystemPrompt =
+    requestOptions && typeof requestOptions.extraSystemPrompt === "string"
+      ? requestOptions.extraSystemPrompt.trim()
+      : "";
+
+  if (extraSystemPrompt) {
+    params.extraSystemPrompt = extraSystemPrompt;
+  }
+
+  const thinking =
+    requestOptions && typeof requestOptions.thinking === "string"
+      ? requestOptions.thinking.trim().toLowerCase()
+      : "";
+  if (thinking) {
+    params.thinking = thinking;
+  }
+
+  if (
+    attachment &&
+    typeof attachment === "object" &&
+    typeof attachment.base64Data === "string" &&
+    attachment.base64Data
+  ) {
+    const normalizedAttachment = {
+      type: attachment.kind || "image",
+      mimeType: attachment.mimeType || "image/jpeg",
+      fileName: attachment.name || "image.jpg",
+      content: attachment.base64Data,
+    };
+    if (typeof attachment.source === "string" && attachment.source) {
+      normalizedAttachment.source = attachment.source;
+    }
+    if (Number.isFinite(attachment.sizeBytes) && attachment.sizeBytes > 0) {
+      normalizedAttachment.sizeBytes = Math.floor(attachment.sizeBytes);
+    }
+    if (Number.isFinite(attachment.widthPx) && attachment.widthPx > 0) {
+      normalizedAttachment.widthPx = Math.floor(attachment.widthPx);
+    }
+    if (Number.isFinite(attachment.heightPx) && attachment.heightPx > 0) {
+      normalizedAttachment.heightPx = Math.floor(attachment.heightPx);
+    }
+    params.attachments = [
+      normalizedAttachment,
+    ];
+  }
+
+  return params;
+}
+
+/**
+ * Bridge the relay runtime to OpenClaw structured RPC method calls.
+ *
+ * This keeps relay-facing bridge semantics unchanged while switching
+ * send/approval operations to request-based structured RPC calls.
+ *
+ * @param {{openclawClient: object, idempotencyKeyFactory?: () => string}} opts
+ * @returns {object}
+ */
+function createPluginRpcGatewayBridge(opts) {
+  const openclawClient = opts && opts.openclawClient;
+  const idempotencyKeyFactory =
+    opts && typeof opts.idempotencyKeyFactory === "function"
+      ? opts.idempotencyKeyFactory
+      : defaultIdempotencyKey;
+
+  if (!openclawClient || typeof openclawClient !== "object") {
+    throw new Error("Plugin RPC bridge requires an openclawClient object");
+  }
+  if (typeof openclawClient.request !== "function") {
+    throw new Error("Plugin RPC bridge requires openclawClient.request()");
+  }
+
+  function start() {
+    if (typeof openclawClient.start === "function") {
+      return openclawClient.start();
+    }
+  }
+
+  function stop() {
+    if (typeof openclawClient.stop === "function") {
+      return openclawClient.stop();
+    }
+  }
+
+  function request(method, params, requestOpts) {
+    return callRequestMethod(openclawClient, method, params, requestOpts);
+  }
+
+  function sendMessage(text, sessionKey, attachment, requestOptions) {
+    return request(
+      "agent",
+      buildAgentRequestParams(
+        text,
+        sessionKey,
+        attachment,
+        idempotencyKeyFactory,
+        requestOptions,
+      ),
+      { expectFinal: false },
+    );
+  }
+
+  function resolveApproval(id, decision) {
+    return request("exec.approval.resolve", { id, decision });
+  }
+
+  function off(eventName, listener) {
+    removeListenerCompat(openclawClient, eventName, listener);
+  }
+
+  function subscribe(eventName, listener) {
+    callClientMethod(openclawClient, "on", [eventName, listener]);
+    return () => off(eventName, listener);
+  }
+
+  return {
+    kind: "plugin-rpc-openclaw-client",
+    start,
+    stop,
+    sendMessage,
+    request,
+    resolveApproval,
+    on: subscribe,
+    off,
+    rawClient: openclawClient,
+  };
+}
+
+export { createPluginRpcGatewayBridge };