ohmyvibe 0.1.0

package/.env.example

@@ -0,0 +1,2 @@
+MANAGEMENT_SERVER_URL=http://localhost:3310
+DAEMON_NAME=ohmyvibe-local

package/README.md

@@ -0,0 +1,140 @@
+# OhMyVibe
+
+这是一个 `VibeCoding` 控制台：
+
+- `daemon -> control server <- browser` 架构（daemon 主动连接管理端）
+- 每个会话独立启动一个 `codex app-server` 子进程
+- daemon 统一管理多会话、消息发送、中断、状态同步
+- 额外提供一个标准 `ACP` bridge 入口，方便后续给编辑器或其他 ACP client 接入
+- 应用侧 session 本地持久化到 `data/sessions.json`
+- 支持从 Codex 历史 `~/.codex/sessions` 恢复会话，并绑定到原始 Codex thread
+- Web 控制台为独立 React + shadcn 风格项目，浏览器只连接管理端
+
+## 为什么这样做
+
+当前官方能力里，`Codex CLI` 暴露的是 `app-server` 自动化接口，而不是原生 `ACP agent`。因此这个 MVP 采用两层桥接：
+
+1. 南向：daemon 通过 `codex app-server --listen stdio://` 控制 Codex
+2. 北向：daemon 自己暴露 `ACP` 兼容 agent，供外部 ACP client 使用
+
+这能保证现在就能正确接入 Codex，同时不把上层协议绑死在 Codex 私有接口上。
+
+## 运行
+
+要求：
+
+- Node.js 22+
+- 本机已安装并可运行 `codex`
+- `codex` 已完成登录
+
+1. 启动 Web 管理端（API + 页面）：
+
+```bash
+npm install
+npm --prefix web install
+npm --prefix web run build
+npm run web:server
+```
+
+默认监听 `http://localhost:3310`
+默认读取 `web/.env`
+
+2. 在被控机器启动 daemon，并主动连接管理端：
+
+```bash
+npm run daemon
+```
+
+daemon 不再暴露本地 HTTP API，浏览器也不应直接连接 daemon。
+默认读取根目录 `.env`
+
+可选环境变量：
+
+- `DAEMON_ID`：固定 daemon 标识
+- `DAEMON_NAME`：展示名称
+
+3. 浏览器访问管理端页面：
+
+```bash
+http://your-control-host:3310
+```
+
+开发模式（前端热更新）：
+
+```bash
+npm run web:dev
+```
+
+启动 ACP bridge：
+
+```bash
+npm run acp
+```
+
+## 全局安装 daemon
+
+如果你要把 daemon 作为全局命令安装，当前包已经支持：
+
+```bash
+npm install -g ohmyvibe
+```
+
+然后直接启动：
+
+```bash
+ohmyvibe --management-server-url http://localhost:3310
+```
+
+也可以显式指定 daemon 名称或 id：
+
+```bash
+ohmyvibe daemon \
+  --management-server-url http://localhost:3310 \
+  --daemon-name ohmyvibe-local \
+  --daemon-id local-1
+```
+
+如果仍然想走环境变量，也支持：
+
+- `MANAGEMENT_SERVER_URL`
+- `DAEMON_ID`
+- `DAEMON_NAME`
+
+发布前可先验证打包内容：
+
+```bash
+npm run build:daemon
+npm run pack:dry-run
+```
+
+正式发布：
+
+```bash
+npm publish --access public
+```
+
+## 现在支持的能力
+
+- 创建多个独立 Codex 会话
+- daemon 重启后恢复应用内 session 列表与 transcript
+- 给指定会话发送消息
+- 流式接收 assistant 文本增量
+- 用 `item/*` 与 `turn/*` 事件维护实时 transcript
+- 中断运行中的 turn
+- 关闭会话
+- 从 Codex 历史会话列表恢复，并继续在同一 `threadId` 上对话
+- 使用独立前端从其他设备远程管理 daemon
+- daemon 主动连接管理端，浏览器不需要直连 daemon
+
+## 后续建议
+
+- 把 `turn/interrupt`、审批、文件 diff、命令执行输出做成更细粒度 UI
+- 将 ACP session 和 web session 统一到同一后端存储
+- 为 `codex app-server` 请求/通知补完整类型约束
+
+## 参考文档
+
+- OpenAI Codex App Server: https://developers.openai.com/codex/app-server
+- OpenAI Codex CLI repo: https://github.com/openai/codex
+- ACP 协议主页: https://agentclientprotocol.com
+- ACP TypeScript SDK: https://www.npmjs.com/package/@agentclientprotocol/sdk

package/dist/acp/index.js

