codeksei 0.1.0 → 0.1.1

package/src/adapters/runtime/codex/session-store.js

@@ -1,77 +1,77 @@
-const fs = require("fs");
-const path = require("path");
-const { normalizeModelCatalog } = require("./model-catalog");
-
-class SessionStore {
-  constructor({ filePath }) {
-    this.filePath = filePath;
-    this.state = createEmptyState();
-    this.ensureParentDirectory();
-    this.load();
-  }
-
-  ensureParentDirectory() {
-    fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
-  }
-
-  load() {
-    try {
-      const raw = fs.readFileSync(this.filePath, "utf8");
-      const parsed = JSON.parse(raw);
-      if (parsed && typeof parsed === "object" && parsed.bindings) {
-        this.state = {
-          ...createEmptyState(),
-          ...parsed,
-          bindings: parsed.bindings || {},
-          approvalCommandAllowlistByWorkspaceRoot: parsed.approvalCommandAllowlistByWorkspaceRoot || {},
-          approvalPromptStateByThreadId: parsed.approvalPromptStateByThreadId || {},
-          availableModelCatalog: parsed.availableModelCatalog || {
-            models: [],
-            updatedAt: "",
-          },
-        };
-      }
-    } catch {
-      this.state = createEmptyState();
-    }
-  }
-
-  save() {
-    fs.writeFileSync(this.filePath, JSON.stringify(this.state, null, 2));
-  }
-
-  getBinding(bindingKey) {
-    return this.state.bindings[bindingKey] || null;
-  }
-
-  listBindings() {
-    return Object.entries(this.state.bindings || {}).map(([bindingKey, binding]) => ({
-      bindingKey,
-      ...(binding || {}),
-    }));
-  }
-
-  getActiveWorkspaceRoot(bindingKey) {
-    return normalizeValue(this.state.bindings[bindingKey]?.activeWorkspaceRoot);
-  }
-
-  updateBinding(bindingKey, nextBinding) {
-    this.state.bindings[bindingKey] = {
-      ...(this.state.bindings[bindingKey] || {}),
-      ...(nextBinding || {}),
-    };
-    this.save();
-    return this.state.bindings[bindingKey];
-  }
-
-  getThreadIdForWorkspace(bindingKey, workspaceRoot) {
-    const normalizedWorkspaceRoot = normalizeValue(workspaceRoot);
-    if (!normalizedWorkspaceRoot) {
-      return "";
-    }
-    return this.state.bindings[bindingKey]?.threadIdByWorkspaceRoot?.[normalizedWorkspaceRoot] || "";
-  }
-
+const fs = require("fs");
+const path = require("path");
+const { normalizeModelCatalog } = require("./model-catalog");
+
+class SessionStore {
+  constructor({ filePath }) {
+    this.filePath = filePath;
+    this.state = createEmptyState();
+    this.ensureParentDirectory();
+    this.load();
+  }
+
+  ensureParentDirectory() {
+    fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+  }
+
+  load() {
+    try {
+      const raw = fs.readFileSync(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && parsed.bindings) {
+        this.state = {
+          ...createEmptyState(),
+          ...parsed,
+          bindings: parsed.bindings || {},
+          approvalCommandAllowlistByWorkspaceRoot: parsed.approvalCommandAllowlistByWorkspaceRoot || {},
+          approvalPromptStateByThreadId: parsed.approvalPromptStateByThreadId || {},
+          availableModelCatalog: parsed.availableModelCatalog || {
+            models: [],
+            updatedAt: "",
+          },
+        };
+      }
+    } catch {
+      this.state = createEmptyState();
+    }
+  }
+
+  save() {
+    fs.writeFileSync(this.filePath, JSON.stringify(this.state, null, 2));
+  }
+
+  getBinding(bindingKey) {
+    return this.state.bindings[bindingKey] || null;
+  }
+
+  listBindings() {
+    return Object.entries(this.state.bindings || {}).map(([bindingKey, binding]) => ({
+      bindingKey,
+      ...(binding || {}),
+    }));
+  }
+
+  getActiveWorkspaceRoot(bindingKey) {
+    return normalizeValue(this.state.bindings[bindingKey]?.activeWorkspaceRoot);
+  }
+
+  updateBinding(bindingKey, nextBinding) {
+    this.state.bindings[bindingKey] = {
+      ...(this.state.bindings[bindingKey] || {}),
+      ...(nextBinding || {}),
+    };
+    this.save();
+    return this.state.bindings[bindingKey];
+  }
+
+  getThreadIdForWorkspace(bindingKey, workspaceRoot) {
+    const normalizedWorkspaceRoot = normalizeValue(workspaceRoot);
+    if (!normalizedWorkspaceRoot) {
+      return "";
+    }
+    return this.state.bindings[bindingKey]?.threadIdByWorkspaceRoot?.[normalizedWorkspaceRoot] || "";
+  }
+
   setThreadIdForWorkspace(bindingKey, workspaceRoot, threadId, extra = {}) {
     const normalizedWorkspaceRoot = normalizeValue(workspaceRoot);
     const normalizedThreadId = normalizeValue(threadId);
@@ -100,38 +100,38 @@ class SessionStore {
       workspaceBootstrapThreadIdByWorkspaceRoot,
     });
   }
-
-  getCodexParamsForWorkspace(bindingKey, workspaceRoot) {
-    const normalizedWorkspaceRoot = normalizeValue(workspaceRoot);
-    if (!normalizedWorkspaceRoot) {
-      return { model: "" };
-    }
-    const current = this.getBinding(bindingKey) || {};
-    const codexParamsByWorkspaceRoot = getCodexParamsMap(current);
-    const entry = codexParamsByWorkspaceRoot[normalizedWorkspaceRoot];
-    return {
-      model: normalizeValue(entry?.model),
-    };
-  }
-
-  setCodexParamsForWorkspace(bindingKey, workspaceRoot, { model = "" }) {
-    const normalizedWorkspaceRoot = normalizeValue(workspaceRoot);
-    if (!normalizedWorkspaceRoot) {
-      return this.getBinding(bindingKey);
-    }
-    const current = this.getBinding(bindingKey) || {};
-    const codexParamsByWorkspaceRoot = {
-      ...getCodexParamsMap(current),
-      [normalizedWorkspaceRoot]: {
-        model: normalizeValue(model),
-      },
-    };
-    return this.updateBinding(bindingKey, {
-      ...current,
-      codexParamsByWorkspaceRoot,
-    });
-  }
-
+
+  getCodexParamsForWorkspace(bindingKey, workspaceRoot) {
+    const normalizedWorkspaceRoot = normalizeValue(workspaceRoot);
+    if (!normalizedWorkspaceRoot) {
+      return { model: "" };
+    }
+    const current = this.getBinding(bindingKey) || {};
+    const codexParamsByWorkspaceRoot = getCodexParamsMap(current);
+    const entry = codexParamsByWorkspaceRoot[normalizedWorkspaceRoot];
+    return {
+      model: normalizeValue(entry?.model),
+    };
+  }
+
+  setCodexParamsForWorkspace(bindingKey, workspaceRoot, { model = "" }) {
+    const normalizedWorkspaceRoot = normalizeValue(workspaceRoot);
+    if (!normalizedWorkspaceRoot) {
+      return this.getBinding(bindingKey);
+    }
+    const current = this.getBinding(bindingKey) || {};
+    const codexParamsByWorkspaceRoot = {
+      ...getCodexParamsMap(current),
+      [normalizedWorkspaceRoot]: {
+        model: normalizeValue(model),
+      },
+    };
+    return this.updateBinding(bindingKey, {
+      ...current,
+      codexParamsByWorkspaceRoot,
+    });
+  }
+
   clearThreadIdForWorkspace(bindingKey, workspaceRoot) {
     const normalizedWorkspaceRoot = normalizeValue(workspaceRoot);
     if (!normalizedWorkspaceRoot) {
@@ -152,37 +152,37 @@ class SessionStore {
       workspaceBootstrapThreadIdByWorkspaceRoot,
     });
   }
-
-  setActiveWorkspaceRoot(bindingKey, workspaceRoot) {
-    const normalizedWorkspaceRoot = normalizeValue(workspaceRoot);
-    if (!normalizedWorkspaceRoot) {
-      return this.getBinding(bindingKey);
-    }
-    return this.updateBinding(bindingKey, {
-      activeWorkspaceRoot: normalizedWorkspaceRoot,
-    });
-  }
-
-  listWorkspaceRoots(bindingKey) {
-    const current = this.getBinding(bindingKey) || {};
-    return Object.keys(getThreadMap(current));
-  }
-
+
+  setActiveWorkspaceRoot(bindingKey, workspaceRoot) {
+    const normalizedWorkspaceRoot = normalizeValue(workspaceRoot);
+    if (!normalizedWorkspaceRoot) {
+      return this.getBinding(bindingKey);
+    }
+    return this.updateBinding(bindingKey, {
+      activeWorkspaceRoot: normalizedWorkspaceRoot,
+    });
+  }
+
+  listWorkspaceRoots(bindingKey) {
+    const current = this.getBinding(bindingKey) || {};
+    return Object.keys(getThreadMap(current));
+  }
+
   findBindingForThreadId(threadId) {
-    const normalizedThreadId = normalizeValue(threadId);
-    if (!normalizedThreadId) {
-      return null;
-    }
-    for (const [bindingKey, binding] of Object.entries(this.state.bindings || {})) {
-      for (const [workspaceRoot, candidateThreadId] of Object.entries(getThreadMap(binding))) {
-        if (normalizeValue(candidateThreadId) === normalizedThreadId) {
-          return {
-            bindingKey,
-            workspaceRoot: normalizeValue(workspaceRoot),
-          };
-        }
-      }
-    }
+    const normalizedThreadId = normalizeValue(threadId);
+    if (!normalizedThreadId) {
+      return null;
+    }
+    for (const [bindingKey, binding] of Object.entries(this.state.bindings || {})) {
+      for (const [workspaceRoot, candidateThreadId] of Object.entries(getThreadMap(binding))) {
+        if (normalizeValue(candidateThreadId) === normalizedThreadId) {
+          return {
+            bindingKey,
+            workspaceRoot: normalizeValue(workspaceRoot),
+          };
+        }
+      }
+    }
     return null;
   }
 
@@ -212,141 +212,141 @@ class SessionStore {
       workspaceBootstrapThreadIdByWorkspaceRoot,
     });
   }
