@minimalcorp/tsunagi 0.1.55 → 0.3.0

package/dist/server/lib/pty-env-sync.js

@@ -0,0 +1,139 @@
+import { execFile } from 'child_process';
+import { ptyManager } from '../pty-manager.js';
+import { prisma } from './db.js';
+import { resolvePtyLaunch, startPtySession } from './pty-launch.js';
+/**
+ * tsunagi の環境変数（Claude プロファイルの割り当てを含む）の変更を、起動中の PTY に反映する。
+ *
+ * 動いているプロセスの環境変数は外から書き換えられないため、PTY を作り直して反映する
+ * （claude タブは --resume で同じ会話に戻る）。作業を壊さないよう、claude が応答中・許可待ちの間や
+ * シェルでコマンドを実行中の間、直近にユーザー入力があった間は作り直さず「反映待ち」にしておき、
+ * 安全になった時点で作り直す。
+ */
+/** 直近の入力からこの時間が経つまでは作り直さない（入力中の文字を消さないため） */
+const INPUT_IDLE_MS = 15_000;
+/** 反映待ちの PTY を作り直せるか確認する間隔 */
+const CHECK_INTERVAL_MS = 5_000;
+/** claude がこの状態の間は作り直さない（hooks が Tab.status に記録する） */
+const BUSY_TAB_STATUSES = new Set(['running', 'waiting']);
+let io = null;
+let checking = false;
+function emitPending(session) {
+    io?.to(`tab:${session.sessionId}`).emit('env-pending', {
+        sessionId: session.sessionId,
+        pending: session.envPending,
+    });
+}
+/** 環境変数の比較用キー（キー順に依存しない） */
+function launchKey(env, unsetKeys) {
+    const sorted = Object.keys(env)
+        .sort()
+        .map((key) => [key, env[key]]);
+    return JSON.stringify([sorted, [...unsetKeys].sort()]);
+}
+async function resolveFor(session) {
+    try {
+        return await resolvePtyLaunch(session.sessionId, session.options.request ?? {});
+    }
+    catch (err) {
+        console.warn(`[pty-env-sync] Failed to resolve env for ${session.sessionId}:`, err);
+        return null;
+    }
+}
+/** シェル配下でコマンドが動いているか（pgrep は該当なしのとき exit 1） */
+function hasChildProcess(pid) {
+    return new Promise((resolve) => {
+        execFile('pgrep', ['-P', String(pid)], (err) => resolve(!err));
+    });
+}
+async function canRespawnNow(session) {
+    if (Date.now() - session.lastInputAt < INPUT_IDLE_MS)
+        return false;
+    const tab = await prisma.tab
+        .findUnique({ where: { tabId: session.sessionId }, select: { mode: true, status: true } })
+        .catch(() => null);
+    if (tab && tab.mode !== 'terminal')
+        return !BUSY_TAB_STATUSES.has(tab.status);
+    return !(await hasChildProcess(session.pty.pid));
+}
+/** PTY を最新の環境変数で作り直す。クライアントには pty-respawned で再接続させる */
+async function respawn(session) {
+    const launch = await resolveFor(session);
+    if (!launch)
+        return;
+    const { sessionId } = session;
+    // 判定から作り直しまでの間に別経路で作り直し・削除されていれば何もしない
+    if (ptyManager.getSession(sessionId) !== session)
+        return;
+    session.respawning = true;
+    ptyManager.deleteSession(sessionId);
+    try {
+        await startPtySession(sessionId, launch, {
+            request: session.options.request ?? {},
+            launchClaude: session.options.launchClaude ?? false,
+        });
+    }
+    catch (err) {
+        console.error(`[pty-env-sync] Failed to respawn ${sessionId}:`, err);
+        io?.to(`tab:${sessionId}`).emit('exit', { exitCode: -1 });
+        return;
+    }
+    console.log(`[pty-env-sync] Respawned ${sessionId} with updated env`);
+    io?.to(`tab:${sessionId}`).emit('pty-respawned', { sessionId });
+}
+/** 反映待ちの PTY のうち、安全なものを作り直す */
+async function respawnPendingSessions() {
+    if (checking)
+        return;
+    checking = true;
+    try {
+        for (const sessionId of ptyManager.listSessions()) {
+            const session = ptyManager.getSession(sessionId);
+            if (!session?.envPending || session.respawning)
+                continue;
+            if (await canRespawnNow(session))
+                await respawn(session);
+        }
+    }
+    finally {
+        checking = false;
+    }
+}
+/** 起動時に一度呼ぶ。反映待ちの PTY を定期的に確認する */
+export function initPtyEnvSync(server) {
+    io = server;
+    setInterval(() => void respawnPendingSessions(), CHECK_INTERVAL_MS).unref();
+}
+/**
+ * tsunagi の環境変数（Claude プロファイルの割り当て・プロファイル削除を含む）を変更した後に呼ぶ。
+ * 起動中の PTY ごとに環境変数を解決し直し、作成時と違えば反映待ちにする。
+ */
+export async function notifyEnvChanged() {
+    for (const sessionId of ptyManager.listSessions()) {
+        const session = ptyManager.getSession(sessionId);
+        if (!session?.options.syncEnv || session.respawning)
+            continue;
+        const launch = await resolveFor(session);
+        if (!launch)
+            continue;
+        const pending = launchKey(launch.env, launch.unsetKeys) !==
+            launchKey(session.appliedEnv, session.appliedUnsetKeys);
+        if (pending !== session.envPending) {
+            session.envPending = pending;
+            emitPending(session);
+        }
+    }
+    await respawnPendingSessions();
+}
+/** 反映待ちの PTY を、ユーザー操作で今すぐ作り直す */
+export async function respawnSessionNow(sessionId) {
+    const session = ptyManager.getSession(sessionId);
+    if (!session || session.respawning)
+        return false;
+    await respawn(session);
+    return true;
+}
+/** join したクライアントに現在の反映待ち状態を伝える */
+export function getEnvPending(sessionId) {
+    return ptyManager.getSession(sessionId)?.envPending ?? false;
+}

