@minimalcorp/tsunagi 0.1.37 → 0.1.39

package/dist/server/routes/local-llm.js

@@ -0,0 +1,192 @@
+import http from 'node:http';
+import https from 'node:https';
+import { activate, beginRequest, endRequest, ensureActiveLoaded, getLocalLlmSettings, getLocalLlmStatus, listLocalLlmModels, parseLocalLlmSettings, unloadAll, } from '../lib/local-llm.js';
+import { LOCAL_MODEL_ALIAS, parseContextTokens } from '../lib/local-llm-env.js';
+import { estimateLmStudioLoad, getLmStudioSettings } from '../lib/lmstudio.js';
+// Claude Code のリクエストは会話が長いと数 MB になる（画像を含む場合はさらに大きい）
+const PROXY_BODY_LIMIT = 200 * 1024 * 1024;
+// 転送先に渡すリクエストヘッダー（認証は転送先に合わせて付け直す）
+const FORWARD_REQUEST_HEADERS = ['content-type', 'accept', 'anthropic-version', 'anthropic-beta'];
+// クライアントに返さないレスポンスヘッダー（Node が付け直す／中継で意味が変わる）
+const HOP_BY_HOP_HEADERS = new Set([
+    'connection',
+    'keep-alive',
+    'transfer-encoding',
+    'content-length',
+]);
+/** Anthropic API 形式のエラー。4xx は Claude Code が再送せずそのまま表示する */
+function sendApiError(reply, status, message) {
+    return reply.status(status).send({
+        type: 'error',
+        error: { type: status >= 500 ? 'api_error' : 'invalid_request_error', message },
+    });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * ローカルLLMタブの Claude Code からのリクエストを、使用中のモデルに書き換えて転送する。
+ * 使用中のモデルがメモリになければ（他のモデルを解放してから）読み込む。
+ * ローカルLLMはプロンプトの読み込みに数分かかるため、転送にタイムアウトは設けない。
+ */
+async function proxy(request, reply) {
+    const path = request.params['*'];
+    // モデル一覧は使用中のモデルだけを返す（Claude Code のモデル自動取得用。既定では使われない）
+    if (request.method === 'GET' && path === 'v1/models') {
+        return reply.send({
+            data: [{ id: LOCAL_MODEL_ALIAS, type: 'model', display_name: 'ローカルLLM' }],
+            has_more: false,
+        });
+    }
+    beginRequest();
+    let finished = false;
+    const finish = () => {
+        if (finished)
+            return;
+        finished = true;
+        endRequest();
+    };
+    let target;
+    try {
+        target = await ensureActiveLoaded();
+    }
+    catch (error) {
+        finish();
+        return sendApiError(reply, 400, errorMessage(error));
+    }
+    let body;
+    if (request.body !== undefined && request.body !== null) {
+        const json = request.body;
+        if (typeof json === 'object' && 'model' in json)
+            json.model = target.runModel;
+        body = Buffer.from(JSON.stringify(json));
+    }
+    const query = request.raw.url?.includes('?')
+        ? request.raw.url.slice(request.raw.url.indexOf('?'))
+        : '';
+    const url = new URL(`${target.baseUrl}/${path}${query}`);
+    const headers = {
+        'x-api-key': target.authToken,
+        authorization: `Bearer ${target.authToken}`,
+    };
+    for (const name of FORWARD_REQUEST_HEADERS) {
+        const value = request.headers[name];
+        if (typeof value === 'string')
+            headers[name] = value;
+    }
+    if (body)
+        headers['content-length'] = String(body.length);
+    await reply.hijack();
+    const upstream = (url.protocol === 'https:' ? https : http).request(url, {
+        method: request.method,
+        headers,
+    });
+    // クライアント（Claude Code）が中断したら転送先も止める（ESC で生成を止めたときにモデルを空ける）
+    reply.raw.on('close', () => {
+        if (!reply.raw.writableFinished)
+            upstream.destroy();
+        finish();
+    });
+    upstream.on('response', (res) => {
+        const responseHeaders = {};
+        for (const [name, value] of Object.entries(res.headers)) {
+            if (value !== undefined && !HOP_BY_HOP_HEADERS.has(name))
+                responseHeaders[name] = value;
+        }
+        reply.raw.writeHead(res.statusCode ?? 502, responseHeaders);
+        res.pipe(reply.raw);
+        res.on('end', finish);
+        res.on('error', finish);
+    });
+    upstream.on('error', (error) => {
+        finish();
+        if (!reply.raw.headersSent) {
+            reply.raw.writeHead(502, { 'content-type': 'application/json' });
+            reply.raw.end(JSON.stringify({
+                type: 'error',
+                error: {
+                    type: 'api_error',
+                    message: `ローカルLLM（${target.baseUrl}）に接続できません: ${error.message}`,
+                },
+            }));
+        }
+        else {
+            reply.raw.destroy(error);
+        }
+    });
+    upstream.end(body);
+}
+export async function localLlmRoutes(fastify) {
+    // ---- 中継口（ローカルLLMタブの ANTHROPIC_BASE_URL） ----
+    fastify.route({
+        method: ['GET', 'POST'],
+        url: '/local-llm/proxy/*',
+        bodyLimit: PROXY_BODY_LIMIT,
+        handler: proxy,
+    });
+    // ---- PreModelSwitch フック（ローカルLLMタブの --settings で登録） ----
+    // モデルは Settings でだけ切り替えるため、/model による切り替えは常に拒否する。
+    // Claude Code は /model の Enter や `/model 名前` の結果を ~/.claude/settings.json の model に保存し、
+    // 通常の Claude タブの既定モデルまで変えてしまう。opus / sonnet 等の別名も中継口の名前に割り当てて
+    // いるため「同じモデル」への切り替えに見えるが、保存はされるので区別せずに拒否する
+    fastify.post('/hooks/local-llm/pre-model-switch', async (_request, reply) => {
+        return reply.send({
+            hookSpecificOutput: {
+                hookEventName: 'PreModelSwitch',
+                permissionDecision: 'deny',
+                permissionDecisionReason: 'ローカルLLMのタブでは /model でモデルを切り替えられません。tsunagi の Settings（Claude Code のローカルLLM）で切り替えてください（全タブに反映されます）',
+            },
+        });
+    });
+    // ---- Settings ----
+    fastify.get('/settings/local-llm', async (_request, reply) => {
+        return reply.send({ data: await getLocalLlmSettings() });
+    });
+    // 使用中のモデルが変わった場合は、他のモデルを解放して読み込みを始める（完了は待たない）
+    fastify.put('/settings/local-llm', async (request, reply) => {
+        const parsed = parseLocalLlmSettings(request.body);
+        if ('error' in parsed)
+            return reply.status(400).send({ error: parsed.error });
+        const result = await activate(parsed.settings);
+        if (!result.ok)
+            return reply.status(409).send({ error: result.error });
+        return reply.send({ data: result.settings });
+    });
+    fastify.get('/settings/local-llm/status', async (_request, reply) => {
+        return reply.send({ data: await getLocalLlmStatus() });
+    });
+    fastify.get('/settings/local-llm/models', async (_request, reply) => {
+        return reply.send({ data: await listLocalLlmModels() });
+    });
+    // 使用中のモデルを今すぐ読み込む（完了は待たない）
+    fastify.post('/settings/local-llm/load', async (_request, reply) => {
+        ensureActiveLoaded().catch(() => undefined);
+        return reply.status(202).send({ data: await getLocalLlmStatus() });
+    });
+    fastify.post('/settings/local-llm/unload', async (_request, reply) => {
+        try {
+            await unloadAll();
+        }
+        catch (error) {
+            return reply.status(502).send({ error: `モデルを解放できません: ${errorMessage(error)}` });
+        }
+        return reply.send({ data: await getLocalLlmStatus() });
+    });
+    // GET /settings/local-llm/estimate?model=&contextTokens= - LM Studio の必要メモリの見積もり
+    fastify.get('/settings/local-llm/estimate', async (request, reply) => {
+        const { model } = request.query;
+        const contextTokens = parseContextTokens(request.query.contextTokens);
+        if (!model || !contextTokens) {
+            return reply.status(400).send({ error: 'model and contextTokens are required' });
+        }
+        try {
+            const data = await estimateLmStudioLoad(await getLmStudioSettings(), model, contextTokens);
+            return reply.send({ data });
+        }
+        catch (error) {
+            return reply
+                .status(502)
+                .send({ error: `メモリの見積もりを取得できません: ${errorMessage(error)}` });
+        }
+    });
+}

package/dist/server/routes/mcp-web.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from 'fastify';
+export declare function mcpWebRoutes(fastify: FastifyInstance): Promise<void>;

package/dist/server/routes/mcp-web.js

@@ -0,0 +1,107 @@
+import { randomUUID } from 'node:crypto';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { searchWeb } from '../lib/searxng.js';
+/**
+ * ローカルLLMタブ専用の Web 検索 MCP。組み込み WebSearch（Anthropic のサーバーツール）が
+ * 使えないため、SearXNG で検索する web_search を1つだけ提供する。
+ * ローカルLLMはツール数が増えるほど呼び出し精度が落ちるため、ツールは増やさない。
+ */
+const DEFAULT_MAX_RESULTS = 8;
+const MAX_RESULTS_LIMIT = 20;
+/** セッションIDをキーにしたtransportのMap */
+const transports = new Map();
+function createWebMcpServer() {
+    const server = new Server({ name: 'tsunagi-web', version: '1.0.0' }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [
+            {
+                name: 'web_search',
+                description: 'Search the web and return result titles, URLs and snippets. ' +
+                    'Use WebFetch on a result URL to read the full page.',
+                inputSchema: {
+                    type: 'object',
+                    required: ['query'],
+                    properties: {
+                        query: { type: 'string', description: 'Search query' },
+                        max_results: {
+                            type: 'number',
+                            description: `Number of results (default ${DEFAULT_MAX_RESULTS}, max ${MAX_RESULTS_LIMIT})`,
+                        },
+                    },
+                    additionalProperties: false,
+                },
+            },
+        ],
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        if (name !== 'web_search') {
+            return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+        }
+        const query = typeof args?.query === 'string' ? args.query.trim() : '';
+        if (!query) {
+            return { content: [{ type: 'text', text: '`query` is required' }], isError: true };
+        }
+        const requested = Number(args?.max_results);
+        const maxResults = Number.isInteger(requested) && requested > 0
+            ? Math.min(requested, MAX_RESULTS_LIMIT)
+            : DEFAULT_MAX_RESULTS;
+        try {
+            const results = await searchWeb(query, maxResults);
+            const text = results.length === 0
+                ? `No results for "${query}".`
+                : results
+                    .map((r, i) => `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.snippet}`.trimEnd())
+                    .join('\n\n');
+            return { content: [{ type: 'text', text }] };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
+                isError: true,
+            };
+        }
+    });
+    return server;
+}
+export async function mcpWebRoutes(fastify) {
+    // POST /mcp/web - セッション初期化またはメッセージ処理
+    fastify.post('/mcp/web', async (request, reply) => {
+        const sessionId = request.headers['mcp-session-id'];
+        if (sessionId) {
+            const transport = transports.get(sessionId);
+            if (!transport) {
+                return reply.status(404).send({ error: `Session not found: ${sessionId}` });
+            }
+            await reply.hijack();
+            await transport.handleRequest(request.raw, reply.raw, request.body);
+            return;
+        }
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+            onsessioninitialized: (id) => {
+                transports.set(id, transport);
+            },
+            onsessionclosed: (id) => {
+                transports.delete(id);
+            },
+        });
+        await createWebMcpServer().connect(transport);
+        await reply.hijack();
+        await transport.handleRequest(request.raw, reply.raw, request.body);
+    });
+    // GET / DELETE /mcp/web - SSEストリーム / セッション終了（既存セッション用）
+    const handleExisting = async (request, reply) => {
+        const sessionId = request.headers['mcp-session-id'];
+        const transport = sessionId ? transports.get(sessionId) : undefined;
+        if (!transport) {
+            return reply.status(400).send({ error: 'Invalid or missing mcp-session-id header' });
+        }
+        await reply.hijack();
+        await transport.handleRequest(request.raw, reply.raw);
+    };
+    fastify.get('/mcp/web', handleExisting);
+    fastify.delete('/mcp/web', handleExisting);
+}

