dsh-codex-oauth 0.1.1 → 0.2.0

package/README.md

@@ -2,47 +2,68 @@
 
 [English](README.md) | [中文](README.zh.md)
 
-DSH adapter that uses the same OpenAI Codex OAuth credential as Pi:
-`~/.pi/agent/auth.json` → `openai-codex`.
+A standalone [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) plugin for using ChatGPT Plus/Pro Codex models through OpenAI's Codex OAuth flow. Pi is **not** required.
 
-It uses Pi's installed `@earendil-works/pi-ai` Codex provider and DSH's public
-`dsh-llm-pi-ai` adapter, including the official Codex Responses transport, images,
-tool calls, reasoning replay, compaction, and OAuth refresh. It does not copy the
-token into an API-key environment variable.
+It uses the official `openaiCodexProvider` from `@earendil-works/pi-ai` and DSH's public `dsh-llm-pi-ai` adapter. It supports streaming, tool calls, reasoning, images, replay, compaction, automatic token refresh, and the Codex model catalog.
+
+This is the ChatGPT Codex backend, not a general OpenAI Platform API-key adapter.
 
 ## Install
 
 ```bash
 dsh plugin --profile web add dsh-codex-oauth
+dsh web
 ```
 
-For a manual profile install, add the package to the profile and include this
-entry in its `cordis.patch.yml`:
+For an `npx` installation:
 
-```yaml
-- insert:
-    - id: llm-codex-oauth
-      name: dsh-codex-oauth
+```bash
+npx @deepseek-ai/dsh plugin --profile web add dsh-codex-oauth
+npx @deepseek-ai/dsh web
 ```
 
-The profile must also include the normal `llm` service. Restart:
+## Sign in
+
+The plugin owns its own credential file and login flow. No Pi installation or token copying is needed.
+
+### CLI
 
 ```bash
-npx @deepseek-ai/dsh web
+dsh plugin --profile web exec dsh-openai-codex login
+# headless machines:
+dsh plugin --profile web exec dsh-openai-codex login --device-code
+
+dsh plugin --profile web exec dsh-openai-codex status
+dsh plugin --profile web exec dsh-openai-codex logout
 ```
 
-Then select provider `openai-codex` in the model picker.
+The browser login opens OpenAI's authorization page and completes through a localhost callback. `--device-code` is the fallback for machines without a usable browser.
+
+After signing in, choose `openai-codex` in the DSH model picker.
+
+### Credentials
+
+Credentials are stored at:
+
+```text
+$DSH_HOME/.openai-codex-auth.json
+```
+
+The default is `~/.dsh/.openai-codex-auth.json`. The file is written atomically with owner-only permissions, and refresh/login/logout operations use a cross-process file lock. The plugin never reads or modifies `~/.pi/agent/auth.json` or `~/.codex/auth.json`.
+
+## Development
+
+```bash
+npm test
+```
 
-## Scope
+The test requires the DSH and `pi-ai` peer dependencies supplied by a DSH profile.
 
-The plugin delegates message conversion, streaming, image attachments, tool calls,
-reasoning replay, and compaction to DSH's public `dsh-llm-pi-ai` adapter. It only
-bridges the credential store to Pi's existing OAuth document.
+## Limitations
 
-The plugin reads/writes `~/.pi/agent/auth.json` and never prints token values.
-Because Pi and DSH do not share a cross-application lock, avoid starting both at the
-same time while an OAuth refresh may occur; a future version may use a separate DSH
-credential file and its own login flow to remove that race.
+- ChatGPT plan eligibility, model access, quotas, and backend behavior are controlled by OpenAI and may change.
+- Codex endpoints are not public OpenAI Platform API endpoints.
+- Filesystem, shell, MCP, permissions, attachments, and other DSH capabilities come from the active profile.
 
 ## License
 

package/README.zh.md

@@ -2,71 +2,67 @@
 
 [English](README.md) | 中文
 
-让 [DeepSeek Harness（dsh）](https://github.com/deepseek-ai/deepseek-harness)
-复用 Pi 已登录的 ChatGPT Plus/Pro Codex OAuth，在不使用 OpenAI Platform API Key 的情况下调用 `openai-codex` 模型。
+一个独立的 [DeepSeek Harness（dsh）](https://github.com/deepseek-ai/deepseek-harness) 插件，通过 OpenAI Codex OAuth 使用 ChatGPT Plus/Pro 订阅模型。
 
-本插件不是普通的 OpenAI API 适配器，也不会把 ChatGPT 订阅变成通用 API 凭据。它使用 Pi 的 Codex provider、官方 Codex Responses 传输和 DSH 公共的 `dsh-llm-pi-ai` 适配器。
+**不需要安装 Pi。** 插件使用 `@earendil-works/pi-ai` 提供的 Codex provider，以及 DSH 公共的 `dsh-llm-pi-ai` 适配器，支持流式输出、工具调用、推理、图片、replay、上下文压缩、OAuth 自动刷新和 Codex 模型目录。
 
-## 功能
-
-- 复用 `~/.pi/agent/auth.json` 中的 `openai-codex` OAuth 凭据；
-- access token 过期时自动使用 refresh token 更新；
-- 使用 Pi 同款 Codex 模型目录；
-- 支持流式输出、工具调用、推理、图片输入、replay 和上下文压缩；
-- 不读取或打印 API Key，也不会把 token 放进环境变量。
+这是 ChatGPT Codex 后端接入，不是普通的 OpenAI Platform API Key 适配器。
 
 ## 安装
 
-将插件安装到 dsh 的 `web` profile：
-
 ```bash
 dsh plugin --profile web add dsh-codex-oauth
 dsh web
 ```
 
-如果使用的是 `npx` 版本：
+如果使用 `npx`：
 
 ```bash
 npx @deepseek-ai/dsh plugin --profile web add dsh-codex-oauth
 npx @deepseek-ai/dsh web
 ```
 
-启动后，在模型选择器中选择：
+## 登录
 
-```text
-Provider: openai-codex
-```
+插件拥有独立的 OAuth 登录流程和凭据文件。新用户不需要安装 Pi，也不需要复制任何 token。
 
-也可以手动把下面的条目加入 profile 的 `cordis.patch.yml`：
+### 命令行登录
 
-```yaml
-- insert:
-    - id: llm-codex-oauth
-      name: dsh-codex-oauth
+```bash
+dsh plugin --profile web exec dsh-openai-codex login
 ```
 
