@minko-ai/minko 0.1.0 → 0.1.1

package/dist/index.js

@@ -0,0 +1,199 @@
+import fs from 'node:fs';
+import { parseArgs, HELP_TEXT } from "./cli/argv.js";
+import { runConfigCommand } from "./cli/configCommand.js";
+import { runPowerCommand } from "./cli/powerCommand.js";
+import { runPluginCommand } from "./cli/pluginCommand.js";
+import { runForkCommand } from "./cli/forkCommand.js";
+import { runLoginCommand } from "./cli/loginCommand.js";
+import { runStatusCommand } from "./cli/statusCommand.js";
+import { runDoctorCommand } from "./cli/doctorCommand.js";
+import { runSandboxCommand } from "./cli/sandboxCommand.js";
+import { runRagServer } from "./rag/server.js";
+import { runMcpServer } from "./mcp/server.js";
+import { runMcpLoginCommand } from "./cli/mcpLoginCommand.js";
+import { runSdkServer } from "./sdk/server.js";
+import { runCommandsCommand } from "./cli/commandsCommand.js";
+import { runExportCommand } from "./cli/exportCommand.js";
+import { runLinkCommand } from "./cli/linkCommand.js";
+import { runRelayCommand } from "./cli/relayCommand.js";
+import { runServeCommand } from "./cli/serveCommand.js";
+import { runApp } from "./cli/app.js";
+import { activeProvider, configProblems, loadConfig, saveConfig, } from "./config/store.js";
+import { homeFallbackWarning } from "./config/paths.js";
+import { isLive, listStatuses, statusLabel } from "./session/liveness.js";
+import { readVersion } from "./util/version.js";
+import { providerChain } from "./providers/factory.js";
+import { SessionStore } from "./session/store.js";
+import { Painter } from "./ui/ansi.js";
+export async function main(argv) {
+    const painter = new Painter();
+    let parsed;
+    try {
+        parsed = parseArgs(argv);
+    }
+    catch (error) {
+        process.stderr.write(painter.error((error instanceof Error ? error.message : String(error)) + '\n'));
+        process.exitCode = 1;
+        return;
+    }
+    switch (parsed.command) {
+        case 'help':
+            process.stdout.write(HELP_TEXT + '\n');
+            return;
+        case 'version':
+            process.stdout.write('minko ' + readVersion() + '\n');
+            return;
+        case 'link':
+            process.exitCode = await runLinkCommand(parsed.port, parsed.host, parsed.relay, parsed.lanOnly);
+            return;
+        case 'relay':
+            process.exitCode = await runRelayCommand(parsed.port);
+            return;
+        case 'serve':
+            process.exitCode = await runServeCommand();
+            return;
+        case 'sessions':
+            printSessions(painter, parsed.json);
+            return;
+        case 'power':
+            process.exitCode = await runPowerCommand(parsed.mode);
+            return;
+        case 'plugin':
+            process.exitCode = await runPluginCommand(parsed.action, parsed.target);
+            return;
+        case 'fork':
+            process.exitCode = await runForkCommand(parsed.id, parsed.name);
+            return;
+        case 'login':
+            process.exitCode = await runLoginCommand();
+            return;
+        case 'status':
+            process.exitCode = await runStatusCommand(parsed.json);
+            return;
+        case 'doctor':
+            process.exitCode = await runDoctorCommand(parsed.json);
+            return;
+        case 'sandbox':
+            process.exitCode = await runSandboxCommand(parsed.json);
+            return;
+        case 'rag':
+            process.exitCode = await runRagServer({ port: parsed.port, host: parsed.host });
+            return;
+        case 'mcp-server':
+            process.exitCode = await runMcpServer();
+            return;
+        case 'mcp-login':
+            process.exitCode = await runMcpLoginCommand(parsed.server);
+            return;
+        case 'commands':
+            process.exitCode = await runCommandsCommand(parsed.json);
+            return;
+        case 'sdk': {
+            const sdkConfig = loadConfig();
+            const sdkProblems = configProblems(sdkConfig);
+            if (sdkProblems.length > 0) {
+                for (const problem of sdkProblems) {
+                    process.stderr.write(painter.error('· ' + problem + '\n'));
+                }
+                process.exitCode = 1;
+                return;
+            }
+            const sdkChain = providerChain(sdkConfig);
+            if (!sdkChain) {
+                process.exitCode = 1;
+                return;
+            }
+            process.exitCode = await runSdkServer({
+                config: sdkConfig,
+                getProvider: () => sdkChain.provider,
+            });
+            return;
+        }
+        case 'export':
+            process.exitCode = await runExportCommand(parsed.id, parsed.format, parsed.out);
+            return;
+        case 'config': {
+            process.exitCode = await runConfigCommand(parsed);
+            return;
+        }
+        case 'run':
+            break;
+        default:
+            return;
+    }
+    const config = loadConfig();
+    const fallbackNote = homeFallbackWarning();
+    if (fallbackNote) {
+        process.stderr.write(painter.warn('· ' + fallbackNote) + '\n');
+    }
+    const problems = configProblems(config);
+    if (problems.length > 0) {
+        for (const problem of problems) {
+            process.stderr.write(painter.error('· ' + problem + '\n'));
+        }
+        process.exitCode = 1;
+        return;
+    }
+    const chain = providerChain(config, parsed.model);
+    if (!chain) {
+        process.exitCode = 1;
+        return;
+    }
+    const { provider, model } = chain;
+    process.exitCode = await runApp({
+        config,
+        provider,
+        providerName: chain.name,
+        model,
+        cwd: process.cwd(),
+        auto: parsed.auto,
+        print: parsed.print,
+        prompt: parsed.prompt,
+        continueSession: parsed.continue,
+        resumeId: parsed.resume,
+        version: readVersion(),
+        setModel: (next) => {
+            const fresh = loadConfig();
+            const entry = fresh.providers[fresh.active];
+            if (!entry) {
+                throw new Error('当前没有可用的模型配置');
+            }
+            const chain = providerChain(fresh, next);
+            if (!chain) {
+                throw new Error('当前没有可用的模型配置');
+            }
+            saveConfig({
+                ...fresh,
+                providers: { ...fresh.providers, [fresh.active]: { ...entry, model: next } },
+            });
+            return chain.provider;
+        },
+    });
+}
+function printSessions(painter, json) {
+    const store = new SessionStore();
+    const metas = store.list();
+    const statuses = new Map(listStatuses(store.dir).map((status) => [status.sessionId, status]));
+    const rows = metas.map((meta) => {
+        const status = statuses.get(meta.id);
+        const live = isLive(status ?? null);
+        return {
+            ...meta,
+            status: live ? status?.status ?? null : null,
+            statusLabel: statusLabel(live ? status?.status : null),
+        };
+    });
+    if (json) {
+        process.stdout.write(JSON.stringify(rows, null, 2) + '\n');
+        return;
+    }
+    if (rows.length === 0) {
+        process.stdout.write('  ' + painter.muted('还没有保存的会话。') + '\n');
+        return;
+    }
+    for (const meta of rows.slice(0, 30)) {
+        process.stdout.write('  ' + painter.primary('●') + ' ' + painter.soft(meta.id) + '  '
+            + painter.muted(meta.title) + '  ' + painter.dimmed('[' + meta.statusLabel + ']') + '\n    '
+            + painter.dimmed(meta.cwd + ' · ' + meta.updatedAt.slice(0, 16).replace('T', ' ')) + '\n');
+    }
+}

