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

package/lib/crypto/service.js

@@ -0,0 +1,242 @@
+// @ts-nocheck
+import { createCipheriv, createDecipheriv, createHash } from 'node:crypto';
+import { DatabaseSync } from 'node:sqlite';
+import { dirname, resolve } from 'node:path';
+import { mkdirSync } from 'node:fs';
+export class CryptoError extends Error {
+    code;
+    itemIndex;
+    constructor(code, message, itemIndex) {
+        super(message);
+        this.code = code;
+        this.itemIndex = itemIndex;
+    }
+}
+const parse = (x) => JSON.parse(x);
+export class CryptoService {
+    db;
+    queue = Promise.resolve();
+    constructor(path) {
+        mkdirSync(dirname(resolve(path)), { recursive: true });
+        this.db = new DatabaseSync(path);
+        this.db.exec('PRAGMA busy_timeout=5000; CREATE TABLE IF NOT EXISTS crypto_profiles (id INTEGER PRIMARY KEY AUTOINCREMENT,name TEXT NOT NULL UNIQUE,is_default INTEGER NOT NULL DEFAULT 0,config_json TEXT NOT NULL,created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP);');
+    }
+    close() {
+        this.db.close();
+    }
+    write(fn) {
+        const run = this.queue.then(fn);
+        this.queue = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    list() {
+        return this.db
+            .prepare('SELECT * FROM crypto_profiles ORDER BY is_default DESC,updated_at DESC,id')
+            .all().map(this.row);
+    }
+    save(payload) {
+        return this.write(() => {
+            const name = payload.name.trim() || '未命名配置';
+            if (payload.id)
+                this.db
+                    .prepare('UPDATE crypto_profiles SET name=?,config_json=?,updated_at=CURRENT_TIMESTAMP WHERE id=?')
+                    .run(name, JSON.stringify(payload.config), payload.id);
+            else {
+                this.db
+                    .prepare('INSERT INTO crypto_profiles(name,config_json) VALUES(?,?)')
+                    .run(name, JSON.stringify(payload.config));
+                payload.id = Number(this.db.prepare('SELECT last_insert_rowid() id').get().id);
+            }
+            return this.list().find((x) => x.id === payload.id);
+        });
+    }
+    rename(id, name) {
+        return this.write(() => {
+            this.db
+                .prepare('UPDATE crypto_profiles SET name=?,updated_at=CURRENT_TIMESTAMP WHERE id=?')
+                .run(name.trim() || '未命名配置', id);
+            return this.list().find((x) => x.id === id);
+        });
+    }
+    delete(id) {
+        return this.write(() => {
+            this.db.prepare('DELETE FROM crypto_profiles WHERE id=?').run(id);
+        });
+    }
+    setDefault(id) {
+        return this.write(() => {
+            this.db.exec('UPDATE crypto_profiles SET is_default=0');
+            this.db.prepare('UPDATE crypto_profiles SET is_default=1 WHERE id=?').run(id);
+        });
+    }
+    execute(request) {
+        const c = request.config;
+        const algorithm = c.algorithm;
+        const list = c.batch?.mode === 'list';
+        const items = list
+            ? splitBatch(request.input, String(c.batch.separator ?? ','), String(c.batch.wrapper ?? '"'))
+            : [request.input];
+        const outputs = items.map((item, i) => {
+            try {
+                return item === '' && ['decrypt', 'decode'].includes(request.operation)
+                    ? ''
+                    : transform(item, request.operation, c);
+            }
+            catch (e) {
+                if (list && ['decrypt', 'decode'].includes(request.operation))
+                    return `${request.operation === 'decrypt' ? '解密失败：' : '解码失败：'}${item}`;
+                throw new CryptoError('item-failed', e instanceof Error ? e.message : String(e), i);
+            }
+        });
+        return {
+            output: list
+                ? outputs
+                    .map((x) => `${c.batch.wrapper ?? '"'}${x}${c.batch.wrapper ?? '"'}`)
+                    .join(c.batch.separator ?? ',')
+                : outputs[0],
+            itemCount: outputs.length,
+            algorithm,
+        };
+    }
+    row(row) {
+        return {
+            id: Number(row.id),
+            name: String(row.name),
+            isDefault: Boolean(row.is_default),
+            config: parse(row.config_json),
+            createdAt: String(row.created_at),
+            updatedAt: String(row.updated_at),
+        };
+    }
+}
+function splitBatch(input, separator, wrapper) {
+    if (!separator)
+        throw new CryptoError('invalid-batch', '分隔符不能为空');
+    const isNewline = /^(?:\r\n|\r|\n|\u0085|\u2028|\u2029)$/.test(separator);
+    const separators = isNewline
+        ? ['\r\n', '\n', '\r', '\u0085', '\u2028', '\u2029']
+        : separator === ','
+            ? [',', '，']
+            : separator === ';'
+                ? [';', '；']
+                : [separator];
+    const matchSeparator = (position) => separators
+        .sort((a, b) => b.length - a.length)
+        .find((value) => input.startsWith(value, position));
+    if (!wrapper) {
+        const out = [];
+        let start = 0;
+        for (let i = 0; i < input.length;) {
+            const matched = matchSeparator(i);
+            if (matched) {
+                out.push(input.slice(start, i).trim());
+                i += matched.length;
+                start = i;
+            }
+            else
+                i++;
+        }
+        out.push(input.slice(start).trim());
+        return out;
+    }
+    const out = [];
+    let i = 0;
+    let trailingSeparator = false;
+    while (i <= input.length) {
+        while (i < input.length && /[ \t\f\v]/.test(input[i]))
+            i++;
+        if (i >= input.length) {
+            if (trailingSeparator || out.length === 0)
+                out.push('');
+            break;
+        }
+        const emptySeparator = matchSeparator(i);
+        if (emptySeparator) {
+            out.push('');
+            i += emptySeparator.length;
+            trailingSeparator = true;
+            continue;
+        }
+        if (!input.startsWith(wrapper, i))
+            throw new CryptoError('invalid-batch', `第 ${i + 1} 个字符必须是包裹符`);
+        i += wrapper.length;
+        const start = i;
+        let end = -1;
+        while (i < input.length) {
+            if (input.startsWith(wrapper, i)) {
+                end = i;
+                i += wrapper.length;
+                break;
+            }
+            i++;
+        }
+        if (end < 0)
+            throw new CryptoError('invalid-batch', '包裹符未闭合');
+        out.push(input.slice(start, end).trim());
+        trailingSeparator = false;
+        while (i < input.length && /[ \t\f\v]/.test(input[i]))
+            i++;
+        if (i === input.length)
+            break;
+        const matched = matchSeparator(i);
+        if (!matched)
+            throw new CryptoError('invalid-batch', '项之间缺少分隔符');
+        i += matched.length;
+        trailingSeparator = true;
+    }
+    if (!out.length)
+        throw new CryptoError('invalid-batch', '批量输入不能为空');
+    return out;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function bytes(value, encoding) {
+    if (encoding === 'hex') {
+        if (!/^(?:[0-9a-f]{2})*$/i.test(value))
+            throw new Error('Hex 内容无效');
+        return Buffer.from(value, 'hex');
+    }
+    if (encoding === 'base64')
+        return Buffer.from(value, 'base64');
+    return Buffer.from(value, 'utf8');
+}
+function transform(input, operation, c) {
+    const inEnc = c.inputEncoding || 'utf8', outEnc = c.outputEncoding || 'base64';
+    if (c.algorithm === 'base64') {
+        if (operation === 'encode')
+            return Buffer.from(input, inEnc === 'hex' ? 'hex' : inEnc === 'base64' ? 'base64' : 'utf8').toString(outEnc === 'hex' ? 'hex' : 'base64');
+        if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(input))
+            throw new Error('Base64 内容无效');
+        const decoded = Buffer.from(input, 'base64');
+        return outEnc === 'hex'
+            ? decoded.toString('hex')
+            : outEnc === 'base64'
+                ? decoded.toString('base64')
+                : decoded.toString('utf8');
+    }
+    if (c.algorithm === 'sm3') {
+        const b = bytes(input, inEnc);
+        const h = createHash('sm3').update(b).digest();
+        return outEnc === 'hex' ? h.toString('hex') : h.toString('base64');
+    }
+    const key = bytes(String(c.key || ''), c.keyEncoding || 'utf8');
+    const mode = c.mode || 'cbc';
+    const cipherName = c.algorithm === 'aes' ? `aes-${key.length * 8}-${mode}` : `sm4-${mode}`;
+    if (![16, 24, 32].includes(key.length) || (c.algorithm === 'sm4' && key.length !== 16))
+        throw new Error('密钥长度无效');
+    const iv = mode === 'ecb' ? null : bytes(String(c.iv || ''), c.ivEncoding || 'utf8');
+    if (iv !== null && iv.length !== 16)
+        throw new Error('IV 必须为 16 字节');
+    const options = c.padding === 'nopadding' ? { autoPadding: false } : undefined;
+    const data = bytes(input, inEnc);
+    const x = operation === 'encrypt'
+        ? createCipheriv(cipherName, key, iv, options)
+        : createDecipheriv(cipherName, key, iv, options);
+    const result = Buffer.concat([x.update(data), x.final()]);
+    return outEnc === 'hex'
+        ? result.toString('hex')
+        : outEnc === 'utf8'
+            ? result.toString('utf8')
+            : result.toString('base64');
+}

package/lib/index.js

@@ -0,0 +1,41 @@
+import { dshHomePath } from '@deepseek-ai/dsh-home-paths';
+import { handleRpcRequest, RPC_CHANNEL } from './process-manager/rpc.js';
+import { ApiRunnerService } from './api-runner/service.js';
+import { MockDataDatabase } from './mock-data/database.js';
+import { CryptoService } from './crypto/service.js';
+import z from '@deepseek-ai/schemastery';
+export const name = 'dev-tools';
+export const inject = ['connection', 'webServer'];
+export const Config = z
+    .object({
+    apiRunner: z
+        .object({
+        requestTimeoutMs: z.number().default(30000),
+        maxResponseBytes: z.number().default(4194304),
+        historyLimit: z.number().default(100),
+    })
+        .default({}),
+})
+    .default({});
+export function apply(ctx, config) {
+    ctx.inject(['connection', 'webServer'], (rpcCtx) => {
+        const webServer = rpcCtx.webServer;
+        const options = config.apiRunner ?? {};
+        const api = new ApiRunnerService(dshHomePath('plugins', 'dev-tools', 'dev-tools-api.sqlite'), options.requestTimeoutMs ?? 30000, options.maxResponseBytes ?? 4194304, options.historyLimit ?? 100);
+        const mock = new MockDataDatabase(dshHomePath('plugins', 'dev-tools', 'dev-tools-mock.sqlite'));
+        const crypto = new CryptoService(dshHomePath('plugins', 'dev-tools', 'dev-tools-crypto.sqlite'));
+        rpcCtx.effect(() => {
+            const unregister = webServer.register({
+                kind: 'prefix',
+                path: RPC_CHANNEL,
+                handler: (request, response) => handleRpcRequest(rpcCtx.connection, request, response, api, mock, crypto),
+            });
+            return () => {
+                unregister();
+                api.close();
+                mock.close();
+                crypto.close();
+            };
+        }, 'dev-tools: RPC route');
+    });
+}

package/lib/mock-data/database.js

@@ -0,0 +1,92 @@
+import { DatabaseSync } from 'node:sqlite';
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+export class MockDataDatabase {
+    db;
+    queue = Promise.resolve();
+    constructor(path) {
+        mkdirSync(dirname(path), { recursive: true });
+        this.db = new DatabaseSync(path);
+        this.db.exec('PRAGMA busy_timeout=5000; CREATE TABLE IF NOT EXISTS mock_scenarios (id INTEGER PRIMARY KEY AUTOINCREMENT,name TEXT NOT NULL,fields_json TEXT NOT NULL,created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,last_used_at TEXT);');
+    }
+    close() {
+        this.db.close();
+    }
+    run(task) {
+        const result = this.queue.then(task);
+        this.queue = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    map(row) {
+        return {
+            id: Number(row.id),
+            name: String(row.name),
+            fields: JSON.parse(String(row.fields_json)),
+            createdAt: String(row.created_at),
+            updatedAt: String(row.updated_at),
+            lastUsedAt: row.last_used_at ? String(row.last_used_at) : null,
+        };
+    }
+    list() {
+        return this.db
+            .prepare('SELECT * FROM mock_scenarios ORDER BY COALESCE(last_used_at, updated_at) DESC, id DESC')
+            .all().map((x) => this.map(x));
+    }
+    save(payload) {
+        return this.run(() => {
+            const name = payload.name.trim();
+            if (!name)
+                throw new Error('场景名称不能为空');
+            const fields = JSON.stringify(payload.fields);
+            if (payload.id)
+                this.db
+                    .prepare('UPDATE mock_scenarios SET name=?,fields_json=?,updated_at=CURRENT_TIMESTAMP WHERE id=?')
+                    .run(name, fields, payload.id);
+            else {
+                this.db
+                    .prepare('INSERT INTO mock_scenarios(name,fields_json) VALUES(?,?)')
+                    .run(name, fields);
+                payload.id = Number(this.db.prepare('SELECT last_insert_rowid() id').get().id);
+            }
+            const row = this.db
+                .prepare('SELECT * FROM mock_scenarios WHERE id=?')
+                .get(payload.id);
+            return this.map(row);
+        });
+    }
+    rename(id, value) {
+        return this.run(() => {
+            const name = value.trim();
+            if (!Number.isInteger(id) || id <= 0)
+                throw new Error('场景 id 无效');
+            if (!name)
+                throw new Error('场景名称不能为空');
+            const result = this.db
+                .prepare('UPDATE mock_scenarios SET name=?,updated_at=CURRENT_TIMESTAMP WHERE id=?')
+                .run(name, id);
+            if (Number(result.changes) === 0)
+                throw new Error('场景不存在');
+            return this.map(this.db.prepare('SELECT * FROM mock_scenarios WHERE id=?').get(id));
+        });
+    }
+    delete(id) {
+        return this.run(() => {
+            if (!Number.isInteger(id) || id <= 0)
+                throw new Error('场景 id 无效');
+            const result = this.db.prepare('DELETE FROM mock_scenarios WHERE id=?').run(id);
+            if (Number(result.changes) === 0)
+                throw new Error('场景不存在');
+        });
+    }
+    use(id) {
+        return this.run(() => {
+            this.db
+                .prepare('UPDATE mock_scenarios SET last_used_at=CURRENT_TIMESTAMP WHERE id=?')
+                .run(id);
+            const row = this.db.prepare('SELECT * FROM mock_scenarios WHERE id=?').get(id);
+            if (!row)
+                throw new Error('场景不存在');
+            return this.map(row);
+        });
+    }
+}

package/lib/process-manager/rpc.js

@@ -0,0 +1,277 @@
+import { DEV_TOOLS_RPC_CHANNEL, } from '../shared/process-manager.js';
+import { ProcessManagerError, findFileLockers, getProcessDetail, listProcesses, terminateProcess, } from './service.js';
+import { ApiRunnerError } from '../api-runner/service.js';
+export const RPC_CHANNEL = DEV_TOOLS_RPC_CHANNEL;
+export async function handleRpcRequest(connection, request, response, api, mock, crypto) {
+    const rejection = connection.requestRejection(request);
+    if (rejection !== undefined) {
+        response.writeHead(rejection);
+        response.end(rejection === 401 ? 'unauthorized' : 'forbidden');
+        return;
+    }
+    const endpoint = endpointFromRequest(request);
+    if (request.method !== 'POST' || endpoint === null) {
+        response.writeHead(404);
+        response.end('not found');
+        return;
+    }
+    const mediaType = request.headers['content-type']?.split(';', 1)[0]?.trim().toLowerCase();
+    if (mediaType !== 'application/json') {
+        response.writeHead(415);
+        response.end('content type must be application/json');
+        return;
+    }
+    let message;
+    try {
+        message = parseClientRequest(await readJsonBody(request));
+    }
+    catch {
+        response.writeHead(400);
+        response.end('invalid rpc request');
+        return;
+    }
+    if (message.method !== endpoint) {
+        writeRpcResult(response, message.rpcId, fail('invalid-payload', `method ${JSON.stringify(message.method)} does not match endpoint ${JSON.stringify(endpoint)}`));
+        return;
+    }
+    if (endpoint.startsWith('api/')) {
+        if (!api) {
+            writeRpcResult(response, message.rpcId, fail('unavailable', 'API runner is unavailable'));
+            return;
+        }
+        try {
+            writeRpcResult(response, message.rpcId, ok(await dispatchApi(api, endpoint, message.payload)));
+        }
+        catch (error) {
+            const e = error instanceof ApiRunnerError
+                ? error
+                : new ApiRunnerError('internal', error instanceof Error ? error.message : String(error));
+            writeRpcResult(response, message.rpcId, fail(e.code, e.message));
+        }
+        return;
+    }
+    if (endpoint.startsWith('mock/')) {
+        if (!mock) {
+            writeRpcResult(response, message.rpcId, fail('unavailable', 'Mock Data is unavailable'));
+            return;
+        }
+        try {
+            writeRpcResult(response, message.rpcId, ok(await dispatchMock(mock, endpoint, message.payload)));
+        }
+        catch (error) {
+            writeRpcResult(response, message.rpcId, fail('mock-error', error instanceof Error ? error.message : String(error)));
+        }
+        return;
+    }
+    if (endpoint.startsWith('crypto/')) {
+        if (!crypto) {
+            writeRpcResult(response, message.rpcId, fail('unavailable', 'Crypto is unavailable'));
+            return;
+        }
+        try {
+            writeRpcResult(response, message.rpcId, ok(await dispatchCrypto(crypto, endpoint, message.payload)));
+        }
+        catch (error) {
+            const e = error;
+            writeRpcResult(response, message.rpcId, fail(e.code ?? 'crypto-error', e.message ?? String(error), e.itemIndex === undefined ? {} : { itemIndex: e.itemIndex }));
+        }
+        return;
+    }
+    try {
+        writeRpcResult(response, message.rpcId, await dispatch(endpoint, message.payload));
+    }
+    catch (error) {
+        writeRpcResult(response, message.rpcId, fail('internal', error instanceof Error ? error.message : String(error)));
+    }
+}
+async function dispatchCrypto(service, endpoint, payload) {
+    switch (endpoint) {
+        case 'crypto/profiles/list':
+            return service.list();
+        case 'crypto/profiles/save':
+            return service.save(payload);
+        case 'crypto/profiles/rename':
+            return service.rename(Number(payload?.id), String(payload?.name ?? ''));
+        case 'crypto/profiles/delete':
+            return service.delete(Number(payload?.id));
+        case 'crypto/profiles/set-default':
+            return service.setDefault(Number(payload?.id));
+        case 'crypto/execute':
+            return service.execute(payload);
+    }
+}
+async function dispatchMock(db, endpoint, payload) {
+    switch (endpoint) {
+        case 'mock/scenarios/list':
+            return db.list();
+        case 'mock/scenarios/save':
+            return db.save(payload);
+        case 'mock/scenarios/use':
+            return db.use(Number(payload?.id));
+        case 'mock/scenarios/rename':
+            return db.rename(Number(payload?.id), String(payload?.name ?? ''));
+        case 'mock/scenarios/delete':
+            return db.delete(Number(payload?.id));
+        default:
+            throw new Error(`unknown endpoint "${endpoint}"`);
+    }
+}
+async function dispatchApi(api, endpoint, payload) {
+    switch (endpoint) {
+        case 'api/send':
+            return api.send(payload);
+        case 'api/collections/list':
+            return api.database.listCollections();
+        case 'api/collections/create':
+            return api.database.createCollection(String(payload?.name ?? ''));
+        case 'api/collections/ensure':
+            return api.database.ensureCollection(String(payload?.name ?? ''));
+        case 'api/collections/rename':
+            return api.database.renameCollection(Number(payload?.id), String(payload?.name ?? ''));
+        case 'api/collections/delete':
+            return api.database.deleteCollection(Number(payload?.id));
+        case 'api/collections/reorder':
+            return api.database.reorderCollections((payload?.ids ?? []).map(Number));
+        case 'api/requests/list':
+            return api.database.listRequests();
+        case 'api/requests/save':
+            return api.database.saveRequest(payload);
+        case 'api/requests/rename':
+            return api.database.renameRequest(Number(payload?.id), String(payload?.name ?? ''));
+        case 'api/requests/delete':
+            return api.database.deleteRequest(Number(payload?.id));
+        case 'api/requests/reorder':
+            return api.database.reorderRequests(Number(payload?.collectionId), (payload?.ids ?? []).map(Number));
+        case 'api/requests/move':
+            return api.database.moveRequest(Number(payload?.id), Number(payload?.collectionId));
+        case 'api/history/list':
+            return api.database.listHistory(Number(payload?.limit ?? 100));
+        case 'api/history/delete':
+            return api.database.deleteHistory(Number(payload?.id));
+        case 'api/history/clear':
+            return api.database.clearHistory();
+    }
+}
+function parseClientRequest(value) {
+    if (typeof value !== 'object' || value === null)
+        throw new TypeError('request must be an object');
+    const message = value;
+    if (message.type !== 'client-request' ||
+        typeof message.rpcId !== 'string' ||
+        typeof message.method !== 'string' ||
+        !('payload' in message)) {
+        throw new TypeError('invalid client request envelope');
+    }
+    return {
+        type: 'client-request',
+        rpcId: message.rpcId,
+        method: message.method,
+        payload: message.payload,
+    };
+}
+function endpointFromRequest(request) {
+    const pathname = new URL(request.url ?? '/', 'http://x').pathname;
+    const prefix = `${RPC_CHANNEL}/`;
+    if (!pathname.startsWith(prefix))
+        return null;
+    const endpoint = pathname.slice(prefix.length);
+    return endpoint || null;
+}
+async function readJsonBody(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.byteLength;
+        if (size > 1024 * 1024)
+            throw new RangeError('request body exceeds 1 MiB');
+        chunks.push(buffer);
+    }
+    return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+}
+function writeRpcResult(response, rpcId, result) {
+    response.writeHead(200, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ type: 'server-response', rpcId, result }));
+}
+function ok(value) {
+    return { ok: true, value };
+}
+function fail(code, message, details = {}) {
+    return { ok: false, error: { code, message, details } };
+}
+export async function dispatch(endpoint, payload) {
+    try {
+        switch (endpoint) {
+            case 'process/list': {
+                const input = parseListPayload(payload);
+                return ok(await listProcesses(input.query));
+            }
+            case 'process/detail': {
+                const input = parseDetailPayload(payload);
+                return ok(await getProcessDetail(input.pid));
+            }
+            case 'process/terminate': {
+                const input = parseTerminatePayload(payload);
+                return ok(terminateProcess(input.pid, input.force));
+            }
+            case 'file/lockers': {
+                const input = parseFileLockPayload(payload);
+                return ok(await findFileLockers(input.path));
+            }
+            default:
+                return fail('unknown-endpoint', `unknown endpoint "${endpoint}"`);
+        }
+    }
+    catch (error) {
+        if (error instanceof ProcessManagerError) {
+            return fail(error.code, error.message, error.details);
+        }
+        return fail('internal', error instanceof Error ? error.message : String(error));
+    }
+}
+function parseListPayload(payload) {
+    if (typeof payload !== 'object' || payload === null || !('query' in payload)) {
+        throw new ProcessManagerError('invalid-payload', 'process/list requires a query string');
+    }
+    const query = payload.query;
+    if (typeof query !== 'string') {
+        throw new ProcessManagerError('invalid-payload', 'process/list requires a query string');
+    }
+    return { query };
+}
+function parseDetailPayload(payload) {
+    if (typeof payload !== 'object' || payload === null || !('pid' in payload)) {
+        throw new ProcessManagerError('invalid-payload', 'process/detail requires a pid');
+    }
+    const pid = payload.pid;
+    if (!isPid(pid)) {
+        throw new ProcessManagerError('invalid-payload', 'process/detail requires a positive pid');
+    }
+    return { pid };
+}
+function parseTerminatePayload(payload) {
+    if (typeof payload !== 'object' || payload === null || !('pid' in payload)) {
+        throw new ProcessManagerError('invalid-payload', 'process/terminate requires a pid');
+    }
+    const value = payload;
+    if (!isPid(value.pid)) {
+        throw new ProcessManagerError('invalid-payload', 'process/terminate requires a positive pid');
+    }
+    if (value.force !== undefined && typeof value.force !== 'boolean') {
+        throw new ProcessManagerError('invalid-payload', 'process/terminate force must be boolean');
+    }
+    return { pid: value.pid, force: value.force };
+}
+function parseFileLockPayload(payload) {
+    if (typeof payload !== 'object' || payload === null || !('path' in payload)) {
+        throw new ProcessManagerError('invalid-payload', 'file/lockers requires a path');
+    }
+    const path = payload.path;
+    if (typeof path !== 'string' || !path.trim()) {
+        throw new ProcessManagerError('invalid-payload', 'file/lockers requires a non-empty path');
+    }
+    return { path };
+}
+function isPid(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value > 0;
+}