-## 前置条件
+无图形浏览器的机器：
 
-Pi 必须已经完成 OpenAI Codex 登录，并且存在：
+```bash
+dsh plugin --profile web exec dsh-openai-codex login --device-code
+```
 
-```text
-~/.pi/agent/auth.json
+查看状态和退出登录：
+
+```bash
+dsh plugin --profile web exec dsh-openai-codex status
+dsh plugin --profile web exec dsh-openai-codex logout
 ```
 
-文件中应有 `openai-codex` OAuth 条目。插件不会替用户登录，也不会要求复制 token。
+浏览器登录会打开 OpenAI 授权页面，并通过 localhost 回调完成。登录后，在 DSH 模型选择器中选择 `openai-codex`。
 
-## 凭据与并发注意事项
+### 凭据存储
 
-插件只使用 Pi 的现有凭据文件，并会在 OAuth 刷新后写回该文件。Pi 与 DSH 并不共享同一个跨应用锁，因此在 token 可能刷新时，不建议同时运行 Pi 和 DSH。
+凭据默认存储在：
 
-卸载插件不会删除 Pi 的登录凭据。若要退出登录，请通过 Pi 自己的 `/logout` 完成。
+```text
+~/.dsh/.openai-codex-auth.json
+```
 
-## 限制
+也可以通过 `DSH_HOME` 改变目录。文件采用原子写入、仅所有者可读写（`0600`），登录、刷新和退出登录使用跨进程文件锁。
 
-- ChatGPT 订阅权限、模型目录、配额和 Codex 后端行为由 OpenAI 控制，可能变化；
-- 插件依赖 DSH 的公共 `dsh-llm-pi-ai` 适配器，需与当前 DSH 版本兼容；
-- 这是 Codex 后端接入，不是公开的 OpenAI Platform API；
-- DSH 的其他能力（文件系统、Shell、MCP、权限、附件等）仍由当前 profile 提供。
+插件**不会**读取或修改：
+
+```text
+~/.pi/agent/auth.json
+~/.codex/auth.json
+```
 
 ## 开发与测试
 
@@ -74,7 +70,13 @@ Pi 必须已经完成 OpenAI Codex 登录，并且存在：
 npm test
 ```
 
-测试需要 DSH 和 Pi 的依赖已经安装或由 DSH profile 提供。
+测试需要当前 DSH profile 提供 DSH 和 `pi-ai` peer dependencies。
+
+## 限制
+
+- ChatGPT 套餐资格、模型权限、配额和后端行为由 OpenAI 控制，可能变化；
+- Codex 端点不是公开的 OpenAI Platform API 端点；
+- 文件系统、Shell、MCP、权限、附件等能力仍由当前 DSH profile 提供。
 
 ## 许可证
 

