codex-to-im 1.0.21 → 1.0.23

package/README.md

@@ -159,7 +159,7 @@ codex-to-im stop
 - `/t 0`：切换到当前聊天的临时线程。
 - `/new`：在当前正式会话目录下新建线程。
 - `/new <路径或项目名>`：按指定目录新建线程。
-- `/mode <ask|code>`：切换运行模式。
+- `/mode <ask|code|plan>`：切换运行模式。
 - `/reasoning <1-5>`：切换思考级别。
 - `/model`：查看当前模型和可选模型。
 - `/model <模型名>`：切换当前 IM 会话模型。

package/README_EN.md

@@ -2,89 +2,62 @@
 
 [中文版](README.md)
 
-`codex-to-im` is a local bridge app that connects Codex desktop sessions to IM channels such as Feishu/Lark and Weixin.
+`codex-to-im` is a local bridge app that connects Codex to IM channels such as Feishu/Lark and Weixin.
 
-The product is no longer centered around a Codex skill. The main path is:
+Its main path is not to modify Codex itself, but to:
 
-1. Install `codex-to-im`
-2. Open the local web workbench
-3. Create one or more channel instances in the workbench
-4. Start the bridge in the background
-5. Bind real desktop Codex threads to Feishu or Weixin chats
+1. start a local web workbench and bridge on your machine
+2. create and configure one or more channel instances in the workbench
+3. bind desktop Codex sessions to IM chats
+4. continue the same conversation, switch threads, and inspect status from IM
 
-Optional: if you want Codex to know it can send local files or images back to IM without relying on bridge-injected prompt text, install the bundled `codex-to-im` skill from the workbench.
+## Core Capabilities
 
-## Project Origin
+- Shared desktop threads: bind a thread currently used in Codex Desktop to IM and continue the same conversation there.
+- IM remote control: inspect current status, switch threads, create threads, change mode, change reasoning effort, switch model, stop the current task, and inspect history from IM.
+- Local web workbench: central place for configuration, channel login, logs, session management, and binding management.
+- Feishu streaming cards: Feishu can show streaming shared-thread responses and tool progress updates.
+- Attachment send-back: send local images or files back to Feishu; if you want Codex to actively use that capability, install the bundled `codex-to-im` skill.
+- Local-first: services, config, logs, and the bridge all run on the local machine; LAN access to the web console is optional.
 
-The current codebase is a consolidated continuation of two earlier repositories:
+## Supported Channels
 
-- `Claude-to-IM`
-- `Claude-to-IM-skill`
+- Feishu: supports multiple bot instances, connectivity testing, shared threads, streaming cards, image sending, and file sending.
+- Weixin: supports multiple instances, QR login, shared threads, and text feedback.
 
-`codex-to-im` is based on those two projects and has been reworked toward a single-package local app and shared-thread workflow.
+Each channel instance can have its own alias, for example:
 
-Windows host installation guide: [docs/install-windows.md](docs/install-windows.md)
+- `Feishu Main`
+- `Feishu Backup`
+- `Weixin Work`
 
-## What It Includes
+These aliases only distinguish different chat entry points. They do not change Codex session semantics.
 
-- Local background bridge service
-- Local web workbench for configuration, testing, logs, and bindings
-- Multi-instance Feishu bot setup and connectivity testing
-- Multi-instance Weixin login flow
-- Desktop session discovery from `~/.codex/sessions`
-- Web-side binding updates for IM chats
-
-## Install
+## Quick Start
 
 ### Prerequisites
 
 - Node.js 20+
-- If you use the `codex` or `auto` runtime, complete Codex authentication under the same OS user account
-
-`codex-to-im` now ships with the required `@openai/codex-sdk` / Codex CLI platform dependency, so you do not need to install a separate global Codex CLI just to run the bridge.
+- Codex login state or API credentials available under the current OS user
 
-You still need Codex credentials to be available for the current user. Any of these is sufficient:
+Any of the following is sufficient:
 
 - a logged-in Codex Desktop App
-- an existing Codex CLI login state
+- a logged-in Codex CLI
 - `CTI_CODEX_API_KEY`, `CODEX_API_KEY`, or `OPENAI_API_KEY`
 
