@aflueza/dev-tools 0.0.0-stage → 0.2.1-rc.2

package/README.md

@@ -1,3 +1,13 @@
-# Temporary Holding Version
+# Aflueza Dev Tools DSH Plugin
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+独立的 DSH 开发工具插件，通过右侧侧边栏提供开发辅助工具。
+
+当前包含命名格式、JSON、XML formatter、文本对比、Hit API、Mock 数据和进程管理器。代码编辑区使用 Monaco Editor；文本对比支持实时左右对照、交换和清空文本、复制任一侧内容、忽略行首尾空白及差异统计。进程管理器通过 DSH 主进程读取本机进程和端口信息；按钮、菜单、图标和视觉 token 与 Harness 保持一致。
+
+API 请求历史、Mock 数据和加密配置保存在 `~/.dsh/plugins/dev-tools/` 下的 SQLite 数据库中；同一 Windows 用户的 Web 与桌面端共用这些数据。
+
+进程管理器支持按名称、命令行、PID 或端口号搜索，默认不加载全量进程，并提供详情、端口绑定、自动刷新和结束进程。也可以输入完整文件或目录路径，查找当前占用该文件、或占用目录内文件的进程；目录查询会流式递归遍历并按批检查，一旦发现占用进程就立即停止继续扫描。Windows 使用系统 Restart Manager，其他平台依赖 `lsof`。读取或结束受当前用户权限限制，失败会在面板内展示。
+
+```powershell
+pnpm dsh plugin --profile web add @aflueza/dev-tools@0.2.1-rc.2
+```

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: dev-tools
+      name: '@aflueza/dev-tools'

package/lib/api-runner/database.js

