dsh-api-runner 0.1.0 → 0.2.0

package/package.json

@@ -1,77 +1,71 @@
-{
-  "name": "dsh-api-runner",
-  "version": "0.1.0",
-  "description": "DSH 插件：按配置调用后端 HTTP 接口、启停/重启本地开发服务、增量读取日志并等待日志特征，让模型能\"改完自己验\"。",
-  "type": "module",
-  "license": "MIT",
-  "author": "Moz (lhhzmz229)",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/lhhzmz229/dsh-api-runner.git"
-  },
-  "homepage": "https://github.com/lhhzmz229/dsh-api-runner#readme",
-  "bugs": {
-    "url": "https://github.com/lhhzmz229/dsh-api-runner/issues"
-  },
-  "keywords": [
-    "dsh",
-    "dsh-plugin",
-    "deepseek-harness",
-    "api-runner",
-    "http-client",
-    "log-tail",
-    "spring-boot",
-    "java",
-    "devtools"
-  ],
-  "main": "src/main.js",
-  "exports": {
-    ".": "./src/main.js",
-    "./runner": "./src/main.js",
-    "./client": "./client/client.js",
-    "./package.json": "./package.json"
-  },
-  "engines": {
-    "node": ">=20",
-    "dsh": ">=0.1.0-rc.6 <0.2.0-0 || >=0.2.0-rc.1 <0.3.0-0"
-  },
-  "scripts": {
-    "test": "node test/smoke.mjs && node test/plugin.mjs",
-    "test:all": "node test/smoke.mjs && node test/plugin.mjs && node test/client.mjs && node test/managed.mjs && node test/java.mjs",
-    "stage": "node scripts/stage.mjs",
-    "release": "node scripts/stage.mjs --release"
-  },
-  "dependencies": {
-    "yaml": "^2.8.0"
-  },
-  "peerDependencies": {
-    "dsh-better-sidebar": ">=0.12.0"
-  },
-  "peerDependenciesMeta": {
-    "dsh-better-sidebar": {
-      "optional": true
-    }
-  },
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    },
-    "client": {
-      "platform": "web",
-      "inject": [
-        "dsh-better-sidebar"
-      ]
-    }
-  },
-  "files": [
-    "cordis.patch.yml",
-    "src",
-    "client",
-    "docs",
-    "scripts",
-    "test",
-    "README.md",
-    "LICENSE",
-    "dsh-api-runner.example.yml"
-  ]
-}
+{
+  "name": "dsh-api-runner",
+  "version": "0.2.0",
+  "description": "DSH 插件：按配置调用后端 HTTP 接口、启停/重启本地开发服务、增量读取日志并等待日志特征，让模型能\"改完自己验\"。",
+  "type": "module",
+  "license": "MIT",
+  "author": "Moz (lhhzmz229)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lhhzmz229/dsh-api-runner.git"
+  },
+  "homepage": "https://github.com/lhhzmz229/dsh-api-runner#readme",
+  "bugs": {
+    "url": "https://github.com/lhhzmz229/dsh-api-runner/issues"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "api-runner",
+    "http-client",
+    "log-tail",
+    "spring-boot",
+    "java",
+    "devtools"
+  ],
+  "main": "src/main.js",
+  "exports": {
+    ".": "./src/main.js",
+    "./runner": "./src/main.js",
+    "./client": "./client/client.js",
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=20",
+    "dsh": ">=0.1.0-rc.6 <0.2.0-0 || >=0.2.0-rc.1 <0.3.0-0"
+  },
+  "scripts": {
+    "test": "node test/smoke.mjs && node test/plugin.mjs",
+    "test:all": "node test/smoke.mjs && node test/plugin.mjs && node test/client.mjs && node test/managed.mjs && node test/java.mjs",
+    "stage": "node scripts/stage.mjs",
+    "release": "node scripts/stage.mjs --release"
+  },
+  "dependencies": {
+    "yaml": "^2.8.0"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-sidebar",
+        "@deepseek-ai/dsh-client-ui-sidebar-right"
+      ]
+    }
+  },
+  "files": [
+    "cordis.patch.yml",
+    "src",
+    "client",
+    "docs",
+    "scripts",
+    "test",
+    "README.md",
+    "LICENSE",
+    "dsh-api-runner.example.yml"
+  ]
+}