-If the machine does not have any Codex login state yet, the simplest path is still to install the global CLI once and log in:
-
-```bash
-npm install -g @openai/codex
-codex auth login
-```
-
-### Global install
+### Install
 
 ```bash
 npm install -g codex-to-im
 ```
 
-### Local development
-
-```bash
-npm install
-npm run build
-```
-
-Windows maintenance note:
-
-- The repo includes [patch-codex-sdk-windows-hide.js](scripts/patch-codex-sdk-windows-hide.js), which applies a conservative postinstall patch to `@openai/codex-sdk`.
-- This exists because on Windows the SDK may spawn the bundled Codex CLI without `windowsHide`, causing a black console window to flash for each IM-triggered run.
-- When upgrading `@openai/codex-sdk`, verify that the spawn block still matches; if upstream fixes this natively, remove the patch instead of carrying it forward.
-
-## Run
-
-Start the local app:
+### Start
 
 ```bash
 codex-to-im
 ```
 
-This launches the local workbench and opens it in your browser.
-
 If you only want the background bridge without opening the UI:
 
 ```bash
@@ -93,7 +66,7 @@ codex-to-im start
 
 ### Boot Autostart on Windows
 
-The bridge can be registered as a Windows boot task. The Web UI remains on-demand and is still opened manually with `codex-to-im`.
+The current implementation can register the **bridge** as a Windows boot task. The UI is still opened on demand with `codex-to-im`.
 
 ```powershell
 codex-to-im autostart status
@@ -104,161 +77,121 @@ codex-to-im autostart uninstall
 Notes:
 
 - `codex-to-im autostart install` and `codex-to-im autostart uninstall` must be run from an **elevated Administrator PowerShell / terminal**.
-- Installation prompts for the current Windows account password so the startup task can be created.
+- Installation prompts for the current Windows account password so the boot task can be created.
 - Autostart only launches the bridge; it does not open the Web UI.
-- Running `codex-to-im` manually later only starts the UI if needed and will not duplicate the bridge.
-- The current implementation uses Windows Task Scheduler and does not require WinSW, NSSM, or PM2.
-- The Web UI is read-only for autostart status; enable/disable it from the administrator terminal commands above.
+- Running `codex-to-im` manually later only starts the UI if needed and does not duplicate the bridge.
+- The current implementation uses the built-in Windows Task Scheduler and does not depend on WinSW or NSSM.
+- The web workbench only shows autostart status; enable or disable it from the administrator commands above.
 
-By default the workbench runs at:
+By default the local workbench opens at:
 
 ```text
 http://127.0.0.1:4781
 ```
 
-If that port is already occupied, the app automatically finds an available local port and prints the actual address to the terminal when starting.
-
-By default, the web workbench only accepts local access.
-
-If you want to open it from your phone or another device on the same LAN, enable `允许局域网访问 Web 控制台` in the `配置` page. When enabled:
-
-- the workbench shows detected LAN URLs
-- the workbench displays an access token
-- LAN devices see a login page before they can view or modify settings
-- you can also copy a ready-to-use login link that includes `?token=...`
-
-If you forget the current address, run:
+If you want to inspect the current address or service state:
 
 ```bash
 codex-to-im url
-```
-
-Check the current local service state:
-
-```bash
 codex-to-im status
 ```
 
-Stop the background UI and bridge:
+If you want to stop the local UI and bridge:
 
 ```bash
 codex-to-im stop
 ```
 
-## Main Workflow
-
-1. Open the workbench
-2. Create a Feishu or Weixin channel instance in the workbench
-3. Give the instance an alias such as `Feishu Main` or `Weixin Work`
-4. Save config and test connectivity
-5. Start the bridge
-6. Open the desktop sessions section
-7. Bind a Feishu or Weixin chat to the target thread
-8. Continue the same Codex thread from IM
-
-If LAN access is enabled, the easiest path is to copy the LAN login link from the local workbench and open it on your phone or another device on the same network.
-
-Useful commands:
+## Typical Workflows
 
