@minimalcorp/tsunagi 0.1.54 → 0.2.0

package/dist/plugin-lifecycle.js

@@ -1,20 +1,19 @@
 import { execSync } from 'node:child_process';
 import * as fs from 'node:fs';
+import * as os from 'node:os';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 /**
  * Claude Code plugin lifecycle management.
  *
- * Strategy: clean install on startup, unconditional uninstall on shutdown.
+ * Strategy: load the plugin per session via `CLAUDE_CODE_PLUGIN_DIRS`.
  *
- * - Uses only the `claude` CLI commands; no direct manipulation of
- *   `~/.claude/settings.json` or other internal files.
- * - On startup, any pre-existing tsunagi marketplace / plugin is considered
- *   an orphan from a previous abnormal termination and is cleaned up before
- *   installing a fresh copy. This is safe because tsunagi enforces single
- *   instance via the PID lock.
- * - On shutdown, uninstall is attempted unconditionally and failures are
- *   ignored so that cleanup never blocks process exit.
+ * - The server sets `CLAUDE_CODE_PLUGIN_DIRS` on every PTY it spawns
+ *   (apps/server/src/pty-manager.ts), so only Claude sessions started inside
+ *   tsunagi load the plugin. Nothing is written to the user's Claude Code
+ *   settings, so there is nothing to clean up on shutdown.
+ * - Older tsunagi versions installed the plugin into user scope via a local
+ *   marketplace. That registration is removed once on startup.
  */
 const THIS_DIR = path.dirname(fileURLToPath(import.meta.url));
 // dev (tsx): apps/cli/src/plugin-lifecycle.ts → THIS_DIR = apps/cli/src
@@ -22,39 +21,59 @@ const THIS_DIR = path.dirname(fileURLToPath(import.meta.url));
 // prod (compiled): <pkg>/dist/plugin-lifecycle.js → THIS_DIR = <pkg>/dist
 //   → ../tsunagi-marketplace = <pkg>/tsunagi-marketplace ✓
 const MARKETPLACE_NAME = 'tsunagi-marketplace';
