@minimalcorp/tsunagi 0.1.38 → 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' });

package/dist/server/routes/terminal.js

@@ -5,8 +5,10 @@ import { ptyManager } from '../pty-manager.js';
 import { prisma } from '../lib/db.js';
 import { getWorktreePath } from '../lib/worktree-manager.js';
 import { getEnv } from '../lib/repositories/environment.js';
-import { ensureClaudeOnboardingCompleted } from '../lib/claude-config-guard.js';
-import { OLLAMA_UNSET_ENV_KEYS, buildOllamaEnv, getOllamaSettings, } from '../lib/ollama-settings.js';
+import { ensureClaudeOnboardingCompleted, removeLocalModelFromUserSettings, } from '../lib/claude-config-guard.js';
+import { LOCAL_LLM_UNSET_ENV_KEYS, LOCAL_MODEL_ALIAS, buildLocalLlmEnv, } from '../lib/local-llm-env.js';
+import { ensureActiveLoaded, getLocalLlmSettings } from '../lib/local-llm.js';
+import { LOCAL_LLM_PROXY_URL, buildClaudeCommand, isLocalLlmMode } from '../lib/claude-command.js';
 // サーバーはプロジェクトルートから起動されるため process.cwd() でルートを取得
 const TSUNAGI_EDITOR_PATH = path.resolve(process.cwd(), 'scripts/monaco-editor.sh');
 // Fastify(API) の公開ポート。index.ts と同じ既定値・同じ環境変数(TSUNAGI_SERVER_PORT)を見る。
