workspacecord 1.0.2

package/dist/chunk-WE4X3JB3.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+
+// src/utils.ts
+import { resolve, isAbsolute } from "path";
+import { homedir } from "os";
+function sanitizeName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50) || "session";
+}
+function resolvePath(p) {
+  if (p.startsWith("~/") || p === "~") {
+    return p.replace("~", homedir());
+  }
+  return isAbsolute(p) ? p : resolve(process.cwd(), p);
+}
+function isPathAllowed(path, allowedPaths) {
+  if (allowedPaths.length === 0) return true;
+  const resolved = resolvePath(path);
+  return allowedPaths.some((allowed) => {
+    const resolvedAllowed = resolvePath(allowed);
+    return resolved === resolvedAllowed || resolved.startsWith(resolvedAllowed + "/");
+  });
+}
+function projectNameFromChannel(channelName) {
+  return channelName;
+}
+function formatDuration(ms) {
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ${s % 60}s`;
+  const h = Math.floor(m / 60);
+  return `${h}h ${m % 60}m`;
+}
+function formatRelative(ts) {
+  const diff = Date.now() - ts;
+  if (diff < 6e4) return "just now";
+  if (diff < 36e5) return `${Math.floor(diff / 6e4)}m ago`;
+  if (diff < 864e5) return `${Math.floor(diff / 36e5)}h ago`;
+  return `${Math.floor(diff / 864e5)}d ago`;
+}
+function truncate(s, max) {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 1) + "\u2026";
+}
+function isUserAllowed(userId, allowedUsers, allowAll) {
+  if (allowAll) return true;
+  if (allowedUsers.length === 0) return true;
+  return allowedUsers.includes(userId);
+}
+var ABORT_PATTERNS = ["abort", "cancel", "interrupt", "killed", "signal"];
+function isAbortError(err) {
+  if (err instanceof Error && err.name === "AbortError") return true;
+  const msg = (err.message || "").toLowerCase();
+  return ABORT_PATTERNS.some((p) => msg.includes(p));
+}
+function isAbortErrorMessage(messages) {
+  return messages.some((m) => ABORT_PATTERNS.some((p) => m.toLowerCase().includes(p)));
+}
+function detectNumberedOptions(text) {
+  const lines = text.trim().split("\n");
+  const options = [];
+  const optionRegex = /^\s*(\d+)[.)]\s+(.+)$/;
+  let firstOptionLine = -1;
+  let lastOptionLine = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const match = lines[i].match(optionRegex);
+    if (match) {
+      if (firstOptionLine === -1) firstOptionLine = i;
+      lastOptionLine = i;
+      options.push(match[2].trim());
+    }
+  }
+  if (options.length < 2 || options.length > 6) return null;
+  if (options.some((o) => o.length > 80)) return null;
+  const linesAfter = lines.slice(lastOptionLine + 1).filter((l) => l.trim()).length;
+  if (linesAfter > 3) return null;
+  const preamble = lines.slice(0, firstOptionLine).join(" ").toLowerCase();
+  const hasQuestion = /\?\s*$/.test(preamble.trim()) || /\b(which|choose|select|pick|prefer|would you like|how would you|what approach|option)\b/.test(
+    preamble
+  );
+  return hasQuestion ? options : null;
+}
+function detectYesNoPrompt(text) {
+  const lower = text.toLowerCase();
+  return /\b(y\/n|yes\/no|confirm|proceed)\b/.test(lower) || /\?\s*$/.test(text.trim()) && /\b(should|would you|do you want|shall)\b/.test(lower);
+}
+function formatUptime(startTime) {
+  const ms = Date.now() - startTime;
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ${hours % 24}h`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m`;
+  return `${seconds}s`;
+}
+function splitMessage(text, max = 1900) {
+  if (text.length <= max) return [text];
+  const chunks = [];
+  let i = 0;
+  while (i < text.length) {
+    chunks.push(text.slice(i, i + max));
+    i += max;
+  }
+  return chunks;
+}
+function formatCost(usd) {
+  if (usd === 0) return "$0.00";
+  if (usd < 0.01) return `$${usd.toFixed(4)}`;
+  return `$${usd.toFixed(2)}`;
+}
+
+export {
+  sanitizeName,
+  resolvePath,
+  isPathAllowed,
+  projectNameFromChannel,
+  formatDuration,
+  formatRelative,
+  truncate,
+  isUserAllowed,
+  isAbortError,
+  isAbortErrorMessage,
+  detectNumberedOptions,
+  detectYesNoPrompt,
+  formatUptime,
+  splitMessage,
+  formatCost
+};

package/dist/cli.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+var command = process.argv[2];
+switch (command) {
+  case "setup": {
+    const { handleConfig } = await import("./config-cli-F2B5SYHJ.js");
+    await handleConfig(["setup"]);
+    break;
+  }
+  case "config": {
+    const { handleConfig } = await import("./config-cli-F2B5SYHJ.js");
+    await handleConfig(process.argv.slice(3));
+    break;
+  }
+  case "start":
+  case void 0: {
+    const { startBot } = await import("./bot-B5HN4ZW6.js");
+    console.log("workspacecord starting...");
+    await startBot();
+    break;
+  }
+  case "project": {
+    const { handleProject } = await import("./project-cli-FEMPZIRQ.js");
+    await handleProject(process.argv.slice(3));
+    break;
+  }
+  case "daemon": {
+    const { handleDaemon } = await import("./daemon-NW4WRMQK.js");
+    await handleDaemon(process.argv[3]);
+    break;
+  }
+  case "codex": {
+    const { handleCodexCommand } = await import("./codex-launcher-IF2IPLBP.js");
+    await handleCodexCommand(process.argv.slice(3));
+    break;
+  }
+  case "help":
+  case "--help":
+  case "-h": {
+    console.log(`
+  \x1B[1mworkspacecord\x1B[0m \u2014 Discord bot for multi-agent coding sessions
+
+  \x1B[1mUsage:\x1B[0m
+    workspacecord                     Start the bot
+    workspacecord config setup        Interactive configuration wizard
+    workspacecord config get <key>    Read a config value
+    workspacecord config set <k> <v>  Write a config value
+    workspacecord config list         List all config values
+    workspacecord config path         Show config file path
+    workspacecord project <subcommand> Manage mounted projects
+    workspacecord daemon              Manage background service (install/uninstall/status)
+    workspacecord codex [options]     Launch managed Codex session with remote approval
+    workspacecord help                Show this help message
+
+  \x1B[1mQuick start:\x1B[0m
+    1. workspacecord config setup      Configure Discord app, token, permissions
+    2. workspacecord project init      Mount a local project
+    3. workspacecord                   Start the bot
+    4. /project setup project:<name> Bind a Discord category to the mounted project
+    5. /agent spawn label:<task>    Create an agent session
+
+  \x1B[2mhttps://github.com/xuhongbo/WorkspaceCord\x1B[0m
+`);
+    break;
+  }
+  default:
+    console.error(`Unknown command: ${command}`);
+    console.error("Run \x1B[36mworkspacecord help\x1B[0m for usage.");
+    process.exit(1);
+}

package/dist/codex-launcher-IF2IPLBP.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+import {
+  getConfigValue
+} from "./chunk-OKI4UVGY.js";
+import "./chunk-K3NQKI34.js";
+
+// src/cli/codex-launcher.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+async function launchManagedCodex(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const codexBin = resolveCodexPath();
+  if (!existsSync(cwd)) {
+    console.error(`\u274C \u5DE5\u4F5C\u76EE\u5F55\u4E0D\u5B58\u5728: ${cwd}`);
+    process.exit(1);
+  }
+  const codexArgs = [];
+  if (options.model) {
+    codexArgs.push("--model", options.model);
+  }
+  if (options.sandboxMode) {
+    codexArgs.push("--sandbox-mode", options.sandboxMode);
+  }
+  if (options.approvalPolicy) {
+    codexArgs.push("--approval-policy", options.approvalPolicy);
+  }
+  const env = {
+    ...process.env,
+    workspacecord_MANAGED: "1",
+    workspacecord_SESSION_CWD: cwd
+  };
+  if (options.args) {
+    codexArgs.push(...options.args);
+  }
+  console.log("\u{1F680} \u542F\u52A8\u53D7\u7BA1 Codex \u4F1A\u8BDD...");
+  console.log(`\u{1F4C1} \u5DE5\u4F5C\u76EE\u5F55: ${cwd}`);
+  console.log(`\u{1F527} \u53C2\u6570: ${codexArgs.join(" ")}`);
+  console.log("");
+  console.log("\u{1F4A1} \u6B64\u4F1A\u8BDD\u652F\u6301 Discord \u8FDC\u7A0B\u5BA1\u6279\u80FD\u529B");
+  console.log("   \u5728 Discord \u4E2D\u53EF\u4EE5\u8FDC\u7A0B\u5141\u8BB8/\u62D2\u7EDD\u64CD\u4F5C");
+  console.log("");
+  const codex = spawn(codexBin, codexArgs, {
+    cwd,
+    env,
+    stdio: "inherit"
+  });
+  codex.on("error", (err) => {
+    console.error("\u274C \u542F\u52A8 Codex \u5931\u8D25:", err.message);
+    console.error("");
+    console.error("\u8BF7\u786E\u4FDD\u5DF2\u5B89\u88C5 Codex CLI:");
+    console.error("  npm install -g @openai/codex");
+    process.exit(1);
+  });
+  codex.on("exit", (code) => {
+    if (code !== 0 && code !== null) {
+      console.error(`
+\u274C Codex \u9000\u51FA\uFF0C\u4EE3\u7801: ${code}`);
+      process.exit(code);
+    }
+  });
+}
+function resolveCodexPath() {
+  return process.env.CODEX_PATH || getConfigValue("CODEX_PATH") || "codex";
+}
+function isManagedSession() {
+  return process.env.workspacecord_MANAGED === "1";
+}
+function getManagedSessionCwd() {
+  return process.env.workspacecord_SESSION_CWD;
+}
+async function handleCodexCommand(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--cwd":
+        options.cwd = args[++i];
+        break;
+      case "--model":
+        options.model = args[++i];
+        break;
+      case "--sandbox-mode":
+        options.sandboxMode = args[++i];
+        break;
+      case "--approval-policy":
+        options.approvalPolicy = args[++i];
+        break;
+      case "--help":
+      case "-h":
+        printHelp();
+        return;
+      default:
+        if (!options.args) options.args = [];
+        options.args.push(arg);
+    }
+  }
+  await launchManagedCodex(options);
+}
+function printHelp() {
+  console.log(`
+\x1B[1mworkspacecord codex\x1B[0m \u2014 \u542F\u52A8\u53D7\u7BA1 Codex \u4F1A\u8BDD
+
+\x1B[1m\u7528\u6CD5:\x1B[0m
+  workspacecord codex [\u9009\u9879]
+
+\x1B[1m\u9009\u9879:\x1B[0m
+  --cwd <path>              \u5DE5\u4F5C\u76EE\u5F55\uFF08\u9ED8\u8BA4\uFF1A\u5F53\u524D\u76EE\u5F55\uFF09
+  --model <model>           \u6A21\u578B\u540D\u79F0\uFF08\u5982\uFF1Agpt-4\uFF09
+  --sandbox-mode <mode>     \u6C99\u7BB1\u6A21\u5F0F\uFF1Aread-only | workspace-write | danger-full-access
+  --approval-policy <policy> \u5BA1\u6279\u7B56\u7565\uFF1Anever | on-request | on-failure | untrusted
+  --help, -h                \u663E\u793A\u6B64\u5E2E\u52A9\u4FE1\u606F
+
+\x1B[1m\u53D7\u7BA1\u4F1A\u8BDD\u7279\u6027:\x1B[0m
+  \u2713 \u5FEB\u901F\u53D1\u73B0 - \u4F1A\u8BDD\u81EA\u52A8\u540C\u6B65\u5230 Discord
+  \u2713 \u72B6\u6001\u76D1\u63A7 - \u5B9E\u65F6\u663E\u793A\u6267\u884C\u72B6\u6001
+  \u2713 \u8FDC\u7A0B\u5BA1\u6279 - \u5728 Discord \u4E2D\u5141\u8BB8/\u62D2\u7EDD\u64CD\u4F5C
+  \u2713 \u7EC8\u7AEF\u5904\u7406 - \u4ECD\u53EF\u5728\u7EC8\u7AEF\u76F4\u63A5\u5904\u7406
+
+\x1B[1m\u793A\u4F8B:\x1B[0m
+  workspacecord codex
+  workspacecord codex --cwd /path/to/project
+  workspacecord codex --model gpt-4 --sandbox-mode workspace-write
+
+\x1B[2m\u66F4\u591A\u4FE1\u606F: https://github.com/xuhongbo/workspacecord\x1B[0m
+`);
+}
+export {
+  getManagedSessionCwd,
+  handleCodexCommand,
+  isManagedSession,
+  launchManagedCodex
+};

package/dist/codex-provider-7CI5W34X.js

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+import {
+  config
+} from "./chunk-2LBNM64L.js";
+import "./chunk-OKI4UVGY.js";
+import "./chunk-K3NQKI34.js";
+
+// src/providers/codex-provider.ts
+import { writeFileSync, readFileSync, unlinkSync, existsSync, mkdtempSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+// src/providers/codex/helpers.ts
+function buildCodexOptions() {
+  const codexOpts = {};
+  if (config.codexApiKey) codexOpts.apiKey = config.codexApiKey;
+  if (config.codexBaseUrl) codexOpts.baseUrl = config.codexBaseUrl;
+  if (config.codexPath) codexOpts.codexPathOverride = config.codexPath;
+  return codexOpts;
+}
+function buildThreadOptions(options) {
+  const threadOptions = {
+    workingDirectory: options.directory,
+    skipGitRepoCheck: true
+  };
+  if (options.model) threadOptions.model = options.model;
+  if (options.sandboxMode) threadOptions.sandboxMode = options.sandboxMode;
+  if (options.approvalPolicy) threadOptions.approvalPolicy = options.approvalPolicy;
+  if (options.networkAccessEnabled !== void 0) {
+    threadOptions.networkAccessEnabled = options.networkAccessEnabled;
+  }
+  if (options.webSearchMode && options.webSearchMode !== "disabled") {
+    threadOptions.webSearchMode = options.webSearchMode;
+  }
+  if (options.modelReasoningEffort) {
+    threadOptions.modelReasoningEffort = options.modelReasoningEffort;
+  }
+  return threadOptions;
+}
+function parseFileChanges(item) {
+  const raw = item.changes || item.files || [];
+  return raw.map((f) => ({
+    filePath: String(f.path || f.file_path || f.filePath || ""),
+    changeKind: f.kind || f.change_kind || f.changeKind || "update"
+  }));
+}
+function parseTodoItems(item) {
+  const raw = item.items || item.todos || [];
+  return raw.map((t) => ({
+    text: String(t.text || t.description || ""),
+    completed: Boolean(t.completed ?? t.done ?? false)
+  }));
+}
+
+// src/providers/codex-provider.ts
+var Codex = null;
+async function loadSdk() {
+  if (Codex) return;
+  const mod = await import("@openai/codex-sdk");
+  Codex = mod.Codex;
+}
+var SENTINEL_START = "<!-- workspacecord-persona-start -->";
+var SENTINEL_END = "<!-- workspacecord-persona-end -->";
+function stripInjectedAgentsMd(content) {
+  return content.replace(
+    new RegExp(`${escapeRegex(SENTINEL_START)}[\\s\\S]*?${escapeRegex(SENTINEL_END)}\\n?`, "g"),
+    ""
+  );
+}
+function injectAgentsMd(directory, parts) {
+  if (parts.length === 0) return null;
+  const agentsPath = join(directory, "AGENTS.md");
+  const injected = `${SENTINEL_START}
+${parts.join("\n\n")}
+${SENTINEL_END}`;
+  const existed = existsSync(agentsPath);
+  const current = existed ? readFileSync(agentsPath, "utf-8") : "";
+  const cleaned = stripInjectedAgentsMd(current).trimEnd();
+  writeFileSync(agentsPath, cleaned ? `${cleaned}
+
+${injected}
+` : `${injected}
+`, "utf-8");
+  return { existed };
+}
+function restoreAgentsMd(directory, state) {
+  if (!state) return;
+  const agentsPath = join(directory, "AGENTS.md");
+  if (!existsSync(agentsPath)) return;
+  const cleaned = stripInjectedAgentsMd(readFileSync(agentsPath, "utf-8")).trimEnd();
+  if (!state.existed && !cleaned) {
+    try {
+      unlinkSync(agentsPath);
+    } catch {
+    }
+    return;
+  }
+  writeFileSync(agentsPath, cleaned ? `${cleaned}
+` : "", "utf-8");
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function writeImagesToTemp(blocks) {
+  const textParts = [];
+  const localImages = [];
+  for (const block of blocks) {
+    if (block.type === "text") {
+      textParts.push(block.text);
+    } else if (block.type === "image") {
+      const dir = mkdtempSync(join(tmpdir(), "workspacecord-img-"));
+      const ext = block.source.media_type.split("/")[1] || "png";
+      const filePath = join(dir, `image.${ext}`);
+      writeFileSync(filePath, Buffer.from(block.source.data, "base64"));
+      localImages.push({ type: "local_image", path: filePath });
+    } else if (block.type === "local_image") {
+      localImages.push(block);
+    }
+  }
+  return { textParts, localImages };
+}
+var CodexProvider = class {
+  name = "codex";
+  supports(feature) {
+    return ["command_execution", "file_changes", "reasoning", "todo_list", "continue"].includes(
+      feature
+    );
+  }
+  async *sendPrompt(prompt, options) {
+    await loadSdk();
+    let input;
+    if (typeof prompt === "string") {
+      input = prompt;
+    } else {
+      const { textParts, localImages } = writeImagesToTemp(prompt);
+      const inputParts = [];
+      for (const img of localImages) {
+        inputParts.push({ type: "local_image", path: img.path });
+      }
+      if (textParts.length > 0) {
+        inputParts.push({ type: "text", text: textParts.join("\n") });
+      }
+      input = inputParts.length === 1 && inputParts[0].type === "text" ? inputParts[0].text ?? "" : inputParts;
+    }
+    let originalAgents = null;
+    try {
+      originalAgents = injectAgentsMd(options.directory, options.systemPromptParts);
+      const codex = new Codex(buildCodexOptions());
+      const threadOptions = buildThreadOptions(options);
+      const thread = options.providerSessionId ? codex.resumeThread(options.providerSessionId, threadOptions) : codex.startThread(threadOptions);
+      const { events } = await thread.runStreamed(input);
+      yield* this.translateEvents(events, options.abortController);
+    } finally {
+      restoreAgentsMd(options.directory, originalAgents);
+    }
+  }
+  async *continueSession(options) {
+    await loadSdk();
+    if (!options.providerSessionId) {
+      yield { type: "error", message: "No session to continue \u2014 no previous thread ID." };
+      return;
+    }
+    let originalAgents = null;
+    try {
+      originalAgents = injectAgentsMd(options.directory, options.systemPromptParts);
+      const codex = new Codex(buildCodexOptions());
+      const thread = codex.resumeThread(options.providerSessionId, buildThreadOptions(options));
+      const { events } = await thread.runStreamed("Continue from where you left off.");
+      yield* this.translateEvents(events, options.abortController);
+    } finally {
+      restoreAgentsMd(options.directory, originalAgents);
+    }
+  }
+  async *translateEvents(events, abortController) {
+    const messageText = /* @__PURE__ */ new Map();
+    const startTime = Date.now();
+    try {
+      for await (const event of events) {
+        if (abortController.signal.aborted) break;
+        switch (event.type) {
+          case "thread.started":
+            yield { type: "session_init", providerSessionId: event.thread_id || "" };
+            break;
+          case "item.started":
+          case "item.updated": {
+            const item = event.item;
+            if (!item) break;
+            if (item.type === "agent_message") {
+              const itemId = String(item.id || "");
+              const prev = messageText.get(itemId) || "";
+              const text = String(item.text || "");
+              if (text.length > prev.length) {
+                yield { type: "text_delta", text: text.slice(prev.length) };
+                messageText.set(itemId, text);
+              }
+            }
+            if (item.type === "reasoning" && event.type === "item.updated") {
+              const text = String(item.summary || item.content || "");
+              if (text) yield { type: "reasoning", text };
+            }
+            break;
+          }
+          case "item.completed": {
+            const item = event.item;
+            if (!item) break;
+            switch (item.type) {
+              case "agent_message": {
+                const itemId = String(item.id || "");
+                const prev = messageText.get(itemId) || "";
+                const text = String(item.text || "");
+                if (text.length > prev.length) {
+                  yield { type: "text_delta", text: text.slice(prev.length) };
+                }
+                messageText.delete(itemId);
+                break;
+              }
+              case "command_execution":
+                yield {
+                  type: "command_execution",
+                  command: String(item.command || ""),
+                  output: String(item.aggregated_output ?? item.output ?? ""),
+                  exitCode: typeof item.exit_code === "number" ? item.exit_code : typeof item.exitCode === "number" ? item.exitCode : null,
+                  status: String(item.status || "completed")
+                };
+                break;
+              case "file_change": {
+                const changes = parseFileChanges(item);
+                if (changes.length > 0) yield { type: "file_change", changes };
+                break;
+              }
+              case "reasoning": {
+                const text = String(item.summary || item.content || "");
+                if (text) yield { type: "reasoning", text };
+                break;
+              }
+              case "todo_list": {
+                const items = parseTodoItems(item);
+                if (items.length > 0) yield { type: "todo_list", items };
+                break;
+              }
+              case "mcp_tool_call":
+                yield {
+                  type: "tool_start",
+                  toolName: `${String(item.server || "")}/${String(item.tool || "")}`,
+                  toolInput: JSON.stringify(item.arguments || item.input || {})
+                };
+                if (item.status === "completed" || item.status === "failed") {
+                  yield {
+                    type: "tool_result",
+                    toolName: `${String(item.server || "")}/${String(item.tool || "")}`,
+                    result: typeof item.output === "string" ? item.output : JSON.stringify(item.output || ""),
+                    isError: item.status === "failed"
+                  };
+                }
+                break;
+              case "web_search":
+                yield { type: "web_search", query: String(item.query || "") };
+                break;
+              case "error":
+                yield { type: "error", message: String(item.message || "Unknown error") };
+                break;
+            }
+            break;
+          }
+          case "turn.completed": {
+            const usage = event.usage;
+            const inputTokens = usage?.input_tokens || 0;
+            const outputTokens = usage?.output_tokens || 0;
+            const costUsd = (inputTokens * 2 + outputTokens * 8) / 1e6;
+            yield {
+              type: "result",
+              success: true,
+              costUsd,
+              durationMs: Date.now() - startTime,
+              numTurns: 1,
+              errors: []
+            };
+            break;
+          }
+          case "turn.failed":
+            yield {
+              type: "result",
+              success: false,
+              costUsd: 0,
+              durationMs: Date.now() - startTime,
+              numTurns: 1,
+              errors: [event.error || "Turn failed"]
+            };
+            break;
+          case "error":
+            yield { type: "error", message: event.message || "Unknown error" };
+            break;
+        }
+      }
+    } catch (err) {
+      if (!abortController.signal.aborted) {
+        yield { type: "error", message: err.message || "Codex stream error" };
+      }
+    }
+  }
+};
+export {
+  CodexProvider
+};