package/dist/link/protocol.js

@@ -0,0 +1,159 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { minkoHome } from "../config/paths.js";
+export function encodeLink(payload) {
+    const params = new URLSearchParams();
+    params.set('h', payload.host);
+    params.set('p', String(payload.port));
+    params.set('t', payload.token);
+    params.set('n', payload.name);
+    if (payload.relay && payload.relay.length > 0) {
+        try {
+            const url = new URL(payload.relay);
+            params.set('s', url.protocol === 'https:' ? '1' : '0');
+            params.set('r', url.host);
+        }
+        catch {
+            params.set('s', '0');
+            params.set('r', payload.relay.replace(/^https?:\/\//, ''));
+        }
+    }
+    if (payload.room && payload.room.length > 0) {
+        params.set('o', payload.room);
+    }
+    return 'minko://l?' + params.toString();
+}
+export function decodeLink(uri) {
+    const text = uri.trim();
+    if (text.startsWith('minko://link?d=')) {
+        return decodeLegacy(text);
+    }
+    if (!text.startsWith('minko://l?')) {
+        return null;
+    }
+    try {
+        const params = new URLSearchParams(text.slice('minko://l?'.length));
+        const host = params.get('h') ?? '';
+        const port = Number(params.get('p') ?? '0');
+        const token = params.get('t') ?? '';
+        if (host.length === 0 || !Number.isInteger(port) || port <= 0 || token.length === 0) {
+            return null;
+        }
+        const relayHost = params.get('r');
+        const payload = {
+            v: 1,
+            host,
+            port,
+            token,
+            name: params.get('n') ?? host,
+        };
+        if (relayHost && relayHost.length > 0) {
+            payload.relay = (params.get('s') === '1' ? 'https://' : 'http://') + relayHost;
+            payload.room = params.get('o') ?? '';
+        }
+        return payload;
+    }
+    catch {
+        return null;
+    }
+}
+function decodeLegacy(uri) {
+    const match = /^minko:\/\/link\?d=([A-Za-z0-9_-]+)$/.exec(uri.trim());
+    if (!match) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(Buffer.from(match[1], 'base64url').toString('utf8'));
+        if (parsed.v !== 1 || typeof parsed.host !== 'string' || typeof parsed.port !== 'number'
+            || typeof parsed.token !== 'string') {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function devicePath() {
+    return path.join(minkoHome(), 'device.json');
+}
+export function loadOrCreateDevice() {
+    const file = devicePath();
+    if (fs.existsSync(file)) {
+        try {
+            const saved = JSON.parse(fs.readFileSync(file, 'utf8'));
+            if (saved.id && saved.privateKey && saved.publicKey) {
+                return saved;
+            }
+        }
+        catch {
+            // regenerate below
+        }
+    }
+    const { publicKey, privateKey } = crypto.generateKeyPairSync('ed25519');
+    const identity = {
+        id: crypto.randomUUID(),
+        name: os.hostname() || 'minko-pc',
+        publicKey: publicKey.export({ type: 'spki', format: 'der' }).toString('base64'),
+        privateKey: privateKey.export({ type: 'pkcs8', format: 'pem' }).toString(),
+        phones: [],
+    };
+    saveDevice(identity);
+    return identity;
+}
+export function saveDevice(identity) {
+    const file = devicePath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(identity, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
+}
+export function recordPhone(identity, name) {
+    const phones = identity.phones ?? [];
+    const clean = name.trim().slice(0, 24) || '手机';
+    if (phones.some((phone) => phone.name === clean)) {
+        return;
+    }
+    phones.push({ name: clean, at: new Date().toISOString() });
+    identity.phones = phones;
+    saveDevice(identity);
+}
+export function pidFilePath() {
+    return path.join(minkoHome(), 'serve.pid');
+}
+export function newToken() {
+    return crypto.randomBytes(12).toString('hex');
+}
+/** Prefers a real LAN address; skips VPN/tunnel adapters like 198.18/15. */
+export function lanAddress() {
+    const interfaces = os.networkInterfaces();
+    const candidates = [];
+    for (const addresses of Object.values(interfaces)) {
+        for (const address of addresses ?? []) {
+            if (address.family !== 'IPv4' || address.internal) {
+                continue;
+            }
+            if (address.address.startsWith('198.18.') || address.address.startsWith('198.19.')) {
+                continue;
+            }
+            if (address.address.startsWith('169.254.')) {
+                continue;
+            }
+            candidates.push(address.address);
+        }
+    }
+    const score = (ip) => {
+        if (ip.startsWith('192.168.')) {
+            return 3;
+        }
+        if (ip.startsWith('10.')) {
+            return 2;
+        }
+        if (/^172\.(1[6-9]|2\d|3[01])\./.test(ip)) {
+            return 1;
+        }
+        return 0;
+    };
+    candidates.sort((a, b) => score(b) - score(a));
+    return candidates.length > 0 ? candidates[0] : '127.0.0.1';
+}

package/dist/link/relay.js

@@ -0,0 +1,184 @@
+import http from 'node:http';
+import crypto from 'node:crypto';
+const CALL_TIMEOUT_MS = 120000;
+const MAX_BODY = 1024 * 1024;
+/**
+ * Public relay for `minko -link --relay`. The PC keeps an outbound SSE tunnel,
+ * the phone posts calls here, and the relay forwards them to the PC and back.
+ */
+export class RelayServer {
+    server = null;
+    rooms = new Map();
+    async start(host, port) {
+        this.server = http.createServer((request, response) => {
+            void this.handle(request, response).catch(() => {
+                writeText(response, 500, 'relay error');
+            });
+        });
+        await new Promise((resolve, reject) => {
+            this.server?.once('error', reject);
+            this.server?.listen(port, host, () => resolve());
+        });
+        const address = this.server.address();
+        return typeof address === 'object' && address ? address.port : port;
+    }
+    async stop() {
+        for (const room of this.rooms.values()) {
+            room.agent?.end();
+        }
+        this.rooms.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, rooms: this.rooms.size });
+            return;
+        }
+        const tunnel = /^\/tunnel\/([A-Za-z0-9_-]+)$/.exec(path);
+        if (tunnel && request.method === 'GET') {
+            this.connect(tunnel[1], request, response);
+            return;
+        }
+        const reply = /^\/tunnel\/([A-Za-z0-9_-]+)\/response$/.exec(path);
+        if (reply && request.method === 'POST') {
+            await this.deliver(reply[1], request, response);
+            return;
+        }
+        const call = /^\/relay\/([A-Za-z0-9_-]+)\/call$/.exec(path);
+        if (call && request.method === 'POST') {
+            await this.call(call[1], request, response);
+            return;
+        }
+        const status = /^\/relay\/([A-Za-z0-9_-]+)\/health$/.exec(path);
+        if (status) {
+            const room = this.rooms.get(status[1]);
+            writeJson(response, 200, { online: Boolean(room && room.agent) });
+            return;
+        }
+        writeJson(response, 404, { error: 'not found' });
+    }
+    connect(roomId, request, response) {
+        const token = bearer(request);
+        let room = this.rooms.get(roomId);
+        if (!room) {
+            room = { token, agent: null, pending: new Map() };
+            this.rooms.set(roomId, room);
+        }
+        else if (room.token !== token) {
+            writeJson(response, 401, { error: 'unauthorized' });
+            return;
+        }
+        room.agent?.end();
+        room.agent = response;
+        response.writeHead(200, {
+            'content-type': 'text/event-stream; charset=utf-8',
+            'cache-control': 'no-cache',
+            connection: 'keep-alive',
+        });
+        response.write('event: ready\ndata: {}\n\n');
+        request.on('close', () => {
+            if (room && room.agent === response) {
+                room.agent = null;
+            }
+        });
+    }
+    async deliver(roomId, request, response) {
+        const room = this.rooms.get(roomId);
+        if (!room || room.token !== bearer(request)) {
+            writeJson(response, 401, { error: 'unauthorized' });
+            return;
+        }
+        const payload = await readJson(request);
+        const id = typeof payload.id === 'string' ? payload.id : '';
+        const pending = room.pending.get(id);
+        if (!pending) {
+            writeJson(response, 404, { error: 'unknown call' });
+            return;
+        }
+        room.pending.delete(id);
+        pending.resolve({
+            status: typeof payload.status === 'number' ? payload.status : 200,
+            body: typeof payload.body === 'string' ? payload.body : '',
+        });
+        writeJson(response, 200, { ok: true });
+    }
+    async call(roomId, request, response) {
+        const room = this.rooms.get(roomId);
+        if (!room || room.token !== bearer(request)) {
+            writeJson(response, 401, { error: 'unauthorized' });
+            return;
+        }
+        if (!room.agent) {
+            writeJson(response, 503, { error: '电脑不在线' });
+            return;
+        }
+        const payload = await readJson(request);
+        const id = crypto.randomBytes(8).toString('hex');
+        const method = typeof payload.method === 'string' ? payload.method : 'GET';
+        const path = typeof payload.path === 'string' ? payload.path : '/sessions';
+        const body = typeof payload.body === 'string' ? payload.body : '';
+        const result = await new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                room.pending.delete(id);
+                resolve({ status: 504, body: '{"error":"电脑响应超时"}' });
+            }, CALL_TIMEOUT_MS);
+            room.pending.set(id, {
+                resolve: (value) => {
+                    clearTimeout(timer);
+                    resolve(value);
+                },
+            });
+            room.agent?.write('event: request\ndata: '
+                + JSON.stringify({ id, method, path, body }) + '\n\n');
+        });
+        response.writeHead(result.status, { 'content-type': 'application/json; charset=utf-8' });
+        response.end(result.body);
+    }
+}
+function bearer(request) {
+    return (request.headers.authorization ?? '').replace(/^Bearer\s+/i, '');
+}
+function writeJson(response, status, body) {
+    const payload = JSON.stringify(body);
+    response.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'content-length': Buffer.byteLength(payload),
+    });
+    response.end(payload);
+}
+function writeText(response, status, text) {
+    response.writeHead(status, { 'content-type': 'text/plain; charset=utf-8' });
+    response.end(text);
+}
+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 {};
+    }
+}