-- `/` / `/status` shows the current session
-- `/h` / `/help` shows help
-- `/t` / `/threads` lists the most recent 10 desktop threads, `/t all` / `/threads all` lists up to 200 of them, `/t n 100` / `/threads n 100` lists the most recent 100 desktop threads (also capped at 200), and `/t 1` / `/thread 1` binds the first one
-- `/n` / `/new` creates a new thread in the current formal session directory; these IM-created threads are only guaranteed to continue inside IM and will not automatically appear in the Codex Desktop thread list
-- `/n proj1` / `/new proj1` creates a new project session under the default workspace root
-- `/m` / `/mode` shows or changes the current mode; options: `code` / `plan` / `ask`
-- `/r` / `/reasoning` shows or changes the current reasoning effort; options: `1|2|3|4|5`
-- `/his` / `/history` shows the summarized history, and `/his raw` / `/history raw` shows raw history
-- `/t 0` / `/thread 0` enters a temporary draft thread that does not pollute the main work thread
-- `1 / 2 / 3` or `/perm ...` handles permission prompts
-- N is configurable in the web workbench under the basic settings panel
-- The workbench command guide shows both short commands and compatible original commands
+### 1. Take over a desktop thread
 
-If you enable Feishu streaming response cards, the Feishu app must have the required permissions published first, at minimum:
+After creating a Feishu or Weixin channel instance in the web workbench, start the bridge.
+Then send:
 
-- `cardkit:card:write`
-- `cardkit:card:read`
-- `im:message:update`
-
-If those permissions are missing, the bridge log will usually show `99991672` with `cardkit:card:write`, and the bridge falls back to a final-result message.
-
-Also note that under the current `codex` runtime, the `Codex CLI / SDK` typically emits the assistant text only when the `agent_message` item is completed, not as token-level deltas. In practice that means Feishu "streaming cards" currently behave more like:
-
-- early `Thinking / Tool Progress` updates
-- final response text written into the card at completion
-
-So character-by-character text streaming is not guaranteed in the current implementation.
-
-If creating a new session fails with `Not inside a trusted directory`, either:
-
-- switch to a trusted project with `/new /absolute/path` or `/new proj1`, or
-- enable `Allow Codex outside trusted Git repos` in the basic settings and restart the bridge
-
-The configuration page also includes Codex runtime controls:
-
-- `Default workspace root`
-  - parent directory used for `/new proj1`
-  - falls back to `~/cx2im` when left empty, expanded for the current OS
-- `Codex filesystem permission`
-  - `read-only`, `workspace-write`, or `danger-full-access`
-  - default: `workspace-write`
-- `Codex reasoning effort`
-  - global default reasoning level
-  - can be overridden per IM session with `/reasoning`
-  - official runtime levels are `minimal`, `low`, `medium`, `high`, `xhigh`
-- IM numeric aliases are `1=minimal`, `2=low`, `3=medium`, `4=high`, `5=xhigh`
+```text
+/t
+```
 
-The primary persisted configuration now lives in:
+to list the latest 10 desktop threads. Send:
 
-- `~/.codex-to-im/config.v2.json`
+```text
+/t all
+```
 
-The legacy `config.env` file is still written as a compatibility snapshot, but it no longer fully represents multi-instance channel setup.
+to list up to 200 desktop threads. Then use:
 
-If you are using `codex-to-im` on your own development machine for real coding work, the more aggressive recommended setup is:
+```text
+/t 1
+```
 
-- set `Codex filesystem permission` to `danger-full-access`
-- set `Codex reasoning effort` to `xhigh`
+to switch to the selected thread.
 
-This is closer to a full-power `code` workflow. It fits a controlled local project, but is not a good default for unknown repositories or higher-risk environments.
+### 2. Continue from IM
 
-The channel pages also expose a “Use Markdown for bridge feedback” switch:
-- enabled by default for Feishu
-- disabled by default for WeChat
-- affects text sent through the bridge, including normal replies, shared-thread mirror messages, and system feedback such as `/h`, `/status`, and `/threads`
+Once the binding is established, send normal messages to continue the current thread.
+If the same shared thread is also used on desktop, its output is mirrored back to IM.
 
-Each channel instance can have its own alias. The alias only identifies which IM entry point handled the chat; it does not change Codex session semantics or model behavior.
+### 3. Create a new IM thread
 