package/src/java-runner.js

@@ -267,7 +267,7 @@ export class JavaRunner {
             extraJvmArgs: [`-DdshApiRunner.runId=${id}`],
         });
         this._ensureLogHeader(logPath, `接管 pid ${sourcePid}（${id}）`);
-        const spawned = spawnService({ javaExe: snapshot.javaExe, argv: built.argv, cwd: snapshot.cwd, logPath });
+        const spawned = await spawnService({ javaExe: snapshot.javaExe, argv: built.argv, cwd: snapshot.cwd, logPath });
         if (!spawned.ok) return { ok: false, code: 'SPAWN_FAILED', message: spawned.message, compile };
 
         const record = {
@@ -459,7 +459,7 @@ export class JavaRunner {
 
         // 每次重启开一个新日志段，历史启动记录不被覆盖
         const logPath = this.logPathOf(entry.id);
-        const spawned = spawnService({ javaExe: entry.javaExe, argv: entry.argv, cwd: entry.cwd, logPath });
+        const spawned = await spawnService({ javaExe: entry.javaExe, argv: entry.argv, cwd: entry.cwd, logPath });
         if (!spawned.ok) return { ok: false, code: 'SPAWN_FAILED', message: spawned.message, compile };
 
         const record = { ...entry, pid: spawned.pid, logPath, argv: entry.argv, startedAt: new Date().toISOString(), stoppedAt: '' };
@@ -530,7 +530,7 @@ export class JavaRunner {
         });
         const logPath = this.logPathOf(id);
         this._ensureLogHeader(logPath, `按保存的配置启动 ${id}`);
-        const spawned = spawnService({ javaExe: saved.javaExe, argv: built.argv, cwd: saved.cwd, logPath });
+        const spawned = await spawnService({ javaExe: saved.javaExe, argv: built.argv, cwd: saved.cwd, logPath });
         if (!spawned.ok) return { ok: false, code: 'SPAWN_FAILED', message: spawned.message, compile };
 
         const record = {

package/src/main.js

@@ -61,8 +61,13 @@ const PARAMETERS = {
         log_id: { type: 'string', description: '日志 id 或 name（log、wait_log、reset_log 用；省略时取第一个日志）' },
         java_action: {
             type: 'string',
-            enum: ['list', 'start', 'stop', 'restart', 'log', 'status', 'detail', 'ignore', 'unignore', 'save', 'unsave', 'start_saved', 'settings'],
-            description: 'Java 服务动作（action=java 用）：list 列出；detail 服务详情+日志；start 接管启动（先编译再杀旧进程）；stop/restart 只对插件启动的生效；log 读日志；ignore/unignore 在面板列表中隐藏/恢复；save 把当前进程的启动配方向保存下来（之后不用 IDEA 也能起）；unsave 删除保存；start_saved 按保存的配置启动；settings 读写插件设置（数据目录/默认工作区）',
+            enum: ['list', 'start', 'stop', 'restart', 'log', 'status', 'detail', 'ignore', 'unignore', 'save', 'unsave', 'start_saved', 'start_all', 'settings'],
+            description: 'Java 服务动作（action=java 用）：list 列出；detail 服务详情+日志；start 接管启动（先编译再杀旧进程）；stop/restart 只对插件启动的生效；log 读日志；ignore/unignore 在面板列表中隐藏/恢复；save 把当前进程的启动配方向保存下来（之后不用 IDEA 也能起）；unsave 删除保存；start_saved 按保存的配置启动一个；start_all 一键启动所有已保存的服务（已运行的跳过，单个失败不影响其余，返回每个的成败）；settings 读写插件设置（数据目录/默认工作区）',
+        },
+        java_ids: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'java_action=start_all 时只启动这些服务（省略则启动全部已保存的）',
         },
         pid: { type: 'number', description: '要接管的 Java 进程 pid（java_action=start 用）' },
         java_id: { type: 'string', description: '插件托管的服务名或 pid（java_action=stop/restart/log/save/unsave/start_saved 用）' },
@@ -187,6 +192,18 @@ async function runTool(service, args, projectPath) {
                     timeoutMs,
                 });
             }