@@ -0,0 +1,92 @@
+import { Readable, Writable } from "node:stream";
+import { AgentSideConnection, PROTOCOL_VERSION, ndJsonStream, } from "@agentclientprotocol/sdk";
+import { SessionManager } from "../daemon/sessionManager.js";
+class OhMyVibeAcpAgent {
+    connection;
+    sessions;
+    acpToManaged;
+    constructor(connection, sessions, acpToManaged = new Map()) {
+        this.connection = connection;
+        this.sessions = sessions;
+        this.acpToManaged = acpToManaged;
+    }
+    async initialize() {
+        return {
+            protocolVersion: PROTOCOL_VERSION,
+            agentCapabilities: {
+                loadSession: false,
+            },
+        };
+    }
+    async newSession(params) {
+        const session = await this.sessions.create({
+            cwd: params.cwd,
+            approvalPolicy: "never",
+            sandbox: "workspace-write",
+        });
+        this.acpToManaged.set(session.id, session.id);
+        return { sessionId: session.id };
+    }
+    async authenticate() {
+        return {};
+    }
+    async prompt(params) {
+        const managedId = this.resolveSession(params.sessionId);
+        const text = (params.prompt ?? [])
+            .filter((block) => block?.type === "text")
+            .map((block) => block.text)
+            .join("\n");
+        await this.sessions.sendMessage(managedId, text);
+        const listener = async (event) => {
+            if (event.type !== "session-entry" || event.sessionId !== managedId) {
+                return;
+            }
+            if (event.entry.kind === "assistant") {
+                await this.connection.sessionUpdate({
+                    sessionId: params.sessionId,
+                    update: {
+                        sessionUpdate: "agent_message_chunk",
+                        content: {
+                            type: "text",
+                            text: event.entry.text,
+                        },
+                    },
+                });
+            }
+        };
+        this.sessions.on("event", listener);
+        try {
+            while (true) {
+                const session = this.sessions.get(managedId);
+                const status = session?.status;
+                if (!session ||
+                    (status !== undefined && ["completed", "interrupted", "failed", "idle"].includes(status))) {
+                    return {
+                        stopReason: status === "interrupted" ? "cancelled" : "end_turn",
+                    };
+                }
+                await new Promise((resolve) => setTimeout(resolve, 200));
+            }
+        }
+        finally {
+            this.sessions.off("event", listener);
+        }
+    }
+    async cancel(params) {
+        const managedId = this.resolveSession(params.sessionId);
+        await this.sessions.interrupt(managedId);
+    }
+    resolveSession(sessionId) {
+        const managedId = this.acpToManaged.get(sessionId) ?? sessionId;
+        const session = this.sessions.get(managedId);
+        if (!session) {
+            throw new Error(`ACP session not found: ${sessionId}`);
+        }
+        return managedId;
+    }
+}
+const sessionManager = new SessionManager();
+const input = Writable.toWeb(process.stdout);
+const output = Readable.toWeb(process.stdin);
+const stream = ndJsonStream(input, output);
+new AgentSideConnection((connection) => new OhMyVibeAcpAgent(connection, sessionManager), stream);