-## Update
+```text
+/new
+```
 
-On Windows, `npm update -g codex-to-im` can fail with `EBUSY` if the background UI or bridge is still running from the global install directory.
+This creates a new thread under the working directory of the current formal session.
+If there is no formal session yet, or the current session is temporary, the command fails.
 
-Recommended update flow:
+You can also specify a directory explicitly:
 
-```bash
-codex-to-im stop
-npm update -g codex-to-im
-codex-to-im
+```text
+/new my-project
+/new D:\work\my-project
 ```
 
-## Repo Layout
+## Common Commands
+
+- `/` or `/status`: inspect the current session, thread, model, mode, reasoning effort, and shared-mirror status.
+- `/t`: list the latest 10 desktop threads.
+- `/t all`: list up to 200 desktop threads.
+- `/t n 100`: list the latest 100 desktop threads, capped at 200.
+- `/t 1`: switch to desktop thread 1.
+- `/t 0`: switch to the temporary thread for the current chat.
+- `/new`: create a new thread under the current formal session directory.
+- `/new <path or project name>`: create a new thread under the specified directory.
+- `/mode <ask|code|plan>`: change the runtime mode.
+- `/reasoning <1-5>`: change the reasoning effort.
+- `/model`: inspect the current model and available models.
+- `/model <model name>`: change the model for the current IM session.
+- `/history`: inspect the current thread history summary.
+- `/stop`: stop the current task.
+- `/unbind`: remove the binding between the current chat and the session.
+
+## Key Settings
+
+Common settings in the workbench include:
+
+- Default workspace root: used for relative paths such as `/new my-project`.
+- Codex filesystem permission: for example `workspace-write` or `danger-full-access`.
+- Codex reasoning effort: `1-5`.
+- Default model: chosen from the models available on the local machine.
+- Use Markdown for feedback: controls whether bridge text feedback is sent through markdown rendering.
+- Allow LAN access to the Web console: useful when opening the workbench from a phone or another device on the same LAN.
+- Channel instances: you can create multiple Feishu or Weixin bot/account entry points and assign an alias to each instance.
+
+The primary config file is:
 
-- `src/ui-server.ts` — local workbench UI and HTTP API
-- `src/service-manager.ts` — bridge and UI lifecycle management
-- `src/desktop-sessions.ts` — desktop thread discovery from Codex session files
-- `src/session-bindings.ts` — binding summaries and web-side binding updates
-- `src/lib/bridge/` — bridge runtime and IM channel routing
-- `docs/` — PRD and shared-thread design docs
+- `~/.codex-to-im/config.v2.json`
 
-## Development
+The compatibility `config.env` file is still kept as a snapshot and fallback for older tooling, but it no longer fully represents multi-instance channel configuration.
 
-```bash
-npm run typecheck
-npm run build
-```
+## Current Boundaries
 
-## Status
+- Threads created with `/new` are only guaranteed to continue inside IM; they are not guaranteed to automatically appear in the Codex Desktop thread list.
+- One session can only be bound to one chat at a time, and that exclusivity also applies across Feishu and Weixin.
+- Feishu attachments currently support images and files; videos are currently sent as files and are not guaranteed to render with native preview.
+- `/t` shows only the latest 10 desktop threads by default; `/t all` is capped at 200, and `/t n 100` is also capped at 200.
 
-Current product direction:
+## More Docs
 
-- Standalone local app first
-- Web workbench first
-- Shared Codex thread model first
+- Windows installation guide: [docs/install-windows.md](docs/install-windows.md)
+- Chinese version: [README.md](README.md)

package/SECURITY.md

@@ -4,8 +4,6 @@
 
 Credentials are stored in `~/.codex-to-im/config.env` and the local runtime data under `~/.codex-to-im/`.
 
-The app still falls back to `~/.claude-to-im/` on machines that already have legacy data, but new installs should treat `~/.codex-to-im/` as the primary home.
-
 This repository never stores secrets in source control.
 
 ## Log Redaction
@@ -30,9 +28,7 @@ If a token is rotated or suspected to be exposed:
 3. Restart the bridge from the workbench
 4. Review recent logs under `~/.codex-to-im/logs/`
 
-## Legacy Data
-
-If you upgraded from an older `claude-to-im` install, check both of these locations during diagnosis:
+## Home Directory
 
-- `~/.codex-to-im/`
-- `~/.claude-to-im/`
+Current builds read and write only `~/.codex-to-im/`.
+If a legacy home directory from older releases still exists on a machine, treat it as historical leftover data rather than an active runtime home.

package/dist/cli.mjs

@@ -15,15 +15,9 @@ import { fileURLToPath } from "node:url";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-var LEGACY_CTI_HOME = path.join(os.homedir(), ".claude-to-im");
 var DEFAULT_CTI_HOME = path.join(os.homedir(), ".codex-to-im");
 var DEFAULT_WORKSPACE_ROOT = path.join(os.homedir(), "cx2im");
-function resolveDefaultCtiHome() {
-  if (fs.existsSync(DEFAULT_CTI_HOME)) return DEFAULT_CTI_HOME;
-  if (fs.existsSync(LEGACY_CTI_HOME)) return LEGACY_CTI_HOME;
-  return DEFAULT_CTI_HOME;
-}
-var CTI_HOME = process.env.CTI_HOME || resolveDefaultCtiHome();
+var CTI_HOME = process.env.CTI_HOME || DEFAULT_CTI_HOME;
 var CONFIG_PATH = path.join(CTI_HOME, "config.env");
 var CONFIG_V2_PATH = path.join(CTI_HOME, "config.v2.json");
 function parseEnvFile(content) {
@@ -61,6 +55,7 @@ var uiStatusFile = path2.join(runtimeDir, "ui-server.json");
 var uiPort = 4781;
 var bridgeAutostartTaskName = "CodexToIMBridge";
 var bridgeAutostartLauncherFile = path2.join(runtimeDir, "bridge-autostart.ps1");
+var npmUninstallLogFile = path2.join(runtimeDir, "npm-uninstall.log");
 var WINDOWS_HIDE = process.platform === "win32" ? { windowsHide: true } : {};
 function ensureDirs() {
   fs2.mkdirSync(runtimeDir, { recursive: true });
@@ -179,6 +174,68 @@ function ensureBridgeAutostartLauncher() {
 function parsePowerShellJson(raw) {
   return JSON.parse(raw);
 }
+function buildDeferredGlobalNpmUninstallLaunch(options = {}) {
+  const packageName = options.packageName || "codex-to-im";
+  const logPath = options.logPath || npmUninstallLogFile;
+  const delayMs = options.delayMs ?? 1500;
+  const platform = options.platform || process.platform;
+  const npmCommand = options.npmCommand || (platform === "win32" ? "npm.cmd" : "npm");
+  const command = options.nodePath || process.execPath;
+  const cwd = options.cwd || os2.homedir();
+  const script = [
+    "const { spawn } = require('node:child_process');",
+    "const fs = require('node:fs');",
+    `const logPath = ${JSON.stringify(logPath)};`,
+    `const npmCommand = ${JSON.stringify(npmCommand)};`,
+    `const npmArgs = ['uninstall', '-g', ${JSON.stringify(packageName)}];`,
+    `const childCwd = ${JSON.stringify(cwd)};`,
+    `const delayMs = ${JSON.stringify(delayMs)};`,
+    "const writeLog = (message) => {",
+    "  try { fs.appendFileSync(logPath, String(message).endsWith('\\n') ? String(message) : String(message) + '\\n'); } catch {}",
+    "};",
+    "setTimeout(() => {",
+    "  let fd;",
+    "  try { fd = fs.openSync(logPath, 'a'); } catch (error) { writeLog(error); process.exit(1); return; }",
+    "  const child = spawn(npmCommand, npmArgs, { cwd: childCwd, detached: false, stdio: ['ignore', fd, fd], windowsHide: true });",
+    "  child.on('error', (error) => { writeLog(error); process.exit(1); });",
+    "  child.on('close', (code) => { process.exit(typeof code === 'number' ? code : 0); });",
+    "}, delayMs);"
+  ].join("\n");
+  return {
+    command,
+    args: ["-e", script],
+    npmCommand,
+    logPath,
+    delayMs
+  };
+}
+async function launchDeferredGlobalNpmUninstall() {
+  ensureDirs();
+  const launch = buildDeferredGlobalNpmUninstallLaunch();
+  fs2.writeFileSync(
+    launch.logPath,
+    [
+      `[${(/* @__PURE__ */ new Date()).toISOString()}] Scheduling global uninstall.`,
+      `${launch.npmCommand} uninstall -g codex-to-im`,
+      ""
+    ].join("\n"),
+    "utf-8"
+  );
+  await new Promise((resolve, reject) => {
+    const child = spawn(launch.command, launch.args, {
+      cwd: os2.homedir(),
+      detached: true,
+      stdio: "ignore",
+      ...WINDOWS_HIDE
+    });
+    child.once("error", reject);
+    child.once("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
+  return launch;
+}
 function getUiServerUrl(port = uiPort) {
   return `http://127.0.0.1:${port}`;
 }
