dsh-api-runner 0.0.0-stage → 0.2.0

package/cordis.patch.yml

@@ -0,0 +1,9 @@
+# dsh-api-runner bundle patch（dsh.bundle.patch：顶层数组 loader patch entries）
+# 安装：dsh plugin --profile desktop add "link:/绝对路径/到/dsh-api-runner"
+#
+# name 写包名时由 DSH 从安装目录解析入口，这是发布形态（提交到仓库、别人装得上的就是这一份）。
+# 开发期改源码后必须让入口 URL 变化（Node 按模块 URL 缓存 ESM），此时跑 `node scripts/stage.mjs`
+# 会把下面这行改成本机 build/vN/main.js 的 file URL；提交前跑 `node scripts/stage.mjs --release` 改回来。
+- insert:
+    - id: api-runner
+      name: dsh-api-runner

package/dsh-api-runner.example.yml

@@ -0,0 +1,92 @@
+# dsh-api-runner 配置示例
+# 位置：${DSH_HOME}/api-runner.yml（全局），或 <项目>/.dsh/api-runner.yml（项目级，覆盖全局）
+# 改完保存即生效，不需要重启 DSH。
+#
+# 引用环境变量：${SOME_ENV}（在 url/headers/command 里都可以用）
+# 调用期占位符：{name}（模型调接口时通过 params 传入，会替换 URL 与 body 里的同名占位）
+
+defaults:
+  timeoutMs: 30000
+
+env:
+  # 可以在这里定义命名常量，例如：
+  # API_HOST: http://127.0.0.1:8080
+  # TOKEN: ${DEV_TOKEN}
+
+apis:
+  # 最小配置
+  - id: health
+    name: 健康检查
+    method: GET
+    url: http://127.0.0.1:8080/actuator/health
+
+  # 路径占位 + query 参数
+  - id: get-user
+    name: 查询用户
+    method: GET
+    url: http://127.0.0.1:8080/api/users/{id}
+    headers:
+      Authorization: "Bearer ${DEV_TOKEN}"
+    query:
+      verbose: "true"
+
+  # POST JSON：body 里的 {name} 由模型传参替换
+  - id: create-order
+    name: 创建订单
+    method: POST
+    url: http://127.0.0.1:8080/api/orders
+    headers:
+      Content-Type: application/json
+      Authorization: "Bearer ${DEV_TOKEN}"
+    body:
+      userId: "{userId}"
+      amount: "{amount}"
+      remark: "{remark}"
+
+  # POST 表单
+  - id: login
+    name: 登录
+    method: POST
+    url: http://127.0.0.1:8080/api/login
+    headers:
+      Content-Type: application/x-www-form-urlencoded
+    body:
+      username: "{username}"
+      password: "{password}"
+
+services:
+  # managed：插件托管进程（启动/停止/重启都由插件做，DSH 重启后服务仍在跑）
+  - id: app
+    name: 本地后端
+    mode: managed
+    cwd: ./            # 相对配置文件所在目录解析
+    # Windows 下 .cmd/.bat 会自动用 shell 启动
+    command: ./mvnw.cmd
+    args: ["spring-boot:run"]
+    env:
+      SPRING_PROFILES_ACTIVE: dev
+    logPath: ./logs/app.log        # 子进程 stdout/stderr 追加到这里
+    startupTimeoutMs: 90000        # 等健康检查通过的最长时间
+    stopTimeoutMs: 15000
+    health:
+      url: http://127.0.0.1:8080/actuator/health
+      expectStatus: 200
+      intervalMs: 1000
+      timeoutMs: 2000
+
+  # observe：进程由 IDEA 启动（用 IDEA 的 restart 按钮），插件只观测
+  - id: idea-app
+    name: IDEA 里跑的 Spring Boot
+    mode: observe
+    health:
+      url: http://127.0.0.1:8080/actuator/health
+      expectStatus: 200
+      ports: [8080]
+
+logs:
+  - id: app-log
+    name: 后端日志
+    path: ./logs/app.log
+  - id: idea-console
+    name: IDEA 控制台重定向文件（若你在 Run Configuration 里配了）
+    path: ./logs/idea-console.log