package/dist/cli.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import "dotenv/config";
+function printHelp() {
+    console.log(`OhMyVibe CLI
+
+Usage:
+  ohmyvibe [command] [options]
+
+Commands:
+  daemon        Start the managed daemon (default)
+  acp           Start the ACP bridge
+
+Options:
+  -u, --management-server-url <url>  Control server URL
+  --daemon-id <id>                   Override daemon id
+  -n, --daemon-name <name>           Override daemon display name
+  -h, --help                         Show help
+  -v, --version                      Show version
+
+Examples:
+  ohmyvibe --management-server-url http://localhost:3310
+  ohmyvibe daemon -u http://localhost:3310 -n my-daemon
+  ohmyvibe acp
+`);
+}
+function printVersion() {
+    console.log("0.1.0");
+}
+function readOptionValue(args, index, flag) {
+    const value = args[index + 1];
+    if (!value || value.startsWith("-")) {
+        throw new Error(`Missing value for ${flag}`);
+    }
+    return value;
+}
+function parseCliArgs(argv) {
+    let command = "daemon";
+    let startIndex = 0;
+    const first = argv[0];
+    if (first === "daemon" || first === "acp") {
+        command = first;
+        startIndex = 1;
+    }
+    const options = { command };
+    for (let index = startIndex; index < argv.length; index += 1) {
+        const arg = argv[index];
+        switch (arg) {
+            case "-u":
+            case "--management-server-url":
+                options.managementServerUrl = readOptionValue(argv, index, arg);
+                index += 1;
+                break;
+            case "--daemon-id":
+                options.daemonId = readOptionValue(argv, index, arg);
+                index += 1;
+                break;
+            case "-n":
+            case "--daemon-name":
+                options.daemonName = readOptionValue(argv, index, arg);
+                index += 1;
+                break;
+            case "-h":
+            case "--help":
+                options.help = true;
+                break;
+            case "-v":
+            case "--version":
+                options.version = true;
+                break;
+            default:
+                throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+    return options;
+}
+function applyEnvOverrides(options) {
+    if (options.managementServerUrl) {
+        process.env.MANAGEMENT_SERVER_URL = options.managementServerUrl;
+    }
+    if (options.daemonId) {
+        process.env.DAEMON_ID = options.daemonId;
+    }
+    if (options.daemonName) {
+        process.env.DAEMON_NAME = options.daemonName;
+    }
+}
+async function run() {
+    const options = parseCliArgs(process.argv.slice(2));
+    if (options.version) {
+        printVersion();
+        return;
+    }
+    if (options.help) {
+        printHelp();
+        return;
+    }
+    applyEnvOverrides(options);
+    if (options.command === "acp") {
+        await import("./acp/index.js");
+        return;
+    }
+    await import("./daemon/index.js");
+}
+try {
+    await run();
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`OhMyVibe CLI error: ${message}`);
+    process.exitCode = 1;
+}

package/dist/daemon/codexAppServerClient.js

@@ -0,0 +1,101 @@
+import { JsonRpcProcess } from "./jsonRpc.js";
+export class CodexAppServerClient {
+    rpc;
+    constructor(options) {
+        const command = process.platform === "win32" ? process.env.ComSpec ?? "cmd.exe" : "codex";
+        const args = process.platform === "win32"
+            ? ["/d", "/s", "/c", "codex.cmd app-server --listen stdio://"]
+            : ["app-server", "--listen", "stdio://"];
+        this.rpc = new JsonRpcProcess(command, args, options.cwd);
+    }
+    onNotification(listener) {
+        this.rpc.on("notification", listener);
+    }
+    onRequest(listener) {
+        this.rpc.on("request", listener);
+    }
+    onStderr(listener) {
+        this.rpc.on("stderr", listener);
+    }
+    onExit(listener) {
+        this.rpc.on("exit", listener);
+    }
+    initialize() {
+        return this.rpc.request("initialize", {
+            clientInfo: {
+                name: "ohmyvibe-daemon",
+                title: "OhMyVibe Daemon",
+                version: "0.1.0",
+            },
+            capabilities: {
+                experimentalApi: true,
+            },
+        });
+    }
+    threadStart(params) {
+        return this.rpc.request("thread/start", {
+            cwd: params.cwd,
+            model: params.model ?? null,
+            sandbox: params.sandbox ?? "workspace-write",
+            approvalPolicy: params.approvalPolicy ?? "never",
+            personality: "pragmatic",
+        });
+    }
+    threadResume(params) {
+        return this.rpc.request("thread/resume", {
+            threadId: params.threadId,
+            cwd: params.cwd ?? null,
+            model: params.model ?? null,
+            sandbox: params.sandbox ?? "workspace-write",
+            approvalPolicy: params.approvalPolicy ?? "never",
+            personality: "pragmatic",
+        });
+    }
+    turnStart(params) {
+        return this.rpc.request("turn/start", {
+            threadId: params.threadId,
+            effort: params.effort ?? null,
+            model: params.model ?? null,
+            approvalPolicy: params.approvalPolicy ?? null,
+            summary: params.summary ?? "detailed",
+            input: [
+                {
+                    type: "text",
+                    text: params.text,
+                },
+            ],
+        });
+    }
+    threadRead(threadId) {
+        return this.rpc.request("thread/read", { threadId });
+    }
+    threadList(params) {
+        return this.rpc.request("thread/list", {
+            limit: params?.limit ?? 100,
+            cursor: params?.cursor ?? null,
+            cwd: params?.cwd ?? null,
+            searchTerm: params?.searchTerm ?? null,
+            sortKey: params?.sortKey ?? "updated_at",
+            sourceKinds: params?.sourceKinds ?? ["cli", "vscode", "appServer", "unknown"],
+            archived: params?.archived ?? false,
+        });
+    }
+    turnInterrupt(threadId, turnId) {
+        return this.rpc.request("turn/interrupt", { threadId, turnId });
+    }
+    modelList() {
+        return this.rpc.request("model/list", {
+            includeHidden: false,
+            limit: 50,
+        });
+    }
+    respond(requestId, result) {
+        this.rpc.respond(requestId, result);
+    }
+    respondError(requestId, message, code = -32601) {
+        this.rpc.respondError(requestId, code, message);
+    }
+    close() {
+        return this.rpc.close();
+    }
+}

package/dist/daemon/httpServer.js

@@ -0,0 +1,117 @@
+import express from "express";
+import http from "node:http";
+import { WebSocketServer } from "ws";
+export function startHttpServer(sessionManager, port) {
+    const app = express();
+    const allowOrigin = process.env.ALLOW_ORIGIN ?? "*";
+    app.use((req, res, next) => {
+        res.setHeader("Access-Control-Allow-Origin", allowOrigin);
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        res.setHeader("Access-Control-Allow-Methods", "GET,POST,DELETE,OPTIONS");
+        if (req.method === "OPTIONS") {
+            res.status(204).end();
+            return;
+        }
+        next();
+    });
+    app.use(express.json());
+    app.get("/api/sessions", (_req, res) => {
+        res.json(sessionManager.list());
+    });
+    app.get("/api/config", async (_req, res) => {
+        try {
+            res.json(await sessionManager.getConfig());
+        }
+        catch (error) {
+            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+        }
+    });
+    app.get("/api/history", async (_req, res) => {
+        try {
+            res.json(await sessionManager.listHistory());
+        }
+        catch (error) {
+            res.status(500).json({ error: error instanceof Error ? error.message : String(error) });
+        }
+    });
+    app.post("/api/sessions", async (req, res) => {
+        try {
+            const body = req.body;
+            const session = await sessionManager.create(body);
+            res.status(201).json(session);
+        }
+        catch (error) {
+            res.status(400).json({ error: error instanceof Error ? error.message : String(error) });
+        }
+    });
+    app.post("/api/history/:threadId/restore", async (req, res) => {
+        try {
+            const body = (req.body ?? {});
+            const session = await sessionManager.restore({
+                threadId: req.params.threadId,
+                cwd: body.cwd,
+                model: body.model,
+                reasoningEffort: body.reasoningEffort,
+                sandbox: body.sandbox,
+                approvalPolicy: body.approvalPolicy,
+            });
+            res.status(201).json(session);
+        }
+        catch (error) {
+            res.status(400).json({ error: error instanceof Error ? error.message : String(error) });
+        }
+    });
+    app.get("/api/sessions/:sessionId", (req, res) => {
+        const session = sessionManager.get(req.params.sessionId);
+        if (!session) {
+            res.status(404).json({ error: "Session not found" });
+            return;
+        }
+        res.json(session);
+    });
+    app.post("/api/sessions/:sessionId/messages", async (req, res) => {
+        try {
+            const body = req.body;
+            await sessionManager.sendMessage(req.params.sessionId, body.text);
+            res.status(202).json({ ok: true });
+        }
+        catch (error) {
+            res.status(400).json({ error: error instanceof Error ? error.message : String(error) });
+        }
+    });
+    app.post("/api/sessions/:sessionId/interrupt", async (req, res) => {
+        try {
+            await sessionManager.interrupt(req.params.sessionId);
+            res.status(202).json({ ok: true });
+        }
+        catch (error) {
+            res.status(400).json({ error: error instanceof Error ? error.message : String(error) });
+        }
+    });
+    app.delete("/api/sessions/:sessionId", async (req, res) => {
+        try {
+            await sessionManager.close(req.params.sessionId);
+            res.status(204).end();
+        }
+        catch (error) {
+            res.status(400).json({ error: error instanceof Error ? error.message : String(error) });
+        }
+    });
+    app.get("/", (_req, res) => {
+        res.json({ name: "ohmyvibe-daemon", ok: true });
+    });
+    const server = http.createServer(app);
+    const wss = new WebSocketServer({ server, path: "/ws" });
+    wss.on("connection", (socket) => {
+        socket.send(JSON.stringify({ type: "hello", sessions: sessionManager.list() }));
+        const listener = (event) => {
+            socket.send(JSON.stringify(event));
+        };
+        sessionManager.on("event", listener);
+        socket.on("close", () => {
+            sessionManager.off("event", listener);
+        });
+    });
+    server.listen(port);
+    return server;
+}

package/dist/daemon/index.js

@@ -0,0 +1,15 @@
+import "dotenv/config";
+import { ManagementBridge } from "./managementBridge.js";
+import { SessionManager } from "./sessionManager.js";
+const sessionManager = new SessionManager();
+const managementServerUrl = process.env.MANAGEMENT_SERVER_URL;
+if (!managementServerUrl) {
+    throw new Error("MANAGEMENT_SERVER_URL is required");
+}
+const bridge = new ManagementBridge(sessionManager, {
+    serverUrl: managementServerUrl,
+    daemonId: process.env.DAEMON_ID,
+    daemonName: process.env.DAEMON_NAME,
+});
+bridge.start();
+console.log(`OhMyVibe daemon connecting to ${managementServerUrl}`);