package/SPEC.md

@@ -0,0 +1,73 @@
+# dsh-codex-oauth 独立登录规格
+
+## 目标
+
+让新用户只安装 DSH 插件即可登录并使用 ChatGPT Codex 订阅，不要求安装 Pi，也不读取或修改 `~/.pi/agent/auth.json`。
+
+## 用户流程
+
+### CLI（第一版）
+
+1. 安装插件并重启 DSH；
+2. 执行 `dsh-openai-codex login`；
+3. 插件打开 OpenAI OAuth 授权页；
+4. 用户在浏览器中批准；
+5. localhost 回调完成登录；
+6. DSH 使用 `openai-codex` 模型。
+
+无图形浏览器时使用 `login --device-code`。
+
+### Web（后续）
+
+后续可在 DSH 设置页增加登录按钮；第一版不承诺 Web 登录入口。
+
+### 命令
+
+提供：
+
+```bash
+dsh plugin --profile web exec dsh-openai-codex login
+dsh plugin --profile web exec dsh-openai-codex status
+dsh plugin --profile web exec dsh-openai-codex logout
+```
+
+无图形浏览器时提供 `login --device-code`。
+
+## 凭据
+
+- 存储位置：`$DSH_HOME/.openai-codex-auth.json`，默认 `~/.dsh/.openai-codex-auth.json`；
+- 格式：版本化 JSON，字段为 `version` 和 `credential`；
+- `credential` 保留 `type`, `access`, `refresh`, `expires`, `accountId`；
+- 原子写入，文件权限 `0600`，目录权限 `0700`；
+- 刷新、登录、登出使用跨进程文件锁；
+- 不读取、复制、修改 `~/.pi/agent/auth.json` 或 `~/.codex/auth.json`。
+
+## API 与模型
+
+- 使用 `@earendil-works/pi-ai` 的 `openaiCodexProvider`；
+- 使用 DSH 公共 `PiAiAdapter`；
+- 使用 Codex Responses endpoint，不伪装成普通 OpenAI Platform API；
+- 保留流式输出、工具调用、推理、图片、replay 和 compaction；
+- 新建 agent 默认模型沿用 Codex catalog 中的可用模型，不硬编码不存在的模型。
+
+## 安全边界
+
+- OAuth 密码、授权码、access token、refresh token 不进入日志、session、Git 或错误信息；
+- Web 登录回调只接受 localhost 同源请求，并返回 `no-store`；
+- 插件移除不自动删除凭据；登出必须由用户明确执行；
+- 不实现普通 OpenAI API Key 兼容层。
+
+## 明确不做
+
+- 不依赖 Pi；
+- 不导入 Pi 的 auth 文件；
+- 不修改 DSH 源码；
+- 第一版不加入独立搜索、图片生成和额度面板；这些属于后续功能。
+
+## 验收标准
+
+- 干净环境安装插件后，`status` 返回 signed out；
+- CLI OAuth 登录后，`status` 返回 signed in，且不打印 token；
+- access token 过期后请求会自动刷新并持久化；
+- 删除 Pi auth 文件不影响 DSH 插件；
+- Web profile 能加载 `openai-codex`，且公共 DSH adapter 的图片、工具和 replay 测试继续通过。

package/bin/dsh-openai-codex.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+import { authPath, login, logout, status } from "../lib/auth.js";
+
+function openBrowser(raw) {
+  const url = new URL(raw);
+  if (url.protocol !== "https:") throw new Error("Refusing to open a non-HTTPS OAuth URL");
+  const command = process.platform === "darwin" ? ["open", url.href] : process.platform === "win32" ? ["rundll32.exe", "url.dll,FileProtocolHandler", url.href] : ["xdg-open", url.href];
+  const child = spawn(command[0], command.slice(1), { detached: true, stdio: "ignore", windowsHide: true });
+  child.on("error", () => {}); child.unref();
+}
+function safeMessage(error) {
+  return String(error?.message ?? error)
+    .replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/gu, "[redacted token]")
+    .replace(/(\b(?:code|token|refresh_token|access_token)=)[^&\s]+/giu, "$1[redacted]");
+}
+function help() {
+  console.log("Usage: dsh-openai-codex <login|logout|status> [--device-code]");
+}
+
+const [action, ...flags] = process.argv.slice(2);
+if (!action || action === "--help" || action === "-h") { help(); process.exit(0); }
+if (!["login", "logout", "status"].includes(action) || flags.some((flag) => flag !== "--device-code") || (action !== "login" && flags.length)) { help(); process.exit(1); }
+try {
+  if (action === "status") {
+    const value = await status();
+    if (!value.authenticated) { console.log("OpenAI Codex for dsh: signed out"); process.exitCode = 1; }
+    else console.log(`OpenAI Codex for dsh: signed in; refresh is automatic`);
+  } else if (action === "logout") {
+    await logout(); console.log(`OpenAI Codex for dsh: signed out; removed ${authPath()}`);
+  } else {
+    const readline = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+      await login(undefined, {
+        prompt: async (prompt) => {
+          if (prompt.type === "select") return flags.includes("--device-code") ? "device_code" : "browser";
+          return readline.question(`${prompt.message}: `, { signal: prompt.signal });
+        },
+        notify: (event) => {
+          if (event.type === "auth_url") { console.log(`Open this URL to sign in:\n${event.url}`); openBrowser(event.url); }
+          else if (event.type === "device_code") { console.log(`Open ${event.verificationUri} and enter ${event.userCode}`); openBrowser(event.verificationUri); }
+          else if (event.message) console.log(event.message);
+        },
+      });
+    } finally { readline.close(); }
+    console.log(`OpenAI Codex for dsh: signed in; credentials saved to ${authPath()}`);
+  }
+} catch (error) {
+  console.error(`dsh-openai-codex: ${safeMessage(error)}`);
+  process.exitCode = 1;
+}

