@minko-ai/minko 0.1.0 → 0.1.1

package/dist/link/server.js

@@ -0,0 +1,566 @@
+import http from 'node:http';
+import fs from 'node:fs';
+import { runAgent } from "../agent/loop.js";
+import { loadProjectContext } from "../agent/context.js";
+import { createSubagentTool } from "../agent/subagent.js";
+import { createPlanTools } from "../agent/plan.js";
+import { createMemoryTools, defaultMemoryDir, loadMemoryContext, } from "../agent/memory.js";
+import { WorkerRegistry, createWorkerTools } from "../agent/workers.js";
+import { WorkerStore } from "../agent/workerStore.js";
+import { LaneRegistry, createLaneTools } from "../agent/lanes.js";
+import { TaskRegistry, createTaskTools } from "../agent/tasks.js";
+import { CronScheduler, createCronTools } from "../agent/cron.js";
+import { BranchLockStore, createBranchTools } from "../agent/branchLock.js";
+import { ApprovalTokenStore, createApprovalTools } from "../agent/approvalTokens.js";
+import { closeLspClients } from "../lsp/tool.js";
+import { loadPlugins, mergeHooks } from "../plugins/loader.js";
+import { systemPrompt } from "../agent/prompt.js";
+import { ALL_TOOLS } from "../tools/registry.js";
+import { titleFromMessages } from "../session/store.js";
+import { TurnRecorder } from "../session/recorder.js";
+import { friendlyError } from "../util/errors.js";
+import { isLive, readStatus, writeStatus } from "../session/liveness.js";
+const MAX_BODY = 1024 * 1024;
+/** LAN API used by the phone: list/create sessions and stream replies as SSE. */
+export class LinkServer {
+    options;
+    server = null;
+    running = new Map();
+    agentTool;
+    memoryDir = defaultMemoryDir();
+    memoryTools;
+    workers;
+    workerTools;
+    workerStore;
+    lanes;
+    laneTools;
+    taskTools;
+    crons;
+    cronTools;
+    branchTools;
+    approvalTokens;
+    approvalTools;
+    pluginTools;
+    effectiveHooks;
+    approvals = new Map();
+    nextApproval = 0;
+    onLog = () => { };
+    constructor(options) {
+        this.options = options;
+        this.agentTool = createSubagentTool({
+            getProvider: () => this.options.provider,
+            getConfig: () => this.options.config,
+        });
+        this.memoryTools = createMemoryTools(this.memoryDir);
+        this.workerStore = new WorkerStore(options.workerStoreDir);
+        this.approvalTokens = new ApprovalTokenStore(options.approvalStoreDir);
+        this.workers = new WorkerRegistry({
+            getProvider: () => this.options.provider,
+            getConfig: () => this.options.config,
+            cwd: this.options.cwd,
+            store: this.workerStore,
+            approvalStore: this.approvalTokens,
+            // Remote worker writes need an explicit full-power mode; there is no
+            // per-worker approval UI yet.
+            approve: async () => this.options.power === 'full',
+        });
+        this.workerTools = createWorkerTools(this.workers);
+        const branchLocks = new BranchLockStore(options.branchLockDir);
+        this.branchTools = createBranchTools(branchLocks);
+        this.lanes = new LaneRegistry({
+            getProvider: () => this.options.provider,
+            getConfig: () => this.options.config,
+            cwd: this.options.cwd,
+            lockStore: branchLocks,
+            approvalStore: this.approvalTokens,
+            approve: async () => this.options.power === 'full',
+        });
+        this.laneTools = createLaneTools(this.lanes);
+        this.taskTools = createTaskTools(new TaskRegistry({
+            workers: this.workers,
+            storeDir: options.taskStoreDir,
+        }));
+        this.crons = new CronScheduler({
+            workers: this.workers,
+            storeDir: options.cronStoreDir,
+        });
+        this.cronTools = createCronTools(this.crons);
+        this.approvalTools = createApprovalTools(this.approvalTokens);
+        const pluginLoad = loadPlugins(undefined, options.config?.plugins.disabled ?? []);
+        this.pluginTools = pluginLoad.plugins.flatMap((plugin) => plugin.tools);
+        this.effectiveHooks = mergeHooks(options.toolHooks, ...pluginLoad.plugins.map((plugin) => plugin.hooks));
+    }
+    async start(host, port) {
+        this.server = http.createServer((request, response) => {
+            void this.handle(request, response).catch((error) => {
+                writeJson(response, 500, { error: friendlyError(error) });
+            });
+        });
+        await new Promise((resolve, reject) => {
+            this.server?.once('error', reject);
+            this.server?.listen(port, host, () => resolve());
+        });
+        const address = this.server.address();
+        this.crons.start();
+        return typeof address === 'object' && address ? address.port : port;
+    }
+    requestApproval(sessionId, meta, request, send, signal) {
+        const id = sessionId + ':' + (this.nextApproval + 1).toString(36);
+        this.nextApproval += 1;
+        this.markStatus(sessionId, 'waiting_approval', meta);
+        return new Promise((resolve) => {
+            let settled = false;
+            const finish = (allowed) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                const pending = this.approvals.get(id);
+                if (pending) {
+                    clearTimeout(pending.timer);
+                    this.approvals.delete(id);
+                }
+                signal.removeEventListener('abort', onAbort);
+                this.markStatus(sessionId, 'running', meta);
+                try {
+                    send('approval_resolved', { id, allowed });
+                }
+                catch {
+                    // The SSE connection may already be closed.
+                }
+                resolve(allowed);
+            };
+            const onAbort = () => finish(false);
+            signal.addEventListener('abort', onAbort, { once: true });
+            const timer = setTimeout(() => finish(false), 120_000);
+            timer.unref?.();
+            this.approvals.set(id, { resolve: finish, timer, sessionId });
+            try {
+                send('approval_request', {
+                    id,
+                    tool: request.tool,
+                    title: request.title,
+                    detail: request.detail,
+                    danger: request.danger,
+                });
+            }
+            catch {
+                finish(false);
+            }
+        });
+    }
+    markStatus(id, status, meta) {
+        writeStatus(this.options.store.dir, {
+            sessionId: id,
+            status,
+            pid: process.pid,
+            updatedAt: new Date().toISOString(),
+            title: meta.title,
+            cwd: meta.cwd,
+        });
+    }
+    async stop() {
+        this.crons.stop();
+        this.workers.stopAll();
+        this.lanes.closeAll();
+        await closeLspClients();
+        for (const pending of [...this.approvals.values()]) {
+            pending.resolve(false);
+        }
+        this.approvals.clear();
+        for (const controller of this.running.values()) {
+            controller.abort();
+        }
+        this.running.clear();
+        await new Promise((resolve) => {
+            if (!this.server) {
+                resolve();
+                return;
+            }
+            const server = this.server;
+            this.server = null;
+            server.close(() => resolve());
+            server.closeAllConnections?.();
+        });
+    }
+    async handle(request, response) {
+        const url = new URL(request.url ?? '/', 'http://localhost');
+        const path = url.pathname;
+        if (path === '/health') {
+            writeJson(response, 200, {
+                ok: true,
+                name: this.options.name,
+                deviceId: this.options.deviceId,
+                version: this.options.version,
+            });
+            return;
+        }
+        const token = (request.headers.authorization ?? '').replace(/^Bearer\s+/i, '');
+        if (token !== this.options.token) {
+            writeJson(response, 401, { error: 'unauthorized' });
+            return;
+        }
+        if (path === '/pair') {
+            if (request.method === 'GET') {
+                writeJson(response, 200, { phones: this.options.getPhones ? this.options.getPhones() : [] });
+                return;
+            }
+            if (request.method === 'POST') {
+                const body = await readJson(request);
+                const name = typeof body.name === 'string' ? body.name.trim().slice(0, 24) : '手机';
+                this.options.onPair?.(name);
+                this.onLog('手机已配对：' + name);
+                writeJson(response, 200, { ok: true });
+                return;
+            }
+        }
+        if (path === '/roots' && request.method === 'GET') {
+            writeJson(response, 200, { roots: fileRoots() });
+            return;
+        }
+        if (path === '/workers' && request.method === 'GET') {
+            writeJson(response, 200, { workers: this.workerStore.list() });
+            return;
+        }
+        if (path === '/approvals' && request.method === 'GET') {
+            writeJson(response, 200, { tokens: this.approvalTokens.list() });
+            return;
+        }
+        if (path === '/approvals' && request.method === 'POST') {
+            const body = await readJson(request);
+            const token = this.approvalTokens.create({
+                tool: typeof body.tool === 'string' ? body.tool : '',
+                pattern: typeof body.pattern === 'string' ? body.pattern : undefined,
+                maxUses: typeof body.max_uses === 'number' ? body.max_uses : undefined,
+                expiresMinutes: typeof body.expires_minutes === 'number' ? body.expires_minutes : undefined,
+                reason: typeof body.reason === 'string' ? body.reason : undefined,
+            });
+            writeJson(response, 201, { token });
+            return;
+        }
+        const approvalMatch = /^\/approvals\/([A-Za-z0-9._-]+)$/.exec(path);
+        if (approvalMatch && request.method === 'DELETE') {
+            const removed = this.approvalTokens.revoke(approvalMatch[1]);
+            writeJson(response, removed ? 200 : 404, { ok: removed });
+            return;
+        }
+        const workerStopMatch = /^\/workers\/([A-Za-z0-9._-]+)\/stop$/.exec(path);
+        if (workerStopMatch && request.method === 'POST') {
+            const stopped = this.workers.stop(workerStopMatch[1]);
+            if (!stopped) {
+                writeJson(response, 404, { error: 'worker 不在当前进程中运行' });
+                return;
+            }
+            writeJson(response, 200, { ok: true });
+            return;
+        }
+        const workerMatch = /^\/workers\/([A-Za-z0-9._-]+)$/.exec(path);
+        if (workerMatch && request.method === 'GET') {
+            const record = this.workerStore.get(workerMatch[1]);
+            if (!record) {
+                writeJson(response, 404, { error: 'worker not found' });
+                return;
+            }
+            writeJson(response, 200, record);
+            return;
+        }
+        if (path === '/sessions' && request.method === 'GET') {
+            const sessions = this.options.store.list().map((meta) => {
+                const live = readStatus(this.options.store.dir, meta.id);
+                const active = isLive(live);
+                return {
+                    ...meta,
+                    status: active ? live?.status ?? 'idle' : 'idle',
+                    live: active && live?.status !== 'idle',
+                };
+            });
+            const workers = this.workerStore.list();
+            writeJson(response, 200, {
+                sessions,
+                workers: {
+                    total: workers.length,
+                    active: workers.filter((worker) => worker.state === 'running' || worker.state === 'queued').length,
+                },
+            });
+            return;
+        }
+        if (path === '/sessions' && request.method === 'POST') {
+            const body = await readJson(request);
+            const cwd = typeof body.cwd === 'string' && body.cwd.length > 0 ? body.cwd : this.options.cwd;
+            const meta = this.options.store.create(cwd, 'remote');
+            if (typeof body.title === 'string' && body.title.length > 0) {
+                meta.title = body.title.slice(0, 60);
+                this.options.store.save(meta, []);
+            }
+            this.onLog('新建会话 ' + meta.id + '（' + cwd + '）');
+            writeJson(response, 201, { session: meta });
+            return;
+        }
+        const approveMatch = /^\/sessions\/([A-Za-z0-9._-]+)\/approve$/.exec(path);
+        if (approveMatch && request.method === 'POST') {
+            const body = await readJson(request);
+            const approvalId = typeof body.id === 'string' ? body.id : '';
+            const pending = this.approvals.get(approvalId);
+            if (!pending || pending.sessionId !== approveMatch[1]) {
+                writeJson(response, 404, { error: 'approval not found' });
+                return;
+            }
+            pending.resolve(body.allow === true);
+            writeJson(response, 200, { ok: true });
+            return;
+        }
+        const sessionMatch = /^\/sessions\/([A-Za-z0-9._-]+)$/.exec(path);
+        if (sessionMatch) {
+            const id = sessionMatch[1];
+            if (request.method === 'GET') {
+                const record = this.options.store.load(id);
+                if (!record) {
+                    writeJson(response, 404, { error: 'not found' });
+                    return;
+                }
+                writeJson(response, 200, record);
+                return;
+            }
+            if (request.method === 'DELETE') {
+                const removed = this.options.store.delete(id);
+                writeJson(response, removed ? 200 : 404, { ok: removed });
+                return;
+            }
+        }
+        const messageMatch = /^\/sessions\/([A-Za-z0-9._-]+)\/messages$/.exec(path);
+        if (messageMatch && request.method === 'POST') {
+            await this.handleMessage(messageMatch[1], request, response);
+            return;
+        }
+        writeJson(response, 404, { error: 'not found' });
+    }
+    async handleMessage(id, request, response) {
+        const record = this.options.store.load(id);
+        if (!record) {
+            writeJson(response, 404, { error: 'not found' });
+            return;
+        }
+        if (this.running.has(id)) {
+            writeJson(response, 409, { error: 'busy' });
+            return;
+        }
+        const body = await readJson(request);
+        const text = typeof body.text === 'string' ? body.text.trim() : '';
+        if (text.length === 0) {
+            writeJson(response, 400, { error: 'text is required' });
+            return;
+        }
+        const wantsStream = new URL(request.url ?? '/', 'http://localhost').searchParams.get('stream') !== '0';
+        if (!wantsStream) {
+            await this.replyOnce(id, record, text, response);
+            return;
+        }
+        response.writeHead(200, {
+            'content-type': 'text/event-stream; charset=utf-8',
+            'cache-control': 'no-cache',
+            connection: 'keep-alive',
+        });
+        const send = (event, data) => {
+            response.write('event: ' + event + '\ndata: ' + JSON.stringify(data) + '\n\n');
+        };
+        const controller = new AbortController();
+        this.running.set(id, controller);
+        response.on('close', () => {
+            controller.abort();
+            this.running.delete(id);
+        });
+        const history = [...record.messages, { role: 'user', content: text }];
+        const recorder = new TurnRecorder(this.options.store, record.meta, history);
+        const planTools = createPlanTools(record.meta);
+        this.markStatus(id, 'running', record.meta);
+        send('accepted', { session: id });
+        try {
+            const outcome = await runAgent({
+                provider: this.options.provider,
+                tools: [
+                    ...ALL_TOOLS,
+                    ...(this.options.mcpTools ?? []),
+                    ...planTools,
+                    ...this.memoryTools,
+                    ...this.workerTools,
+                    ...this.pluginTools,
+                    ...this.laneTools,
+                    ...this.taskTools,
+                    ...this.cronTools,
+                    ...this.branchTools,
+                    ...this.approvalTools,
+                    this.agentTool,
+                ],
+                messages: [{
+                        role: 'system',
+                        content: systemPrompt({
+                            cwd: record.meta.cwd,
+                            project: loadProjectContext(record.meta.cwd),
+                            planMode: record.meta.planMode,
+                            memory: loadMemoryContext(this.memoryDir),
+                        }),
+                    }, ...history],
+                cwd: record.meta.cwd,
+                signal: controller.signal,
+                approval: 'ask',
+                power: this.options.power,
+                permissions: this.options.permissions,
+                toolHooks: this.effectiveHooks,
+                planState: record.meta,
+                config: this.options.config,
+                approvalStore: this.approvalTokens,
+                hooks: {
+                    onText: (delta) => send('text', { text: delta }),
+                    onToolStart: (call, args) => send('tool_start', { name: call.name, args }),
+                    onToolEnd: (call, result) => send('tool_end', {
+                        name: call.name, ok: result.ok, ms: result.ms,
+                    }),
+                    approve: (request) => this.requestApproval(id, record.meta, request, send, controller.signal),
+                    onNotice: (notice) => send('notice', { text: notice }),
+                    onAssistantMessage: (message) => recorder.record(message),
+                },
+            });
+            const messages = outcome.messages.filter((message) => message.role !== 'system');
+            record.meta.title = titleFromMessages(messages);
+            record.meta.updatedAt = new Date().toISOString();
+            recorder.commit(messages);
+            this.markStatus(id, 'idle', record.meta);
+            send('done', { usage: outcome.usage, session: record.meta });
+        }
+        catch (error) {
+            record.meta.title = titleFromMessages(recorder.snapshot());
+            record.meta.updatedAt = new Date().toISOString();
+            recorder.recover();
+            this.markStatus(id, 'idle', record.meta);
+            send('error', { message: friendlyError(error) });
+        }
+        finally {
+            this.running.delete(id);
+            response.end();
+        }
+    }
+    /** Non-streaming variant for simple clients: waits and returns one JSON. */
+    async replyOnce(id, record, text, response) {
+        const controller = new AbortController();
+        this.running.set(id, controller);
+        const history = [...record.messages, { role: 'user', content: text }];
+        const recorder = new TurnRecorder(this.options.store, record.meta, history);
+        const planTools = createPlanTools(record.meta);
+        this.markStatus(id, 'running', record.meta);
+        try {
+            const outcome = await runAgent({
+                provider: this.options.provider,
+                tools: [
+                    ...ALL_TOOLS,
+                    ...(this.options.mcpTools ?? []),
+                    ...planTools,
+                    ...this.memoryTools,
+                    ...this.workerTools,
+                    ...this.pluginTools,
+                    ...this.laneTools,
+                    ...this.taskTools,
+                    ...this.cronTools,
+                    ...this.branchTools,
+                    ...this.approvalTools,
+                    this.agentTool,
+                ],
+                messages: [{
+                        role: 'system',
+                        content: systemPrompt({
+                            cwd: record.meta.cwd,
+                            project: loadProjectContext(record.meta.cwd),
+                            planMode: record.meta.planMode,
+                            memory: loadMemoryContext(this.memoryDir),
+                        }),
+                    }, ...history],
+                cwd: record.meta.cwd,
+                signal: controller.signal,
+                approval: 'ask',
+                power: this.options.power,
+                permissions: this.options.permissions,
+                toolHooks: this.effectiveHooks,
+                planState: record.meta,
+                config: this.options.config,
+                approvalStore: this.approvalTokens,
+                hooks: {
+                    onText: () => { },
+                    approve: async () => false,
+                    onAssistantMessage: (message) => recorder.record(message),
+                },
+            });
+            const messages = outcome.messages.filter((message) => message.role !== 'system');
+            record.meta.title = titleFromMessages(messages);
+            record.meta.updatedAt = new Date().toISOString();
+            recorder.commit(messages);
+            this.markStatus(id, 'idle', record.meta);
+            const last = messages[messages.length - 1];
+            writeJson(response, 200, {
+                text: last && last.role === 'assistant' ? last.content : '',
+                usage: outcome.usage,
+                session: record.meta,
+            });
+        }
+        catch (error) {
+            record.meta.title = titleFromMessages(recorder.snapshot());
+            record.meta.updatedAt = new Date().toISOString();
+            recorder.recover();
+            this.markStatus(id, 'idle', record.meta);
+            writeJson(response, 500, { error: friendlyError(error) });
+        }
+        finally {
+            this.running.delete(id);
+        }
+    }
+}
+/** Drives (Windows) or / so the phone can pick where a session lives. */
+export function fileRoots() {
+    if (process.platform !== 'win32') {
+        return [{ name: '/', path: '/' }];
+    }
+    const roots = [];
+    for (let code = 65; code <= 90; code += 1) {
+        const letter = String.fromCharCode(code);
+        const path = letter + ':\\';
+        try {
+            if (fs.existsSync(path)) {
+                roots.push({ name: letter + ':', path });
+            }
+        }
+        catch {
+            // unreadable drive, skip
+        }
+    }
+    return roots;
+}
+function writeJson(response, status, body) {
+    if (response.headersSent) {
+        return;
+    }
+    const payload = JSON.stringify(body);
+    response.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'content-length': Buffer.byteLength(payload),
+    });
+    response.end(payload);
+}
+async function readJson(request) {
+    let size = 0;
+    const chunks = [];
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > MAX_BODY) {
+            throw new Error('请求体过大');
+        }
+        chunks.push(buffer);
+    }
+    if (chunks.length === 0) {
+        return {};
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        return {};
+    }
+}

