@mtayfur/opencode-codex-fast 1.0.1

package/README.md

@@ -0,0 +1,90 @@
+# OpenCode Codex Fast
+
+`@mtayfur/opencode-codex-fast` adds a global Fast Mode toggle for ChatGPT Codex. When enabled, matching HTTP
+requests include:
+
+```json
+{
+  "service_tier": "priority"
+}
+```
+
+Other providers and endpoints are unaffected.
+
+## Installation
+
+### OpenCode installer
+
+Install both plugin targets with OpenCode:
+
+```sh
+opencode plugin --global @mtayfur/opencode-codex-fast
+```
+
+The package uses separate server and TUI entry points. The installer registers both targets.
+
+### Manual configuration
+
+Add the package to `~/.config/opencode/opencode.jsonc` (`opencode.json` is also supported):
+
+```jsonc
+{
+  "plugin": ["@mtayfur/opencode-codex-fast"]
+}
+```
+
+Add the same package to `~/.config/opencode/tui.json`:
+
+```json
+{
+  "plugin": ["@mtayfur/opencode-codex-fast"]
+}
+```
+
+Restart OpenCode after installation or configuration changes.
+
+### Local checkout
+
+For a local checkout, run `bun run --cwd packages/codex-fast setup`. Use `setup:uninstall` to remove both local
+registrations.
+
+## Usage
+
+Run `/fast` or select `codex.fast.toggle` from the command palette. The command updates the global state and shows a
+toast; it does not create a session message or call a model.
+
+- `⚡` — Fast Mode is enabled.
+- `🐢` — Fast Mode is disabled.
+
+The icon appears only in sessions using the `openai` provider. A model change is reflected after the first prompt sent
+with that model.
+
+## Behavior
+
+Fast Mode applies to primary agents and sub-agents that use the ChatGPT Codex HTTP endpoint:
+
+- Protocol: `https:`
+- Hostname: `chatgpt.com`
+- Pathname: `/backend-api/codex/responses`
+
+The state is read before every matching request. Experimental WebSocket transports may bypass `globalThis.fetch` and
+are not supported.
+
+## State
+
+The state file contains only the `enabled` boolean. Its location is:
+
+- `$XDG_CONFIG_HOME/opencode/codex-fast.json`
+- `%APPDATA%\opencode\codex-fast.json` on Windows
+- `~/.config/opencode/codex-fast.json` otherwise
+
+Missing or invalid state means disabled. Writes are atomic.
+
+## Development
+
+```sh
+bun install --frozen-lockfile
+bun run --filter @mtayfur/opencode-codex-fast typecheck
+bun run --filter @mtayfur/opencode-codex-fast build
+npm pack ./packages/codex-fast --dry-run
+```

package/dist/fast-status.d.ts

@@ -0,0 +1,6 @@
+/** @jsxImportSource @opentui/solid */
+import type { Accessor } from "solid-js";
+export declare function FastStatus(props: {
+    enabled: Accessor<boolean>;
+    providerID: Accessor<string | undefined>;
+}): any;

package/dist/server.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from "@opencode-ai/plugin";
+type ReadEnabled = () => Promise<boolean>;
+export declare function installFetchInterceptor(readEnabled?: ReadEnabled): () => void;
+declare const _default: {
+    id: string;
+    server: Plugin;
+};
+export default _default;

package/dist/server.js