@@ -396,6 +453,27 @@ async function uninstallBridgeAutostart() {
   }
   return await getBridgeAutostartStatus();
 }
+async function uninstallCodexToImPackage() {
+  const autostartBefore = await getBridgeAutostartStatus();
+  if (process.platform === "win32" && autostartBefore.installed) {
+    await ensureWindowsAdminSession();
+  }
+  const ui = await stopUiServer();
+  const bridge = await stopBridge();
+  const autostart = autostartBefore.installed ? await uninstallBridgeAutostart() : autostartBefore;
+  if (autostart.installed) {
+    throw new Error(`\u672A\u80FD\u5220\u9664\u5F00\u673A\u81EA\u542F\u52A8\u4EFB\u52A1 ${autostart.taskName}\uFF0C\u5DF2\u53D6\u6D88 npm \u5168\u5C40\u5378\u8F7D\u3002`);
+  }
+  const launch = await launchDeferredGlobalNpmUninstall();
+  return {
+    ui,
+    bridge,
+    autostart,
+    npmCommand: launch.npmCommand,
+    logPath: launch.logPath,
+    scheduled: true
+  };
+}
 async function ensureUiServerRunning() {
   ensureDirs();
   const current = getUiServerStatus();
@@ -573,6 +651,19 @@ async function main() {
       );
       return;
     }