package/package.json

@@ -1,6 +1,71 @@
-{
-  "name": "dsh-api-runner",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+{
+  "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/scripts/stage.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * stage.mjs —— 把 src/ 打包到一个全新的 build/v<序号>/ 并用它改写 cordis.patch.yml 的入口。
+ *
+ * 为什么需要它：DSH 的插件 loader 用 ESM 动态 import，Node 按 URL 缓存模块。
+ * 同一个页面进程里 toggle bundle 只会重跑 apply，不会重新 import 模块，
+ * 所以改了 src/ 之后必须让入口 URL 变化，否则继续跑旧代码。
+ *
+ * 用法：
+ *   node scripts/stage.mjs            # 递增版本号，自动改写 patch
+ *   node scripts/stage.mjs --clean    # 只保留最新一版 build
+ *   node scripts/stage.mjs --release  # 把 patch 的入口改回包名（提交/发布用）
+ * 之后到 DSH 里把 dsh-api-runner 这个 bundle 关掉再打开。
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const srcDir = path.join(root, 'src');
+const buildDir = path.join(root, 'build');
+const PACKAGE_NAME = 'dsh-api-runner';
+const patchPath = path.join(root, 'cordis.patch.yml');
+
+/** 把 patch 里的入口行改写成给定的 name，返回是否改动过 */
+function rewriteEntry(name) {
+    const patch = fs.readFileSync(patchPath, 'utf8');
+    const rewritten = patch.replace(/^(\s+name:\s*).*$/m, `$1${name}`);
+    if (rewritten === patch && !patch.includes(name)) {
+        console.error('cordis.patch.yml 里没找到 name 行，未改写');
+        process.exit(1);
+    }
+    if (rewritten !== patch) fs.writeFileSync(patchPath, rewritten, 'utf8');
+    return rewritten !== patch;
+}
+
+// 发布形态：入口写包名，DSH 从安装目录解析；提交到仓库前跑这个
+if (process.argv.includes('--release')) {
+    rewriteEntry(PACKAGE_NAME);
+    console.log(`cordis.patch.yml 入口 → ${PACKAGE_NAME}（发布形态，不含本机路径）`);
+    process.exit(0);
+}
+
+function nextVersion() {
+    if (!fs.existsSync(buildDir)) return 1;
+    const used = fs.readdirSync(buildDir)
+        .map((name) => /^v(\d+)$/.exec(name))
+        .filter(Boolean)
+        .map((m) => Number(m[1]));
+    return used.length ? Math.max(...used) + 1 : 1;
+}
+
+const version = `v${nextVersion()}`;
+const outDir = path.join(buildDir, version);
+fs.mkdirSync(outDir, { recursive: true });
+
+const files = fs.readdirSync(srcDir).filter((name) => name.endsWith('.js'));
+for (const name of files) fs.copyFileSync(path.join(srcDir, name), path.join(outDir, name));
+
+// 入口统一叫 main.js（与 src/main.js 对齐），loader 只需一个入口 URL。
+const entry = path.join(outDir, 'main.js');
+if (!fs.existsSync(entry)) {
+    console.error(`src/main.js 不存在，无法确定插件入口`);
+    process.exit(1);
+}
+
+const entryUrl = pathToFileURL(entry).href;
+rewriteEntry(entryUrl);
+
+if (process.argv.includes('--clean')) {
+    for (const name of fs.readdirSync(buildDir)) {
+        if (name !== version) fs.rmSync(path.join(buildDir, name), { recursive: true, force: true });
+    }
+}
+
+console.log(`已发布 ${files.length} 个文件 → ${outDir}`);
+console.log(`cordis.patch.yml 入口 → ${entryUrl}`);
+console.log('下一步：在 DSH 里把 dsh-api-runner bundle 关掉再打开（set_bundle false → true）');

package/src/api.js

@@ -0,0 +1,194 @@
+/**
+ * 接口调用：按配置里的接口定义发 HTTP 请求。
+ *
+ * 约定：
+ *  - url 支持 {param} 路径占位，params 里的键会同时用于路径替换与 query 拼接；
+ *  - body 支持 {param} 模板展开；若 body 是对象且定义了 json 类型，序列化为 JSON；
+ *  - 超时用 AbortSignal.timeout，失败统一返回结构化结果而不是抛异常（工具层好渲染）。
+ */
+import { expandBraces, expandDeep, isPlainObject, truncateText, tryJson } from './util.js';
+
+const DEFAULT_TIMEOUT = 30_000;
+
+/** 把 params 里未被 url 占位消耗的键拼成 query string */
+function buildQuery(query, params, url) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(query || {})) {
+        if (value === undefined || value === null) continue;
+        search.append(key, String(expandBraces(value, params)));
+    }
+    for (const [key, value] of Object.entries(params || {})) {
+        if (value === undefined || value === null) continue;
+        // url 占位已用的键不再重复进 query
+        if (url.includes(`{${key}}`)) continue;
+        if (key in (query || {})) continue;
+        search.append(key, typeof value === 'object' ? JSON.stringify(value) : String(value));
+    }
+    const text = search.toString();
+    return text === '' ? '' : `?${text}`;
+}
+
+/** 拼接完整 URL：baseUrl + url（+ query），并对展开后的地址做合法性校验 */
+function buildUrl(api, params) {
+    let target = expandBraces(api.url, params);
+    if (api.baseUrl) {
+        const base = api.baseUrl.endsWith('/') ? api.baseUrl.slice(0, -1) : api.baseUrl;
+        if (!/^https?:\/\//i.test(target)) target = `${base}/${target.replace(/^\//, '')}`;
+    }
+    const queryText = buildQuery(api.query, params, api.url).replace(/^\?/, '');
+    let normalized = target;
+    if (queryText !== '') normalized = `${target}${target.includes('?') ? '&' : '?'}${queryText}`;
+    try {
+        const parsed = new URL(normalized);
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+            throw new Error(`不支持的协议 ${parsed.protocol}`);
+        }
+        return parsed.toString();
+    } catch (error) {
+        throw new Error(`接口 ${api.id} 的 URL 非法：${normalized}（${error.message}）`);
+    }
+}
+
+/**
+ * 依据 method 决定是否带 body，并按 content-type 处理。
+ *
+ * 注意：headers 是**真实要发出去的**请求头对象，这里必须原地补 content-type。
+ * 早期实现内部又拷贝了一份，导致 JSON body 实际以 fetch 默认的
+ * `text/plain;charset=UTF-8` 发出，Spring 端直接 500：
+ * `Content type 'text/plain;charset=UTF-8' not supported`。
+ */
+function buildBody(api, params, headers) {
+    const method = api.method;
+    if (method === 'GET' || method === 'HEAD') return undefined;
+    if (api.body === undefined || api.body === null) return undefined;
+
+    const expanded = expandDeep(api.body, {}, params);
+    const contentType = findHeader(headers, 'content-type');
+    if (typeof expanded === 'string') {
+        // body 是字符串时，如果内容看起来是 JSON 就按 JSON 发；否则明确用 text/plain。
+        // 两者都必须**显式**设置：fetch 在没设 content-type 时默认 text/plain，
+        // 对 Spring 的 @RequestBody JSON 接口会直接 500。
+        if (!contentType) {
+            setHeader(headers, 'content-type', tryJson(expanded) !== undefined
+                ? 'application/json; charset=utf-8'
+                : 'text/plain; charset=utf-8');
+        }
+        return expanded;
+    }
+    if (contentType && /x-www-form-urlencoded/i.test(contentType)) {
+        return new URLSearchParams(flattenPairs(expanded)).toString();
+    }
+    if (!contentType) setHeader(headers, 'content-type', 'application/json; charset=utf-8');
+    return JSON.stringify(expanded);
+}
+
+function flattenPairs(value) {
+    const out = [];
+    for (const [key, item] of Object.entries(value || {})) {
+        if (item === undefined || item === null) continue;
+        out.push([key, typeof item === 'object' ? JSON.stringify(item) : String(item)]);
+    }
+    return out;
+}
+
+function normalizeHeaders(headers) {
+    const out = {};
+    for (const [key, value] of Object.entries(headers || {})) {
+        if (value === undefined || value === null) continue;
+        out[key] = String(value);
+    }
+    return out;
+}
+
+function findHeader(headers, name) {
+    const key = Object.keys(headers).find((item) => item.toLowerCase() === name.toLowerCase());
+    return key ? headers[key] : undefined;
+}
+
+function setHeader(headers, name, value) {
+    const existing = Object.keys(headers).find((item) => item.toLowerCase() === name.toLowerCase());
+    if (existing) headers[existing] = value;
+    else headers[name] = value;
+}
+
+/**
+ * 执行一次接口调用。
+ * @returns {Promise<{ok:boolean,apiId:string,method:string,url:string,status:number,statusText:string,
+ *   durationMs:number,headers:Record<string,string>,body:string,json?:unknown,error?:string}>}
+ */
+export async function callApi(api, params = {}, options = {}) {
+    const started = Date.now();
+    const timeoutMs = Number(options.timeoutMs || api.timeoutMs || DEFAULT_TIMEOUT);
+    const result = {
+        ok: false,
+        apiId: api.id,
+        name: api.name,
+        method: api.method,
+        url: '',
+        status: 0,
+        statusText: '',
+        durationMs: 0,
+        headers: {},
+        body: '',
+    };
+
+    let url;
+    let headers;
+    let body;
+    try {
+        url = buildUrl(api, params);
+        headers = normalizeHeaders(expandDeep(api.headers || {}, {}, params));
+        body = buildBody(api, params, headers);
+    } catch (error) {
+        result.error = error.message;
+        result.durationMs = Date.now() - started;
+        return result;
+    }
+    result.url = url;
+
+    if (api.baseUrl) setHeader(headers, 'accept', findHeader(headers, 'accept') || 'application/json, text/plain, */*');
+
+    try {
+        const response = await fetch(url, {
+            method: api.method,
+            headers,
+            body,
+            signal: AbortSignal.timeout(timeoutMs),
+            redirect: 'follow',
+        });
+        result.status = response.status;
+        result.statusText = response.statusText;
+        result.ok = response.ok;
+        for (const [key, value] of response.headers.entries()) result.headers[key] = value;
+        const text = await response.text();
+        const maxBytes = Number(options.maxBodyBytes || 32 * 1024);
+        result.body = truncateText(text, maxBytes);
+        const parsed = tryJson(text);
+        if (parsed !== undefined) result.json = parsed;
+        if (text.length > (result.body || '').length) result.truncated = true;
+    } catch (error) {
+        result.error = error.name === 'TimeoutError'
+            ? `请求超时（${timeoutMs}ms）`
+            : String(error?.message || error);
+    }
+    result.durationMs = Date.now() - started;
+    return result;
+}
+
+/** 从响应 JSON 里按简单路径取值（a.b[0].c），用于校验 */
+export function pickPath(value, dotted) {
+    if (!dotted || !isPlainObject(Object(value)) && !Array.isArray(value)) return undefined;
+    let cursor = value;
+    for (const raw of String(dotted).split('.')) {
+        if (cursor === undefined || cursor === null) return undefined;
+        const match = /^([^[\]]*)((\[\d+\])*)$/.exec(raw);
+        if (!match) return undefined;
+        const [, head, indexes] = match;
+        if (head) cursor = cursor[head];
+        for (const idx of indexes.match(/\d+/g) || []) {
+            if (!Array.isArray(cursor)) return undefined;
+            cursor = cursor[Number(idx)];
+        }
+    }
+    return cursor;
+}