package/lib/auth.js

@@ -0,0 +1,21 @@
+import { createModels } from "@earendil-works/pi-ai";
+import { openaiCodexProvider } from "@earendil-works/pi-ai/providers/openai-codex";
+import { CodexCredentialStore, OPENAI_CODEX_PROVIDER, authPath } from "./store.js";
+
+function models(store) {
+  const value = createModels({ credentials: store });
+  value.setProvider(openaiCodexProvider());
+  return value;
+}
+
+export async function login(store = new CodexCredentialStore(), interaction) {
+  await models(store).login(OPENAI_CODEX_PROVIDER, "oauth", interaction);
+}
+export async function logout(store = new CodexCredentialStore()) {
+  await store.delete(OPENAI_CODEX_PROVIDER);
+}
+export async function status(store = new CodexCredentialStore()) {
+  const credential = await store.read(OPENAI_CODEX_PROVIDER);
+  return credential?.type === "oauth" ? { authenticated: true, expiresAt: new Date(credential.expires) } : { authenticated: false };
+}
+export { authPath };

package/lib/index.js

@@ -1,13 +1,14 @@
 import { createCodexAdapter } from "./adapter.js";
-import { PiCodexCredentialStore, OPENAI_CODEX_PROVIDER, PI_AUTH_FILE } from "./store.js";
+import { CodexCredentialStore, OPENAI_CODEX_PROVIDER, authPath } from "./store.js";
+export { login, logout, status } from "./auth.js";
 
 export const name = "llm-codex-oauth";
 export const inject = ["llm"];
 