+    case "uninstall": {
+      const result = await uninstallCodexToImPackage();
+      process.stdout.write(
+        [
+          `Stopped services. UI running=${result.ui.running ? "yes" : "no"}, Bridge running=${result.bridge.running ? "yes" : "no"}`,
+          result.autostart.installed ? `Bridge autostart still installed: ${result.autostart.taskName}` : "Bridge autostart removed.",
+          `Global npm uninstall scheduled via ${result.npmCommand}.`,
+          `Log: ${result.logPath}`,
+          "\u5F53\u524D\u547D\u4EE4\u9000\u51FA\u540E\uFF0C\u540E\u53F0\u4F1A\u7EE7\u7EED\u6267\u884C\u5168\u5C40\u5378\u8F7D\u3002"
+        ].join("\n") + "\n"
+      );
+      return;
+    }
     case "status": {
       const ui = getUiServerStatus();
       const bridge = getBridgeStatus();
@@ -607,6 +698,7 @@ async function main() {
           return;
         }
         case "install": {
+          await ensureWindowsAdminSession();
           const password = await promptHidden("\u8BF7\u8F93\u5165\u5F53\u524D Windows \u767B\u5F55\u5BC6\u7801\uFF08\u7528\u4E8E\u521B\u5EFA\u5F00\u673A\u542F\u52A8\u4EFB\u52A1\uFF09: ");
           const status = await installBridgeAutostart(password);
           process.stdout.write(`Bridge autostart installed. Task: ${status.taskName}
@@ -627,7 +719,7 @@ async function main() {
       }
     }
     default:
-      process.stdout.write("Usage: codex-to-im [start|open|url|stop|status|autostart]\n");
+      process.stdout.write("Usage: codex-to-im [start|open|url|stop|status|autostart|uninstall]\n");
   }
 }
 main().catch((error) => {