@@ -35,6 +37,22 @@ function stripTerminalQueries(s) {
         .replace(/\x1b\[[?>]?[0-9;]*n/g, '') // DSR: ESC[?6n(主犯) / ESC[6n / ESC[5n など
         .replace(/\x1b\[[?>=]?[0-9;]*c/g, ''); // DA: ESC[c / ESC[0c / ESC[>c / ESC[=c
 }
+/**
+ * ローカルLLMタブで注入する環境変数を返す。Claude Code は tsunagi の中継口に接続し、
+ * 中継口が使用中のモデルへ転送する。最初の発言を待たせないよう、読み込みはここで始めておく（完了は待たない）
+ */
+async function prepareLocalLlm() {
+    const { active, extraEnv } = await getLocalLlmSettings();
+    if (!active) {
+        throw new Error('ローカルLLMのモデルが未設定です。Settings で使用するモデルを選んでください');
+    }
+    ensureActiveLoaded().catch(() => undefined);
+    return buildLocalLlmEnv({
+        proxyUrl: LOCAL_LLM_PROXY_URL,
+        contextTokens: active.contextTokens,
+        extraEnv,
+    });
+}
 export async function terminalRoutes(fastify) {
     const io = fastify.io;
     // socket.io イベントハンドラ
@@ -182,7 +200,8 @@ export async function terminalRoutes(fastify) {
     });
     // POST /terminal/sessions - セッション作成（または既存セッション再利用）
     fastify.post('/terminal/sessions', async (request, reply) => {
-        const { cwd, env, sessionId: requestedSessionId, command } = request.body ?? {};
+        const { cwd, env, sessionId: requestedSessionId, claude } = request.body ?? {};
+        let { command } = request.body ?? {};
         const sessionId = requestedSessionId ?? crypto.randomUUID();
         // 既存セッションが生きていれば再利用
         const existing = ptyManager.getSession(sessionId);
@@ -226,21 +245,25 @@ export async function terminalRoutes(fastify) {
             catch (err) {
                 fastify.log.warn({ err }, 'Failed to load env vars');
             }
-            // Ollama タブ: Anthropic の代わりに Ollama の Anthropic 互換 API で claude を動かす。
+            // ローカルLLMタブ: Anthropic の代わりに tsunagi の中継口（→ Ollama / LM Studio）で claude を動かす。
             // DB の環境変数より後に適用し、Anthropic の認証トークンは環境変数ごと取り除く。
             let providerEnv = {};
             let unsetKeys = [];
-            if (tabMode === 'ollama') {
-                const ollama = await getOllamaSettings();
-                if (!ollama.model) {
+            if (isLocalLlmMode(tabMode)) {
+                try {
+                    providerEnv = await prepareLocalLlm();
+                }
+                catch (err) {
                     return reply
                         .status(400)
-                        .send({ error: 'Ollama のモデルが未設定です。Settings で設定してください' });
+                        .send({ error: err instanceof Error ? err.message : String(err) });
                 }
-                providerEnv = buildOllamaEnv(ollama);
-                unsetKeys = OLLAMA_UNSET_ENV_KEYS;
+                unsetKeys = LOCAL_LLM_UNSET_ENV_KEYS;
+            }
+            if (claude) {
+                command = await buildClaudeCommand(sessionId, (tabMode ?? 'claude'));
             }
-            // 優先順位: リクエストで渡されたenv > Ollama等のprovider env > DB env(global/owner/repo) > tsunagi独自のEDITOR設定
+            // 優先順位: リクエストで渡されたenv > ローカルLLMのprovider env > DB env(global/owner/repo) > tsunagi独自のEDITOR設定
             // tsunagi-editor.sh をデフォルトにすることで Ctrl+G が Monaco Modal を開く。
             // DB / リクエストで EDITOR が明示設定されている場合はそちらが優先される。
             const tsunagiDefaultEnv = {
@@ -259,6 +282,8 @@ export async function terminalRoutes(fastify) {
                 // いると、次回 claude 起動時にオンボーディングウィザードが表示され --resume/
                 // --session-id を前提にした自動起動フローが止まるため、起動前に補正する。
                 await ensureClaudeOnboardingCompleted();
+                // 監視の取りこぼしに備え、起動前にも中継口の名前が既定モデルに残っていないか補正する
+                await removeLocalModelFromUserSettings(LOCAL_MODEL_ALIAS);
                 // シェルの初期化（プロンプト表示）を待つため少し遅延させて書き込む
                 setTimeout(() => {
                     session.pty.write(cmd);
@@ -271,6 +296,23 @@ export async function terminalRoutes(fastify) {
             return reply.status(500).send({ error: message });
         }
     });
+    // POST /terminal/sessions/:sessionId/claude - 既存 PTY で claude を（再）起動する
+    // コマンドはタブの mode に応じてサーバーで組み立てる（ローカルLLMタブは引数が付くため）
+    fastify.post('/terminal/sessions/:sessionId/claude', async (request, reply) => {
+        const { sessionId } = request.params;
+        const session = ptyManager.getSession(sessionId);
+        if (!session) {
+            return reply.status(404).send({ error: 'Session not found' });
+        }
+        const tab = await prisma.tab.findUnique({ where: { tabId: sessionId } }).catch(() => null);
+        const mode = (tab?.mode ?? 'claude');
+        if (isLocalLlmMode(mode)) {
+            // 最初の発言を待たせないよう読み込みを始めておく（未設定等のエラーは中継口がタブに返す）
+            ensureActiveLoaded().catch(() => undefined);
+        }
+        session.pty.write(`${await buildClaudeCommand(sessionId, mode)}\n`);
+        return reply.status(204).send();
+    });
     // DELETE /terminal/sessions/:sessionId - セッション明示削除（PTY kill）
     fastify.delete('/terminal/sessions/:sessionId', async (request, reply) => {
         const { sessionId } = request.params;

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@minimalcorp/tsunagi",
-  "version": "0.1.38",
+  "version": "0.1.39",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@minimalcorp/tsunagi",
-      "version": "0.1.38",
+      "version": "0.1.39",
       "license": "SEE LICENSE IN LICENSE",
       "os": [
         "darwin",
@@ -234,9 +234,9 @@
       }
     },
     "node_modules/@fastify/multipart": {
-      "version": "10.1.1",
-      "resolved": "https://registry.npmjs.org/@fastify/multipart/-/multipart-10.1.1.tgz",
-      "integrity": "sha512-jyRHgnFVdchZRKjJRf6kGPEiDp3Bg4MLo4d6/krt8Z4RutLrqL5IYWihx8a4tnv7Tu7JfuHcyC+dU9zPzTxiSg==",
+      "version": "10.1.2",
+      "resolved": "https://registry.npmjs.org/@fastify/multipart/-/multipart-10.1.2.tgz",
+      "integrity": "sha512-WHsqW5ffDXCbXXtdBQDryxu58fQvFPVGh4E4MlCO6hwCLNm0lYTCS6GKXUw2P64REDoECUNpMVvtMMstdIyBjQ==",
       "funding": [
         {
           "type": "github",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minimalcorp/tsunagi",
-  "version": "0.1.38",
+  "version": "0.1.39",
   "description": "Multi-repo GitHub project management with Claude AI integration, designed for visualizing and controlling AI-driven development locally.",
   "keywords": [
     "tsunagi",