@@ -0,0 +1,216 @@
+import { DatabaseSync } from 'node:sqlite';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+const SCHEMA_VERSION = 2;
+const HISTORY_LIMIT = 100;
+const json = (value) => JSON.stringify(value);
+const parse = (value) => JSON.parse(value);
+export class ApiDatabase {
+    historyLimit;
+    db;
+    writeQueue = Promise.resolve();
+    constructor(path, historyLimit = HISTORY_LIMIT) {
+        this.historyLimit = historyLimit;
+        mkdirSync(dirname(path), { recursive: true });
+        this.db = new DatabaseSync(path);
+        this.db.exec('PRAGMA foreign_keys = ON; PRAGMA busy_timeout = 5000;');
+        const version = Number(this.db.prepare('PRAGMA user_version').get().user_version);
+        if (version > SCHEMA_VERSION)
+            throw new Error(`api database schema ${version} is newer than supported ${SCHEMA_VERSION}`);
+        this.db
+            .exec(`CREATE TABLE IF NOT EXISTS api_collections (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL UNIQUE, order_index INTEGER NOT NULL DEFAULT 0, created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP);
+      CREATE TABLE IF NOT EXISTS api_requests (id INTEGER PRIMARY KEY AUTOINCREMENT, collection_id INTEGER NOT NULL REFERENCES api_collections(id) ON DELETE CASCADE, name TEXT NOT NULL, order_index INTEGER NOT NULL DEFAULT 0, method TEXT NOT NULL, url TEXT NOT NULL, query_params_json TEXT NOT NULL, headers_json TEXT NOT NULL, body_mode TEXT NOT NULL, body TEXT NOT NULL, body_form_data_json TEXT NOT NULL, created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP, updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP);
+      CREATE TABLE IF NOT EXISTS api_history (id INTEGER PRIMARY KEY AUTOINCREMENT, request_snapshot_json TEXT NOT NULL, response_summary_json TEXT NOT NULL, created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP);`);
+        for (const sql of [
+            'ALTER TABLE api_collections ADD COLUMN order_index INTEGER NOT NULL DEFAULT 0',
+            'ALTER TABLE api_requests ADD COLUMN order_index INTEGER NOT NULL DEFAULT 0',
+        ]) {
+            try {
+                this.db.exec(sql);
+            }
+            catch { }
+        }
+        this.db.exec('UPDATE api_collections SET order_index=id WHERE order_index=0; UPDATE api_requests SET order_index=id WHERE order_index=0;');
+        this.db.exec(`PRAGMA user_version = ${SCHEMA_VERSION}`);
+    }
+    close() {
+        this.db.close();
+    }
+    enqueue(task) {
+        const run = this.writeQueue.then(task);
+        this.writeQueue = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    listCollections() {
+        return this.db
+            .prepare('SELECT id,name,order_index,created_at,updated_at FROM api_collections ORDER BY order_index,id')
+            .all().map(this.collection);
+    }
+    createCollection(name) {
+        return this.enqueue(() => {
+            const n = name.trim() || '新集合';
+            const max = Number(this.db.prepare('SELECT COALESCE(MAX(order_index),0) n FROM api_collections').get().n);
+            this.db.prepare('INSERT INTO api_collections(name,order_index) VALUES (?,?)').run(n, max + 1);
+            const row = this.db.prepare('SELECT last_insert_rowid() id').get();
+            if (row.id === undefined)
+                throw new Error('failed to read created collection id');
+            return this.getCollection(Number(row.id));
+        });
+    }
+    ensureCollection(name) {
+        const found = this.listCollections().find((x) => x.name === (name.trim() || '新集合'));
+        return found ? Promise.resolve(found) : this.createCollection(name);
+    }
+    renameCollection(id, name) {
+        return this.enqueue(() => {
+            this.db
+                .prepare('UPDATE api_collections SET name=?,updated_at=CURRENT_TIMESTAMP WHERE id=?')
+                .run(name.trim() || '未命名集合', id);
+            return this.getCollection(id);
+        });
+    }
+    deleteCollection(id) {
+        return this.enqueue(() => {
+            this.db.prepare('DELETE FROM api_collections WHERE id=?').run(id);
+        });
+    }
+    getCollection(id) {
+        const row = this.db
+            .prepare('SELECT id,name,created_at,updated_at FROM api_collections WHERE id=?')
+            .get(id);
+        if (!row)
+            throw new Error('collection not found');
+        return this.collection(row);
+    }
+    collection(row) {
+        return {
+            id: Number(row.id),
+            name: String(row.name),
+            orderIndex: Number(row.order_index),
+            createdAt: String(row.created_at),
+            updatedAt: String(row.updated_at),
+        };
+    }
+    listRequests() {
+        return this.db
+            .prepare('SELECT * FROM api_requests ORDER BY collection_id,order_index,id')
+            .all().map((row) => ({
+            id: Number(row.id),
+            collectionId: Number(row.collection_id),
+            name: String(row.name),
+            orderIndex: Number(row.order_index),
+            request: {
+                method: row.method,
+                url: row.url,
+                queryParams: parse(row.query_params_json),
+                headers: parse(row.headers_json),
+                bodyMode: row.body_mode,
+                body: row.body,
+                bodyFormData: parse(row.body_form_data_json),
+            },
+            createdAt: String(row.created_at),
+            updatedAt: String(row.updated_at),
+        }));
+    }
+    saveRequest(payload) {
+        return this.enqueue(() => {
+            const r = sanitize(payload.request);
+            const args = [
+                payload.collectionId,
+                payload.name.trim() || '未命名请求',
+                r.method,
+                r.url,
+                json(r.queryParams),
+                json(r.headers),
+                r.bodyMode,
+                r.body,
+                json(r.bodyFormData),
+            ];
+            let id = payload.id;
+            if (id)
+                this.db
+                    .prepare('UPDATE api_requests SET collection_id=?,name=?,method=?,url=?,query_params_json=?,headers_json=?,body_mode=?,body=?,body_form_data_json=?,updated_at=CURRENT_TIMESTAMP WHERE id=?')
+                    .run(...args, id);
+            else {
+                this.db
+                    .prepare('INSERT INTO api_requests(collection_id,name,method,url,query_params_json,headers_json,body_mode,body,body_form_data_json) VALUES(?,?,?,?,?,?,?,?,?)')
+                    .run(...args);
+                const row = this.db.prepare('SELECT last_insert_rowid() id').get();
+                if (row.id === undefined)
+                    throw new Error('failed to read created request id');
+                id = Number(row.id);
+            }
+            return this.listRequests().find((x) => x.id === id);
+        });
+    }
+    renameRequest(id, name) {
+        return this.enqueue(() => {
+            this.db
+                .prepare('UPDATE api_requests SET name=?,updated_at=CURRENT_TIMESTAMP WHERE id=?')
+                .run(name.trim() || '未命名请求', id);
+            return this.listRequests().find((x) => x.id === id);
+        });
+    }
+    reorderCollections(ids) {
+        return this.enqueue(() => ids.forEach((id, i) => this.db.prepare('UPDATE api_collections SET order_index=? WHERE id=?').run(i, id)));
+    }
+    reorderRequests(collectionId, ids) {
+        return this.enqueue(() => ids.forEach((id, i) => this.db
+            .prepare('UPDATE api_requests SET order_index=? WHERE id=? AND collection_id=?')
+            .run(i, id, collectionId)));
+    }
+    moveRequest(id, collectionId) {
+        return this.enqueue(() => {
+            const max = Number(this.db
+                .prepare('SELECT COALESCE(MAX(order_index),0) n FROM api_requests WHERE collection_id=?')
+                .get(collectionId).n);
+            this.db
+                .prepare('UPDATE api_requests SET collection_id=?,order_index=?,updated_at=CURRENT_TIMESTAMP WHERE id=?')
+                .run(collectionId, max + 1, id);
+            return this.listRequests().find((x) => x.id === id);
+        });
+    }
+    deleteRequest(id) {
+        return this.enqueue(() => {
+            this.db.prepare('DELETE FROM api_requests WHERE id=?').run(id);
+        });
+    }
+    listHistory(limit = this.historyLimit) {
+        return this.db
+            .prepare('SELECT * FROM api_history ORDER BY id DESC LIMIT ?')
+            .all(Math.min(Math.max(limit, 1), this.historyLimit)).map((row) => ({
+            id: Number(row.id),
+            requestSnapshot: parse(row.request_snapshot_json),
+            responseSummary: parse(row.response_summary_json),
+            createdAt: String(row.created_at),
+        }));
+    }
+    addHistory(request, response) {
+        return this.enqueue(() => {
+            this.db
+                .prepare('INSERT INTO api_history(request_snapshot_json,response_summary_json) VALUES(?,?)')
+                .run(json(sanitize(request)), json(response));
+            this.db
+                .prepare('DELETE FROM api_history WHERE id NOT IN (SELECT id FROM api_history ORDER BY id DESC LIMIT ?)')
+                .run(this.historyLimit);
+        });
+    }
+    deleteHistory(id) {
+        return this.enqueue(() => {
+            this.db.prepare('DELETE FROM api_history WHERE id=?').run(id);
+        });
+    }
+    clearHistory() {
+        return this.enqueue(() => {
+            this.db.prepare('DELETE FROM api_history').run();
+        });
+    }
+}
+function sanitize(r) {
+    return {
+        ...r,
+        queryParams: r.queryParams ?? [],
+        headers: r.headers ?? [],
+        bodyFormData: (r.bodyFormData ?? []).map((x) => ({ ...x, fileContent: undefined })),
+    };
+}

package/lib/api-runner/service.js

@@ -0,0 +1,121 @@
+import { readFile } from 'node:fs/promises';
+import { performance } from 'node:perf_hooks';
+import { ApiDatabase } from './database.js';
+export class ApiRunnerError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+export class ApiRunnerService {
+    timeoutMs;
+    maxBytes;
+    database;
+    constructor(path, timeoutMs = 30_000, maxBytes = 4 * 1024 * 1024, historyLimit = 100) {
+        this.timeoutMs = timeoutMs;
+        this.maxBytes = maxBytes;
+        this.database = new ApiDatabase(path, historyLimit);
+    }
+    close() {
+        this.database.close();
+    }
+    async send(request) {
+        if (!['GET', 'POST', 'PUT', 'PATCH', 'DELETE'].includes(request.method))
+            throw new ApiRunnerError('invalid-method', '仅支持 GET、POST、PUT、PATCH 和 DELETE 请求。');
+        let url;
+        try {
+            url = new URL(request.url.trim());
+        }
+        catch {
+            throw new ApiRunnerError('invalid-url', 'URL 无效。');
+        }
+        if (!['http:', 'https:'].includes(url.protocol))
+            throw new ApiRunnerError('invalid-url', 'URL 必须以 http:// 或 https:// 开头。');
+        for (const row of request.queryParams ?? [])
+            if (row.enabled && row.key.trim())
+                url.searchParams.append(row.key.trim(), row.value);
+        const headers = new Headers();
+        for (const row of request.headers ?? [])
+            if (row.enabled && row.key.trim()) {
+                try {
+                    headers.set(row.key.trim(), row.value);
+                }
+                catch {
+                    throw new ApiRunnerError('invalid-header', `请求头无效：${row.key}`);
+                }
+            }
+        let body;
+        if (request.method !== 'GET' && request.bodyMode !== 'none') {
+            if (request.bodyMode === 'form-data') {
+                const form = new FormData();
+                for (const row of request.bodyFormData ?? [])
+                    if (row.enabled && row.key.trim()) {
+                        if (row.kind === 'file' && (row.filePath || row.fileContent?.length)) {
+                            const bytes = row.filePath
+                                ? await readFile(row.filePath)
+                                : new Uint8Array(row.fileContent ?? []);
+                            form.append(row.key, new Blob([bytes], { type: row.fileMimeType || 'application/octet-stream' }), row.fileName);
+                        }
+                        else
+                            form.append(row.key, row.value);
+                    }
+                body = form;
+            }
+            else {
+                body = request.body;
+                if (request.bodyMode === 'json' && !headers.has('content-type'))
+                    headers.set('content-type', 'application/json');
+            }
+        }
+        const started = performance.now();
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await fetch(url, {
+                method: request.method,
+                headers,
+                body,
+                signal: controller.signal,
+            });
+            const reader = response.body?.getReader();
+            let text = '';
+            let size = 0;
+            if (reader) {
+                const decoder = new TextDecoder();
+                while (true) {
+                    const next = await reader.read();
+                    if (next.done) {
+                        text += decoder.decode();
+                        break;
+                    }
+                    size += next.value.byteLength;
+                    if (size > this.maxBytes)
+                        throw new ApiRunnerError('response-too-large', '响应超过大小限制。');
+                    text += decoder.decode(next.value, { stream: true });
+                }
+            }
+            else
+                text = await response.text();
+            const result = {
+                status: response.status,
+                statusText: response.statusText,
+                durationMs: Math.round(performance.now() - started),
+                body: text,
+                headers: [...response.headers].map(([key, value]) => ({ key, value })),
+            };
+            await this.database.addHistory(request, result);
+            return { ...result, request };
+        }
+        catch (error) {
+            if (error instanceof ApiRunnerError)
+                throw error;
+            if (controller.signal.aborted)
+                throw new ApiRunnerError('timeout', '请求超时。');
+            throw new ApiRunnerError('network-error', error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}