@xiaohhhh1/canvas-agent 0.2.2

package/dist/http-server.js

@@ -0,0 +1,230 @@
+import express from "express";
+import { DEFAULT_PORT, ensureSiteWorkspace, loadConfig, saveConfig, updateSiteWorkspace } from "./config.js";
+import { CanvasSession } from "./canvas-session.js";
+import { startRelayBridge } from "./relay-bridge.js";
+import { archiveCodexThread, interruptCodexTurn, isRecoverableThreadError, listCodexThreads, readCodexThread, resumeCodexThread, runClaudeTurn, runCodexTurn, startCodexThread, summarizeCodexThread, verifyCodexThreadWorkspace, withAgentPrompt } from "./agents.js";
+export function startHttpServer() {
+    const config = loadConfig(true);
+    const port = Number(process.env.PORT) || Number(new URL(config.url).port) || DEFAULT_PORT;
+    config.url = `http://127.0.0.1:${port}`;
+    saveConfig(config);
+    const session = new CanvasSession();
+    const emit = (type, payload) => {
+        const data = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { value: payload };
+        const threadId = String(data.threadId || data.thread_id || ensureSiteWorkspace(config).activeThreadId || "");
+        threadId ? session.emitThread(type, threadId, data) : session.emitAll(type, data);
+    };
+    const setActiveThread = (activeThreadId, payload = {}) => {
+        const workspace = updateSiteWorkspace(config, { activeThreadId: activeThreadId || undefined });
+        session.emitThread("workspace_changed", activeThreadId, { ...payload, activeThreadId });
+        return workspace;
+    };
+    const app = express();
+    app.disable("x-powered-by");
+    app.use(express.json({ limit: "30mb" }));
+    app.use((req, res, next) => {
+        const url = requestUrl(req, config);
+        if (!setCors(req, res, url, config))
+            return void res.status(403).json({ ok: false, error: "origin not allowed" });
+        if (req.method === "OPTIONS")
+            return void res.json({});
+        next();
+    });
+    app.get("/health", (_req, res) => res.json(session.health()));
+    app.get("/config", (_req, res) => res.json({ ok: true, url: config.url, hasToken: true }));
+    app.use((req, res, next) => {
+        if (validToken(req, requestUrl(req, config), config.token))
+            return next();
+        res.status(401).json({ ok: false, error: "invalid token" });
+    });
+    app.get("/events", (req, res) => session.openEvents(requestUrl(req, config), res));
+    app.post("/canvas/state", (req, res) => {
+        session.updateState(req.body, String(req.query.clientId || "") || undefined);
+        res.json({ ok: true });
+    });
+    app.post("/canvas/activate", (req, res) => {
+        session.activateClient(String(req.query.clientId || ""));
+        res.json({ ok: true });
+    });
+    app.post("/canvas/result", (req, res) => {
+        const ok = session.resolveResult(String(req.query.clientId || ""), req.body);
+        res.status(ok ? 200 : 409).json({ ok });
+    });
+    app.get("/agent/attachments/:attachmentId", route(async (req, res) => {
+        const attachment = session.getTurnAttachment(String(req.query.clientId || ""), routeParam(req.params.attachmentId));
+        const data = attachment.dataUrl.split(",", 2)[1];
+        if (!data)
+            throw new Error("图片附件内容无效");
+        res.setHeader("Cache-Control", "no-store");
+        res.type(attachment.type).send(Buffer.from(data, "base64"));
+    }));
+    app.post("/api/tools", route(async (req, res) => res.json({ ok: true, result: await session.callTool(req.body?.name, req.body?.input || {}) })));
+    app.get("/agent/codex/workspace", (_req, res) => {
+        const workspace = ensureSiteWorkspace(config);
+        res.json({ ok: true, workspace });
+    });
+    app.get("/agent/codex/threads", route(async (req, res) => {
+        const workspace = ensureSiteWorkspace(config);
+        const result = await listCodexThreads(emit, { cwd: workspace.workspacePath, searchTerm: String(req.query.searchTerm || "") });
+        res.json({ ok: true, workspace, ...result });
+    }));
+    app.post("/agent/codex/threads/new", route(async (_req, res) => {
+        if (session.codexBusy)
+            return res.status(409).json({ ok: false, error: "Codex 正在运行，请等待当前任务完成" });
+        const workspace = ensureSiteWorkspace(config);
+        const thread = await startCodexThread(emit, workspace.workspacePath);
+        const activeThreadId = String(thread.id || "");
+        const nextWorkspace = setActiveThread(activeThreadId, { emptyThread: true });
+        res.json({ ok: true, workspace: nextWorkspace, thread: summarizeCodexThread(thread), messages: [] });
+    }));
+    app.get("/agent/codex/threads/:threadId", route(async (req, res) => {
+        const workspace = ensureSiteWorkspace(config);
+        const threadId = routeParam(req.params.threadId);
+        try {
+            res.json({ ok: true, workspace, ...(await readCodexThread(emit, threadId, workspace.workspacePath)) });
+        }
+        catch (error) {
+            if (workspace.activeThreadId !== threadId || !isRecoverableThreadError(error))
+                throw error;
+            res.json({ ok: true, workspace, thread: { id: threadId, preview: "", cwd: workspace.workspacePath }, messages: [] });
+        }
+    }));
+    app.post("/agent/codex/threads/:threadId/resume", route(async (req, res) => {
+        if (session.codexBusy)
+            return res.status(409).json({ ok: false, error: "Codex 正在运行，请等待当前任务完成" });
+        const workspace = ensureSiteWorkspace(config);
+        const threadId = routeParam(req.params.threadId);
+        const result = await resumeCodexThread(emit, threadId, workspace.workspacePath);
+        const nextWorkspace = setActiveThread(threadId);
+        res.json({ ok: true, workspace: nextWorkspace, ...result });
+    }));
+    app.post("/agent/codex/threads/:threadId/delete", route(async (req, res) => {
+        if (session.codexBusy)
+            return res.status(409).json({ ok: false, error: "Codex 正在运行，请等待当前任务完成" });
+        const workspace = ensureSiteWorkspace(config);
+        const threadId = routeParam(req.params.threadId);
+        await archiveCodexThread(emit, threadId, workspace.workspacePath);
+        setActiveThread(workspace.activeThreadId === threadId ? "" : workspace.activeThreadId || "");
+        res.json({ ok: true });
+    }));
+    app.post("/agent/codex/turn", route(async (req, res) => {
+        if (session.codexBusy)
+            return res.status(409).json({ ok: false, error: "Codex 正在运行，请等待当前任务完成" });
+        const attachments = Array.isArray(req.body?.attachments) ? req.body.attachments : [];
+        const workspace = ensureSiteWorkspace(config);
+        const prompt = String(req.body?.prompt || "");
+        if (!prompt.trim())
+            return res.status(400).json({ ok: false, error: "请输入任务内容" });
+        const clientId = String(req.body?.clientId || "");
+        session.setCodexState({ busy: true, threadId: String(req.body?.threadId || workspace.activeThreadId || ""), turnId: "" });
+        try {
+            let threadId = String(req.body?.threadId || workspace.activeThreadId || "");
+            let turnId = "";
+            if (!threadId) {
+                const thread = await startCodexThread(emit, workspace.workspacePath);
+                threadId = String(thread.id || "");
+                setActiveThread(threadId, { emptyThread: true });
+            }
+            else if (threadId !== workspace.activeThreadId) {
+                await verifyCodexThreadWorkspace(emit, threadId, workspace.workspacePath);
+                setActiveThread(threadId);
+            }
+            const attachmentRefs = session.setTurnAttachments(clientId, attachments);
+            const chatMessage = {
+                sourceClientId: clientId,
+                message: { id: String(req.body?.messageId || Date.now()), role: "user", text: String(req.body?.messageText || prompt || `发送了 ${attachments.length} 张图片`) },
+            };
+            let chatThreadId = "";
+            const turnEmit = (type, payload) => {
+                const data = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { value: payload };
+                session.emitThread(type, threadId, data);
+            };
+            void runCodexTurn(withAgentPrompt(withAttachmentContext(prompt, attachmentRefs)), turnEmit, attachments, {
+                threadId,
+                cwd: workspace.workspacePath,
+                appEmit: emit,
+                onStart: clientId ? () => session.bindClient(clientId) : undefined,
+                onThread: (actualThreadId) => {
+                    if (actualThreadId !== threadId) {
+                        threadId = actualThreadId;
+                        setActiveThread(threadId, { emptyThread: true });
+                    }
+                    session.setCodexState({ busy: true, threadId, turnId: "" });
+                    if (chatThreadId !== threadId) {
+                        chatThreadId = threadId;
+                        session.emitThread("chat_message", threadId, chatMessage);
+                    }
+                },
+                onTurn: (actualTurnId) => {
+                    turnId = actualTurnId;
+                    session.setCodexState({ busy: true, threadId, turnId });
+                },
+                onFinish: () => {
+                    session.clearTurnAttachments(clientId);
+                    if (clientId)
+                        session.releaseClient(clientId);
+                    session.setCodexState({ busy: false, threadId, turnId });
+                },
+            });
+            res.json({ ok: true, threadId });
+        }
+        catch (error) {
+            session.setCodexState({ busy: false, threadId: String(req.body?.threadId || workspace.activeThreadId || ""), turnId: "" });
+            throw error;
+        }
+    }));
+    app.post("/agent/codex/interrupt", (req, res) => {
+        const ok = interruptCodexTurn(String(req.body?.threadId || ""));
+        res.json({ ok });
+    });
+    app.post("/agent/claude/turn", (req, res) => {
+        runClaudeTurn(withAgentPrompt(String(req.body?.prompt || "")), emit);
+        res.json({ ok: true });
+    });
+    app.use((_req, res) => res.status(404).json({ ok: false, error: "not found" }));
+    app.use((error, _req, res, _next) => res.status(500).json({ ok: false, error: error.message }));
+    app.listen(port, "127.0.0.1", () => {
+        console.log("Infinite Canvas Agent");
+        console.log(`Local URL: ${config.url}`);
+        console.log(`Connect token: ${config.token}`);
+        console.log("Codex MCP is not installed by this command.");
+        console.log("Optional MCP add: codex mcp add infinite-canvas -- npx -y @xiaohhhh1/canvas-agent mcp");
+        console.log("Remove manually added MCP: codex mcp remove infinite-canvas");
+        startRelayBridge(config);
+    });
+}
+function route(handler) {
+    return (req, res, next) => void handler(req, res).catch(next);
+}
+function routeParam(value) {
+    return Array.isArray(value) ? value[0] || "" : value;
+}
+function requestUrl(req, config) {
+    return new URL(req.originalUrl || req.url || "/", config.url);
+}
+function setCors(req, res, url, config) {
+    const origin = req.headers.origin;
+    res.setHeader("Access-Control-Allow-Origin", origin || "*");
+    res.setHeader("Access-Control-Allow-Headers", "content-type,x-canvas-agent-token");
+    res.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS");
+    res.setHeader("Access-Control-Allow-Private-Network", "true");
+    if (!origin || req.method === "OPTIONS" || url.pathname === "/health" || url.pathname === "/config")
+        return true;
+    config.origins ||= [];
+    if (validToken(req, url, config.token) && !config.origins.includes(origin)) {
+        config.origins.push(origin);
+        saveConfig(config);
+    }
+    res.setHeader("Vary", "Origin");
+    return config.origins.includes(origin);
+}
+function validToken(req, url, token) {
+    const header = req.headers["x-canvas-agent-token"];
+    return url.searchParams.get("token") === token || header === token || (Array.isArray(header) && header.includes(token));
+}
+function withAttachmentContext(prompt, attachments) {
+    if (!attachments.length)
+        return prompt;
+    const list = attachments.map((item, index) => `${index + 1}. attachmentId=${item.id}, name=${JSON.stringify(item.name)}`).join("\n");
+    return `${prompt}\n\n本轮可用图片附件（顺序与图片输入一致）：\n${list}\n需要把附件放入画布或作为生成参考图时，先调用 canvas_create_attachment_nodes，再使用返回的画布节点 ID 创建生成流程。`;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { startHttpServer } from "./http-server.js";
+import { startMcpServer } from "./mcp-server.js";
+if (process.argv[2] === "mcp")
+    await startMcpServer();
+else
+    startHttpServer();

package/dist/mcp-server.d.ts

@@ -0,0 +1 @@
+export declare function startMcpServer(): Promise<void>;

package/dist/mcp-server.js

@@ -0,0 +1,24 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { AGENT_PROMPT, loadConfig, VERSION } from "./config.js";
+import { toolDescriptions, toolInputSchemas, toolNames } from "./schemas.js";
+export async function startMcpServer() {
+    const config = loadConfig(true);
+    const server = new McpServer({ name: "canvas-agent", version: VERSION }, { instructions: AGENT_PROMPT });
+    toolNames.forEach((name) => registerCanvasTool(server, config, name));
+    await server.connect(new StdioServerTransport());
+}
+function registerCanvasTool(server, config, name) {
+    const schema = toolInputSchemas[name];
+    server.registerTool(name, { description: toolDescriptions[name], inputSchema: schema.shape }, async (input) => {
+        const result = await postCanvasAgentTool(config, name, schema.parse(input));
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    });
+}
+async function postCanvasAgentTool(config, name, input) {
+    const res = await fetch(`${config.url}/api/tools`, { method: "POST", headers: { "content-type": "application/json", "x-canvas-agent-token": config.token }, body: JSON.stringify({ name, input }) });
+    const body = (await res.json());
+    if (!body.ok)
+        throw new Error(body.error || "tool call failed");
+    return body.result;
+}

package/dist/relay-bridge.d.ts

@@ -0,0 +1,7 @@
+import type { CanvasAgentConfig } from "./config.js";
+/**
+ * Keeps an outbound, encrypted connection to the production relay.  The canvas
+ * browser can then use same-origin requests instead of directly reaching a
+ * loopback HTTP address, which Chromium clients can block before CORS runs.
+ */
+export declare function startRelayBridge(config: CanvasAgentConfig): () => void;

package/dist/relay-bridge.js

@@ -0,0 +1,126 @@
+import WebSocket from "ws";
+const DEFAULT_RELAY_URL = "wss://canvas.xiaohhhh1.com/api/agent-relay";
+const RECONNECT_DELAY_MS = 3_000;
+/**
+ * Keeps an outbound, encrypted connection to the production relay.  The canvas
+ * browser can then use same-origin requests instead of directly reaching a
+ * loopback HTTP address, which Chromium clients can block before CORS runs.
+ */
+export function startRelayBridge(config) {
+    const relayUrl = process.env.CANVAS_AGENT_RELAY_URL || DEFAULT_RELAY_URL;
+    const subscriptions = new Map();
+    let socket = null;
+    let stopped = false;
+    let reconnectTimer = null;
+    const send = (message) => {
+        if (socket?.readyState === WebSocket.OPEN)
+            socket.send(JSON.stringify(message));
+    };
+    const stopSubscription = (clientId) => {
+        subscriptions.get(clientId)?.abort();
+        subscriptions.delete(clientId);
+    };
+    const startSubscription = (clientId) => {
+        stopSubscription(clientId);
+        const controller = new AbortController();
+        subscriptions.set(clientId, controller);
+        void pipeEvents(clientId, config, controller.signal, send).finally(() => {
+            if (subscriptions.get(clientId) === controller)
+                subscriptions.delete(clientId);
+        });
+    };
+    const handleRequest = async (message) => {
+        try {
+            const target = new URL(message.path, config.url);
+            if (target.origin !== new URL(config.url).origin)
+                throw new Error("relay request target is invalid");
+            const headers = new Headers(message.headers || {});
+            headers.set("x-canvas-agent-token", config.token);
+            const body = message.bodyBase64 ? Buffer.from(message.bodyBase64, "base64") : undefined;
+            const response = await fetch(target, { method: message.method || "GET", headers, body });
+            const bytes = Buffer.from(await response.arrayBuffer());
+            send({
+                type: "response",
+                id: message.id,
+                status: response.status,
+                contentType: response.headers.get("content-type") || "application/octet-stream",
+                bodyBase64: bytes.toString("base64"),
+            });
+        }
+        catch (error) {
+            send({ type: "response", id: message.id, status: 502, contentType: "application/json", bodyBase64: Buffer.from(JSON.stringify({ ok: false, error: error instanceof Error ? error.message : "Agent relay request failed" })).toString("base64") });
+        }
+    };
+    const onMessage = (raw) => {
+        try {
+            const message = JSON.parse(raw.toString());
+            if (message.type === "request")
+                void handleRequest(message);
+            if (message.type === "subscribe")
+                startSubscription(message.clientId);
+            if (message.type === "unsubscribe")
+                stopSubscription(message.clientId);
+        }
+        catch {
+            // Ignore malformed relay messages. The relay never receives a secret in an error response.
+        }
+    };
+    const connect = () => {
+        if (stopped)
+            return;
+        try {
+            socket = new WebSocket(relayUrl);
+            socket.on("open", () => send({ type: "hello", role: "agent", token: config.token }));
+            socket.on("message", onMessage);
+            socket.on("close", () => {
+                subscriptions.forEach((controller) => controller.abort());
+                subscriptions.clear();
+                if (!stopped)
+                    reconnectTimer = setTimeout(connect, RECONNECT_DELAY_MS);
+            });
+            socket.on("error", () => undefined);
+        }
+        catch {
+            reconnectTimer = setTimeout(connect, RECONNECT_DELAY_MS);
+        }
+    };
+    connect();
+    return () => {
+        stopped = true;
+        if (reconnectTimer)
+            clearTimeout(reconnectTimer);
+        subscriptions.forEach((controller) => controller.abort());
+        subscriptions.clear();
+        socket?.close();
+    };
+}
+async function pipeEvents(clientId, config, signal, send) {
+    const eventsUrl = new URL("/events", config.url);
+    eventsUrl.searchParams.set("clientId", clientId);
+    const response = await fetch(eventsUrl, { headers: { "x-canvas-agent-token": config.token }, signal });
+    if (!response.ok || !response.body)
+        throw new Error("Unable to open local Agent event stream");
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (!signal.aborted) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        let end = buffer.indexOf("\n\n");
+        while (end >= 0) {
+            const block = buffer.slice(0, end);
+            buffer = buffer.slice(end + 2);
+            const event = block.match(/^event:\s*(.+)$/m)?.[1] || "message";
+            const data = block
+                .split("\n")
+                .filter((line) => line.startsWith("data:"))
+                .map((line) => line.slice(5).trimStart())
+                .join("\n");
+            if (data)
+                send({ type: "event", clientId, event, data });
+            end = buffer.indexOf("\n\n");
+        }
+    }
+}