codeksei 0.1.0

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

@@ -0,0 +1,376 @@
+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);
+    if (!normalizedWorkspaceRoot) {
+      return this.getBinding(bindingKey);
+    }
+
+    const current = this.getBinding(bindingKey) || {};
+    const threadIdByWorkspaceRoot = {
+      ...getThreadMap(current),
+      [normalizedWorkspaceRoot]: normalizedThreadId,
+    };
+    const workspaceBootstrapThreadIdByWorkspaceRoot = {
+      ...getWorkspaceBootstrapThreadMap(current),
+      [normalizedWorkspaceRoot]:
+        getWorkspaceBootstrapThreadMap(current)[normalizedWorkspaceRoot] === normalizedThreadId
+          ? normalizedThreadId
+          : "",
+    };
+
+    return this.updateBinding(bindingKey, {
+      ...current,
+      ...extra,
+      activeWorkspaceRoot: normalizedWorkspaceRoot,
+      threadIdByWorkspaceRoot,
+      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,
+    });
+  }
+
+  clearThreadIdForWorkspace(bindingKey, workspaceRoot) {
+    const normalizedWorkspaceRoot = normalizeValue(workspaceRoot);
+    if (!normalizedWorkspaceRoot) {
+      return this.getBinding(bindingKey);
+    }
+    const current = this.getBinding(bindingKey) || {};
+    const threadIdByWorkspaceRoot = {
+      ...getThreadMap(current),
+      [normalizedWorkspaceRoot]: "",
+    };
+    const workspaceBootstrapThreadIdByWorkspaceRoot = {
+      ...getWorkspaceBootstrapThreadMap(current),
+      [normalizedWorkspaceRoot]: "",
+    };
+    return this.updateBinding(bindingKey, {
+      ...current,
+      threadIdByWorkspaceRoot,
+      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));
+  }
+
+  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),
+          };
+        }
+      }
+    }
+    return null;
+  }
+
+  hasWorkspaceBootstrapForThread(bindingKey, workspaceRoot, threadId) {
+    const normalizedWorkspaceRoot = normalizeValue(workspaceRoot);
+    const normalizedThreadId = normalizeValue(threadId);
+    if (!normalizedWorkspaceRoot || !normalizedThreadId) {
+      return false;
+    }
+    const current = this.getBinding(bindingKey) || {};
+    return getWorkspaceBootstrapThreadMap(current)[normalizedWorkspaceRoot] === normalizedThreadId;
+  }
+
+  rememberWorkspaceBootstrapForThread(bindingKey, workspaceRoot, threadId) {
+    const normalizedWorkspaceRoot = normalizeValue(workspaceRoot);
+    const normalizedThreadId = normalizeValue(threadId);
+    if (!normalizedWorkspaceRoot || !normalizedThreadId) {
+      return this.getBinding(bindingKey);
+    }
+    const current = this.getBinding(bindingKey) || {};
+    const workspaceBootstrapThreadIdByWorkspaceRoot = {
+      ...getWorkspaceBootstrapThreadMap(current),
+      [normalizedWorkspaceRoot]: normalizedThreadId,
+    };
+    return this.updateBinding(bindingKey, {
+      ...current,
+      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
+    : {};
+}
+
+function getCodexParamsMap(binding) {
+  return binding?.codexParamsByWorkspaceRoot && typeof binding.codexParamsByWorkspaceRoot === "object"
+    ? binding.codexParamsByWorkspaceRoot
+    : {};
+}
+
+function getWorkspaceBootstrapThreadMap(binding) {
+  return binding?.workspaceBootstrapThreadIdByWorkspaceRoot
+    && typeof binding.workspaceBootstrapThreadIdByWorkspaceRoot === "object"
+    ? 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 };

package/src/app/channel-send-file-cli.js

@@ -0,0 +1,57 @@
+async function runChannelSendFileCommand(app) {
+  const args = process.argv.slice(4);
+  if (args.includes("--help") || args.includes("-h")) {
+    printHelp();
+    return;
+  }
+
+  const options = parseArgs(args);
+  if (!options.path) {
+    throw new Error("缺少 --path，指定要发回微信的本地文件路径");
+  }
+
+  const result = await app.sendLocalFileToCurrentChat({
+    senderId: options.user,
+    filePath: options.path,
+  });
+  console.log(`file sent: ${result.filePath}`);
+}
+
+function parseArgs(args) {
+  const options = {
+    path: "",
+    user: "",
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = String(args[index] || "");
+    if (arg === "--path") {
+      options.path = String(args[index + 1] || "");
+      index += 1;
+      continue;
+    }
+    if (arg === "--user") {
+      options.user = String(args[index + 1] || "");
+      index += 1;
+      continue;
+    }
+    throw new Error(`未知参数: ${arg}`);
+  }
+
+  return options;
+}
+
+function printHelp() {
+  console.log([
+    "用法: npm run channel:send-file -- --path /绝对路径 [--user <wechatUserId>]",
+    "",
+    "参数：",
+    "  --path /绝对路径         要发回当前微信聊天的本地文件",
+    "  --user <wechatUserId>   可选，覆盖默认接收用户",
+    "",
+    "示例：",
+    "  npm run channel:send-file -- --path /Users/name/project/README.md",
+  ].join("\n"));
+}
+
+module.exports = { runChannelSendFileCommand };