+            // 一键启动：把「已保存」里的服务全拉起来（或只拉 java_ids 列的那几个）
+            if (javaAction === 'start_all') {
+                const ids = Array.isArray(args.java_ids)
+                    ? args.java_ids.map((id) => String(id))
+                    : (args.java_id ? [String(args.java_id)] : []);
+                return service.startAllSavedJava(projectPath, ids, {
+                    compile: args.compile !== false,
+                    restart: args.restart === true,
+                    timeoutMs,
+                    compileTimeoutMs: args.timeout_ms ? Number(args.timeout_ms) : undefined,
+                });
+            }
             if (javaAction === 'settings') {
                 if (args.settings && typeof args.settings === 'object') return service.saveSettings(asObject(args.settings));
                 return service.settings();
@@ -547,6 +564,18 @@ async function handleHttp(req, res, service, projectOf) {
             timeoutMs: body.timeout_ms ? Number(body.timeout_ms) : undefined,
         }));
     }
+    // 一键启动：后台跑，立刻返回批次 id；面板轮询 java/start-all/status 看进度
+    if (route === 'java/start-all' && req.method === 'POST') {
+        const body = await readBody();
+        return send(200, service.startSavedJavaBatch(pickCwd(cwd, url, body), Array.isArray(body.ids) ? body.ids : [], {
+            compile: body.compile !== false,
+            restart: body.restart === true,
+            timeoutMs: body.timeout_ms ? Number(body.timeout_ms) : undefined,
+        }));
+    }
+    if (route === 'java/start-all/status' && req.method === 'GET') {
+        return send(200, service.startBatchStatus(url.searchParams.get('batch') || ''));
+    }
     if (route === 'settings' && req.method === 'GET') {
         return send(200, service.settings());
     }

package/src/ops.js

@@ -30,6 +30,15 @@ export class ApiRunnerService {
         this.javaRunner = options.javaRunner || new JavaRunner({ homeDir: this.homeDir, settingsStore: this.settingsStore });
         /** 记录最近一次错误，便于排查 */
         this.lastError = '';
+        /**
+         * 一键启动的后台批次：`{ [batchId]: { id, cwd, startedAt, done, total, items, finished, result } }`。
+         *
+         * 为什么放后台跑：一批服务要逐个 mvn 编译，几个服务就是几分钟，
+         * 同步 HTTP 请求会一直挂着（浏览器和 fetch 都可能超时），面板也没法显示进度。
+         * 批次只存内存：DSH 重启后丢批次记录没关系，进程本身已经起来了。
+         */
+        this.startBatches = new Map();
+        this._batchSeq = 0;
     }
 
     /** 面板配置转成 YAML 同构的覆盖层；没有面板存储时返回 undefined */