-
-  getApprovalCommandAllowlistForWorkspace(workspaceRoot) {
-    const normalizedWorkspaceRoot = normalizeValue(workspaceRoot);
-    if (!normalizedWorkspaceRoot) {
-      return [];
-    }
-    const raw = this.state.approvalCommandAllowlistByWorkspaceRoot?.[normalizedWorkspaceRoot];
-    if (!Array.isArray(raw)) {
-      return [];
-    }
-    return raw
-      .filter((entry) => Array.isArray(entry))
-      .map((entry) => entry.map((part) => normalizeValue(part)).filter(Boolean))
-      .filter((entry) => entry.length);
-  }
-
-  rememberApprovalPrefixForWorkspace(workspaceRoot, commandTokens) {
-    const normalizedWorkspaceRoot = normalizeValue(workspaceRoot);
-    const normalizedTokens = normalizeCommandTokens(commandTokens);
-    if (!normalizedWorkspaceRoot || !normalizedTokens.length) {
-      return this.getApprovalCommandAllowlistForWorkspace(workspaceRoot);
-    }
-    const current = this.getApprovalCommandAllowlistForWorkspace(normalizedWorkspaceRoot);
-    if (!current.some((entry) => isSameTokenList(entry, normalizedTokens))) {
-      current.push(normalizedTokens);
-      this.state.approvalCommandAllowlistByWorkspaceRoot = {
-        ...(this.state.approvalCommandAllowlistByWorkspaceRoot || {}),
-        [normalizedWorkspaceRoot]: current,
-      };
-      this.save();
-    }
-    return current;
-  }
-
-  getApprovalPromptState(threadId) {
-    const normalizedThreadId = normalizeValue(threadId);
-    if (!normalizedThreadId) {
-      return null;
-    }
-    const raw = this.state.approvalPromptStateByThreadId?.[normalizedThreadId];
-    if (!raw || typeof raw !== "object") {
-      return null;
-    }
-    return {
-      requestId: normalizeValue(raw.requestId),
-      signature: normalizeValue(raw.signature),
-      promptedAt: normalizeValue(raw.promptedAt),
-    };
-  }
-
-  rememberApprovalPrompt(threadId, requestId, signature = "") {
-    const normalizedThreadId = normalizeValue(threadId);
-    const normalizedRequestId = normalizeValue(requestId);
-    const normalizedSignature = normalizeValue(signature);
-    if (!normalizedThreadId || !normalizedRequestId) {
-      return null;
-    }
-    this.state.approvalPromptStateByThreadId = {
-      ...(this.state.approvalPromptStateByThreadId || {}),
-      [normalizedThreadId]: {
-        requestId: normalizedRequestId,
-        signature: normalizedSignature,
-        promptedAt: new Date().toISOString(),
-      },
-    };
-    this.save();
-    return this.getApprovalPromptState(normalizedThreadId);
-  }
-
-  clearApprovalPrompt(threadId) {
-    const normalizedThreadId = normalizeValue(threadId);
-    if (!normalizedThreadId || !this.state.approvalPromptStateByThreadId?.[normalizedThreadId]) {
-      return;
-    }
-    const next = {
-      ...(this.state.approvalPromptStateByThreadId || {}),
-    };
-    delete next[normalizedThreadId];
-    this.state.approvalPromptStateByThreadId = next;
-    this.save();
-  }
-
-  getAvailableModelCatalog() {
-    const raw = this.state.availableModelCatalog;
-    if (!raw || typeof raw !== "object") {
-      return null;
-    }
-    const models = normalizeModelCatalog(raw.models);
-    if (!models.length) {
-      return null;
-    }
-    const updatedAt = normalizeValue(raw.updatedAt);
-    return { models, updatedAt };
-  }
-
-  setAvailableModelCatalog(models) {
-    const normalizedModels = normalizeModelCatalog(models);
-    if (!normalizedModels.length) {
-      return null;
-    }
-    this.state.availableModelCatalog = {
-      models: normalizedModels,
-      updatedAt: new Date().toISOString(),
-    };
-    this.save();
-    return this.state.availableModelCatalog;
-  }
-
-  buildBindingKey({ workspaceId, accountId, senderId }) {
-    return `${normalizeValue(workspaceId)}:${normalizeValue(accountId)}:${normalizeValue(senderId)}`;
-  }
-}
-
-function createEmptyState() {
-  return {
-    bindings: {},
-    approvalCommandAllowlistByWorkspaceRoot: {},
-    approvalPromptStateByThreadId: {},
-    availableModelCatalog: {
-      models: [],
-      updatedAt: "",
-    },
-  };
-}
-
-function normalizeValue(value) {
-  return typeof value === "string" ? value.trim() : "";
-}
-
-function getThreadMap(binding) {
-  return binding?.threadIdByWorkspaceRoot && typeof binding.threadIdByWorkspaceRoot === "object"
-    ? binding.threadIdByWorkspaceRoot
-    : {};
-}
-
+
+  getApprovalCommandAllowlistForWorkspace(workspaceRoot) {
+    const normalizedWorkspaceRoot = normalizeValue(workspaceRoot);
+    if (!normalizedWorkspaceRoot) {
+      return [];
+    }
+    const raw = this.state.approvalCommandAllowlistByWorkspaceRoot?.[normalizedWorkspaceRoot];
+    if (!Array.isArray(raw)) {
+      return [];
+    }
+    return raw
+      .filter((entry) => Array.isArray(entry))
+      .map((entry) => entry.map((part) => normalizeValue(part)).filter(Boolean))
+      .filter((entry) => entry.length);
+  }
+
+  rememberApprovalPrefixForWorkspace(workspaceRoot, commandTokens) {
+    const normalizedWorkspaceRoot = normalizeValue(workspaceRoot);
+    const normalizedTokens = normalizeCommandTokens(commandTokens);
+    if (!normalizedWorkspaceRoot || !normalizedTokens.length) {
+      return this.getApprovalCommandAllowlistForWorkspace(workspaceRoot);
+    }
+    const current = this.getApprovalCommandAllowlistForWorkspace(normalizedWorkspaceRoot);
+    if (!current.some((entry) => isSameTokenList(entry, normalizedTokens))) {
+      current.push(normalizedTokens);
+      this.state.approvalCommandAllowlistByWorkspaceRoot = {
+        ...(this.state.approvalCommandAllowlistByWorkspaceRoot || {}),
+        [normalizedWorkspaceRoot]: current,
+      };
+      this.save();
+    }
+    return current;
+  }
+
+  getApprovalPromptState(threadId) {
+    const normalizedThreadId = normalizeValue(threadId);
+    if (!normalizedThreadId) {
+      return null;
+    }
+    const raw = this.state.approvalPromptStateByThreadId?.[normalizedThreadId];
+    if (!raw || typeof raw !== "object") {
+      return null;
+    }
+    return {
+      requestId: normalizeValue(raw.requestId),
+      signature: normalizeValue(raw.signature),
+      promptedAt: normalizeValue(raw.promptedAt),
+    };
+  }
+
+  rememberApprovalPrompt(threadId, requestId, signature = "") {
+    const normalizedThreadId = normalizeValue(threadId);
+    const normalizedRequestId = normalizeValue(requestId);
+    const normalizedSignature = normalizeValue(signature);
+    if (!normalizedThreadId || !normalizedRequestId) {
+      return null;
+    }
+    this.state.approvalPromptStateByThreadId = {
+      ...(this.state.approvalPromptStateByThreadId || {}),
+      [normalizedThreadId]: {
+        requestId: normalizedRequestId,
+        signature: normalizedSignature,
+        promptedAt: new Date().toISOString(),
+      },
+    };
+    this.save();
+    return this.getApprovalPromptState(normalizedThreadId);
+  }
+
+  clearApprovalPrompt(threadId) {
+    const normalizedThreadId = normalizeValue(threadId);
+    if (!normalizedThreadId || !this.state.approvalPromptStateByThreadId?.[normalizedThreadId]) {
+      return;
+    }
+    const next = {
+      ...(this.state.approvalPromptStateByThreadId || {}),
+    };
+    delete next[normalizedThreadId];
+    this.state.approvalPromptStateByThreadId = next;
+    this.save();
+  }
+
+  getAvailableModelCatalog() {
+    const raw = this.state.availableModelCatalog;
+    if (!raw || typeof raw !== "object") {
+      return null;
+    }
+    const models = normalizeModelCatalog(raw.models);
+    if (!models.length) {
+      return null;
+    }
+    const updatedAt = normalizeValue(raw.updatedAt);
+    return { models, updatedAt };
+  }
+
+  setAvailableModelCatalog(models) {
+    const normalizedModels = normalizeModelCatalog(models);
+    if (!normalizedModels.length) {
+      return null;
+    }
+    this.state.availableModelCatalog = {
+      models: normalizedModels,
+      updatedAt: new Date().toISOString(),
+    };
+    this.save();
+    return this.state.availableModelCatalog;
+  }
+
+  buildBindingKey({ workspaceId, accountId, senderId }) {
+    return `${normalizeValue(workspaceId)}:${normalizeValue(accountId)}:${normalizeValue(senderId)}`;
+  }
+}
+
+function createEmptyState() {
+  return {
+    bindings: {},
+    approvalCommandAllowlistByWorkspaceRoot: {},
+    approvalPromptStateByThreadId: {},
+    availableModelCatalog: {
+      models: [],
+      updatedAt: "",
+    },
+  };
+}
+
+function normalizeValue(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function getThreadMap(binding) {
+  return binding?.threadIdByWorkspaceRoot && typeof binding.threadIdByWorkspaceRoot === "object"
+    ? binding.threadIdByWorkspaceRoot
+    : {};
+}
+
 function getCodexParamsMap(binding) {
   return binding?.codexParamsByWorkspaceRoot && typeof binding.codexParamsByWorkspaceRoot === "object"
     ? binding.codexParamsByWorkspaceRoot
@@ -359,18 +359,18 @@ function getWorkspaceBootstrapThreadMap(binding) {
     ? binding.workspaceBootstrapThreadIdByWorkspaceRoot
     : {};
 }
-
-function normalizeCommandTokens(tokens) {
-  return Array.isArray(tokens)
-    ? tokens.map((part) => normalizeValue(part)).filter(Boolean)
-    : [];
-}
-
-function isSameTokenList(left, right) {
-  if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
-    return false;
-  }
-  return left.every((value, index) => value === right[index]);
-}
-
-module.exports = { SessionStore };
+
+function normalizeCommandTokens(tokens) {
+  return Array.isArray(tokens)
+    ? tokens.map((part) => normalizeValue(part)).filter(Boolean)
+    : [];
+}
+
+function isSameTokenList(left, right) {
+  if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
+    return false;
+  }
+  return left.every((value, index) => value === right[index]);
+}
+
+module.exports = { SessionStore };