package/dist/server/routes/onboarding.js

@@ -1,15 +1,15 @@
 import { getEnv } from '../lib/repositories/environment.js';
-import { getOllamaSettings, isOllamaReady } from '../lib/ollama-settings.js';
+import { isLocalLlmReady } from '../lib/local-llm.js';
 export async function onboardingRoutes(fastify) {
     // GET /onboarding/status
     fastify.get('/onboarding/status', async (_request, reply) => {
         try {
             const globalEnv = await getEnv('global');
             const hasGlobalToken = Boolean(globalEnv.ANTHROPIC_API_KEY || globalEnv.CLAUDE_CODE_OAUTH_TOKEN);
-            // 実験的機能の Ollama を設定済みなら、Anthropic のトークンがなくても claude を起動できる
-            const ollamaReady = isOllamaReady(await getOllamaSettings());
+            // 実験的機能のローカルLLM（Ollama / LM Studio）を設定済みなら、Anthropic のトークンがなくても claude を起動できる
+            const localLlmReady = await isLocalLlmReady();
             return reply.status(200).send({
-                data: { completed: hasGlobalToken || ollamaReady, hasGlobalToken, ollamaReady },
+                data: { completed: hasGlobalToken || localLlmReady, hasGlobalToken, localLlmReady },
             });
         }
         catch (error) {

package/dist/server/routes/settings.js

@@ -1,11 +1,26 @@
-import { getOllamaAccount, getOllamaSettings, listOllamaModels, parseOllamaSettings, saveOllamaSettings, } from '../lib/ollama-settings.js';
+import { getOllamaAccount, getOllamaSettings, getOllamaStatus, parseOllamaSettings, saveOllamaSettings, } from '../lib/ollama-settings.js';
+import { getLmStudioSettings, getLmStudioStatus, parseLmStudioSettings, saveLmStudioSettings, startLmStudioServer, stopLmStudioServer, } from '../lib/lmstudio.js';
+import { unloadProvider } from '../lib/local-llm.js';
+import { getSearxngSettings, getSearxngStatus, parseSearxngSettings, restartSearxng, saveSearxngSettings, stopSearxng, syncSearxng, } from '../lib/searxng.js';
+import { normalizeBaseUrl } from '../lib/local-llm-env.js';
 /** クエリの baseUrl（未指定なら保存済みの値）を正規化する。不正なら null */
-async function resolveBaseUrl(baseUrl) {
-    const url = (baseUrl || (await getOllamaSettings()).baseUrl).replace(/\/+$/, '');
-    return /^https?:\/\//.test(url) ? url : null;
+async function resolveOllamaBaseUrl(baseUrl) {
+    return normalizeBaseUrl(baseUrl || (await getOllamaSettings()).baseUrl);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** 失敗時は 502 でメッセージを返す（外部プロセス・外部サーバーの操作用） */
+async function sendResult(reply, run, prefix) {
+    try {
+        return reply.status(200).send({ data: await run() });
+    }
+    catch (error) {
+        return reply.status(502).send({ error: `${prefix}: ${errorMessage(error)}` });
+    }
 }
 export async function settingsRoutes(fastify) {
-    // GET /settings/ollama
+    // ---- Ollama ----
     fastify.get('/settings/ollama', async (_request, reply) => {
         try {
             return reply.status(200).send({ data: await getOllamaSettings() });
@@ -15,51 +30,110 @@ export async function settingsRoutes(fastify) {
             return reply.status(500).send({ error: 'Failed to fetch ollama settings' });
         }
     });
-    // PUT /settings/ollama
     fastify.put('/settings/ollama', async (request, reply) => {
         const parsed = parseOllamaSettings(request.body);
         if ('error' in parsed) {
             return reply.status(400).send({ error: parsed.error });
         }
         try {
-            return reply.status(200).send({ data: await saveOllamaSettings(parsed.settings) });
+            // 無効化するプロバイダーに読み込まれたモデルは、以後 tsunagi が管理しないため先に解放する
+            if (!parsed.settings.enabled && (await getOllamaSettings()).enabled) {
+                await unloadProvider('ollama').catch(() => undefined);
+            }
+            const saved = await saveOllamaSettings(parsed.settings);
+            // 有効/無効に合わせて SearXNG を起動・停止する（完了は待たない）
+            void syncSearxng();
+            return reply.status(200).send({ data: saved });
         }
         catch (error) {
             fastify.log.error(error, 'PUT /settings/ollama error');
             return reply.status(500).send({ error: 'Failed to save ollama settings' });
         }
     });
-    // GET /settings/ollama/models - Ollama に pull 済みのモデル一覧
-    // ブラウザから直接叩くと CORS / Docker 内外のホスト名差異が問題になるためサーバー経由にする
-    fastify.get('/settings/ollama/models', async (request, reply) => {
-        const baseUrl = await resolveBaseUrl(request.query.baseUrl);
+    // GET /settings/ollama/status - 接続可否・バージョン・読み込み中のモデル
+    fastify.get('/settings/ollama/status', async (request, reply) => {
+        const baseUrl = await resolveOllamaBaseUrl(request.query.baseUrl);
         if (!baseUrl) {
             return reply.status(400).send({ error: 'baseUrl must be a valid http(s) URL' });
         }
-        try {
-            return reply.status(200).send({ data: { models: await listOllamaModels(baseUrl) } });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return reply
-                .status(502)
-                .send({ error: `Ollama に接続できません (${baseUrl}): ${message}` });
-        }
+        return reply.status(200).send({ data: await getOllamaStatus(baseUrl) });
     });
     // GET /settings/ollama/account - ollama.com のサインイン状態（WebSearch の利用可否）
     fastify.get('/settings/ollama/account', async (request, reply) => {
-        const baseUrl = await resolveBaseUrl(request.query.baseUrl);
+        const baseUrl = await resolveOllamaBaseUrl(request.query.baseUrl);
         if (!baseUrl) {
             return reply.status(400).send({ error: 'baseUrl must be a valid http(s) URL' });
         }
+        return sendResult(reply, () => getOllamaAccount(baseUrl), `Ollama のサインイン状態を取得できません (${baseUrl})`);
+    });
+    // ---- LM Studio ----
+    fastify.get('/settings/lmstudio', async (_request, reply) => {
+        try {
+            return reply.status(200).send({ data: await getLmStudioSettings() });
+        }
+        catch (error) {
+            fastify.log.error(error, 'GET /settings/lmstudio error');
+            return reply.status(500).send({ error: 'Failed to fetch LM Studio settings' });
+        }
+    });
+    fastify.put('/settings/lmstudio', async (request, reply) => {
+        const parsed = parseLmStudioSettings(request.body);
+        if ('error' in parsed) {
+            return reply.status(400).send({ error: parsed.error });
+        }
         try {
-            return reply.status(200).send({ data: await getOllamaAccount(baseUrl) });
+            if (!parsed.settings.enabled && (await getLmStudioSettings()).enabled) {
+                await unloadProvider('lmstudio').catch(() => undefined);
+            }
+            const saved = await saveLmStudioSettings(parsed.settings);
+            void syncSearxng();
+            return reply.status(200).send({ data: saved });
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return reply
-                .status(502)
-                .send({ error: `Ollama のサインイン状態を取得できません (${baseUrl}): ${message}` });
+            fastify.log.error(error, 'PUT /settings/lmstudio error');
+            return reply.status(500).send({ error: 'Failed to save LM Studio settings' });
         }
     });
+    // 以下は保存済みの設定（Base URL・トークン・lms のパス）で LM Studio を操作する。
+    // モデルの読み込み・解放は /settings/local-llm で行う（常に1つだけ載せるため）
+    fastify.get('/settings/lmstudio/status', async (_request, reply) => {
+        return reply.status(200).send({ data: await getLmStudioStatus(await getLmStudioSettings()) });
+    });
+    fastify.post('/settings/lmstudio/server/start', async (_request, reply) => {
+        return sendResult(reply, async () => {
+            const settings = await getLmStudioSettings();
+            await startLmStudioServer(settings);
+            return getLmStudioStatus(settings);
+        }, 'LM Studio のサーバーを起動できません');
+    });
+    fastify.post('/settings/lmstudio/server/stop', async (_request, reply) => {
+        return sendResult(reply, async () => {
+            const settings = await getLmStudioSettings();
+            await stopLmStudioServer(settings);
+            return getLmStudioStatus(settings);
+        }, 'LM Studio のサーバーを停止できません');
+    });
+    // ---- SearXNG（ローカル検索） ----
+    fastify.get('/settings/searxng', async (_request, reply) => {
+        return reply.status(200).send({ data: await getSearxngSettings() });
+    });
+    fastify.put('/settings/searxng', async (request, reply) => {
+        const parsed = parseSearxngSettings(request.body);
+        if ('error' in parsed) {
+            return reply.status(400).send({ error: parsed.error });
+        }
+        return reply.status(200).send({ data: await saveSearxngSettings(parsed.settings) });
+    });
+    fastify.get('/settings/searxng/status', async (_request, reply) => {
+        return reply.status(200).send({ data: await getSearxngStatus() });
+    });
+    // 起動完了（最大60秒）を待たずに返す。状態は status をポーリングして確認する
+    fastify.post('/settings/searxng/restart', async (_request, reply) => {
+        void restartSearxng();
+        return reply.status(202).send({ data: await getSearxngStatus() });
+    });
+    fastify.post('/settings/searxng/stop', async (_request, reply) => {
+        await stopSearxng();
+        return reply.status(200).send({ data: await getSearxngStatus() });
+    });
 }

package/dist/server/routes/tasks.js

@@ -329,7 +329,11 @@ export async function tasksRoutes(fastify) {
         try {
             const { id: taskId } = request.params;
             const requested = request.body?.mode;
-            const mode = requested === 'terminal' || requested === 'ollama' ? requested : 'claude';
+            const mode = requested === 'terminal'
+                ? 'terminal'
+                : requested === 'local' || requested === 'ollama' || requested === 'lmstudio'
+                    ? 'local'
+                    : 'claude';
             const task = await taskRepo.getTask(taskId);
             if (!task) {
                 return reply.status(404).send({ error: 'Task not found' });