-export { OPENAI_CODEX_PROVIDER, PI_AUTH_FILE, PiCodexCredentialStore, createCodexAdapter };
+export { OPENAI_CODEX_PROVIDER, CodexCredentialStore, authPath, createCodexAdapter };
 
 export function apply(ctx) {
-  const credentials = new PiCodexCredentialStore();
+  const credentials = new CodexCredentialStore();
   ctx.llm.registerAdapter(
     [OPENAI_CODEX_PROVIDER],
     createCodexAdapter(credentials, () => ctx.get?.("attachments")),

package/lib/store.js

@@ -1,65 +1,60 @@
 import { mkdir, readFile, stat } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { withFileLock, writeFileAtomic } from "@deepseek-ai/dsh-atomic-write";
 
 export const OPENAI_CODEX_PROVIDER = "openai-codex";
-export const PI_AUTH_FILE = join(homedir(), ".pi", "agent", "auth.json");
-
-function clone(value) {
-  return value === undefined ? undefined : structuredClone(value);
+export const OPENAI_CODEX_AUTH_FILE = ".openai-codex-auth.json";
+export function authPath(home = process.env.DSH_HOME || join(homedir(), ".dsh")) {
+  return resolve(join(home, OPENAI_CODEX_AUTH_FILE));
 }
 
+function clone(value) { return value === undefined ? undefined : structuredClone(value); }
 async function ownerOnly(filename) {
   if (process.platform === "win32") return;
   try {
     if ((await stat(filename)).mode & 0o077) throw new Error(`${filename} must be owner-only (chmod 600)`);
-  } catch (error) {
-    if (error?.code !== "ENOENT") throw error;
-  }
+  } catch (error) { if (error?.code !== "ENOENT") throw error; }
+}
+function parse(text, filename) {
+  let value;
+  try { value = JSON.parse(text); } catch { throw new Error(`${filename} is not valid JSON`); }
+  const credential = value?.credential;
+  if (value?.version !== 1 || !credential || credential.type !== "oauth") throw new Error(`${filename} has an invalid auth format`);
+  for (const key of ["access", "refresh", "accountId"])
+    if (typeof credential[key] !== "string" || credential[key].length === 0) throw new Error(`${filename} credential is invalid`);
+  if (!Number.isFinite(credential.expires) || credential.expires <= 0) throw new Error(`${filename} expiry is invalid`);
+  return clone(credential);
 }
 
-export class PiCodexCredentialStore {
-  constructor(filename = PI_AUTH_FILE) { this.filename = filename; }
-
-  async readAll() {
+export class CodexCredentialStore {
+  constructor(filename = authPath()) { this.filename = filename; }
+  async readCurrent() {
     await ownerOnly(this.filename);
-    try { return JSON.parse(await readFile(this.filename, "utf8")); }
-    catch (error) { if (error?.code === "ENOENT") return {}; throw error; }
-  }
-
-  async read(providerId) {
-    if (providerId !== OPENAI_CODEX_PROVIDER) return undefined;
-    const value = (await this.readAll())[providerId];
-    return value?.type === "oauth" ? clone(value) : undefined;
-  }
-
-  async list() {
-    return (await this.read(OPENAI_CODEX_PROVIDER) === undefined)
-      ? [] : [{ providerId: OPENAI_CODEX_PROVIDER, type: "oauth" }];
+    try { return parse(await readFile(this.filename, "utf8"), this.filename); }
+    catch (error) { if (error?.code === "ENOENT") return undefined; throw error; }
   }
-
+  async read(providerId) { return providerId === OPENAI_CODEX_PROVIDER ? this.readCurrent() : undefined; }
+  async list() { return (await this.readCurrent()) ? [{ providerId: OPENAI_CODEX_PROVIDER, type: "oauth" }] : []; }
   async modify(providerId, fn) {
     if (providerId !== OPENAI_CODEX_PROVIDER) throw new Error(`credential store does not own ${providerId}`);
     await mkdir(dirname(this.filename), { recursive: true, mode: 0o700 });
     return withFileLock(this.filename, async () => {
-      const auth = await this.readAll();
-      const current = auth[providerId];
+      const current = await this.readCurrent();
       const next = await fn(clone(current));
-      if (next === undefined) return clone(current);
-      auth[providerId] = next;
-      await writeFileAtomic(this.filename, `${JSON.stringify(auth, null, 2)}\n`, { mode: 0o600, dirMode: 0o700 });
+      if (next === undefined) return current;
+      const document = { version: 1, credential: next };
+      parse(JSON.stringify(document), this.filename);
+      await writeFileAtomic(this.filename, `${JSON.stringify(document, null, 2)}\n`, { mode: 0o600, dirMode: 0o700 });
       return clone(next);
     });
   }
-
   async delete(providerId) {
     if (providerId !== OPENAI_CODEX_PROVIDER) return;
     await mkdir(dirname(this.filename), { recursive: true, mode: 0o700 });
     await withFileLock(this.filename, async () => {
-      const auth = await this.readAll();
-      delete auth[providerId];
-      await writeFileAtomic(this.filename, `${JSON.stringify(auth, null, 2)}\n`, { mode: 0o600, dirMode: 0o700 });
+      const { rm } = await import("node:fs/promises");
+      await rm(this.filename, { force: true });
     });
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-codex-oauth",
-  "version": "0.1.1",
-  "description": "Use Pi's OpenAI Codex OAuth subscription in DeepSeek Harness",
+  "version": "0.2.0",
+  "description": "Use a ChatGPT Codex subscription in DeepSeek Harness through standalone OAuth",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/eons2long/dsh-codex-oauth.git"
@@ -15,8 +15,9 @@
   "scripts": { "test": "node test/smoke.mjs" },
   "type": "module",
   "main": "lib/index.js",
+  "bin": { "dsh-openai-codex": "bin/dsh-openai-codex.js" },
   "exports": { ".": "./lib/index.js" },
-  "files": ["lib", "cordis.patch.yml", "README.md", "README.zh.md", "LICENSE"],
+  "files": ["lib", "bin", "cordis.patch.yml", "README.md", "README.zh.md", "SPEC.md", "LICENSE"],
   "dsh": { "bundle": { "patch": "./cordis.patch.yml" } },
   "peerDependencies": {
     "@earendil-works/pi-ai": "^0.84.1",