-const PLUGIN_REF = `tsunagi-plugin@${MARKETPLACE_NAME}`;
-function getMarketplaceDir() {
-    const candidate = path.resolve(THIS_DIR, '..', 'tsunagi-marketplace');
-    if (fs.existsSync(path.join(candidate, '.claude-plugin'))) {
-        return candidate;
-    }
-    // Fallback for unexpected layouts
-    return candidate;
+const PLUGIN_NAME = 'tsunagi-plugin';
+const PLUGIN_REF = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
+// CLAUDE_CODE_PLUGIN_DIRS に対応した最初のバージョン
+const MIN_CLAUDE_VERSION = [2, 1, 280];
+function getLegacyCleanupMarkerPath() {
+    const dataDir = process.env.TSUNAGI_DATA_DIR || path.join(os.homedir(), '.tsunagi');
+    return path.join(dataDir, 'state', 'legacy-plugin-removed');
 }
 function debugLog(msg) {
     if (process.env.TSUNAGI_DEBUG) {
         console.log(`[tsunagi:plugin] ${msg}`);
     }
 }
-/** プラグインがインストール済みか確認する */
-function isPluginInstalled() {
+/** PTY の CLAUDE_CODE_PLUGIN_DIRS に渡すプラグインのディレクトリ（絶対パス） */
+export function getPluginDir() {
+    return path.resolve(THIS_DIR, '..', MARKETPLACE_NAME, 'plugins', PLUGIN_NAME);
+}
+/** `claude --version` の出力（例: "2.1.292 (Claude Code)"）から x.y.z を取り出す */
+function getClaudeVersion() {
     try {
-        const output = execSync('claude plugin list', { stdio: 'pipe' }).toString();
-        return output.includes(PLUGIN_REF);
+        const output = execSync('claude --version', { stdio: 'pipe' }).toString();
+        const match = /(\d+)\.(\d+)\.(\d+)/.exec(output);
+        return match ? match.slice(1).map(Number) : null;
     }
     catch {
-        return false;
+        return null;
     }
 }
-/** marketplaceが登録済みか確認する */
-function isMarketplaceAdded() {
-    try {
-        const output = execSync('claude plugin marketplace list', { stdio: 'pipe' }).toString();
-        return output.includes(MARKETPLACE_NAME);
+function isAtLeast(version, min) {
+    for (let i = 0; i < min.length; i++) {
+        if (version[i] !== min[i])
+            return version[i] > min[i];
     }
-    catch {
-        return false;
+    return true;
+}
+/**
+ * Exits the process with code 1 if the `claude` CLI is missing or too old to
+ * load plugins from `CLAUDE_CODE_PLUGIN_DIRS`.
+ */
+export function assertClaudeSupportsPluginDirs() {
+    const minLabel = MIN_CLAUDE_VERSION.join('.');
+    const version = getClaudeVersion();
+    if (!version) {
+        console.error('[tsunagi:plugin] Failed to run `claude --version`.');
+        console.error('[tsunagi:plugin] Ensure the `claude` CLI is installed and available on PATH.');
+        process.exit(1);
     }
+    if (!isAtLeast(version, MIN_CLAUDE_VERSION)) {
+        console.error(`[tsunagi:plugin] Claude Code ${version.join('.')} is too old. tsunagi requires ${minLabel} or later.`);
+        console.error('[tsunagi:plugin] Run `claude update` and start tsunagi again.');
+        process.exit(1);
+    }
+    debugLog(`Claude Code ${version.join('.')}`);
 }
 /**
  * Run a `claude` CLI command. Returns true on success, false on failure.
@@ -73,46 +92,39 @@ function runClaude(args) {
         return false;
     }
 }
+function claudeOutput(args) {
+    try {
+        return execSync(`claude ${args}`, { stdio: 'pipe' }).toString();
+    }
+    catch {
+        return '';
+    }
+}
 /**
- * Ensure a clean plugin state by removing any pre-existing tsunagi plugin /
- * marketplace registrations and then installing fresh copies.
- *
- * Exits the process with code 1 on install failure.
- *
- * @returns `'clean'` if orphaned state was cleaned up before install,
- *          `'fresh'` if no prior state existed.
+ * Remove the user-scope plugin / marketplace registered by older tsunagi
+ * versions. Runs once; a marker file in the state dir records completion.
+ * Never throws and never blocks startup on failure.
  */
-export function ensureCleanPluginState() {
-    // Phase 1: best-effort cleanup of any orphaned state from a previous run.
-    // Check existence first to avoid error output when plugin is not installed (normal first-boot case).
-    const hadOrphan = isPluginInstalled() || isMarketplaceAdded();
-    if (isPluginInstalled()) {
-        runClaude(`plugin uninstall ${PLUGIN_REF}`);
+export function removeLegacyPluginInstall() {
+    const markerPath = getLegacyCleanupMarkerPath();
+    if (fs.existsSync(markerPath))
+        return;
+    // 存在確認してから消す（未登録時のエラー出力を避ける）
+    let removed = true;
+    if (claudeOutput('plugin list').includes(PLUGIN_REF)) {
+        removed = runClaude(`plugin uninstall ${PLUGIN_REF}`) && removed;
     }
-    if (isMarketplaceAdded()) {
-        runClaude(`plugin marketplace remove ${MARKETPLACE_NAME}`);
+    if (claudeOutput('plugin marketplace list').includes(MARKETPLACE_NAME)) {
+        removed = runClaude(`plugin marketplace remove ${MARKETPLACE_NAME}`) && removed;
     }
-    // Phase 2: clean install. Failures here are fatal.
-    const marketplaceDir = getMarketplaceDir();
-    if (!runClaude(`plugin marketplace add ${marketplaceDir}`)) {
-        console.error('[tsunagi:plugin] Failed to add Claude Code marketplace.');
-        console.error('[tsunagi:plugin] Ensure the `claude` CLI is installed and available on PATH.');
-        console.error(`[tsunagi:plugin] Marketplace path: ${marketplaceDir}`);
-        process.exit(1);
+    if (!removed)
+        return; // 次回起動時に再試行する
+    try {
+        fs.mkdirSync(path.dirname(markerPath), { recursive: true });
+        fs.writeFileSync(markerPath, new Date().toISOString(), 'utf-8');
+        debugLog('Legacy plugin registration removed');
     }
-    debugLog('Marketplace added');
-    if (!runClaude(`plugin install ${PLUGIN_REF} --scope user`)) {
-        console.error('[tsunagi:plugin] Failed to install Claude Code plugin.');
-        runClaude(`plugin marketplace remove ${MARKETPLACE_NAME}`);
-        process.exit(1);
+    catch {
+        // マーカーを書けなくても次回再確認するだけ
     }
-    debugLog('Plugin installed');
-    return hadOrphan ? 'clean' : 'fresh';
-}
-/**
- * Best-effort cleanup. Called on process shutdown. Never throws.
- */
-export function cleanupPluginState() {
-    runClaude(`plugin uninstall ${PLUGIN_REF}`);
-    runClaude(`plugin marketplace remove ${MARKETPLACE_NAME}`);
 }

package/dist/server/index.js

@@ -25,6 +25,9 @@ import { stopWhisperServerOnExit } from './lib/whisper-process.js';
 import { settingsRoutes } from './routes/settings.js';
 import { versionRoutes } from './routes/version.js';
 import { startUpdateCheck, stopUpdateCheck } from './lib/update-check.js';
+import { stopAutoUpdate } from './lib/auto-update.js';
+import { RESTART_EXIT_CODE, onRestartRequested } from './lib/restart.js';
+import { ptyManager } from './pty-manager.js';
 import { stopSearxngOnExit, syncSearxng } from './lib/searxng.js';
 import { createBasicAuth } from './basic-auth.js';
 // Fastify は単一の公開エンドポイント。Next.js は内部ポートで動かしプロキシする。
@@ -162,21 +165,33 @@ async function start() {
     watchUserSettingsForLocalModel(LOCAL_MODEL_ALIAS);
     // npm に新しいバージョンが公開されたかを定期確認し、Web に通知する
     startUpdateCheck(io);
-    const shutdown = async (signal) => {
+    let shuttingDown = false;
+    const shutdown = async (signal, exitCode = 0) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
         console.log(`[server] Received ${signal}, shutting down...`);
+        stopUpdateCheck();
+        stopAutoUpdate();
+        // PTY（claude を含む）は SIGHUP 任せにせず、ここで止める
+        ptyManager.deleteAllSessions();
         stopWhisperServerOnExit();
         stopSearxngOnExit();
-        stopUpdateCheck();
         // 設定で有効なら、ローカルLLMのモデルをメモリから外す（バッテリー・メモリ節約）。
         // 開発時の tsx watch はファイル変更のたびに SIGTERM で再起動するため、その場合は外さない
         if (signal === 'SIGINT' || process.env.NODE_ENV === 'production') {
             await unloadOnShutdown();
         }
         await fastify.close();
-        process.exit(0);
+        process.exit(exitCode);
     };
     process.on('SIGINT', () => void shutdown('SIGINT'));
     process.on('SIGTERM', () => void shutdown('SIGTERM'));
+    // 更新の適用（POST /api/version/restart）。apps/cli がこの終了コードを見て新しいバージョンで起動し直す
+    onRestartRequested(() => {
+        io.emit('version:restarting');
+        void shutdown('restart', RESTART_EXIT_CODE);
+    });
     // SIGINT/SIGTERM を経由しない異常終了時の最後の砦（'exit' は同期処理のみ可能）。
     process.on('exit', () => {
         stopWhisperServerOnExit();

package/dist/server/lib/auto-update.d.ts

@@ -0,0 +1,18 @@
+import type { AutoUpdateStatus, RestartBlocker } from '@minimalcorp/tsunagi-shared';
+/** entry が古く、再インストールしてほしいか（apps/cli/src/update-lifecycle.ts が判定する） */
+export declare function isEntryOutdated(): boolean;
+export declare function getAutoUpdateStatus(): AutoUpdateStatus;
+/** 状態が変わったときに呼ぶ（update-check が Web へ通知する） */
+export declare function onAutoUpdateChange(listener: () => void): void;
+/**
+ * version を再起動で適用できるよう用意する（update-check が新しいバージョンを見つけるたびに呼ぶ）。
+ * インストール中は何もしない。より新しいバージョンは次回の確認で用意する。
+ */
+export declare function prepareUpdate(version: string): void;
+/** サーバー終了時にインストールを止める。途中のディレクトリは次回の install で消す */
+export declare function stopAutoUpdate(): void;
+/**
+ * 再起動すると止まってしまう実行中（running / waiting）のタスク。
+ * PTY が残っていないタブは、前回終了時の status が残っているだけなので除く。
+ */
+export declare function findRestartBlockers(): Promise<RestartBlocker[]>;

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

@@ -0,0 +1,208 @@
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ptyManager } from '../pty-manager.js';
+import { getTsunagiDataDir } from './data-path.js';
+import { prisma } from './db.js';
+/**
+ * 新しいバージョンを ~/.tsunagi/versions/<version>/ に `npm install --prefix` で用意し、
+ * state.json の next に書く。再起動（requestRestart）で entry が next の版を起動する。
+ * ディレクトリ構成と entry との取り決めは apps/cli/src/versions.ts と合わせること。
+ */
+const PACKAGE_NAME = '@minimalcorp/tsunagi';
+const COMPLETE_MARKER = '.complete';
+const STDERR_TAIL_MAX_CHARS = 2000;
+// entry 経由かつ npm でインストールされた tsunagi のときだけ apps/cli が設定する
+const enabled = process.env.TSUNAGI_AUTO_UPDATE === '1' && !!process.env.TSUNAGI_VERSION;
+/** entry が古く、再インストールしてほしいか（apps/cli/src/update-lifecycle.ts が判定する） */
+export function isEntryOutdated() {
+    return process.env.TSUNAGI_ENTRY_OUTDATED === '1';
+}
+let status = { state: enabled ? 'idle' : 'disabled', version: null, error: null };
+let installer = null;
+let onChange = null;
+export function getAutoUpdateStatus() {
+    return { ...status };
+}
+/** 状態が変わったときに呼ぶ（update-check が Web へ通知する） */
+export function onAutoUpdateChange(listener) {
+    onChange = listener;
+}
+function setStatus(next) {
+    status = next;
+    onChange?.();
+}
+function getVersionDir(version) {
+    return path.join(getTsunagiDataDir(), 'versions', version);
+}
+function getPackageRoot(version) {
+    return path.join(getVersionDir(version), 'node_modules', ...PACKAGE_NAME.split('/'));
+}
+function getStatePath() {
+    return path.join(getTsunagiDataDir(), 'versions', 'state.json');
+}
+function readState() {
+    try {
+        const state = JSON.parse(fs.readFileSync(getStatePath(), 'utf-8'));
+        return state && typeof state === 'object' ? state : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** 起動に失敗して entry がロールバックしたバージョン */
+function readBrokenVersions() {
+    const { broken } = readState();
+    return Array.isArray(broken) ? broken.filter((v) => typeof v === 'string') : [];
+}
+/** 次の再起動で起動するバージョンを entry に伝える。他のフィールドは残し、rename で置き換える */
+function setNextVersion(version) {
+    const statePath = getStatePath();
+    const tmpPath = `${statePath}.${process.pid}.tmp`;
+    fs.writeFileSync(tmpPath, JSON.stringify({ ...readState(), next: version }, null, 2), 'utf-8');
+    fs.renameSync(tmpPath, statePath);
+}
+/** インストール結果が起動できる形か（entry が起動する dist/app.js があるか） */
+function verifyInstall(version) {
+    const root = getPackageRoot(version);
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf-8'));
+        return (pkg.version === version &&
+            fs.existsSync(path.join(root, 'dist', 'cli.js')) &&
+            fs.existsSync(path.join(root, 'dist', 'app.js')));
+    }
+    catch {
+        return false;
+    }
+}
+/** 実行中の node と同じ場所の npm を優先する（nvm 等で PATH の npm と食い違わないように） */
+function npmCommand() {
+    const candidate = path.join(path.dirname(process.execPath), 'npm');
+    return fs.existsSync(candidate) ? candidate : 'npm';
+}
+/** npx 経由で起動した場合の npm_config_* 等が install に影響しないよう取り除く */
+function installEnv() {
+    const env = {};
+    for (const [key, value] of Object.entries(process.env)) {
+        if (/^npm_/i.test(key) || key === 'NODE_ENV' || key.startsWith('TSUNAGI_'))
+            continue;
+        env[key] = value;
+    }
+    return env;
+}
+function install(version) {
+    const dir = getVersionDir(version);
+    // 前回途中で止まったインストールが残っていれば消してからやり直す
+    fs.rmSync(dir, { recursive: true, force: true });
+    fs.mkdirSync(dir, { recursive: true });
+    setStatus({ state: 'installing', version, error: null });
+    const child = spawn(npmCommand(), [
+        'install',
+        '--prefix',
+        dir,
+        '--no-audit',
+        '--no-fund',
+        '--no-update-notifier',
+        '--loglevel=error',
+        ...(process.env.TSUNAGI_NPM_REGISTRY ? ['--registry', process.env.TSUNAGI_NPM_REGISTRY] : []),
+        `${PACKAGE_NAME}@${version}`,
+    ], { cwd: dir, env: installEnv(), stdio: ['ignore', 'ignore', 'pipe'] });
+    installer = child;
+    let stderrTail = '';
+    child.stderr?.on('data', (chunk) => {
+        stderrTail = (stderrTail + chunk.toString()).slice(-STDERR_TAIL_MAX_CHARS);
+    });
+    let finished = false;
+    const finish = (error) => {
+        if (finished)
+            return;
+        finished = true;
+        if (installer === child)
+            installer = null;
+        // stopAutoUpdate で止めた場合は状態を変えない（サーバー終了中）
+        if (status.state !== 'installing' || status.version !== version)
+            return;
+        if (!error && verifyInstall(version)) {
+            fs.writeFileSync(path.join(dir, COMPLETE_MARKER), new Date().toISOString(), 'utf-8');
+            setNextVersion(version);
+            setStatus({ state: 'ready', version, error: null });
+            return;
+        }
+        fs.rmSync(dir, { recursive: true, force: true });
+        setStatus({
+            state: 'error',
+            version,
+            error: error ?? 'The installed package is incomplete',
+        });
+    };
+    child.on('error', (err) => finish(`Failed to run npm: ${err.message}`));
+    child.on('exit', (code, signal) => {
+        if (code === 0)
+            finish(null);
+        else
+            finish(`npm install failed (${signal ?? `code ${code}`})${stderrTail ? `\n${stderrTail}` : ''}`);
+    });
+}
+/**
+ * version を再起動で適用できるよう用意する（update-check が新しいバージョンを見つけるたびに呼ぶ）。
+ * インストール中は何もしない。より新しいバージョンは次回の確認で用意する。
+ */
+export function prepareUpdate(version) {
+    if (!enabled || installer)
+        return;
+    if (status.state === 'ready' && status.version === version)
+        return;
+    if (readBrokenVersions().includes(version)) {
+        fs.rmSync(getVersionDir(version), { recursive: true, force: true });
+        setStatus({
+            state: 'error',
+            version,
+            error: `v${version} failed to start and was rolled back`,
+        });
+        return;
+    }
+    if (fs.existsSync(path.join(getVersionDir(version), COMPLETE_MARKER))) {
+        setNextVersion(version);
+        setStatus({ state: 'ready', version, error: null });
+        return;
+    }
+    try {
+        install(version);
+    }
+    catch (err) {
+        setStatus({
+            state: 'error',
+            version,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
+/** サーバー終了時にインストールを止める。途中のディレクトリは次回の install で消す */
+export function stopAutoUpdate() {
+    if (!installer)
+        return;
+    try {
+        installer.kill('SIGTERM');
+    }
+    catch {
+        // 既に終了している
+    }
+    installer = null;
+}
+/**
+ * 再起動すると止まってしまう実行中（running / waiting）のタスク。
+ * PTY が残っていないタブは、前回終了時の status が残っているだけなので除く。
+ */
+export async function findRestartBlockers() {
+    const tabs = await prisma.tab.findMany({
+        where: { status: { in: ['running', 'waiting'] } },
+        include: { task: true },
+    });
+    const blockers = new Map();
+    for (const tab of tabs) {
+        if (!ptyManager.getSession(tab.tabId))
+            continue;
+        blockers.set(tab.taskId, { taskId: tab.taskId, title: tab.task.title });
+    }
+    return [...blockers.values()];
+}

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

@@ -39,6 +39,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 */
@@ -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,
@@ -163,5 +186,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/version.js

@@ -1,3 +1,5 @@
+import { findRestartBlockers, getAutoUpdateStatus } from '../lib/auto-update.js';
+import { requestRestart } from '../lib/restart.js';
 import { checkForUpdateNow, getUpdateStatus } from '../lib/update-check.js';
 export async function versionRoutes(fastify) {
     // GET /version - 実行中のバージョンと npm の最新バージョン
@@ -15,4 +17,18 @@ export async function versionRoutes(fastify) {
         }
         return reply.status(200).send({ data: getUpdateStatus() });
     });
+    // POST /version/restart - インストール済みの新しいバージョンを再起動で適用する。
+    // 実行中（running / waiting）のタスクがあれば止まってしまうため 409 で拒否する
+    fastify.post('/version/restart', async (_request, reply) => {
+        if (getAutoUpdateStatus().state !== 'ready') {
+            return reply.status(400).send({ error: 'No update is ready to apply' });
+        }
+        const blockers = await findRestartBlockers();
+        if (blockers.length > 0) {
+            return reply.status(409).send({ error: 'Tasks are running', data: { blockers } });
+        }
+        // 応答を返してから終了処理に入る
+        reply.raw.once('finish', requestRestart);
+        return reply.status(202).send({ data: getUpdateStatus() });
+    });
 }

package/dist/single-instance-lock.js

@@ -7,7 +7,8 @@ import * as path from 'node:path';
  * - Writes current PID to `~/.tsunagi/state/tsunagi.lock` on acquire
  * - On startup, if lock file exists and its PID is alive, exits with error
  * - Stale locks (PID not alive) are removed automatically
- * - Lock is released on SIGINT / SIGTERM / exit
+ * - Lock is released on process exit. Signal handling is left to the caller
+ *   (the entry waits for the app to stop before exiting)
  */
 function getTsunagiDataDir() {
     return process.env.TSUNAGI_DATA_DIR || path.join(os.homedir(), '.tsunagi');
@@ -79,20 +80,5 @@ export function acquireSingleInstanceLock() {
         }
     }
     fs.writeFileSync(lockFilePath, String(process.pid), 'utf-8');
-    process.on('SIGINT', () => {
-        releaseLock();
-        process.exit(0);
-    });
-    process.on('SIGTERM', () => {
-        releaseLock();
-        process.exit(0);
-    });
-    process.on('exit', () => {
-        releaseLock();
-    });
-    process.on('uncaughtException', (err) => {
-        console.error('[tsunagi] Uncaught exception:', err);
-        releaseLock();
-        process.exit(1);
-    });
+    process.on('exit', releaseLock);
 }