ocuclaw 0.1.0

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

@@ -0,0 +1,237 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const STORE_VERSION = 1;
+const STORE_FILENAME = "ocuclaw-settings.json";
+
+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 normalizeOcuClawSystemPrompt(value) {
+  return normalizeTrimmedString(value);
+}
+
+export function normalizeOcuClawDefaultModel(value) {
+  return normalizeTrimmedString(value);
+}
+
+export function normalizeOcuClawDefaultThinking(value) {
+  const normalized = normalizeTrimmedString(value).toLowerCase();
+  if (
+    normalized === "" ||
+    normalized === "off" ||
+    normalized === "minimal" ||
+    normalized === "low" ||
+    normalized === "medium" ||
+    normalized === "high" ||
+    normalized === "xhigh"
+  ) {
+    return normalized;
+  }
+  return "";
+}
+
+function isStoredSnapshotCanonical(value, snapshot) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  return (
+    normalizeTrimmedString(value.systemPrompt) === snapshot.systemPrompt &&
+    normalizeTrimmedString(value.defaultModel) === snapshot.defaultModel &&
+    normalizeOcuClawDefaultThinking(value.defaultThinking) === snapshot.defaultThinking
+  );
+}
+
+export function normalizeOcuClawSettingsSnapshot(value = {}) {
+  return {
+    systemPrompt: normalizeOcuClawSystemPrompt(value.systemPrompt),
+    defaultModel: normalizeOcuClawDefaultModel(value.defaultModel),
+    defaultThinking: normalizeOcuClawDefaultThinking(value.defaultThinking),
+  };
+}
+
+function hasOwn(obj, key) {
+  return !!obj && Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+export function createOcuClawSettingsStore(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 = normalizeOcuClawSettingsSnapshot(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",
+        "ocuclaw_settings_persist_skipped",
+        "debug",
+        null,
+        () => ({
+          reason,
+          systemPromptChars: snapshot.systemPrompt.length,
+          defaultModel: snapshot.defaultModel,
+          defaultThinking: snapshot.defaultThinking,
+        }),
+      );
+      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",
+        "ocuclaw_settings_persisted",
+        "info",
+        null,
+        () => ({
+          reason,
+          statePath,
+          systemPromptChars: snapshot.systemPrompt.length,
+          defaultModel: snapshot.defaultModel,
+          defaultThinking: snapshot.defaultThinking,
+        }),
+      );
+    } catch (err) {
+      logger.error(
+        `[ocuclaw] failed to persist OcuClaw settings: ${err && err.message ? err.message : err}`,
+      );
+      emitDebug(
+        "settings.loadsave",
+        "ocuclaw_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
+          ? normalizeOcuClawSettingsSnapshot(storedSettings)
+          : defaults;
+      emitDebug(
+        "settings.loadsave",
+        "ocuclaw_settings_loaded",
+        "info",
+        null,
+        () => ({
+          statePath,
+          systemPromptChars: loaded.systemPrompt.length,
+          defaultModel: loaded.defaultModel,
+          defaultThinking: loaded.defaultThinking,
+        }),
+      );
+      if (
+        parsed.version !== STORE_VERSION ||
+        !isStoredSnapshotCanonical(storedSettings, loaded)
+      ) {
+        persistSnapshot(loaded, "normalize_loaded_settings");
+      }
+      return loaded;
+    } catch (err) {
+      logger.warn(
+        `[ocuclaw] failed to load OcuClaw settings, falling back to defaults: ${err && err.message ? err.message : err}`,
+      );
+      emitDebug(
+        "settings.loadsave",
+        "ocuclaw_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();
+
+  return {
+    getStatePath() {
+      return statePath;
+    },
+
+    getSnapshot() {
+      return { ...snapshot };
+    },
+
+    async setSettings(patch = {}) {
+      const next = {
+        systemPrompt: hasOwn(patch, "systemPrompt")
+          ? normalizeOcuClawSystemPrompt(patch.systemPrompt)
+          : snapshot.systemPrompt,
+        defaultModel: hasOwn(patch, "defaultModel")
+          ? normalizeOcuClawDefaultModel(patch.defaultModel)
+          : snapshot.defaultModel,
+        defaultThinking: hasOwn(patch, "defaultThinking")
+          ? normalizeOcuClawDefaultThinking(patch.defaultThinking)
+          : snapshot.defaultThinking,
+      };
+      snapshot = next;
+      persistSnapshot(snapshot, "set_settings");
+      return {
+        status: "accepted",
+        settings: { ...snapshot },
+      };
+    },
+  };
+}
+
+export default createOcuClawSettingsStore;

package/dist/runtime/protocol-adapter.js

@@ -0,0 +1,378 @@
+const V1_TO_INTERNAL = {
+  send: "ocuclaw.message.send",
+  newSession: "ocuclaw.session.create",
+  switchSession: "ocuclaw.session.switch",
+  newChat: "ocuclaw.session.reset",
+  getSessions: "ocuclaw.session.list",
+  getStatus: "ocuclaw.runtime.status.get",
+  getModelsCatalog: "ocuclaw.model.catalog.get",
+  getSkills: "ocuclaw.skills.catalog.get",
+  getSonioxModels: "ocuclaw.voice.soniox.models.get",
+  getSessionModelConfig: "ocuclaw.session.config.get",
+  setSessionModelConfig: "ocuclaw.session.config.set",
+  getEvenAiSettings: "ocuclaw.evenai.settings.get",
+  getEvenAiSessions: "ocuclaw.evenai.session.list",
+  setEvenAiSettings: "ocuclaw.evenai.settings.set",
+  getOcuClawSettings: "ocuclaw.settings.get",
+  setOcuClawSettings: "ocuclaw.settings.set",
+  slashCommand: "ocuclaw.command.slash",
+  approvalResponse: "ocuclaw.approval.resolve",
+  subscribeProtocol: "ocuclaw.protocol.tap.subscribe",
+  eventDebug: "ocuclaw.debug.event",
+  "debug-set": "ocuclaw.debug.config.set",
+  "debug-dump": "ocuclaw.debug.events.query",
+  resume: "ocuclaw.sync.resume",
+};
+
+const RESULT_TO_V1 = {
+  "ocuclaw.message.send": "sendAck",
+  "ocuclaw.message.send.ack": "sendAck",
+  "ocuclaw.session.list.result": "sessions",
+  "ocuclaw.session.config.snapshot": "sessionModelConfig",
+  "ocuclaw.session.config.set.ack": "sessionModelConfigAck",
+  "ocuclaw.evenai.settings.snapshot": "evenAiSettings",
+  "ocuclaw.evenai.session.list.result": "evenAiSessions",
+  "ocuclaw.evenai.settings.set.ack": "evenAiSettingsAck",
+  "ocuclaw.settings.snapshot": "ocuClawSettings",
+  "ocuclaw.settings.set.ack": "ocuClawSettingsAck",
+  "ocuclaw.model.catalog.snapshot": "modelsCatalog",
+  "ocuclaw.skills.catalog.snapshot": "skillsCatalog",
+  "ocuclaw.voice.soniox.models.snapshot": "sonioxModels",
+  "ocuclaw.approval.resolve.ack": "approvalResponseAck",
+};
+
+const EVENT_TO_V1 = {
+  "ocuclaw.view.pages.snapshot": "pages",
+  "ocuclaw.runtime.status": "status",
+  "ocuclaw.activity.update": "activity",
+  "ocuclaw.message.stream.delta": "streaming",
+  "ocuclaw.session.switch.applied": "sessionSwitched",
+  "ocuclaw.sync.resume.ack": "resume-ack",
+  "ocuclaw.approval.request": "approval",
+  "ocuclaw.approval.resolved": "approvalResolved",
+  "ocuclaw.remote.control": "remote-control",
+  "ocuclaw.protocol.tap.frame": "protocol",
+};
+
+const INTERNAL_TO_V1 = Object.fromEntries(
+  Object.entries(V1_TO_INTERNAL).map(([type, op]) => [op, type]),
+);
+
+const V1_TO_RESULT = Object.fromEntries(
+  Object.entries(RESULT_TO_V1).map(([op, type]) => [type, op]),
+);
+
+const V1_TO_EVENT = Object.fromEntries(
+  Object.entries(EVENT_TO_V1).map(([event, type]) => [type, event]),
+);
+
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+
+function frameRequestId(frame) {
+  const value = frame.requestId ?? frame.id;
+  return typeof value === "string" ? value : null;
+}
+
+function framePayload(frame) {
+  const { type: _type, ...payload } = frame;
+  return payload;
+}
+
+function clonePayload(value) {
+  return { ...value };
+}
+
+function internalOpPayload(op) {
+  const payload = clonePayload(op.payload || {});
+  delete payload.requestId;
+  delete payload.idempotencyKey;
+  return payload;
+}
+
+function parseV1Inbound(raw) {
+  try {
+    const parsed = asRecord(JSON.parse(raw));
+    if (!parsed || typeof parsed.type !== "string") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function serializeV1Outbound(frame) {
+  return JSON.stringify(frame);
+}
+
+function parseV2Inbound(raw) {
+  try {
+    const parsed = asRecord(JSON.parse(raw));
+    if (!parsed || typeof parsed.type !== "string") {
+      return null;
+    }
+    if (!parsed.type.startsWith("ocuclaw.")) {
+      return null;
+    }
+    const requestId =
+      typeof parsed.requestId === "string" && parsed.requestId.trim()
+        ? parsed.requestId.trim()
+        : null;
+    const idempotencyKey =
+      typeof parsed.idempotencyKey === "string" && parsed.idempotencyKey.trim()
+        ? parsed.idempotencyKey.trim()
+        : null;
+    const { type: op, requestId: _requestId, idempotencyKey: _idempotencyKey, ...payload } = parsed;
+    return {
+      op,
+      requestId,
+      idempotencyKey,
+      payload,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function mapV1InboundToInternalOps(frame, _ctx) {
+  const op = V1_TO_INTERNAL[frame.type];
+  if (!op) {
+    return [];
+  }
+  const idempotencyKey = typeof frame.idempotencyKey === "string" ? frame.idempotencyKey : null;
+  return [
+    {
+      op,
+      requestId: frameRequestId(frame),
+      idempotencyKey,
+      payload: framePayload(frame),
+    },
+  ];
+}
+
+function mapInternalOpToV1Inbound(op, _ctx) {
+  const type = INTERNAL_TO_V1[op.op];
+  if (!type) {
+    return [];
+  }
+
+  const payload = internalOpPayload(op);
+  if (type === "send") {
+    const id =
+      op.requestId ||
+      (typeof payload.id === "string" && payload.id.trim() ? payload.id.trim() : null);
+    if (id) payload.id = id;
+    delete payload.requestId;
+  }
+
+  if (type === "approvalResponse") {
+    if (op.requestId && !payload.requestId) {
+      payload.requestId = op.requestId;
+    }
+  }
+
+  return [{ type, ...payload }];
+}
+
+function mapInternalResultToV1Outbound(result, _ctx) {
+  const type = RESULT_TO_V1[result.op];
+  if (!type) {
+    return [];
+  }
+  if (type !== "sendAck") {
+    return [{ type, ...result.result }];
+  }
+  const payload = clonePayload(result.result || {});
+  const id =
+    result.requestId ||
+    (typeof payload.id === "string" && payload.id.trim() ? payload.id.trim() : null);
+  const status =
+    typeof payload.status === "string"
+      ? payload.status
+      : result.ok
+        ? "accepted"
+        : "rejected";
+  const error =
+    typeof payload.error === "string" && payload.error
+      ? payload.error
+      : !result.ok && result.message
+        ? result.message
+        : undefined;
+  const errorCode =
+    typeof payload.errorCode === "string" && payload.errorCode
+      ? payload.errorCode
+      : !result.ok && result.code
+        ? result.code
+        : undefined;
+  return [
+    {
+      type: "sendAck",
+      id,
+      status,
+      ...(error ? { error } : {}),
+      ...(errorCode ? { errorCode } : {}),
+    },
+  ];
+}
+
+function mapInternalEventToV1Outbound(event, _ctx) {
+  const type = EVENT_TO_V1[event.event];
+  if (!type) {
+    return [];
+  }
+  return [{ type, ...event.payload }];
+}
+
+function mapV1OutboundToInternalResult(frame, _ctx) {
+  const op = V1_TO_RESULT[frame.type];
+  if (!op) {
+    return null;
+  }
+
+  const payload = framePayload(frame);
+  if (frame.type === "sendAck") {
+    return {
+      op: "ocuclaw.message.send.ack",
+      requestId:
+        typeof frame.id === "string" && frame.id.trim() ? frame.id.trim() : null,
+      ok: frame.status === "accepted",
+      code:
+        typeof frame.errorCode === "string" && frame.errorCode.trim()
+          ? frame.errorCode.trim()
+          : frame.status === "accepted"
+            ? "ok"
+            : "request_rejected",
+      message:
+        typeof frame.error === "string" && frame.error.trim()
+          ? frame.error.trim()
+          : null,
+      result: payload,
+    };
+  }
+
+  if (frame.type === "approvalResponseAck") {
+    return {
+      op,
+      requestId:
+        typeof frame.requestId === "string" && frame.requestId.trim()
+          ? frame.requestId.trim()
+          : null,
+      ok: frame.status === "accepted",
+      code:
+        typeof frame.code === "string" && frame.code.trim() ? frame.code.trim() : null,
+      message:
+        typeof frame.message === "string" && frame.message.trim()
+          ? frame.message.trim()
+          : null,
+      result: payload,
+    };
+  }
+
+  if (
+    frame.type === "sessionModelConfigAck" ||
+    frame.type === "evenAiSettingsAck" ||
+    frame.type === "ocuClawSettingsAck"
+  ) {
+    return {
+      op,
+      requestId: null,
+      ok: frame.status === "accepted",
+      code: frame.status === "accepted" ? "ok" : "request_rejected",
+      message:
+        typeof frame.error === "string" && frame.error.trim()
+          ? frame.error.trim()
+          : null,
+      result: payload,
+    };
+  }
+
+  return {
+    op,
+    requestId:
+      typeof frame.requestId === "string" && frame.requestId.trim()
+        ? frame.requestId.trim()
+        : typeof frame.id === "string" && frame.id.trim()
+          ? frame.id.trim()
+          : null,
+    ok: true,
+    code: "ok",
+    message: null,
+    result: payload,
+  };
+}
+
+function mapV1OutboundToInternalEvent(frame, _ctx) {
+  const event = V1_TO_EVENT[frame.type];
+  if (!event) {
+    return null;
+  }
+  return {
+    event,
+    requestId:
+      typeof frame.requestId === "string" && frame.requestId.trim()
+        ? frame.requestId.trim()
+        : null,
+    payload: framePayload(frame),
+  };
+}
+
+function serializeInternalResultToV2Outbound(result) {
+  const payload = {
+    type: result.op,
+    ...(result.requestId ? { requestId: result.requestId } : {}),
+    ...(result.result || {}),
+  };
+  if (result.code && payload.code === undefined) {
+    payload.code = result.code;
+  }
+  if (result.message && payload.message === undefined) {
+    payload.message = result.message;
+  }
+  return JSON.stringify(payload);
+}
+
+function serializeInternalEventToV2Outbound(event) {
+  return JSON.stringify({
+    type: event.event,
+    ...(event.requestId ? { requestId: event.requestId } : {}),
+    ...(event.payload || {}),
+  });
+}
+
+function normalizeInternalError(input) {
+  if (input instanceof Error) {
+    return {
+      code: input.name || "internal_error",
+      message: input.message || "internal error",
+      retryable: false,
+      details: {},
+    };
+  }
+  const value = asRecord(input);
+  return {
+    code: typeof value?.code === "string" ? value.code : "internal_error",
+    message: typeof value?.message === "string" ? value.message : "internal error",
+    retryable: value?.retryable === true,
+    details: asRecord(value?.details) ?? {},
+  };
+}
+
+export {
+  mapInternalEventToV1Outbound,
+  mapInternalOpToV1Inbound,
+  mapInternalResultToV1Outbound,
+  mapV1InboundToInternalOps,
+  mapV1OutboundToInternalEvent,
+  mapV1OutboundToInternalResult,
+  normalizeInternalError,
+  parseV1Inbound,
+  parseV2Inbound,
+  serializeInternalEventToV2Outbound,
+  serializeInternalResultToV2Outbound,
+  serializeV1Outbound,
+};