@meetopenbot/codex 1.0.12 → 1.1.0

package/README.md

@@ -1,37 +1,23 @@
-# openbot-plugin-codex
+# @meetopenbot/codex
 
-Minimal Codex plugin scaffold for OpenBot.
+OpenAI Codex runtime plugin for OpenBot. Each `agent:invoke` starts or resumes a Codex SDK thread in the channel workspace.
 
-## What is included
+## Config
 
-- A plugin registry export (`plugin`) compatible with OpenBot
-- One tool definition: `codex_run`
-- One action handler: `action:codex_run`
-- `@openai/codex-sdk` integration via `Codex` + `thread.run(...)`
+Set an API key with one of:
 
-## Local usage
-
-1. Install dependencies:
-
-   `npm install`
-
-2. Build:
-
-   `npm run build`
-
-3. Load `dist/index.js` from your OpenBot plugin registry/runtime.
-
-## Runtime config
-
-Set an API key using one of the following:
-
-- `CODEX_API_KEY` environment variable
-- `OPENAI_API_KEY` environment variable
 - `apiKey` in plugin options
+- `CODEX_API_KEY`
+- `OPENAI_API_KEY`
+
+Optional:
 
-Optional plugin options:
+- `model` — Codex model id (e.g. `gpt-5.6`). Omit to use the CLI default.
+- `sandboxMode` — `read-only` | `workspace-write` | `danger-full-access` (default `workspace-write`)
+- `approvalPolicy` — `never` | `on-request` | `on-failure` | `untrusted` (default `never`)
+- `workingDirectory` — override the channel cwd
+- `skipGitRepoCheck` — default `true` for non-git channel workspaces
+- `baseURL` — custom OpenAI-compatible endpoint
+- `codexPathOverride` — path to a local `codex` binary (`CODEX_PATH` / `CODEX_CLI_PATH` also work)
 
-- `model` (defaults to `gpt-5-codex`)
-- `baseURL` (for custom OpenAI-compatible endpoints)
-- `workingDirectory`, `skipGitRepoCheck`, `sandboxMode`, `approvalPolicy`
-- `networkAccessEnabled`, `webSearchMode`, `threadId`
+Codex conversation state is stored as `codexThreadId` on the OpenBot thread, not as the OpenBot thread id.

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from '@meetopenbot/plugin-sdk';
+declare const plugin: Plugin;
+export { plugin };
+export default plugin;

package/dist/index.js