@@ -0,0 +1,153 @@
+// @bun
+// src/state.ts
+import { randomUUID } from "crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { basename, dirname, join } from "path";
+var STATE_FILE_NAME = "codex-fast.json";
+function resolveStatePath(options = {}) {
+  const env = options.env ?? process.env;
+  const home = options.home ?? homedir();
+  const platform = options.platform ?? process.platform;
+  const xdgConfigHome = nonEmpty(env.XDG_CONFIG_HOME);
+  const appData = nonEmpty(env.APPDATA);
+  const configRoot = xdgConfigHome ?? (platform === "win32" ? appData : undefined) ?? join(home, ".config");
+  return join(configRoot, "opencode", STATE_FILE_NAME);
+}
+async function readFastMode(filePath = resolveStatePath()) {
+  try {
+    const parsed = JSON.parse(await readFile(filePath, "utf8"));
+    return isRecord(parsed) && parsed.enabled === true;
+  } catch {
+    return false;
+  }
+}
+async function writeFastMode(enabled, filePath = resolveStatePath()) {
+  const directory = dirname(filePath);
+  const temporaryPath = join(directory, `.${basename(filePath)}.${process.pid}.${randomUUID()}.tmp`);
+  await mkdir(directory, { recursive: true });
+  try {
+    await writeFile(temporaryPath, `${JSON.stringify({ enabled }, null, 2)}
+`, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384
+    });
+    await rename(temporaryPath, filePath);
+  } catch (error) {
+    await rm(temporaryPath, { force: true }).catch(() => {
+      return;
+    });
+    throw error;
+  }
+}
+function nonEmpty(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/server.ts
+var PLUGIN_ID = "mtayfur.codex-fast";
+var FETCH_RUNTIME_SYMBOL = Symbol.for("@mtayfur/opencode-codex-fast.fetch-runtime.v1");
+function installFetchInterceptor(readEnabled = readFastMode) {
+  const host = globalThis;
+  const current = host[FETCH_RUNTIME_SYMBOL];
+  const existing = isFetchRuntime(current) ? current : undefined;
+  const runtime = existing ?? createFetchRuntime(globalThis.fetch, readEnabled);
+  if (existing) {
+    const wasInactive = runtime.references === 0;
+    runtime.references += 1;
+    if (wasInactive && globalThis.fetch === runtime.original)
+      globalThis.fetch = runtime.wrapper;
+  } else {
+    host[FETCH_RUNTIME_SYMBOL] = runtime;
+    globalThis.fetch = runtime.wrapper;
+  }
+  let disposed = false;
+  return () => {
+    if (disposed)
+      return;
+    disposed = true;
+    runtime.references = Math.max(0, runtime.references - 1);
+    if (runtime.references !== 0 || globalThis.fetch !== runtime.wrapper)
+      return;
+    globalThis.fetch = runtime.original;
+    if (host[FETCH_RUNTIME_SYMBOL] === runtime)
+      delete host[FETCH_RUNTIME_SYMBOL];
+  };
+}
+function createFetchRuntime(original, readEnabled) {
+  let runtime;
+  const wrapper = Object.assign(async (input, init) => {
+    if (runtime.references === 0 || !isCodexEndpoint(input)) {
+      return original.call(globalThis, input, init);
+    }
+    const enabled = await safelyReadEnabled(readEnabled);
+    if (!enabled || typeof init?.body !== "string") {
+      return original.call(globalThis, input, init);
+    }
+    const body = parseObject(init.body);
+    if (!body || body.service_tier === "priority") {
+      return original.call(globalThis, input, init);
+    }
+    return original.call(globalThis, input, {
+      ...init,
+      body: JSON.stringify({ ...body, service_tier: "priority" })
+    });
+  }, { preconnect: original.preconnect });
+  runtime = { original, wrapper, references: 1 };
+  return runtime;
+}
+function isCodexEndpoint(input) {
+  try {
+    const url = new URL(requestUrl(input));
+    return url.protocol === "https:" && url.hostname === "chatgpt.com" && url.pathname === "/backend-api/codex/responses";
+  } catch {
+    return false;
+  }
+}
+function requestUrl(input) {
+  if (typeof input === "string")
+    return input;
+  if (input instanceof URL)
+    return input.href;
+  return input.url;
+}
+async function safelyReadEnabled(readEnabled) {
+  try {
+    return await readEnabled();
+  } catch {
+    return false;
+  }
+}
+function parseObject(body) {
+  try {
+    const parsed = JSON.parse(body);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function isFetchRuntime(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const candidate = value;
+  return typeof candidate.original === "function" && typeof candidate.wrapper === "function" && typeof candidate.references === "number";
+}
+var server = async () => {
+  const dispose = installFetchInterceptor();
+  return {
+    dispose: async () => dispose()
+  };
+};
+var server_default = {
+  id: PLUGIN_ID,
+  server
+};
+export {
+  installFetchInterceptor,
+  server_default as default
+};

package/dist/state.d.ts

@@ -0,0 +1,8 @@
+export type StatePathOptions = {
+    env?: Readonly<Record<string, string | undefined>>;
+    home?: string;
+    platform?: NodeJS.Platform;
+};
+export declare function resolveStatePath(options?: StatePathOptions): string;
+export declare function readFastMode(filePath?: string): Promise<boolean>;
+export declare function writeFastMode(enabled: boolean, filePath?: string): Promise<void>;

package/dist/tui.d.ts

@@ -0,0 +1,6 @@
+import type { TuiPlugin } from "@opencode-ai/plugin/tui";
+declare const _default: {
+    id: string;
+    tui: TuiPlugin;
+};
+export default _default;

package/dist/tui.js

@@ -0,0 +1,170 @@
+// @bun
+// src/tui.ts
+import { watch } from "fs";
+import { mkdir as mkdir2 } from "fs/promises";
+import { basename as basename2, dirname as dirname2 } from "path";
+import { createComponent, createSignal } from "solid-js";
+
+// src/fast-status.tsx
+import { effect as _$effect } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { memo as _$memo } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+function FastStatus(props) {
+  return (() => {
+    var _el$ = _$createElement("box"), _el$2 = _$createElement("text"), _el$3 = _$createElement("span");
+    _$insertNode(_el$, _el$2);
+    _$setProp(_el$, "paddingRight", 1);
+    _$insertNode(_el$2, _el$3);
+    _$insert(_el$3, () => props.enabled() ? "\u26A1" : "\uD83D\uDC22");
+    _$effect((_$p) => _$setProp(_el$, "visible", props.providerID() === "openai", _$p));
+    return _el$;
+  })();
+}
+
+// src/state.ts
+import { randomUUID } from "crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { basename, dirname, join } from "path";
+var STATE_FILE_NAME = "codex-fast.json";
+function resolveStatePath(options = {}) {
+  const env = options.env ?? process.env;
+  const home = options.home ?? homedir();
+  const platform = options.platform ?? process.platform;
+  const xdgConfigHome = nonEmpty(env.XDG_CONFIG_HOME);
+  const appData = nonEmpty(env.APPDATA);
+  const configRoot = xdgConfigHome ?? (platform === "win32" ? appData : undefined) ?? join(home, ".config");
+  return join(configRoot, "opencode", STATE_FILE_NAME);
+}
+async function readFastMode(filePath = resolveStatePath()) {
+  try {
+    const parsed = JSON.parse(await readFile(filePath, "utf8"));
+    return isRecord(parsed) && parsed.enabled === true;
+  } catch {
+    return false;
+  }
+}
+async function writeFastMode(enabled, filePath = resolveStatePath()) {
+  const directory = dirname(filePath);
+  const temporaryPath = join(directory, `.${basename(filePath)}.${process.pid}.${randomUUID()}.tmp`);
+  await mkdir(directory, { recursive: true });
+  try {
+    await writeFile(temporaryPath, `${JSON.stringify({ enabled }, null, 2)}
+`, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384
+    });
+    await rename(temporaryPath, filePath);
+  } catch (error) {
+    await rm(temporaryPath, { force: true }).catch(() => {
+      return;
+    });
+    throw error;
+  }
+}
+function nonEmpty(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/tui.ts
+var PLUGIN_ID = "mtayfur.codex-fast";
+var TOAST_TITLE = "Codex Fast";
+function registerFastModeCommands(api, setEnabled) {
+  let toggles = Promise.resolve();
+  const disposeCommands = api.keymap.registerLayer({
+    commands: [
+      {
+        namespace: "palette",
+        name: "codex.fast.toggle",
+        title: "Toggle Codex Fast Mode",
+        desc: "Toggle priority service tier for ChatGPT Codex requests",
+        category: TOAST_TITLE,
+        slashName: "fast",
+        run: () => {
+          toggles = toggles.then(() => toggleFastMode(api, setEnabled));
+          return toggles;
+        }
+      }
+    ],
+    bindings: []
+  });
+  api.lifecycle.onDispose(disposeCommands);
+}
+async function toggleFastMode(api, setEnabled) {
+  await setFastMode(api, setEnabled, !await readFastMode());
+}
+async function setFastMode(api, setEnabled, enabled) {
+  try {
+    await writeFastMode(enabled);
+    setEnabled(enabled);
+    showStateToast(api, enabled);
+  } catch {
+    api.ui.toast({
+      title: TOAST_TITLE,
+      message: "Fast mode state could not be updated.",
+      variant: "error"
+    });
+  }
+}
+function showStateToast(api, enabled) {
+  api.ui.toast({
+    title: TOAST_TITLE,
+    message: `Fast mode is now ${enabled ? "ON" : "OFF"}.`,
+    variant: "success"
+  });
+}
+async function watchFastMode(setEnabled) {
+  const stateFile = resolveStatePath();
+  try {
+    await mkdir2(dirname2(stateFile), { recursive: true });
+    const watcher = watch(dirname2(stateFile), (_, filename) => {
+      if (filename && basename2(String(filename)) !== basename2(stateFile))
+        return;
+      readFastMode(stateFile).then(setEnabled);
+    });
+    watcher.on("error", () => watcher.close());
+    return () => watcher.close();
+  } catch {
+    return () => {
+      return;
+    };
+  }
+}
+function sessionProvider(api, sessionID) {
+  const session = api.state.session.get(sessionID);
+  if (session?.model?.providerID)
+    return session.model.providerID;
+  const message = api.state.session.messages(sessionID).findLast((item) => item.role === "user");
+  return message?.model.providerID;
+}
+var tui = async (api) => {
+  const [enabled, setEnabled] = createSignal(await readFastMode());
+  registerFastModeCommands(api, setEnabled);
+  api.lifecycle.onDispose(await watchFastMode(setEnabled));
+  api.slots.register({
+    order: 55,
+    slots: {
+      session_prompt_right(_, props) {
+        return createComponent(FastStatus, {
+          enabled,
+          providerID: () => sessionProvider(api, props.session_id)
+        });
+      }
+    }
+  });
+};
+var tui_default = {
+  id: PLUGIN_ID,
+  tui
+};
+export {
+  tui_default as default
+};

package/package.json

@@ -0,0 +1,70 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@mtayfur/opencode-codex-fast",
+  "version": "1.0.1",
+  "description": "Toggle ChatGPT Codex priority service tier from the OpenCode TUI.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mtayfur/opencode-plugins.git",
+    "directory": "packages/codex-fast"
+  },
+  "bugs": {
+    "url": "https://github.com/mtayfur/opencode-plugins/issues"
+  },
+  "homepage": "https://github.com/mtayfur/opencode-plugins/tree/main/packages/codex-fast#readme",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    },
+    "./tui": {
+      "types": "./dist/tui.d.ts",
+      "import": "./dist/tui.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bun run scripts/build.ts",
+    "setup": "bash ./install.sh",
+    "setup:uninstall": "bash ./install.sh --uninstall",
+    "typecheck": "bun x tsc -p tsconfig.json",
+    "prepack": "bun run build"
+  },
+  "dependencies": {
+    "solid-js": "^1.9.0"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.18.21 <2",
+    "@opentui/core": ">=0.5.1",
+    "@opentui/solid": ">=0.5.1"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "1.18.21",
+    "@opentui/core": "0.5.1",
+    "@opentui/keymap": "0.5.1",
+    "@opentui/solid": "0.5.1",
+    "@types/bun": "1.3.14",
+    "jsonc-parser": "^3.3.1",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "bun": ">=1.3.14",
+    "opencode": "^1.18.21"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "codex",
+    "fast-mode",
+    "priority"
+  ],
+  "packageManager": "bun@1.3.14"
+}