package/dist/server/lib/pty-launch.d.ts

@@ -0,0 +1,36 @@
+import type { TabMode } from '@minimalcorp/tsunagi-shared';
+import { type PtySession } from '../pty-manager.js';
+/** PTY 起動時にクライアントが指定する値（環境変数の自動反映で作り直すときも同じ値を使う） */
+export interface PtyLaunchRequest {
+    cwd?: string;
+    env?: Record<string, string>;
+}
+export interface PtyLaunch {
+    workingDir: string;
+    mode: TabMode | undefined;
+    /** タブ（Task）に紐づくか。紐づくタブは worktree が必須 */
+    hasTab: boolean;
+    env: Record<string, string>;
+    unsetKeys: string[];
+}
+export declare class PtyLaunchError extends Error {
+    readonly statusCode: number;
+    constructor(message: string, statusCode: number);
+}
+/**
+ * sessionId(=tab_id) から PTY の作業ディレクトリと環境変数を解決する。
+ * 環境変数の優先順位: リクエストで渡されたenv > ローカルLLMのprovider env >
+ * DB env(global/owner/repo、Claude プロファイルを CLAUDE_CONFIG_DIR に変換) > tsunagi独自のEDITOR設定
+ */
+export declare function resolvePtyLaunch(sessionId: string, request: PtyLaunchRequest): Promise<PtyLaunch>;
+/**
+ * 解決済みの launch で PTY を作り、claude を起動する。
+ * 新規作成（POST /terminal/sessions）と環境変数変更時の作り直し（pty-env-sync）で共用する。
+ */
+export declare function startPtySession(sessionId: string, launch: PtyLaunch, options: {
+    request: PtyLaunchRequest;
+    launchClaude: boolean;
+    command?: string;
+}): Promise<PtySession>;
+/** 既存 PTY で claude を（再）起動する前の補正。PTY 作成時の環境変数のプロファイルを対象にする */
+export declare function prepareClaudeConfigForSession(session: PtySession): Promise<void>;

package/dist/server/lib/pty-launch.js