@@ -513,12 +522,25 @@ export class ApiRunnerService {
         const result = await listJavaProcesses();
         const runs = this.javaRunner ? this.javaRunner.runs(cwd) : [];
         if (!result.ok) {
+            /**
+             * 没有 jps（没装 JDK）时也必须给全字段。
+             *
+             * 面板会直接读 saved / ignored / maven 并 .map 它们；早期这里只返回
+             * processes，前端拿 undefined 就崩（「已保存」页签整个白掉）。
+             * 而且用户没 JDK 时更需要看到「已保存的配方」和「怎么装 JDK」。
+             */
+            const missingProject = this.projectStore ? this.projectStore.project(cwd) : { bindings: [], ignored: [], saved: [] };
             return {
                 ok: false,
                 code: 'JPS_MISSING',
                 message: result.note,
                 processes: runs.map((run) => this._runView(run)),
                 runs: runs.map((run) => this._runView(run)),
+                saved: (missingProject.saved || []).map((item) => this._savedView(item)),
+                bindings: missingProject.bindings || [],
+                ignored: missingProject.ignored || [],
+                maven: await this._mavenHint(),
+                note: result.note,
             };
         }
         const project = this.projectStore ? this.projectStore.project(cwd) : { bindings: [], ignored: [] };
@@ -702,6 +724,202 @@ export class ApiRunnerService {
         return this.javaRunner.startSaved(cwd, saved, options);
     }
 
+    /**
+     * 一键启动：把「已保存」里的服务批量拉起来。
+     *
+     * 为什么要串行而不是 Promise.all：
+     *   1. Maven 编译在同一个模块上是互斥的（都写 target/），并发跑会互相覆盖，
+     *      出现「编译成功但产物是半成品」这种最难查的错；
+     *   2. 一个服务起不来通常意味着环境有问题（端口、依赖、编译），
+     *      这时候继续把剩下的全拉起来，用户看到的是满屏报错而不是一个明确原因。
+     * 所以默认**逐个启动、遇错继续**：每个失败单独记账，最后一起汇报，
+     * 用户既能看到哪个成功，也能看到哪个为什么失败。
+     *
+     * 已经在跑的跳过（除非 options.restart 为 true），避免把正在调试的进程踢掉。
+     *
+     * @param {string} cwd - 项目目录
+     * @param {string[]} ids - 要启动的服务 id；空数组表示「已保存里的全部」
+     * @param {{compile?:boolean, restart?:boolean, timeoutMs?:number, compileTimeoutMs?:number, onProgress?:Function}} options
+     */
+    async startAllSavedJava(cwd, ids = [], options = {}) {
+        if (!this.projectStore) return { ok: false, code: 'NO_STORE', message: '面板配置存储不可用' };
+        if (!this.javaRunner) return { ok: false, code: 'NO_RUNNER', message: 'Java 托管不可用' };
+
+        const all = this.projectStore.savedJava(cwd) || [];
+        const wanted = Array.isArray(ids) && ids.length > 0
+            ? ids.map((id) => String(id))
+            : all.map((item) => String(item.id));
+        if (wanted.length === 0) {
+            return { ok: false, code: 'NOTHING_SAVED', message: '还没有保存的服务。先在「运行中」里对一个服务点「保存」，之后才能一键启动。' };
+        }
+
+        const aliveIds = new Set((this.javaRunner.runs(cwd) || []).filter((run) => run.alive).map((run) => String(run.id)));
+        const items = [];
+        let started = 0;
+        let skipped = 0;
+        let failed = 0;
+
+        for (const id of wanted) {
+            const saved = all.find((item) => String(item.id) === id);
+            if (!saved) {
+                items.push({ id, ok: false, code: 'NOT_SAVED', message: `没有保存的服务 ${id}` });
+                failed += 1;
+                if (typeof options.onProgress === 'function') {
+                    try {
+                        options.onProgress(items[items.length - 1], items.length, wanted.length);
+                    } catch {
+                        /* 进度回调出错不影响启动 */
+                    }
+                }
+                continue;
+            }
+            if (aliveIds.has(id) && options.restart !== true) {
+                items.push({ id, ok: true, skipped: true, note: `${id} 已在运行，跳过` });
+                skipped += 1;
+                if (typeof options.onProgress === 'function') {
+                    try {
+                        options.onProgress(items[items.length - 1], items.length, wanted.length);
+                    } catch {
+                        /* 进度回调出错不影响启动 */
+                    }
+                }
+                continue;
+            }
+            try {
+                const result = await this.javaRunner.startSaved(cwd, saved, {
+                    compile: options.compile !== false,
+                    timeoutMs: options.timeoutMs,
+                    compileTimeoutMs: options.compileTimeoutMs,
+                });
+                items.push({
+                    id,
+                    ok: result.ok === true,
+                    code: result.code,
+                    pid: result.pid || 0,
+                    port: result.port || 0,
+                    logPath: result.logPath || '',
+                    compile: result.compile,
+                    message: result.message,
+                    note: result.note,
+                });
+                if (result.ok) {
+                    started += 1;
+                    aliveIds.add(id);
+                } else {
+                    failed += 1;
+                }
+            } catch (error) {
+                items.push({ id, ok: false, code: 'UNEXPECTED', message: String(error?.message || error) });
+                failed += 1;
+            }
+            if (typeof options.onProgress === 'function') {
+                try {
+                    options.onProgress(items[items.length - 1], items.length, wanted.length);
+                } catch {
+                    /* 进度回调出错不影响启动 */
+                }
+            }
+        }
+
+        const lines = items.map((item) => {
+            if (item.skipped) return `- ${item.id}：已在运行，跳过`;
+            if (item.ok) return `- ${item.id}：已启动${item.port ? `（端口 ${item.port}）` : ''}`;
+            return `- ${item.id}：失败 —— ${item.message || item.code || '未知原因'}`;
+        });
+        return {
+            ok: failed === 0,
+            code: failed === 0 ? undefined : 'PARTIAL',
+            started,
+            skipped,
+            failed,
+            total: wanted.length,
+            items,
+            message: `一键启动完成：成功 ${started} 个，跳过 ${skipped} 个，失败 ${failed} 个。\n${lines.join('\n')}`,
+        };
+    }
+
+    /**
+     * 在后台跑一次一键启动，立刻返回批次 id。
+     *
+     * 面板拿到 id 后每 1 秒拉一次 `startBatchStatus`，直到 `finished`。
+     * 这样编译期间的几分钟里页面是可交互的，也能看到「3/8 正在编译」这类进度。
+     */
+    startSavedJavaBatch(cwd, ids = [], options = {}) {
+        if (!this.projectStore) return { ok: false, code: 'NO_STORE', message: '面板配置存储不可用' };
+        if (!this.javaRunner) return { ok: false, code: 'NO_RUNNER', message: 'Java 托管不可用' };
+        const all = this.projectStore.savedJava(cwd) || [];
+        const wanted = Array.isArray(ids) && ids.length > 0 ? ids.map((id) => String(id)) : all.map((item) => String(item.id));
+        if (wanted.length === 0) {
+            return { ok: false, code: 'NOTHING_SAVED', message: '还没有保存的服务。先在「运行中」里对一个服务点「保存」，之后才能一键启动。' };
+        }
+
+        this._batchSeq += 1;
+        const batchId = `batch-${Date.now()}-${this._batchSeq}`;
+        const batch = {
+            id: batchId,
+            cwd,
+            startedAt: new Date().toISOString(),
+            done: 0,
+            total: wanted.length,
+            items: [],
+            finished: false,
+            result: null,
+            current: '',
+        };
+        this.startBatches.set(batchId, batch);
+
+        // 只保留最近 10 个批次，避免长时间运行的进程内存里堆一堆历史
+        if (this.startBatches.size > 10) {
+            const oldest = [...this.startBatches.values()].sort((a, b) => String(a.startedAt).localeCompare(String(b.startedAt)));
+            for (const item of oldest.slice(0, this.startBatches.size - 10)) this.startBatches.delete(item.id);
+        }
+
+        // 不 await：立刻把批次 id 还给面板
+        Promise.resolve()
+            .then(() => this.startAllSavedJava(cwd, wanted, {
+                ...options,
+                onProgress: (item, done, total) => {
+                    batch.done = done;
+                    batch.total = total;
+                    batch.current = item.id;
+                    batch.items.push(item);
+                },
+            }))
+            .then((result) => {
+                batch.result = result;
+                batch.finished = true;
+                batch.done = result.total;
+                batch.current = '';
+            })
+            .catch((error) => {
+                batch.finished = true;
+                batch.current = '';
+                batch.result = { ok: false, code: 'UNEXPECTED', message: String(error?.message || error) };
+            });
+
+        return { ok: true, batchId, total: wanted.length, message: `已开始一键启动 ${wanted.length} 个服务` };
+    }
+
+    /** 读一键启动批次进度；id 省略时返回最近一个批次 */
+    startBatchStatus(batchId = '') {
+        const key = String(batchId || '');
+        const batch = key
+            ? this.startBatches.get(key)
+            : [...this.startBatches.values()].sort((a, b) => String(b.startedAt).localeCompare(String(a.startedAt))).pop();
+        if (!batch) return { ok: false, code: 'NO_BATCH', message: '没有这个启动批次（可能已经过期，或 DSH 重启过）' };
+        return {
+            ok: true,
+            batchId: batch.id,
+            finished: batch.finished,
+            done: batch.done,
+            total: batch.total,
+            current: batch.current,
+            startedAt: batch.startedAt,
+            items: batch.items,
+            result: batch.result,
+        };
+    }
+
     /** 插件级设置（数据目录 / 默认工作区 / Maven 主路径） */
     settings() {
         if (!this.settingsStore) {

package/src/restart.js

@@ -437,14 +437,8 @@ export function spawnService({ javaExe, argv, cwd, logPath }) {
     } catch {
         out = 'ignore';
     }
-    try {
-        const child = spawn(exe, argv, {
-            cwd: cwd || undefined,
-            detached: true,
-            stdio: ['ignore', out, out],
-            windowsHide: true,
-        });
-        child.unref();
+
+    const closeOut = () => {
         if (typeof out === 'number') {
             try {
                 fs.closeSync(out);
@@ -452,10 +446,47 @@ export function spawnService({ javaExe, argv, cwd, logPath }) {
                 /* 已交给子进程 */
             }
         }
-        return { ok: true, pid: child.pid, logPath: logPath || '' };
-    } catch (error) {
-        return { ok: false, message: `拉起进程失败：${error?.message || error}`, logPath: logPath || '' };
-    }
+    };
+
+    /**
+     * 返回 Promise：等到 'spawn' 或 'error' 再决定成败。
+     *
+     * 为什么不能直接返回 `{ok:true}`：可执行文件不存在时 spawn **不抛异常**，
+     * 而是异步发 'error'；没有监听器时 Node 把它当未捕获异常，会把 DSH 整个进程崩掉。
+     * 一键启动要连续拉起多个服务，其中一个 javaExe 配错（换机器、JDK 路径变了）
+     * 就足以让宿主挂掉，所以这里必须挂监听器，并且如实报告失败原因。
+     */
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn(exe, argv, {
+                cwd: cwd || undefined,
+                detached: true,
+                stdio: ['ignore', out, out],
+                windowsHide: true,
+            });
+        } catch (error) {
+            closeOut();
+            resolve({ ok: false, message: `拉起进程失败：${error?.message || error}`, logPath: logPath || '' });
+            return;
+        }
+
+        let settled = false;
+        const settle = (value) => {
+            if (settled) return;
+            settled = true;
+            closeOut();
+            resolve(value);
+        };
+
+        child.once('error', (error) => {
+            settle({ ok: false, message: `拉起进程失败：${error?.message || error}`, logPath: logPath || '' });
+        });
+        child.once('spawn', () => {
+            child.unref();
+            settle({ ok: true, pid: child.pid, logPath: logPath || '' });
+        });
+    });
 }
 
 /** 等端口开始 LISTENING（用 TCP 连接探测，不依赖 netstat） */