@@ -8,180 +8,269 @@ import {
 import {
   Codex
 } from "@openai/codex-sdk";
-var codex_default = definePlugin({
+var SANDBOX_MODES = [
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+];
+var APPROVAL_MODES = [
+  "never",
+  "on-request",
+  "on-failure",
+  "untrusted"
+];
+var LEGACY_SANDBOX = {
+  "workspace-read": "read-only",
+  "full-read": "read-only",
+  "full-write": "danger-full-access"
+};
+var LEGACY_APPROVAL = {
+  always: "on-request",
+  automatic: "on-request"
+};
+var AUTH_ERROR_PATTERNS = [
+  "api key",
+  "apikey",
+  "unauthorized",
+  "401",
+  "authentication",
+  "not logged in",
+  "login"
+];
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var asString = (value) => typeof value === "string" && value.trim() ? value.trim() : void 0;
+var isAuthErrorMessage = (message) => {
+  const lower = message.toLowerCase();
+  return AUTH_ERROR_PATTERNS.some((pattern) => lower.includes(pattern));
+};
+var readPersistedThreadId = (state) => {
+  const source = state.threadDetails?.state ?? state.channelDetails?.state;
+  const record = asRecord(source);
+  return asString(record.codexThreadId);
+};
+var persistThreadId = async (state, storage, codexThreadId) => {
+  if (!storage || !state.channelId) return;
+  const patch = { codexThreadId };
+  if (state.threadId) {
+    await storage.patchThreadState({
+      channelId: state.channelId,
+      threadId: state.threadId,
+      state: patch
+    });
+    return;
+  }
+  await storage.patchChannelState({ channelId: state.channelId, state: patch });
+};
+var parseSandboxMode = (value) => {
+  const raw = asString(value);
+  if (!raw) return "workspace-write";
+  if (SANDBOX_MODES.includes(raw)) return raw;
+  return LEGACY_SANDBOX[raw] ?? "workspace-write";
+};
+var parseApprovalPolicy = (value) => {
+  const raw = asString(value);
+  if (!raw) return "never";
+  if (APPROVAL_MODES.includes(raw)) return raw;
+  return LEGACY_APPROVAL[raw] ?? "never";
+};
+var parseModel = (value) => {
+  const raw = asString(value);
+  if (!raw) return void 0;
+  return raw.split("/").pop() || void 0;
+};
+var itemWidget = (item) => {
+  switch (item.type) {
+    case "command_execution":
+      return { title: "Command", body: item.command };
+    case "file_change":
+      return {
+        title: "File change",
+        body: item.changes.map((change) => `${change.kind} ${change.path}`).join("\n")
+      };
+    case "error":
+      return { title: "Error", body: item.message };
+    default:
+      return null;
+  }
+};
+var errorText = (error) => error instanceof Error ? error.message : "Codex request failed.";
+var buildApiKeyWidget = (agentId, threadId, reason) => uiWidget({
+  agentId,
+  threadId,
+  widget: {
+    kind: "form",
+    widgetId: `codex_api_key_request_${Date.now()}`,
+    title: "OpenAI API Key Required",
+    description: `Codex could not authenticate (${reason}). Provide an OpenAI API key to continue. You can get one from the OpenAI dashboard. The key is stored as a workspace variable on your machine and never leaves your local runtime.`,
+    fields: [
+      {
+        id: "apiKey",
+        label: "API Key",
+        type: "password",
+        placeholder: "sk-...",
+        required: true
+      }
+    ],
+    submitLabel: "Save API Key",
+    metadata: {
+      type: "api_key_request",
+      provider: "openai",
+      envVar: "OPENAI_API_KEY",
+      source: "codex"
+    }
+  }
+});
+var plugin = definePlugin({
   id: "codex",
   name: "Codex",
-  description: "Codex integration tools for OpenBot",
+  description: "OpenAI Codex agent. Uses the Codex SDK to read code, edit files, and run shell commands inside the channel's workspace.",
   configSchema: {
     type: "object",
     properties: {
-      apiKey: { type: "string", description: "Codex API Key", format: "password" },
-      baseURL: { type: "string", description: "Custom OpenAI-compatible endpoint" },
-      codexPathOverride: { type: "string", description: "Path to codex CLI" },
-      model: { type: "string", description: "Model to use", default: "gpt-5-codex" },
-      workingDirectory: { type: "string", description: "Working directory for Codex" },
-      skipGitRepoCheck: { type: "boolean", description: "Skip git repo check", default: true },
+      apiKey: {
+        type: "string",
+        description: "OpenAI API key (falls back to CODEX_API_KEY / OPENAI_API_KEY)",
+        format: "password"
+      },
+      model: {
+        type: "string",
+        description: "Codex model id (e.g. gpt-5.6). Leave empty to use the CLI default."
+      },
       sandboxMode: {
         type: "string",
-        enum: ["workspace-read", "workspace-write", "full-read", "full-write"],
-        description: "Sandbox mode",
+        enum: [...SANDBOX_MODES],
+        description: "Filesystem sandbox: read-only | workspace-write | danger-full-access",
         default: "workspace-write"
       },
       approvalPolicy: {
         type: "string",
-        enum: ["always", "never", "automatic"],
-        description: "Approval policy",
+        enum: [...APPROVAL_MODES],
+        description: "When to require approval: never | on-request | on-failure | untrusted",
         default: "never"
       },
-      networkAccessEnabled: { type: "boolean", description: "Enable network access" },
-      webSearchMode: {
+      workingDirectory: {
+        type: "string",
+        description: "Override the channel working directory"
+      },
+      skipGitRepoCheck: {
+        type: "boolean",
+        description: "Skip the Codex git-repo check (needed for non-git channel workspaces)",
+        default: true
+      },
+      baseURL: {
+        type: "string",
+        description: "Custom OpenAI-compatible endpoint"
+      },
+      codexPathOverride: {
         type: "string",
-        enum: ["always", "never", "automatic"],
-        description: "Web search mode"
+        description: "Path to a local Codex CLI binary"
       }
     }
   },
   factory: (context) => {
     const config = context.config;
-    const env = globalThis?.process?.env || {};
-    const apiKey = config.apiKey ?? env.CODEX_API_KEY ?? env.OPENAI_API_KEY;
-    const codexPathOverride = config.codexPathOverride ?? env.CODEX_PATH ?? env.CODEX_CLI_PATH;
-    const model = config.model?.split("/").pop() || "gpt-5-codex";
+    const apiKey = asString(config.apiKey) ?? process.env.CODEX_API_KEY ?? process.env.OPENAI_API_KEY;
+    const codexPathOverride = asString(config.codexPathOverride) ?? process.env.CODEX_PATH ?? process.env.CODEX_CLI_PATH;
+    const model = parseModel(config.model);
+    const sandboxMode = parseSandboxMode(config.sandboxMode);
+    const approvalPolicy = parseApprovalPolicy(config.approvalPolicy);
+    const skipGitRepoCheck = config.skipGitRepoCheck !== false;
+    const workingDirectoryOverride = asString(config.workingDirectory);
+    const baseUrl = asString(config.baseURL);
     let client;
     const getClient = () => {
       if (!client) {
         client = new Codex({
-          apiKey,
+          ...apiKey && { apiKey },
           ...codexPathOverride && { codexPathOverride },
-          ...config.baseURL && { baseUrl: config.baseURL }
+          ...baseUrl && { baseUrl }
         });
       }
       return client;
     };
-    let thread = null;
-    const getThread = (state, meta) => {
-      if (thread) return thread;
-      const workingDirectory = config.workingDirectory || state?.channelDetails?.cwd || globalThis?.process?.cwd() || "/tmp";
-      const threadOptions = {
-        model,
-        workingDirectory,
-        skipGitRepoCheck: config.skipGitRepoCheck ?? true,
-        sandboxMode: config.sandboxMode ?? "workspace-write",
-        approvalPolicy: config.approvalPolicy ?? "never",
-        ...typeof config.networkAccessEnabled === "boolean" && {
-          networkAccessEnabled: config.networkAccessEnabled
-        },
-        ...config.webSearchMode && {
-          webSearchMode: config.webSearchMode
-        }
-      };
-      const threadId = state?.threadId || meta?.threadId;
-      thread = threadId ? getClient().resumeThread(threadId, threadOptions) : getClient().startThread(threadOptions);
-      if (!threadId && state) {
-        state.threadId = thread.id;
-      }
-      return thread;
-    };
     return (builder) => {
       builder.on("agent:invoke", async function* (event, ctx) {
         if (!shouldHandleInvoke(event, context.agentId)) return;
-        const { content } = event.data || {};
+        const content = asString(event.data?.content);
+        const openbotThreadId = event.meta?.threadId || ctx.state.threadId;
         if (!content) {
           yield agentOutput({
             agentId: context.agentId,
             content: "No content provided.",
-            threadId: event.meta?.threadId
+            threadId: openbotThreadId
           });
           return;
         }
-        try {
-          const turn = await getThread(ctx?.state, event.meta).runStreamed(content);
-          for await (const chunk of turn.events) {
-            if (chunk.type === "item.completed") {
-              const { item } = chunk;
-              if (item.type === "agent_message") {
-                yield agentOutput({
-                  agentId: context.agentId,
-                  content: item.text,
-                  threadId: event.meta?.threadId
-                });
-                continue;
-              }
-              let title = "";
-              let body = "";
-              switch (item.type) {
-                case "reasoning":
-                  title = "Reasoning";
-                  body = item.text;
-                  break;
-                case "command_execution":
-                  title = "Command Execution";
-                  body = `Executing: ${item.command}`;
-                  break;
-                case "file_change":
-                  title = "File Change";
-                  body = item.changes.map((change) => `${change.path}: ${change.kind || change.action}`).join("\n");
-                  break;
-                case "mcp_tool_call":
-                  title = `Tool: ${item.tool}`;
-                  body = `Arguments: ${JSON.stringify(item.arguments, null, 2)}`;
-                  if (item.result) {
-                    body += `
-
-Result: ${JSON.stringify(
-                      item.result.structured_content || item.result.content,
-                      null,
-                      2
-                    )}`;
-                  }
-                  if (item.error) {
-                    body += `
-
-Error: ${item.error.message}`;
-                  }
-                  break;
-                case "web_search":
-                  title = "Web Search";
-                  body = `Searching: ${item.query}`;
-                  break;
-                case "todo_list":
-                  title = "Todo List";
-                  body = item.items.map(
-                    (todo) => `- ${todo.text} (${todo.completed ? "completed" : "pending"})`
-                  ).join("\n");
-                  break;
-                case "error":
-                  title = "Error";
-                  body = item.message;
-                  break;
-              }
-              if (title && body) {
-                yield uiWidget({
-                  agentId: context.agentId,
-                  threadId: event.meta?.threadId,
-                  widget: {
-                    kind: "message",
-                    title,
-                    body,
-                    // @ts-ignore
-                    variant: "basic",
-                    display: "collapsed"
-                  }
-                });
-              }
-            }
+        const workingDirectory = workingDirectoryOverride || ctx.state.channelDetails?.cwd || process.cwd();
+        const threadOptions = {
+          workingDirectory,
+          skipGitRepoCheck,
+          sandboxMode,
+          approvalPolicy,
+          ...model && { model }
+        };
+        const savedId = readPersistedThreadId(ctx.state);
+        const thread = savedId ? getClient().resumeThread(savedId, threadOptions) : getClient().startThread(threadOptions);
+        const fail = function* (message) {
+          if (isAuthErrorMessage(message)) {
+            yield buildApiKeyWidget(context.agentId, openbotThreadId, message);
           }
-        } catch (error) {
           yield agentOutput({
             agentId: context.agentId,
-            content: `Error: ${error?.message || "Codex request failed."}`,
-            threadId: event.meta?.threadId
+            content: `Error: ${message}`,
+            threadId: openbotThreadId
+          });
+        };
+        try {
+          const { events } = await thread.runStreamed(content, {
+            signal: context.abortSignal
           });
+          for await (const chunk of events) {
+            if (chunk.type === "thread.started") {
+              await persistThreadId(ctx.state, context.storage, chunk.thread_id);
+              continue;
+            }
+            if (chunk.type === "turn.failed") {
+              yield* fail(chunk.error.message);
+              return;
+            }
+            if (chunk.type === "error") {
+              yield* fail(chunk.message);
+              return;
+            }
+            if (chunk.type !== "item.completed") continue;
+            if (chunk.item.type === "agent_message") {
+              yield agentOutput({
+                agentId: context.agentId,
+                content: chunk.item.text,
+                threadId: openbotThreadId
+              });
+              continue;
+            }
+            const widget = itemWidget(chunk.item);
+            if (!widget) continue;
+            yield uiWidget({
+              agentId: context.agentId,
+              threadId: openbotThreadId,
+              widget: {
+                kind: "message",
+                widgetId: `codex_${chunk.item.id}`,
+                title: widget.title,
+                body: widget.body,
+                variant: "basic",
+                display: "collapsed"
+              }
+            });
+          }
+        } catch (error) {
+          yield* fail(errorText(error));
         }
       });
     };
   }
 });
+var plugin_codex_default = plugin;
 export {
-  codex_default as default
+  plugin_codex_default as default,
+  plugin
 };

package/package.json

@@ -1,30 +1,36 @@
 {
   "name": "@meetopenbot/codex",
-  "version": "1.0.12",
+  "version": "1.1.0",
   "type": "module",
-  "description": "Codex tools plugin for OpenBot",
+  "description": "OpenAI Codex agent plugin for OpenBot",
   "main": "./dist/index.js",
   "publishConfig": {
     "access": "public"
   },
   "exports": {
-    ".": "./dist/index.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
   },
   "files": [
-    "dist",
-    "assets"
+    "dist"
   ],
   "scripts": {
-    "build": "esbuild index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --external:@meetopenbot/plugin-sdk --external:@openai/codex-sdk --external:zod",
-    "prepublishOnly": "npm run build"
+    "build": "esbuild index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --external:@meetopenbot/plugin-sdk --external:@openai/codex-sdk --external:zod && node ../../scripts/write-plugin-declaration.mjs",
+    "dev": "esbuild index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --external:@meetopenbot/plugin-sdk --external:@openai/codex-sdk --external:zod --watch",
+    "typecheck": "tsc --noEmit --allowImportingTsExtensions --module ESNext --moduleResolution Bundler --target ES2022 --skipLibCheck index.ts",
+    "prepack": "pnpm build"
   },
   "dependencies": {
-    "@meetopenbot/plugin-sdk": "^0.1.2",
-    "@openai/codex-sdk": "^0.138.0"
+    "@meetopenbot/plugin-sdk": "workspace:^",
+    "@openai/codex-sdk": "0.148.0"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",
     "esbuild": "^0.21.0",
     "zod": "^4.4.3"
-  }
+  },
+  "types": "./dist/index.d.ts"
 }

package/assets/icon.svg

@@ -1 +0,0 @@
-<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Codex</title><path d="M19.503 0H4.496A4.496 4.496 0 000 4.496v15.007A4.496 4.496 0 004.496 24h15.007A4.496 4.496 0 0024 19.503V4.496A4.496 4.496 0 0019.503 0z" fill="#fff"></path><path d="M9.064 3.344a4.578 4.578 0 012.285-.312c1 .115 1.891.54 2.673 1.275.01.01.024.017.037.021a.09.09 0 00.043 0 4.55 4.55 0 013.046.275l.047.022.116.057a4.581 4.581 0 012.188 2.399c.209.51.313 1.041.315 1.595a4.24 4.24 0 01-.134 1.223.123.123 0 00.03.115c.594.607.988 1.33 1.183 2.17.289 1.425-.007 2.71-.887 3.854l-.136.166a4.548 4.548 0 01-2.201 1.388.123.123 0 00-.081.076c-.191.551-.383 1.023-.74 1.494-.9 1.187-2.222 1.846-3.711 1.838-1.187-.006-2.239-.44-3.157-1.302a.107.107 0 00-.105-.024c-.388.125-.78.143-1.204.138a4.441 4.441 0 01-1.945-.466 4.544 4.544 0 01-1.61-1.335c-.152-.202-.303-.392-.414-.617a5.81 5.81 0 01-.37-.961 4.582 4.582 0 01-.014-2.298.124.124 0 00.006-.056.085.085 0 00-.027-.048 4.467 4.467 0 01-1.034-1.651 3.896 3.896 0 01-.251-1.192 5.189 5.189 0 01.141-1.6c.337-1.112.982-1.985 1.933-2.618.212-.141.413-.251.601-.33.215-.089.43-.164.646-.227a.098.098 0 00.065-.066 4.51 4.51 0 01.829-1.615 4.535 4.535 0 011.837-1.388zm3.482 10.565a.637.637 0 000 1.272h3.636a.637.637 0 100-1.272h-3.636zM8.462 9.23a.637.637 0 00-1.106.631l1.272 2.224-1.266 2.136a.636.636 0 101.095.649l1.454-2.455a.636.636 0 00.005-.64L8.462 9.23z" fill="url(#lobe-icons-codex-_R_0_)"></path><defs><linearGradient gradientUnits="userSpaceOnUse" id="lobe-icons-codex-_R_0_" x1="12" x2="12" y1="3" y2="21"><stop stop-color="#B1A7FF"></stop><stop offset=".5" stop-color="#7A9DFF"></stop><stop offset="1" stop-color="#3941FF"></stop></linearGradient></defs></svg>