oh-my-im 0.1.0

package/README.md

@@ -0,0 +1,14 @@
+# oh-my-im
+
+独立版钉钉机器人到 Codex CLI 桥接程序。
+
+## 使用
+
+```bash
+npm install
+cp .env.example .env
+# 编辑 .env
+npm run dev
+```
+
+详见 [docs/development.md](docs/development.md)。

package/dist/cli.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import { runApp } from "./index.js";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+const command = process.argv[2] ?? "start";
+const here = dirname(fileURLToPath(import.meta.url));
+if (command === "--help" || command === "-h" || command === "help") {
+    console.log([
+        "oh-my-im",
+        "",
+        "Commands:",
+        "  start   start the DingTalk to Codex bridge (default)",
+        "  version print version",
+    ].join("\n"));
+    process.exit(0);
+}
+if (command === "--version" || command === "-v" || command === "version") {
+    const pkgPath = join(here, "..", "package.json");
+    const version = JSON.parse(readFileSync(pkgPath, "utf8")).version ?? "0.1.0";
+    console.log(version);
+    process.exit(0);
+}
+if (command !== "start") {
+    console.error(`Unknown command: ${command}`);
+    process.exit(1);
+}
+await runApp();

package/dist/codex.js

@@ -0,0 +1,168 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { createLogger } from "./logger.js";
+const log = createLogger("Codex");
+function parseJsonLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+}
+function extractText(item) {
+    const itemType = item.type;
+    if (itemType === "agent_message") {
+        return typeof item.message === "string"
+            ? item.message
+            : typeof item.text === "string"
+                ? item.text
+                : undefined;
+    }
+    if (itemType === "message") {
+        const content = item.content;
+        if (!Array.isArray(content))
+            return undefined;
+        return content
+            .map((part) => {
+            if (!part || typeof part !== "object")
+                return "";
+            const p = part;
+            return p.type === "output_text" && p.text ? p.text : "";
+        })
+            .filter(Boolean)
+            .join("\n");
+    }
+    return undefined;
+}
+function buildArgs(prompt, workDir, sessionId, config) {
+    const common = ["--json", "--skip-git-repo-check"];
+    if (config.codexPermissionMode === "bypass") {
+        common.push("--dangerously-bypass-approvals-and-sandbox");
+    }
+    else {
+        common.push("--full-auto");
+    }
+    return sessionId
+        ? ["exec", "resume", ...common, sessionId, "-"]
+        : ["exec", ...common, "--cd", workDir, "-"];
+}
+export function runCodex(prompt, sessionId, config) {
+    return new Promise((resolve, reject) => {
+        const start = Date.now();
+        const args = buildArgs(prompt, config.codexWorkDir, sessionId, config);
+        const env = { ...process.env };
+        if (config.codexProxy) {
+            env.HTTP_PROXY = config.codexProxy;
+            env.HTTPS_PROXY = config.codexProxy;
+            env.http_proxy = config.codexProxy;
+            env.https_proxy = config.codexProxy;
+            env.ALL_PROXY = config.codexProxy;
+            env.all_proxy = config.codexProxy;
+        }
+        log.info(`spawn ${config.codexCliPath} ${args.join(" ")}`);
+        const child = spawn(config.codexCliPath, args, {
+            cwd: config.codexWorkDir,
+            env,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let completed = false;
+        let nextSessionId = sessionId;
+        let accumulated = "";
+        let stderr = "";
+        const toolStats = {};
+        const timeout = setTimeout(() => {
+            if (completed)
+                return;
+            completed = true;
+            child.kill("SIGTERM");
+            log.warn(`timeout after ${config.cliTimeoutMs}ms`);
+            reject(new Error(`Codex CLI timeout after ${Math.round(config.cliTimeoutMs / 1000)}s`));
+        }, config.cliTimeoutMs);
+        timeout.unref();
+        child.stdin.write(prompt);
+        child.stdin.end();
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        const rl = createInterface({ input: child.stdout });
+        rl.on("line", (line) => {
+            const event = parseJsonLine(line);
+            if (!event)
+                return;
+            const payload = event.payload ?? event;
+            const type = payload.type ?? event.type;
+            if (type === "thread.started" || type === "session_meta") {
+                const id = payload.thread_id ?? payload.session_id ?? event.thread_id;
+                if (typeof id === "string" && id) {
+                    nextSessionId = id;
+                    log.debug(`session=${id}`);
+                }
+                return;
+            }
+            if (type === "turn.failed" || type === "error") {
+                const err = payload.error;
+                const message = err?.message ?? (typeof payload.message === "string" ? payload.message : "Codex failed");
+                log.error(message);
+                completed = true;
+                clearTimeout(timeout);
+                reject(new Error(message));
+                return;
+            }
+            if (event.type === "response_item" || type === "item.started" || type === "item.updated" || type === "item.completed") {
+                const item = payload.item ?? payload;
+                const itemType = item.type;
+                if (itemType === "function_call" || itemType === "custom_tool_call") {
+                    const name = typeof item.name === "string" ? item.name : "tool";
+                    toolStats[name] = (toolStats[name] ?? 0) + 1;
+                    log.debug(`tool=${name}`);
+                    return;
+                }
+                const text = extractText(item);
+                if (text)
+                    accumulated += (accumulated ? "\n\n" : "") + text;
+                return;
+            }
+            if (type === "task_complete" || type === "turn.completed") {
+                const last = payload.last_agent_message;
+                if (!accumulated && typeof last === "string")
+                    accumulated = last;
+                completed = true;
+                clearTimeout(timeout);
+                log.info(`completed in ${Date.now() - start}ms`);
+                resolve({
+                    sessionId: nextSessionId,
+                    text: accumulated.trim() || "(无输出)",
+                    toolStats,
+                    durationMs: Date.now() - start,
+                });
+            }
+        });
+        child.on("error", (err) => {
+            if (completed)
+                return;
+            completed = true;
+            clearTimeout(timeout);
+            log.error("spawn error", err);
+            reject(err);
+        });
+        child.on("close", (code) => {
+            if (completed)
+                return;
+            completed = true;
+            clearTimeout(timeout);
+            if (code && code !== 0) {
+                log.error(`exit code ${code}`);
+                reject(new Error(stderr.trim() || `Codex CLI exited with code ${code}`));
+                return;
+            }
+            log.info(`closed cleanly in ${Date.now() - start}ms`);
+            resolve({
+                sessionId: nextSessionId,
+                text: accumulated.trim() || "(无输出)",
+                toolStats,
+                durationMs: Date.now() - start,
+            });
+        });
+    });
+}

package/dist/config.js

@@ -0,0 +1,39 @@
+import "dotenv/config";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+function requireEnv(name) {
+    const value = process.env[name]?.trim();
+    if (!value)
+        throw new Error(`Missing required env: ${name}`);
+    return value;
+}
+function splitCsv(value) {
+    if (!value)
+        return [];
+    return value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function resolveWorkDir() {
+    const configured = process.env.CODEX_WORK_DIR?.trim();
+    const dir = configured ? resolve(configured) : process.cwd();
+    if (!existsSync(dir))
+        throw new Error(`CODEX_WORK_DIR does not exist: ${dir}`);
+    return dir;
+}
+export function loadConfig() {
+    const permissionMode = process.env.CODEX_PERMISSION_MODE?.trim().toLowerCase();
+    const timeoutRaw = process.env.OPEN_IM_CLI_TIMEOUT_MS?.trim();
+    const timeout = timeoutRaw ? Number.parseInt(timeoutRaw, 10) : 30 * 60 * 1000;
+    return {
+        dingtalkClientId: requireEnv("DINGTALK_CLIENT_ID"),
+        dingtalkClientSecret: requireEnv("DINGTALK_CLIENT_SECRET"),
+        codexCliPath: process.env.CODEX_CLI_PATH?.trim() || "codex",
+        codexWorkDir: resolveWorkDir(),
+        codexProxy: process.env.CODEX_PROXY?.trim() || undefined,
+        codexPermissionMode: permissionMode === "bypass" ? "bypass" : undefined,
+        allowedUserIds: splitCsv(process.env.ALLOWED_USER_IDS),
+        cliTimeoutMs: Number.isFinite(timeout) && timeout > 0 ? timeout : 30 * 60 * 1000,
+    };
+}

package/dist/dingtalk.js

@@ -0,0 +1,112 @@
+import { DWClient, TOPIC_ROBOT } from "dingtalk-stream";
+import { createLogger } from "./logger.js";
+const log = createLogger("DingTalk");
+export class DingTalkBot {
+    config;
+    client = null;
+    webhooks = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    async start(onMessage) {
+        this.client = new DWClient({
+            clientId: this.config.dingtalkClientId,
+            clientSecret: this.config.dingtalkClientSecret,
+            keepAlive: true,
+            debug: false,
+        });
+        this.client.registerCallbackListener(TOPIC_ROBOT, async (data) => {
+            const message = this.parseMessage(data);
+            if (!message) {
+                log.warn("Ignored invalid DingTalk payload");
+                this.ack(data.headers.messageId, { ignored: true });
+                return;
+            }
+            try {
+                await onMessage(message);
+                this.ack(message.callbackId, { handled: true });
+            }
+            catch (err) {
+                console.error("[DingTalk] message handling failed:", err);
+                this.ack(message.callbackId, { error: String(err) });
+            }
+        });
+        await this.client.connect();
+        console.log("[DingTalk] stream connected");
+    }
+    stop() {
+        this.client?.disconnect();
+        this.client = null;
+        this.webhooks.clear();
+    }
+    async sendText(conversationId, content) {
+        const webhook = this.webhooks.get(conversationId);
+        if (!webhook)
+            throw new Error(`No sessionWebhook for conversation: ${conversationId}`);
+        const accessToken = await this.getAccessToken();
+        const res = await fetch(webhook, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-acs-dingtalk-access-token": accessToken,
+            },
+            body: JSON.stringify({
+                msgtype: "text",
+                text: { content },
+            }),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`DingTalk reply failed: ${res.status} ${text}`);
+        }
+        log.debug(`Sent DingTalk text to conversation=${conversationId}`);
+    }
+    parseMessage(data) {
+        let payload;
+        try {
+            payload = JSON.parse(data.data);
+        }
+        catch {
+            log.warn("Failed to parse DingTalk payload");
+            return null;
+        }
+        const conversationId = payload.conversationId;
+        const sessionWebhook = payload.sessionWebhook;
+        const senderStaffId = payload.senderStaffId;
+        const senderId = payload.senderId;
+        const msgtype = payload.msgtype;
+        const textPayload = payload.text;
+        const text = msgtype === "text" ? textPayload?.content?.trim() ?? "" : "";
+        if (typeof conversationId !== "string" ||
+            typeof sessionWebhook !== "string" ||
+            typeof senderId !== "string" ||
+            typeof msgtype !== "string") {
+            return null;
+        }
+        this.webhooks.set(conversationId, sessionWebhook);
+        return {
+            callbackId: data.headers.messageId,
+            conversationId,
+            sessionWebhook,
+            senderId,
+            senderStaffId: typeof senderStaffId === "string" ? senderStaffId : undefined,
+            senderNick: typeof payload.senderNick === "string" ? payload.senderNick : undefined,
+            text,
+            msgtype,
+        };
+    }
+    async getAccessToken() {
+        if (!this.client)
+            throw new Error("DingTalk client is not initialized");
+        return this.client.getAccessToken();
+    }
+    ack(messageId, result) {
+        try {
+            this.client?.socketCallBackResponse(messageId, result);
+        }
+        catch (err) {
+            log.warn("DingTalk ack failed:", err);
+        }
+    }
+}

package/dist/index.js

@@ -0,0 +1,103 @@
+import { loadConfig } from "./config.js";
+import { runCodex } from "./codex.js";
+import { DingTalkBot } from "./dingtalk.js";
+import { createLogger } from "./logger.js";
+const log = createLogger("Main");
+function getState(conversations, conversationId) {
+    const existing = conversations.get(conversationId);
+    if (existing)
+        return existing;
+    const created = { busy: false };
+    conversations.set(conversationId, created);
+    return created;
+}
+function isAllowed(message, allowedUserIds) {
+    if (allowedUserIds.length === 0)
+        return true;
+    return allowedUserIds.includes(message.senderStaffId ?? message.senderId);
+}
+function formatStats(stats) {
+    const entries = Object.entries(stats);
+    if (entries.length === 0)
+        return "";
+    return entries.map(([name, count]) => `${name} x${count}`).join(", ");
+}
+async function handleCommand(bot, config, conversations, message, text) {
+    const state = getState(conversations, message.conversationId);
+    if (text === "/help") {
+        await bot.sendText(message.conversationId, [
+            "oh-my-im commands:",
+            "/help - 查看帮助",
+            "/status - 查看运行状态",
+            "/new - 清空当前会话的 Codex session",
+        ].join("\n"));
+        return true;
+    }
+    if (text === "/status") {
+        await bot.sendText(message.conversationId, [
+            "oh-my-im status:",
+            `Codex: ${config.codexCliPath}`,
+            `WorkDir: ${config.codexWorkDir}`,
+            `Current session: ${state.sessionId ?? "new"}`,
+            `Known conversations: ${conversations.size}`,
+        ].join("\n"));
+        return true;
+    }
+    if (text === "/new") {
+        state.sessionId = undefined;
+        await bot.sendText(message.conversationId, "已清空当前会话的 Codex session。");
+        return true;
+    }
+    return false;
+}
+export async function runApp() {
+    const config = loadConfig();
+    const bot = new DingTalkBot(config);
+    const conversations = new Map();
+    async function handleMessage(message) {
+        if (!isAllowed(message, config.allowedUserIds)) {
+            await bot.sendText(message.conversationId, `抱歉，您没有访问权限。\n您的 ID: ${message.senderStaffId ?? message.senderId}`);
+            return;
+        }
+        if (message.msgtype !== "text") {
+            await bot.sendText(message.conversationId, `暂不支持 ${message.msgtype} 消息，请发送文本。`);
+            return;
+        }
+        const text = message.text.trim();
+        if (!text)
+            return;
+        if (await handleCommand(bot, config, conversations, message, text))
+            return;
+        const state = getState(conversations, message.conversationId);
+        if (state.busy) {
+            await bot.sendText(message.conversationId, "当前会话已有 Codex 任务在执行，请稍后再发。");
+            return;
+        }
+        state.busy = true;
+        await bot.sendText(message.conversationId, "Codex 正在处理...");
+        try {
+            const result = await runCodex(text, state.sessionId, config);
+            state.sessionId = result.sessionId ?? state.sessionId;
+            const stats = formatStats(result.toolStats);
+            const note = [`耗时 ${(result.durationMs / 1000).toFixed(1)}s`, stats].filter(Boolean).join(" | ");
+            await bot.sendText(message.conversationId, `${result.text}\n\n${note}`);
+        }
+        catch (err) {
+            log.error("Codex execution failed", err);
+            await bot.sendText(message.conversationId, `Codex 执行失败：${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            state.busy = false;
+        }
+    }
+    process.once("SIGINT", () => {
+        bot.stop();
+        process.exit(0);
+    });
+    process.once("SIGTERM", () => {
+        bot.stop();
+        process.exit(0);
+    });
+    await bot.start(handleMessage);
+    log.info(`ready workDir=${config.codexWorkDir} codex=${config.codexCliPath}`);
+}

package/dist/logger.js

@@ -0,0 +1,34 @@
+const LEVEL_WEIGHT = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+};
+function parseLevel(value) {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "debug" || normalized === "info" || normalized === "warn" || normalized === "error") {
+        return normalized;
+    }
+    return "info";
+}
+export function createLogger(scope) {
+    const minLevel = parseLevel(process.env.LOG_LEVEL);
+    function emit(level, message, ...args) {
+        if (LEVEL_WEIGHT[level] < LEVEL_WEIGHT[minLevel])
+            return;
+        const prefix = `[${new Date().toISOString()}] [${scope}] [${level.toUpperCase()}]`;
+        const line = `${prefix} ${message}`;
+        if (level === "error")
+            console.error(line, ...args);
+        else if (level === "warn")
+            console.warn(line, ...args);
+        else
+            console.log(line, ...args);
+    }
+    return {
+        debug: (message, ...args) => emit("debug", message, ...args),
+        info: (message, ...args) => emit("info", message, ...args),
+        warn: (message, ...args) => emit("warn", message, ...args),
+        error: (message, ...args) => emit("error", message, ...args),
+    };
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "oh-my-im",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "bin": {
+    "oh-my-im": "dist/cli.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:duzhenxun/oh-my-im.git"
+  },
+  "homepage": "https://github.com/duzhenxun/oh-my-im#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsc",
+    "start": "node dist/cli.js",
+    "help": "node dist/cli.js help"
+  },
+  "dependencies": {
+    "dingtalk-stream": "^2.1.4",
+    "dotenv": "^17.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}