agentcord 0.1.8 → 0.1.9

package/dist/cli.js

@@ -4,7 +4,7 @@
 var command = process.argv[2];
 switch (command) {
   case "setup": {
-    const { runSetup } = await import("./setup-PKUBTHQH.js");
+    const { runSetup } = await import("./setup-FO4HRB3B.js");
     await runSetup();
     break;
   }
@@ -18,7 +18,7 @@ switch (command) {
       console.log("Run \x1B[36magentcord setup\x1B[0m to configure.\n");
       process.exit(1);
     }
-    const { startBot } = await import("./bot-MUOL7CRV.js");
+    const { startBot } = await import("./bot-MOK6APSV.js");
     console.log("agentcord starting...");
     await startBot();
     break;

package/dist/codex-provider-672ILQC2.js

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+
+// src/providers/codex-provider.ts
+import { writeFileSync, readFileSync, unlinkSync, existsSync, mkdtempSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+var Codex;
+async function loadSdk() {
+  if (Codex) return;
+  const mod = await import("@openai/codex-sdk");
+  Codex = mod.Codex;
+}
+var SENTINEL_START = "<!-- agentcord-persona-start -->";
+var SENTINEL_END = "<!-- agentcord-persona-end -->";
+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}`;
+  let original = null;
+  if (existsSync(agentsPath)) {
+    original = readFileSync(agentsPath, "utf-8");
+    const cleaned = original.replace(new RegExp(`${escapeRegex(SENTINEL_START)}[\\s\\S]*?${escapeRegex(SENTINEL_END)}\\n?`), "");
+    writeFileSync(agentsPath, cleaned + "\n" + injected + "\n", "utf-8");
+  } else {
+    writeFileSync(agentsPath, injected + "\n", "utf-8");
+  }
+  return original;
+}
+function restoreAgentsMd(directory, original) {
+  const agentsPath = join(directory, "AGENTS.md");
+  if (original === null) {
+    try {
+      unlinkSync(agentsPath);
+    } catch {
+    }
+  } else if (original !== void 0) {
+    writeFileSync(agentsPath, original, "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(), "agentcord-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();
+      const threadOptions = {
+        workingDirectory: options.directory,
+        skipGitRepoCheck: true
+      };
+      if (options.model) threadOptions.model = options.model;
+      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();
+      const threadOptions = {
+        workingDirectory: options.directory,
+        skipGitRepoCheck: true
+      };
+      if (options.model) threadOptions.model = options.model;
+      const thread = codex.resumeThread(options.providerSessionId, threadOptions);
+      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 prev = messageText.get(item.id) || "";
+              const text = item.text || "";
+              if (text.length > prev.length) {
+                yield { type: "text_delta", text: text.slice(prev.length) };
+                messageText.set(item.id, text);
+              }
+            }
+            if (item.type === "reasoning" && event.type === "item.updated") {
+              const text = 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 prev = messageText.get(item.id) || "";
+                const text = item.text || "";
+                if (text.length > prev.length) {
+                  yield { type: "text_delta", text: text.slice(prev.length) };
+                }
+                messageText.delete(item.id);
+                break;
+              }
+              case "command_execution":
+                yield {
+                  type: "command_execution",
+                  command: item.command || "",
+                  output: item.output || "",
+                  exitCode: item.exit_code ?? item.exitCode ?? null,
+                  status: item.status || "completed"
+                };
+                break;
+              case "file_change": {
+                const changes = (item.changes || item.files || []).map((f) => ({
+                  filePath: f.file_path || f.filePath || f.path || "",
+                  changeKind: f.change_kind || f.changeKind || f.action || "update"
+                }));
+                if (changes.length > 0) {
+                  yield { type: "file_change", changes };
+                }
+                break;
+              }
+              case "reasoning": {
+                const text = item.summary || item.content || "";
+                if (text) {
+                  yield { type: "reasoning", text };
+                }
+                break;
+              }
+              case "todo_list": {
+                const items = (item.items || item.todos || []).map((t) => ({
+                  text: t.text || t.description || "",
+                  completed: t.completed ?? t.done ?? false
+                }));
+                if (items.length > 0) {
+                  yield { type: "todo_list", items };
+                }
+                break;
+              }
+              case "mcp_tool_call":
+                yield {
+                  type: "tool_start",
+                  toolName: `${item.server}/${item.tool}`,
+                  toolInput: JSON.stringify(item.arguments || item.input || {})
+                };
+                if (item.status === "completed" || item.status === "failed") {
+                  yield {
+                    type: "tool_result",
+                    toolName: `${item.server}/${item.tool}`,
+                    result: typeof item.output === "string" ? item.output : JSON.stringify(item.output || ""),
+                    isError: item.status === "failed"
+                  };
+                }
+                break;
+              case "error":
+                yield { type: "error", message: 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
+};

package/dist/{setup-PKUBTHQH.js → setup-FO4HRB3B.js}

@@ -300,6 +300,21 @@ async function runSetup() {
       p.log.info(`You can re-run setup with: ${cyan("npm run setup")}`);
     }
   }
+  const installCodex = await p.confirm({
+    message: "Install OpenAI Codex support? (requires @openai/codex-sdk)",
+    initialValue: false
+  });
+  if (p.isCancel(installCodex)) cancelled();
+  if (installCodex) {
+    s.start("Installing @openai/codex-sdk...");
+    try {
+      execSync("npm install @openai/codex-sdk", { cwd: process.cwd(), stdio: "pipe" });
+      s.stop(green("Codex SDK installed"));
+    } catch (err) {
+      s.stop(`Failed to install Codex SDK: ${err.message}`);
+      p.log.warn(`You can install it manually: ${cyan("npm install @openai/codex-sdk")}`);
+    }
+  }
   const installDaemon = await p.confirm({
     message: "Start agentcord as a background service? (auto-starts on boot, restarts on crash)",
     initialValue: true
@@ -317,7 +332,7 @@ async function runSetup() {
     }
   }
   const nextSteps = [
-    `Use ${bold("/claude new <name> <directory>")} in Discord to create your first session.`
+    `Use ${bold("/session new <name>")} in Discord to create your first session.`
   ];
   if (!installDaemon) {
     nextSteps.unshift(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentcord",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "type": "module",
   "description": "Discord bot for managing AI coding agent sessions (Claude Code, Codex, and more)",
   "bin": {
@@ -53,6 +53,9 @@
     "dotenv": "^17.2.4",
     "sharp": "^0.34.5"
   },
+  "optionalDependencies": {
+    "@openai/codex-sdk": "^0.98.0"
+  },
   "devDependencies": {
     "@types/node": "^22.10.0",
     "tsup": "^8.5.1",