cloudcc-cli 2.2.6 → 2.2.8

package/test/timer.cli.test.js

@@ -0,0 +1,107 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const { exec } = require("node:child_process");
+const { promisify } = require("node:util");
+
+const execAsync = promisify(exec);
+const repoRoot = path.resolve(__dirname, "..");
+const scheduleRoot = path.join(repoRoot, "schedule");
+
+function quoteArg(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+async function runCc(args) {
+  const cmd = `npx --prefix "${repoRoot}" cc ${args.map(quoteArg).join(" ")}`;
+  return execAsync(cmd, { cwd: repoRoot });
+}
+
+test("定时任务管理流程：创建→发布→拉取→线上详情→列表→批量拉取前2个→清空 schedule 文件夹", async (t) => {
+  const timerName = `CCTimer${Date.now()}`;
+  const timerDir = path.join(scheduleRoot, timerName);
+  const configPath = path.join(timerDir, "config.json");
+  const javaPath = path.join(timerDir, `${timerName}.java`);
+  let publishedId = null;
+  let topIds = [];
+
+  t.test("1) 创建定时任务", async () => {
+    await runCc(["create", "timer", timerName]);
+
+    assert.equal(fs.existsSync(timerDir), true);
+    assert.equal(fs.existsSync(configPath), true);
+    assert.equal(fs.existsSync(javaPath), true);
+
+    const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    assert.equal(config.name, timerName);
+  });
+
+  t.test("2) 发布定时任务（publish，写回 config.id）", async () => {
+    await runCc(["publish", "timer", timerName]);
+    const configAfterPublish = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    publishedId = configAfterPublish.id || null;
+    assert.ok(publishedId, "publish 后应写入 config.id");
+  });
+
+  t.test("3) 拉取定时任务（pull：覆盖 SOURCE 区域）", async () => {
+    const localJava = fs.readFileSync(javaPath, "utf8");
+    const modifiedJava = localJava.replace(
+      /\/\/ @SOURCE_CONTENT_START[\s\S]*?\/\/ @SOURCE_CONTENT_END/,
+      "// @SOURCE_CONTENT_START\nSystem.out.print(\"LOCAL_ONLY\");\n// @SOURCE_CONTENT_END"
+    );
+    fs.writeFileSync(javaPath, modifiedJava, "utf8");
+
+    await runCc(["pull", "timer", timerName]);
+    const javaAfterPull = fs.readFileSync(javaPath, "utf8");
+    assert.ok(!javaAfterPull.includes("LOCAL_ONLY"), "pull 后应使用远端源码替换本地标记内容");
+  });
+
+  t.test("4) 查询线上定时任务详情（detail：仅使用 id）", async () => {
+    assert.ok(publishedId, "发布后应有 publishedId");
+    await assert.doesNotReject(() => runCc(["detail", "timer", "", publishedId]));
+  });
+
+  t.test("5) get 获取线上定时任务列表（取前2个 id）", async () => {
+    const listQuery = encodeURI(
+      JSON.stringify({
+        shownum: "2000",
+        showpage: "1",
+        fid: "",
+        sname: "",
+        rptcond: "",
+        rptorder: "",
+      })
+    );
+    const { stdout } = await runCc(["get", "timer", listQuery, repoRoot]);
+    const list = JSON.parse(stdout.trim());
+    assert.ok(Array.isArray(list), "get timer 应返回数组");
+    topIds = list.slice(0, 2).map((x) => x.id).filter(Boolean);
+    assert.ok(topIds.length >= 1, "线上定时任务列表至少应包含 1 个 id");
+  });
+
+  t.test("6) 批量拉取前2个定时任务（pullList）", async () => {
+    assert.ok(topIds.length >= 1, "pullList 需要至少 1 个线上定时任务 id");
+    const beforeCount = fs.existsSync(scheduleRoot)
+      ? fs.readdirSync(scheduleRoot).filter((n) => fs.statSync(path.join(scheduleRoot, n)).isDirectory()).length
+      : 0;
+
+    for (const id of topIds) {
+      await runCc(["pullList", "timer", id, repoRoot]);
+    }
+
+    const afterCount = fs.readdirSync(scheduleRoot).filter((n) =>
+      fs.statSync(path.join(scheduleRoot, n)).isDirectory()
+    ).length;
+    assert.ok(afterCount >= beforeCount, "pullList 之后 schedule 目录应存在/可用");
+  });
+
+  t.test("7) 清空 schedule 文件夹", async () => {
+    if (fs.existsSync(scheduleRoot)) {
+      fs.rmSync(scheduleRoot, { recursive: true, force: true });
+    }
+    fs.mkdirSync(scheduleRoot, { recursive: true });
+    const remain = fs.readdirSync(scheduleRoot);
+    assert.equal(remain.length, 0);
+  });
+});

package/test/trigger.cli.test.js

@@ -0,0 +1,146 @@
+const test = require("node:test");
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const { exec } = require("node:child_process");
+const { promisify } = require("node:util");
+
+const execAsync = promisify(exec);
+const repoRoot = path.resolve(__dirname, "..");
+const triggersRoot = path.join(repoRoot, "triggers");
+
+function quoteArg(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+async function runCc(args) {
+  const cmd = `npx --prefix "${repoRoot}" cc ${args.map(quoteArg).join(" ")}`;
+  return execAsync(cmd, { cwd: repoRoot });
+}
+
+test("触发器管理流程：获取对象→创建→doc→发布→拉取→线上详情→列表→批量拉取前2个→清空 triggers 文件夹", async (t) => {
+  let schemetableName = "Account";
+  let targetObjectId = null;
+  let apiname = null;
+  const triggerTime = "beforeInsert";
+  const triggerName = `TestTrigger${Date.now()}`;
+  const namePath = `${schemetableName.toLowerCase()}/${triggerName}`;
+  const triggerDir = path.join(triggersRoot, schemetableName.toLowerCase(), triggerName);
+  const configPath = path.join(triggerDir, "config.json");
+  const javaPath = path.join(triggerDir, `${triggerName}.java`);
+  let topIds = [];
+
+  t.test("1) 获取自定义对象列表（取 schemetableName 用于创建触发器）", async () => {
+    const { stdout } = await runCc(["get", "object", repoRoot, "custom"]);
+    const list = JSON.parse(stdout.trim());
+    assert.ok(Array.isArray(list) && list.length > 0, "get object custom 应返回非空数组");
+    const first = list[0];
+    schemetableName = first.schemetableName || first.label || "Account";
+    targetObjectId = first.id || null;
+    apiname = `NTrigger${Date.now()}`;
+    assert.ok(targetObjectId, "应能拿到自定义对象 id 作为 targetObjectId");
+  });
+
+  t.test("2) 创建触发器", async () => {
+    const body = encodeURI(
+      JSON.stringify({
+        schemetableName,
+        targetObjectId,
+        triggerTime,
+        name: triggerName,
+        apiname,
+      })
+    );
+    await runCc(["create", "triggers", body]);
+
+    const expectedDir = path.join(triggersRoot, schemetableName.toLowerCase(), triggerName);
+    assert.equal(fs.existsSync(expectedDir), true);
+    assert.equal(fs.existsSync(path.join(expectedDir, "config.json")), true);
+    assert.equal(fs.existsSync(path.join(expectedDir, `${triggerName}.java`)), true);
+
+    const config = JSON.parse(fs.readFileSync(path.join(expectedDir, "config.json"), "utf8"));
+    assert.equal(config.name, triggerName);
+    assert.equal(config.apiname, apiname);
+    assert.equal(config.targetObjectId, targetObjectId);
+    assert.equal(config.triggerTime, triggerTime);
+  });
+
+  t.test("3) 获取 doc（triggers overview）", async () => {
+    const { stdout } = await runCc(["doc", "triggers", "overview"]);
+    assert.match(stdout, /触发器|CCTrigger|编辑指南/i);
+  });
+
+  t.test("4) 发布触发器（publish，写回 config.id）", async () => {
+    const namePathForPublish = `${schemetableName.toLowerCase()}/${triggerName}`;
+    await runCc(["publish", "triggers", namePathForPublish]);
+    const configAfterPublish = JSON.parse(
+      fs.readFileSync(path.join(triggersRoot, schemetableName.toLowerCase(), triggerName, "config.json"), "utf8")
+    );
+    assert.ok(configAfterPublish.id, "publish 后应写入 config.id");
+  });
+
+  t.test("5) 拉取触发器（pull：覆盖 SOURCE 区域）", async () => {
+    const triggerPath = path.join(triggersRoot, schemetableName.toLowerCase(), triggerName);
+    const javaPathLocal = path.join(triggerPath, `${triggerName}.java`);
+    const localJava = fs.readFileSync(javaPathLocal, "utf8");
+    const modifiedJava = localJava.replace(
+      /\/\/ @SOURCE_CONTENT_START[\s\S]*?\/\/ @SOURCE_CONTENT_END/,
+      "// @SOURCE_CONTENT_START\nSystem.out.print(\"LOCAL_ONLY\");\n// @SOURCE_CONTENT_END"
+    );
+    fs.writeFileSync(javaPathLocal, modifiedJava, "utf8");
+
+    await runCc(["pull", "triggers", `${schemetableName.toLowerCase()}/${triggerName}`]);
+    const javaAfterPull = fs.readFileSync(javaPathLocal, "utf8");
+    assert.ok(!javaAfterPull.includes("LOCAL_ONLY"), "pull 后应使用远端源码替换本地标记内容");
+  });
+
+  t.test("6) 查询线上触发器详情（detail：仅使用 id）", async () => {
+    const configPathLocal = path.join(triggersRoot, schemetableName.toLowerCase(), triggerName, "config.json");
+    const publishedId = JSON.parse(fs.readFileSync(configPathLocal, "utf8")).id;
+    assert.ok(publishedId, "发布后应有 id");
+    await assert.doesNotReject(() => runCc(["detail", "triggers", "", publishedId]));
+  });
+
+  t.test("7) get 获取线上触发器列表（取前2个 id）", async () => {
+    const listQuery = encodeURI(
+      JSON.stringify({
+        shownum: "2000",
+        showpage: "1",
+        fid: "",
+        sname: "",
+        rptcond: "",
+        rptorder: "",
+      })
+    );
+    const { stdout } = await runCc(["get", "triggers", listQuery, repoRoot]);
+    const list = JSON.parse(stdout.trim());
+    assert.ok(Array.isArray(list), "get triggers 应返回数组");
+    topIds = list.slice(0, 2).map((x) => x.id).filter(Boolean);
+    assert.ok(topIds.length >= 1, "线上触发器列表至少应包含 1 个 id");
+  });
+
+  t.test("8) 批量拉取前2个触发器（pullList）", async () => {
+    assert.ok(topIds.length >= 1, "pullList 需要至少 1 个线上触发器 id");
+    const beforeCount = fs.existsSync(triggersRoot)
+      ? fs.readdirSync(triggersRoot).filter((n) => fs.statSync(path.join(triggersRoot, n)).isDirectory()).length
+      : 0;
+
+    for (const id of topIds) {
+      await runCc(["pullList", "triggers", id, repoRoot]);
+    }
+
+    const afterCount = fs.existsSync(triggersRoot)
+      ? fs.readdirSync(triggersRoot).filter((n) => fs.statSync(path.join(triggersRoot, n)).isDirectory()).length
+      : 0;
+    assert.ok(afterCount >= beforeCount, "pullList 之后 triggers 目录应存在/可用");
+  });
+
+  t.test("9) 清空 triggers 文件夹", async () => {
+    if (fs.existsSync(triggersRoot)) {
+      fs.rmSync(triggersRoot, { recursive: true, force: true });
+    }
+    fs.mkdirSync(triggersRoot, { recursive: true });
+    const remain = fs.readdirSync(triggersRoot);
+    assert.equal(remain.length, 0);
+  });
+});

package/.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-    "java.configuration.updateBuildConfiguration": "automatic"
-}

package/bin/mcp-svc.js

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-/**
- * MCP (Model Context Protocol) Streamable HTTP 服务启动脚本
- * 用于部署到服务器，通过 HTTP 与客户端通信
- * 
- * 使用方法:
- *   node bin/mcp-svc.js
- *   或
- *   MCP_PORT=3000 node bin/mcp-svc.js
- */
-
-require('../src/mcp/index-svc.js');
-

package/src/mcp/MCP/345/234/272/346/231/257/346/250/241/346/213/237.md

@@ -1,8 +0,0 @@
-## 审批
-* 
-* 登录公司系统——》打开小云——〉点击语音输入
-* 1：帮我查看今天需要我审批的记录
-* 2：帮我预算类型的审批记录全部审批通过
-* 3：R017的报备记录文档位置不对，审批拒绝，添加交互确认
-* 4：帮我查看001预算的拆分情况
-

package/src/mcp/index-sse-svc.js

@@ -1,126 +0,0 @@
-/**
- * SSE 版本的 MCP 服务器实现
- * 基于 MCP 协议版本 2024-11-05 (已弃用，主要用于向后兼容测试)
- * 
- * 服务器暴露两个端点：
- * - GET /mcp: 用于建立 SSE 流
- * - POST /messages: 用于接收客户端消息
- */
-
-const { McpServer } = require("@modelcontextprotocol/sdk/server/mcp.js");
-const { SSEServerTransport } = require("@modelcontextprotocol/sdk/server/sse.js");
-const { createMcpExpressApp } = require("@modelcontextprotocol/sdk/server/express.js");
-const { registerAllTools } = require('./tools/index.js');
-const MCP_PORT = process.env.MCP_PORT ? parseInt(process.env.MCP_PORT, 10) : 8018;
-
-// 获取服务器实例（单例模式）
-let mcpServerInstance = null;
-function getServer() {
-    if (!mcpServerInstance) {
-        mcpServerInstance = new McpServer({
-            name: 'cctool',
-            version: '1.0.0'
-        });
-
-        // 注册所有工具
-        registerAllTools(mcpServerInstance);
-    }
-    return mcpServerInstance;
-}
-
-const app = createMcpExpressApp();
-
-// 按 session ID 存储 transports
-const transports = {};
-
-// SSE 端点：用于建立 SSE 流
-app.get('/mcp', async (req, res) => {
-    console.log('Received GET request to /mcp (establishing SSE stream)');
-
-    try {
-        // 为客户端创建新的 SSE transport
-        // POST 消息的端点是 '/messages'
-        const transport = new SSEServerTransport('/messages', res);
-
-        // 按 session ID 存储 transport
-        const sessionId = transport.sessionId;
-        transports[sessionId] = transport;
-
-        // 设置 onclose 处理器，在关闭时清理 transport
-        transport.onclose = () => {
-            console.log(`SSE transport closed for session ${sessionId}`);
-            delete transports[sessionId];
-        };
-
-        // 将 transport 连接到 MCP 服务器
-        const server = getServer();
-        await server.connect(transport);
-
-        console.log(`Established SSE stream with session ID: ${sessionId}`);
-    } catch (error) {
-        console.error('Error establishing SSE stream:', error);
-        if (!res.headersSent) {
-            res.status(500).send('Error establishing SSE stream');
-        }
-    }
-});
-
-// 消息端点：用于接收客户端 JSON-RPC 请求
-app.post('/messages', async (req, res) => {
-    console.log('Received POST request to /messages');
-
-    // 从 URL query 参数中提取 session ID
-    // 在 SSE 协议中，这是客户端根据端点事件添加的
-    const sessionId = req.query.sessionId;
-
-    if (!sessionId) {
-        console.error('No session ID provided in request URL');
-        res.status(400).send('Missing sessionId parameter');
-        return;
-    }
-
-    const transport = transports[sessionId];
-    if (!transport) {
-        console.error(`No active transport found for session ID: ${sessionId}`);
-        res.status(404).send('Session not found');
-        return;
-    }
-
-    try {
-        // 使用 transport 处理 POST 消息
-        await transport.handlePostMessage(req, res, req.body);
-    } catch (error) {
-        console.error('Error handling request:', error);
-        if (!res.headersSent) {
-            res.status(500).send('Error handling request');
-        }
-    }
-});
-
-// 启动服务器
-app.listen(MCP_PORT, error => {
-    if (error) {
-        console.error('Failed to start server:', error);
-        process.exit(1);
-    }
-    console.log(`Simple SSE Server (deprecated protocol version 2024-11-05) listening on port ${MCP_PORT}`);
-});
-
-// Handle server shutdown
-process.on('SIGINT', async () => {
-    console.log('Shutting down server...');
-
-    // Close all active transports to properly clean up resources
-    for (const sessionId in transports) {
-        try {
-            console.log(`Closing transport for session ${sessionId}`);
-            await transports[sessionId].close();
-            delete transports[sessionId];
-        } catch (error) {
-            console.error(`Error closing transport for session ${sessionId}:`, error);
-        }
-    }
-    console.log('Server shutdown complete');
-    process.exit(0);
-});
-

package/src/mcp/index-streamable-svc.js

@@ -1,180 +0,0 @@
-const { randomUUID } = require('node:crypto');
-const { McpServer } = require("@modelcontextprotocol/sdk/server/mcp.js");
-const { StreamableHTTPServerTransport } = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
-const { createMcpExpressApp } = require("@modelcontextprotocol/sdk/server/express.js");
-const { isInitializeRequest } = require("@modelcontextprotocol/sdk/types.js");
-const { InMemoryEventStore } = require("@modelcontextprotocol/sdk/examples/shared/inMemoryEventStore.js");
-const { registerAllTools } = require('./tools/index.js');
-const MCP_PORT = process.env.MCP_PORT ? parseInt(process.env.MCP_PORT, 10) : 8018;
-
-// 获取服务器实例（单例模式）
-
-let mcpServerInstance = null;
-function getServer() {
-    if (!mcpServerInstance) {
-        mcpServerInstance = new McpServer({
-            name: 'cctool',
-            version: '1.0.0'
-        });
-
-        // 注册所有工具
-        registerAllTools(mcpServerInstance);
-    }
-    return mcpServerInstance;
-}
-
-const app = createMcpExpressApp();
-
-// Map to store transports by session ID
-const transports = {};
-
-// MCP POST endpoint
-const mcpPostHandler = async (req, res) => {
-    const sessionId = req.headers['mcp-session-id'];
-    if (sessionId) {
-        console.log(`Received MCP request for session: ${sessionId}`);
-    } else {
-        console.log('Request body:', req.body);
-    }
-    try {
-        let transport;
-        if (sessionId && transports[sessionId]) {
-            // Reuse existing transport
-            transport = transports[sessionId];
-        } else if (!sessionId && isInitializeRequest(req.body)) {
-            // New initialization request
-            const eventStore = new InMemoryEventStore();
-            transport = new StreamableHTTPServerTransport({
-                sessionIdGenerator: () => randomUUID(),
-                eventStore, // Enable resumability
-                onsessioninitialized: sessionId => {
-                    // Store the transport by session ID when session is initialized
-                    // This avoids race conditions where requests might come in before the session is stored
-                    console.log(`Session initialized with ID: ${sessionId}`);
-                    transports[sessionId] = transport;
-                }
-            });
-
-            // Set up onclose handler to clean up transport when closed
-            transport.onclose = () => {
-                const sid = transport.sessionId;
-                if (sid && transports[sid]) {
-                    console.log(`Transport closed for session ${sid}, removing from transports map`);
-                    delete transports[sid];
-                }
-            };
-
-            // Connect the transport to the MCP server BEFORE handling the request
-            // so responses can flow back through the same transport
-            const server = getServer();
-            await server.connect(transport);
-
-            await transport.handleRequest(req, res, req.body);
-            return; // Already handled
-        } else {
-            // Invalid request - no session ID or not initialization request
-            res.status(400).json({
-                jsonrpc: '2.0',
-                error: {
-                    code: -32000,
-                    message: 'Bad Request: No valid session ID provided'
-                },
-                id: null
-            });
-            return;
-        }
-
-        // Handle the request with existing transport - no need to reconnect
-        // The existing transport is already connected to the server
-        await transport.handleRequest(req, res, req.body);
-    } catch (error) {
-        console.error('Error handling MCP request:', error);
-        if (!res.headersSent) {
-            res.status(500).json({
-                jsonrpc: '2.0',
-                error: {
-                    code: -32603,
-                    message: 'Internal server error'
-                },
-                id: null
-            });
-        }
-    }
-};
-
-// Set up POST route
-app.post('/mcp', mcpPostHandler);
-
-// Handle GET requests for SSE streams (using built-in support from StreamableHTTP)
-const mcpGetHandler = async (req, res) => {
-    const sessionId = req.headers['mcp-session-id'];
-    if (!sessionId || !transports[sessionId]) {
-        res.status(400).send('Invalid or missing session ID');
-        return;
-    }
-
-    // Check for Last-Event-ID header for resumability
-    const lastEventId = req.headers['last-event-id'];
-    if (lastEventId) {
-        console.log(`Client reconnecting with Last-Event-ID: ${lastEventId}`);
-    } else {
-        console.log(`Establishing new SSE stream for session ${sessionId}`);
-    }
-
-    const transport = transports[sessionId];
-    await transport.handleRequest(req, res);
-};
-
-// Set up GET route
-app.get('/mcp', mcpGetHandler);
-
-// Handle DELETE requests for session termination (according to MCP spec)
-const mcpDeleteHandler = async (req, res) => {
-    const sessionId = req.headers['mcp-session-id'];
-    if (!sessionId || !transports[sessionId]) {
-        res.status(400).send('Invalid or missing session ID');
-        return;
-    }
-
-    console.log(`Received session termination request for session ${sessionId}`);
-
-    try {
-        const transport = transports[sessionId];
-        await transport.handleRequest(req, res);
-    } catch (error) {
-        console.error('Error handling session termination:', error);
-        if (!res.headersSent) {
-            res.status(500).send('Error processing session termination');
-        }
-    }
-};
-
-// Set up DELETE route
-app.delete('/mcp', mcpDeleteHandler);
-
-app.listen(MCP_PORT, error => {
-    if (error) {
-        console.error('Failed to start server:', error);
-        process.exit(1);
-    }
-    console.log(`MCP Streamable HTTP Server listening on port ${MCP_PORT}`);
-});
-
-// Handle server shutdown
-process.on('SIGINT', async () => {
-    console.log('Shutting down server...');
-
-    // Close all active transports to properly clean up resources
-    for (const sessionId in transports) {
-        try {
-            console.log(`Closing transport for session ${sessionId}`);
-            await transports[sessionId].close();
-            delete transports[sessionId];
-        } catch (error) {
-            console.error(`Error closing transport for session ${sessionId}:`, error);
-        }
-    }
-    console.log('Server shutdown complete');
-    process.exit(0);
-});
-

package/src/mcp/tools/Class Detail Retriever/prompt.js

@@ -1,37 +0,0 @@
-/**
- * Class Detail Getter 工具知识库
- * 提供类详细信息查看指南
- */
-
-module.exports = {
-    description: '查看自定义类的详细信息',
-    parameters: {
-        className: {
-            type: 'string',
-            required: false,
-            description: '类名（可选，优先使用本地查询）'
-        },
-        classId: {
-            type: 'string',
-            required: false,
-            description: '类ID（可选，当没有className时使用服务器查询）'
-        },
-        projectPath: {
-            type: 'string',
-            required: false,
-            description: '项目路径，默认为当前工作目录'
-        }
-    },
-    notes: [
-        '至少需要提供 className 或 classId 其中之一',
-        '如果提供了 className，优先从本地文件获取（更快）',
-        '如果只提供 classId，从服务器查询',
-        '返回信息包括：基本配置、发布状态、服务器信息（如有）和源码预览'
-    ],
-    displayedInfo: [
-        '基本信息：包括类名、版本号、服务器ID、数据来源',
-        '发布状态：是否已发布到服务器',
-        '服务器信息：API名称、状态、创建/更新时间（如有）',
-        '源码预览：显示前50行源码内容'
-    ]
-};