package/dist/link/tunnel.js

@@ -0,0 +1,90 @@
+import { sseEvents } from "../providers/sse.js";
+/** Keeps an outbound SSE tunnel to the relay and forwards calls to the local API. */
+export class TunnelClient {
+    relay;
+    room;
+    token;
+    localPort;
+    stopped = false;
+    controller = null;
+    onLog = () => { };
+    constructor(relay, room, token, localPort) {
+        this.relay = relay.replace(/\/+$/, '');
+        this.room = room;
+        this.token = token;
+        this.localPort = localPort;
+    }
+    start() {
+        void this.loop();
+    }
+    stop() {
+        this.stopped = true;
+        this.controller?.abort();
+        this.controller = null;
+    }
+    async loop() {
+        while (!this.stopped) {
+            try {
+                this.controller = new AbortController();
+                const response = await fetch(this.relay + '/tunnel/' + this.room, {
+                    headers: { authorization: 'Bearer ' + this.token },
+                    signal: this.controller.signal,
+                });
+                if (!response.ok || !response.body) {
+                    throw new Error('relay ' + response.status);
+                }
+                this.onLog('已连接中转 ' + this.relay);
+                for await (const event of sseEvents(response.body)) {
+                    if (event.event === 'request') {
+                        void this.forward(event.data);
+                    }
+                }
+            }
+            catch {
+                if (this.stopped) {
+                    return;
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, 3000));
+        }
+    }
+    async forward(raw) {
+        let message;
+        try {
+            message = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        const id = message.id ?? '';
+        const method = message.method ?? 'GET';
+        const path = message.path ?? '/sessions';
+        try {
+            const init = {
+                method,
+                headers: { authorization: 'Bearer ' + this.token, 'content-type': 'application/json' },
+            };
+            if (method !== 'GET' && method !== 'HEAD') {
+                init.body = message.body ?? '';
+            }
+            const local = await fetch('http://127.0.0.1:' + this.localPort + path, init);
+            const text = await local.text();
+            await this.respond(id, local.status, text);
+        }
+        catch {
+            await this.respond(id, 502, JSON.stringify({ error: '电脑处理失败' }));
+        }
+    }
+    async respond(id, status, body) {
+        try {
+            await fetch(this.relay + '/tunnel/' + this.room + '/response', {
+                method: 'POST',
+                headers: { authorization: 'Bearer ' + this.token, 'content-type': 'application/json' },
+                body: JSON.stringify({ id, status, body }),
+            });
+        }
+        catch {
+            // the relay will time this call out
+        }
+    }
+}