@@ -0,0 +1,141 @@
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { ptyManager } from '../pty-manager.js';
+import { prisma } from './db.js';
+import { getWorktreePath } from './worktree-manager.js';
+import { getEnv } from './repositories/environment.js';
+import { ensureClaudeOnboardingCompleted, removeLocalModelFromUserSettings, watchUserSettingsForLocalModel, } from './claude-config-guard.js';
+import { LOCAL_LLM_UNSET_ENV_KEYS, LOCAL_MODEL_ALIAS, buildLocalLlmEnv } from './local-llm-env.js';
+import { ensureActiveLoaded, getLocalLlmSettings } from './local-llm.js';
+import { LOCAL_LLM_PROXY_URL, buildClaudeCommand, isLocalLlmMode } from './claude-command.js';
+import { resolveClaudeProfileEnv } from './claude-profiles.js';
+// このファイル基準で解決する(cwd 非依存):
+//   dev:        apps/server/src/lib      → apps/server/scripts
+//   build:      apps/server/dist/lib     → apps/server/scripts
+//   npm bundle: <pkg>/dist/server/lib    → <pkg>/dist/scripts
+const TSUNAGI_EDITOR_PATH = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../scripts/monaco-editor.sh');
+// Fastify(API) の公開ポート。index.ts と同じ既定値・同じ環境変数(TSUNAGI_SERVER_PORT)を見る。
+// monaco-editor.sh など PTY 内のプロセスが API を叩く際の同一ホスト向けベース URL に使う。
+const SERVER_PORT = Number(process.env.TSUNAGI_SERVER_PORT) || 2791;
+export class PtyLaunchError extends Error {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+/**
+ * sessionId(=tab_id) から PTY の作業ディレクトリと環境変数を解決する。
+ * 環境変数の優先順位: リクエストで渡されたenv > ローカルLLMのprovider env >
+ * DB env(global/owner/repo、Claude プロファイルを CLAUDE_CONFIG_DIR に変換) > tsunagi独自のEDITOR設定
+ */
+export async function resolvePtyLaunch(sessionId, request) {
+    // Taskに紐づかないタブは Tab レコードが存在しないため null になる。
+    const tab = await prisma.tab.findUnique({
+        where: { tabId: sessionId },
+        include: { task: true },
+    });
+    // cwd は Task があればサーバー側で worktree パスを導出する（クライアントの state に依存しない）。
+    // クライアント指定の cwd は Task に紐づかないタブのフォールバックとしてのみ使う。
+    const defaultDir = path.join(os.homedir(), '.tsunagi', 'workspaces');
+    let workingDir = tab
+        ? getWorktreePath(tab.task.owner, tab.task.repo, tab.task.branch)
+        : (request.cwd ?? defaultDir);
+    // cwd が存在するか確認。Task のタブは worktree 必須（無ければ起動しない）、
+    // それ以外はデフォルトにフォールバック
+    try {
+        await fs.access(workingDir);
+    }
+    catch {
+        if (tab)
+            throw new PtyLaunchError(`Worktree not found at ${workingDir}`, 409);
+        workingDir = defaultDir;
+    }
+    // repo スコープまで階層マージした環境変数を取得する（global → owner → repo、後勝ちで上書き）。
+    // Taskに紐づかないタブは global のみになる。
+    // 読み込みに失敗したら起動しない（空の環境変数で起動・作り直しすると設定が抜け落ちるため）
+    const dbEnv = tab ? await getEnv('repo', tab.task.owner, tab.task.repo) : await getEnv('global');
+    const profile = resolveClaudeProfileEnv(dbEnv);
+    // ローカルLLMタブ: Anthropic の代わりに tsunagi の中継口（→ Ollama / LM Studio）で claude を動かす。
+    // DB の環境変数より後に適用し、Anthropic の認証トークンは環境変数ごと取り除く。
+    const mode = tab?.mode;
+    let providerEnv = {};
+    let unsetKeys = profile.unsetKeys;
+    if (isLocalLlmMode(mode)) {
+        const { active, extraEnv } = await getLocalLlmSettings();
+        if (!active) {
+            throw new PtyLaunchError('ローカルLLMのモデルが未設定です。Settings で使用するモデルを選んでください', 400);
+        }
+        providerEnv = buildLocalLlmEnv({
+            proxyUrl: LOCAL_LLM_PROXY_URL,
+            contextTokens: active.contextTokens,
+            extraEnv,
+        });
+        unsetKeys = [...new Set([...unsetKeys, ...LOCAL_LLM_UNSET_ENV_KEYS])];
+    }
+    // tsunagi-editor.sh をデフォルトにすることで Ctrl+G が Monaco Modal を開く。
+    // DB / リクエストで EDITOR が明示設定されている場合はそちらが優先される。
+    const tsunagiDefaultEnv = {
+        EDITOR: TSUNAGI_EDITOR_PATH,
+        TSUNAGI_SESSION_ID: sessionId,
+        // monaco-editor.sh が API(Fastify) を叩くためのベース URL。サーバーと同一
+        // ホストなので localhost。単一ポート化で API は SERVER_PORT(既定 2791)。
+        TSUNAGI_API_BASE: `http://localhost:${SERVER_PORT}`,
+    };
+    return {
+        workingDir,
+        mode,
+        hasTab: Boolean(tab),
+        env: { ...tsunagiDefaultEnv, ...profile.env, ...providerEnv, ...request.env },
+        unsetKeys,
+    };
+}
+/**
+ * claude 起動前の補正。claude logout で .claude.json の hasCompletedOnboarding がリセットされて
+ * いると、次回 claude 起動時にオンボーディングウィザードが表示され --resume/--session-id を前提にした
+ * 自動起動フローが止まるため補正する。監視の取りこぼしに備え、中継口の名前が既定モデルに残って
+ * いないかも補正する。対象はタブが使う Claude プロファイルの設定ディレクトリ。
+ */
+async function prepareClaudeConfig(env) {
+    // PTY は外側 Terminal の環境を継承するため、プロファイル未指定なら外側の CLAUDE_CONFIG_DIR に従う
+    const configDir = env.CLAUDE_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR;
+    await ensureClaudeOnboardingCompleted(configDir);
+    await removeLocalModelFromUserSettings(LOCAL_MODEL_ALIAS, configDir);
+    watchUserSettingsForLocalModel(LOCAL_MODEL_ALIAS, configDir);
+}
+/**
+ * 解決済みの launch で PTY を作り、claude を起動する。
+ * 新規作成（POST /terminal/sessions）と環境変数変更時の作り直し（pty-env-sync）で共用する。
+ */
+export async function startPtySession(sessionId, launch, options) {
+    await fs.mkdir(launch.workingDir, { recursive: true });
+    let command = options.command;
+    if (options.launchClaude) {
+        if (isLocalLlmMode(launch.mode)) {
+            // 最初の発言を待たせないよう読み込みを始めておく（完了は待たない）
+            ensureActiveLoaded().catch(() => undefined);
+        }
+        command = await buildClaudeCommand(sessionId, launch.mode ?? 'claude');
+    }
+    const session = ptyManager.createSession(sessionId, launch.workingDir, launch.env, launch.unsetKeys, {
+        request: options.request,
+        launchClaude: options.launchClaude,
+        syncEnv: true,
+    });
+    // コマンドが指定されていればPTY起動後にシェルへ書き込む
+    if (command) {
+        const cmd = command.endsWith('\n') ? command : command + '\n';
+        await prepareClaudeConfig(launch.env);
+        // シェルの初期化（プロンプト表示）を待つため少し遅延させて書き込む
+        setTimeout(() => {
+            session.pty.write(cmd);
+        }, 300);
+    }
+    return session;
+}
+/** 既存 PTY で claude を（再）起動する前の補正。PTY 作成時の環境変数のプロファイルを対象にする */
+export async function prepareClaudeConfigForSession(session) {
+    await prepareClaudeConfig(session.appliedEnv);
+}

package/dist/server/lib/repositories/environment.js

@@ -21,48 +21,22 @@ export async function getAllEnv(scope, owner, repo) {
 // 環境変数取得（優先順位: repo > owner > global）
 export async function getEnv(scope, owner, repo) {
     const result = {};
-    // Claude認証トークンのキー定義
-    const CLAUDE_TOKEN_KEYS = ['ANTHROPIC_API_KEY', 'CLAUDE_CODE_OAUTH_TOKEN'];
-    // Helper: Claude認証トークンをクリア
-    const clearClaudeTokens = () => {
-        CLAUDE_TOKEN_KEYS.forEach((key) => delete result[key]);
-    };
-    // Helper: 環境変数リストにClaude認証トークンが含まれるか
-    const hasClaudeToken = (envs) => {
-        return envs.some((env) => CLAUDE_TOKEN_KEYS.includes(env.key));
+    const apply = (envs) => {
+        envs.forEach((env) => {
+            result[env.key] = env.value;
+        });
     };
     // グローバル変数を先に適用（有効なもののみ）
-    const globalEnvs = await prisma.environmentVariable.findMany({
-        where: { scope: 'global', enabled: true },
-    });
-    globalEnvs.forEach((env) => {
-        result[env.key] = env.value;
-    });
+    apply(await prisma.environmentVariable.findMany({ where: { scope: 'global', enabled: true } }));
     // owner変数を適用（上書き、有効なもののみ）
     if (scope === 'owner' || scope === 'repo') {
-        const ownerEnvs = await prisma.environmentVariable.findMany({
-            where: { scope: 'owner', owner, enabled: true },
-        });
-        // Ownerスコープで新しいClaude認証トークンがあれば、Globalのものをクリア
-        if (hasClaudeToken(ownerEnvs)) {
-            clearClaudeTokens();
-        }
-        ownerEnvs.forEach((env) => {
-            result[env.key] = env.value;
-        });
+        apply(await prisma.environmentVariable.findMany({ where: { scope: 'owner', owner, enabled: true } }));
     }
     // repo変数を適用（上書き、有効なもののみ）
     if (scope === 'repo') {
-        const repoEnvs = await prisma.environmentVariable.findMany({
+        apply(await prisma.environmentVariable.findMany({
             where: { scope: 'repo', owner, repo, enabled: true },
-        });
-        // Repoスコープで新しいClaude認証トークンがあれば、以前のものをクリア
-        if (hasClaudeToken(repoEnvs)) {
-            clearClaudeTokens();
-        }
-        repoEnvs.forEach((env) => {
-            result[env.key] = env.value;
-        });
+        }));
     }
     return result;
 }

package/dist/server/lib/restart.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 更新を適用するための再起動。Fastify はこの終了コードで終了し、apps/cli の app が残りを止めて
+ * 同じコードで終了すると、entry が新しいバージョンで起動し直す（apps/cli/src/versions.ts と合わせる）。
+ */
+export declare const RESTART_EXIT_CODE = 75;
+/** index.ts が終了処理を登録する */
+export declare function onRestartRequested(fn: () => void): void;
+export declare function requestRestart(): void;

package/dist/server/lib/restart.js

@@ -0,0 +1,13 @@
+/**
+ * 更新を適用するための再起動。Fastify はこの終了コードで終了し、apps/cli の app が残りを止めて
+ * 同じコードで終了すると、entry が新しいバージョンで起動し直す（apps/cli/src/versions.ts と合わせる）。
+ */
+export const RESTART_EXIT_CODE = 75;
+let handler = null;
+/** index.ts が終了処理を登録する */
+export function onRestartRequested(fn) {
+    handler = fn;
+}
+export function requestRestart() {
+    handler?.();
+}

package/dist/server/lib/update-check.js

@@ -1,5 +1,8 @@
-// 公開パッケージの latest dist-tag のみを返す軽量エンドポイント（数KB）
-const REGISTRY_URL = 'https://registry.npmjs.org/@minimalcorp%2ftsunagi/latest';
+import { getAutoUpdateStatus, isEntryOutdated, onAutoUpdateChange, prepareUpdate, } from './auto-update.js';
+// 公開パッケージの latest dist-tag のみを返す軽量エンドポイント（数KB）。
+// TSUNAGI_NPM_REGISTRY でミラー・検証用 registry に差し替えられる（自動更新の install も同じ registry を使う）
+const REGISTRY_BASE = (process.env.TSUNAGI_NPM_REGISTRY || 'https://registry.npmjs.org').replace(/\/+$/, '');
+const REGISTRY_URL = `${REGISTRY_BASE}/@minimalcorp%2ftsunagi/latest`;
 const CHECK_INTERVAL_MS = 60 * 60 * 1000;
 const FETCH_TIMEOUT_MS = 10_000;
 // 実行中のバージョンは apps/cli が自身の package.json から注入する。
@@ -29,7 +32,10 @@ export function isNewer(latest, current) {
     return false;
 }
 export function getUpdateStatus() {
-    return { ...status };
+    return { ...status, autoUpdate: getAutoUpdateStatus(), entryOutdated: isEntryOutdated() };
+}
+function emitStatus() {
+    socket?.emit('version:status', getUpdateStatus());
 }
 /** registry を確認して status を更新する。確認できなければ false（前回の結果を保持） */
 async function check() {
@@ -46,7 +52,10 @@ async function check() {
         status.updateAvailable = isNewer(version, status.current);
         status.checkedAt = new Date().toISOString();
         // checkedAt も表示しているため、変化の有無に関わらず通知する
-        socket?.emit('version:status', getUpdateStatus());
+        emitStatus();
+        // 新しいバージョンは自動でインストールしておき、再起動のタイミングだけユーザーに任せる
+        if (status.updateAvailable)
+            prepareUpdate(version);
         return true;
     }
     catch {
@@ -62,6 +71,7 @@ export function startUpdateCheck(io) {
     if (!status.current || timer)
         return;
     socket = io;
+    onAutoUpdateChange(emitStatus);
     void check();
     timer = setInterval(() => void check(), CHECK_INTERVAL_MS);
     timer.unref();

package/dist/server/pty-manager.d.ts

@@ -1,8 +1,30 @@
 import * as pty from 'node-pty';
+/** PTY 作成時の付随情報（環境変数の変更を反映するために作り直すときに使う） */
+export interface PtySessionOptions {
+    /** クライアントが指定した cwd / env */
+    request?: {
+        cwd?: string;
+        env?: Record<string, string>;
+    };
+    /** 作成時に claude を起動したか（作り直し後も claude を --resume で起動する） */
+    launchClaude?: boolean;
+    /** tsunagi の環境変数の変更を自動で反映する対象か（Claude のログイン用 PTY 等は対象外） */
+    syncEnv?: boolean;
+}
 export interface PtySession {
     pty: pty.IPty;
     sessionId: string;
     cwd: string;
+    /** 作成時に渡した環境変数と取り除いたキー（変更検知の比較元） */
+    appliedEnv: Record<string, string>;
+    appliedUnsetKeys: string[];
+    options: PtySessionOptions;
+    /** tsunagi の環境変数が変わり、作り直し待ちの状態 */
+    envPending: boolean;
+    /** 環境変数の反映のために kill 中。onExit で「セッション終了」として扱わない */
+    respawning: boolean;
+    /** 最後にユーザー入力があった時刻（入力中の作り直しを避けるため） */
+    lastInputAt: number;
     /** PTY出力のリングバッファ（再接続時にまとめて送信） */
     scrollback: string[];
     scrollbackSize: number;
@@ -24,7 +46,7 @@ declare class PtyManager {
      * @param unsetKeys 外側 Terminal や DB 由来でも内部ターミナルに渡さない環境変数キー
      *   （例: Ollama タブでは Anthropic の認証トークンを取り除く）
      */
-    createSession(sessionId: string, cwd: string, env?: Record<string, string>, unsetKeys?: string[]): PtySession;
+    createSession(sessionId: string, cwd: string, env?: Record<string, string>, unsetKeys?: string[], options?: PtySessionOptions): PtySession;
     getSession(sessionId: string): PtySession | undefined;
     deleteSession(sessionId: string): void;
     /**
@@ -39,6 +61,8 @@ declare class PtyManager {
      */
     cancelGc(sessionId: string): void;
     listSessions(): string[];
+    /** サーバー終了時に全セッションを止める（SIGHUP 任せにせず明示的に kill する） */
+    deleteAllSessions(): void;
 }
 export declare const ptyManager: PtyManager;
 export {};

package/dist/server/pty-manager.js

@@ -3,8 +3,9 @@ import * as os from 'os';
 const SCROLLBACK_MAX_BYTES = 256 * 1024; // 256KB
 const SESSION_GC_INTERVAL_MS = 30 * 60 * 1000; // 30分
 /**
- * apps/cli が Fastify サーバー起動時に自分で注入する環境変数
- * （TSUNAGI_SERVER_PORT, NODE_ENV, TSUNAGI_NEXT_PORT, TSUNAGI_OUTER_NODE_ENV）。
+ * apps/cli（entry・app）が Fastify サーバー起動時に自分で注入する環境変数
+ * （TSUNAGI_SERVER_PORT, NODE_ENV, TSUNAGI_NEXT_PORT, TSUNAGI_OUTER_NODE_ENV, TSUNAGI_PLUGIN_DIR,
+ * TSUNAGI_ENTRY_*, TSUNAGI_LAST_GOOD, TSUNAGI_AUTO_UPDATE, TSUNAGI_RESTARTED）。
  * サーバープロセス自身の制御用に後から足された値のため、内部ターミナルには継承しない。
  * 外側 Terminal 由来の環境変数はこのリストと無関係に、これまで通り全て継承する
  * （PORT はここでは扱わない。apps/cli は generic な PORT を上書きせず、専用キー
@@ -21,7 +22,28 @@ const TSUNAGI_INJECTED_ENV_KEYS = [
     'NODE_ENV',
     'TSUNAGI_NEXT_PORT',
     'TSUNAGI_OUTER_NODE_ENV',
+    'TSUNAGI_PLUGIN_DIR',
+    'TSUNAGI_ENTRY_PROTOCOL',
+    'TSUNAGI_ENTRY_PACKAGE_ROOT',
+    'TSUNAGI_ENTRY_OUTDATED',
+    'TSUNAGI_LAST_GOOD',
+    'TSUNAGI_AUTO_UPDATE',
+    'TSUNAGI_RESTARTED',
 ];
+/**
+ * tsunagi の Claude Code プラグイン（hooks・MCP・skill）を、内部ターミナルで起動する claude に
+ * セッション単位で読み込ませる。ユーザー設定にはインストールしないため、tsunagi 外の claude には
+ * 影響しない。外側 Terminal や DB で CLAUDE_CODE_PLUGIN_DIRS が設定済みなら、その後ろに追加する。
+ */
+function addTsunagiPluginDir(env) {
+    const pluginDir = process.env.TSUNAGI_PLUGIN_DIR;
+    if (!pluginDir)
+        return;
+    const dirs = (env.CLAUDE_CODE_PLUGIN_DIRS ?? '').split(':').filter(Boolean);
+    if (!dirs.includes(pluginDir))
+        dirs.push(pluginDir);
+    env.CLAUDE_CODE_PLUGIN_DIRS = dirs.join(':');
+}
 class PtyManager {
     sessions = new Map();
     /** sessionId → 最後に input を送信した socket.id */
@@ -41,7 +63,7 @@ class PtyManager {
      * @param unsetKeys 外側 Terminal や DB 由来でも内部ターミナルに渡さない環境変数キー
      *   （例: Ollama タブでは Anthropic の認証トークンを取り除く）
      */
-    createSession(sessionId, cwd, env, unsetKeys = []) {
+    createSession(sessionId, cwd, env = {}, unsetKeys = [], options = {}) {
         if (this.sessions.has(sessionId)) {
             throw new Error(`Session already exists: ${sessionId}`);
         }
@@ -67,6 +89,7 @@ class PtyManager {
         for (const key of unsetKeys) {
             delete spawnEnv[key];
         }
+        addTsunagiPluginDir(spawnEnv);
         const ptyProcess = pty.spawn(shell, [], {
             name: 'xterm-256color',
             cols: 80,
@@ -79,6 +102,12 @@ class PtyManager {
             pty: ptyProcess,
             sessionId,
             cwd,
+            appliedEnv: env,
+            appliedUnsetKeys: unsetKeys,
+            options,
+            envPending: false,
+            respawning: false,
+            lastInputAt: 0,
             scrollback: [],
             scrollbackSize: 0,
             lastOutputAt: now,
@@ -163,5 +192,11 @@ class PtyManager {
     listSessions() {
         return Array.from(this.sessions.keys());
     }
+    /** サーバー終了時に全セッションを止める（SIGHUP 任せにせず明示的に kill する） */
+    deleteAllSessions() {
+        for (const sessionId of Array.from(this.sessions.keys())) {
+            this.deleteSession(sessionId);
+        }
+    }
 }
 export const ptyManager = new PtyManager();

package/dist/server/routes/claude-profiles.d.ts

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