@minimalcorp/tsunagi 0.2.0 → 0.3.1

package/dist/server/generated/prisma/models/ClaudeProfile.js

@@ -0,0 +1 @@
+export {};

package/dist/server/generated/prisma/models.d.ts

@@ -2,5 +2,6 @@ export type * from './models/Repository.js';
 export type * from './models/Task.js';
 export type * from './models/Tab.js';
 export type * from './models/EnvironmentVariable.js';
+export type * from './models/ClaudeProfile.js';
 export type * from './models/AppSetting.js';
 export type * from './commonInputTypes.js';

package/dist/server/index.js

@@ -10,6 +10,7 @@ import { envRoutes } from './routes/env.js';
 import { worktreesRoutes } from './routes/worktrees.js';
 import { commandsRoutes } from './routes/commands.js';
 import { onboardingRoutes } from './routes/onboarding.js';
+import { claudeProfilesRoutes } from './routes/claude-profiles.js';
 import { internalRoutes } from './routes/internal.js';
 import { hooksRoutes } from './routes/hooks.js';
 import { mcpRoutes } from './routes/mcp.js';
@@ -45,8 +46,11 @@ const extraOrigins = (process.env.TSUNAGI_EXTRA_CORS_ORIGINS ?? '')
 const corsOrigins = [`http://localhost:${NEXT_PORT}`, ...extraOrigins];
 // TSUNAGI_BASIC_AUTH_USER / TSUNAGI_BASIC_AUTH_PASSWORD が両方ある時だけ有効。
 const basicAuth = createBasicAuth();
+const SHUTDOWN_TIMEOUT_MS = 20_000;
 async function start() {
     const fastify = Fastify({
+        // 終了時に処理中のリクエスト（プロキシ中・ロングポーリング等）も閉じ、close() が待ち続けないようにする
+        forceCloseConnections: true,
         logger: {
             level: process.env.LOG_LEVEL || (process.env.NODE_ENV === 'production' ? 'error' : 'info'),
         },
@@ -93,6 +97,12 @@ async function start() {
         pingTimeout: 15000,
     });
     fastify.decorate('io', io);
+    // fastify.close() は upgrade 済みの WebSocket を閉じず、engine.io は http server の close を待って
+    // 閉じるため、互いに待ち合って close() が返らない（ブラウザが開いていると再起動が止まる）。先に閉じる
+    fastify.addHook('preClose', (done) => {
+        io.close();
+        done();
+    });
     fastify.get('/health', async () => ({ status: 'ok' }));
     await fastify.register(tasksRoutes, { prefix: '/api' });
     await fastify.register(reposRoutes, { prefix: '/api' });
@@ -100,6 +110,7 @@ async function start() {
     await fastify.register(worktreesRoutes, { prefix: '/api' });
     await fastify.register(commandsRoutes, { prefix: '/api' });
     await fastify.register(onboardingRoutes, { prefix: '/api' });
+    await fastify.register(claudeProfilesRoutes, { prefix: '/api' });
     await fastify.register(internalRoutes, { prefix: '/api' });
     await fastify.register(hooksRoutes, { prefix: '/api' });
     await fastify.register(mcpRoutes, { prefix: '/api' });
@@ -171,6 +182,12 @@ async function start() {
             return;
         shuttingDown = true;
         console.log(`[server] Received ${signal}, shutting down...`);
+        // 終了処理がどこかで止まっても終了する。restart は apps/cli の app 側に強制終了がないため必須。
+        // unloadOnShutdown の上限（10秒）より長く、app の CHILD_EXIT_TIMEOUT_MS（30秒）より短くする
+        setTimeout(() => {
+            console.error(`[server] Shutdown timed out after ${SHUTDOWN_TIMEOUT_MS}ms, exiting`);
+            process.exit(exitCode);
+        }, SHUTDOWN_TIMEOUT_MS).unref();
         stopUpdateCheck();
         stopAutoUpdate();
         // PTY（claude を含む）は SIGHUP 任せにせず、ここで止める

package/dist/server/lib/claude-config-guard.d.ts

@@ -5,17 +5,19 @@
  * どこか1セッションで logout すると以降全タブでオンボーディングウィザード
  * （対話UIではなく初回セットアップ画面）が起動してしまい、--resume/--session-id
  * を前提にした自動起動フローが止まる。claude 起動直前にこのフラグだけ補正する。
+ * configDir はタブが使う Claude プロファイルの CLAUDE_CONFIG_DIR（未指定は ~/.claude.json）。
  */
-export declare function ensureClaudeOnboardingCompleted(): Promise<void>;
+export declare function ensureClaudeOnboardingCompleted(configDir?: string): Promise<void>;
 /**
  * ローカルLLMタブで /model の一覧から「ローカルLLM」を Enter で選ぶと、Claude Code は同じモデルへの
  * 切り替えとみなして PreModelSwitch フックを通さずに ~/.claude/settings.json の model に
  * 中継口の名前（localModelAlias）を保存する。そのままだと通常の Claude タブがその名前で起動して
- * 壊れるため取り除く。
+ * 壊れるため取り除く。configDir はタブが使う Claude プロファイルの CLAUDE_CONFIG_DIR。
  */
-export declare function removeLocalModelFromUserSettings(localModelAlias: string): Promise<void>;
+export declare function removeLocalModelFromUserSettings(localModelAlias: string, configDir?: string): Promise<void>;
 /**
- * ~/.claude/settings.json の変更を監視し、中継口の名前が保存されたらすぐ取り除く。
+ * settings.json の変更を監視し、中継口の名前が保存されたらすぐ取り除く。
  * Claude Code は tmp ファイル経由で置き換えることがあるため、ファイルではなくディレクトリを監視する。
+ * configDir は Claude プロファイルの CLAUDE_CONFIG_DIR（未指定は外側 Terminal の設定 or ~/.claude）。
  */
-export declare function watchUserSettingsForLocalModel(localModelAlias: string): void;
+export declare function watchUserSettingsForLocalModel(localModelAlias: string, configDir?: string): void;

package/dist/server/lib/claude-config-guard.js

@@ -2,6 +2,13 @@ import { watch } from 'fs';
 import * as fs from 'fs/promises';
 import * as os from 'os';
 import * as path from 'path';
+/** Claude Code の設定ファイルの場所。CLAUDE_CONFIG_DIR 指定時は .claude.json もその中に置かれる */
+function claudeJsonPath(configDir) {
+    return configDir ? path.join(configDir, '.claude.json') : path.join(os.homedir(), '.claude.json');
+}
+function userSettingsDir(configDir) {
+    return configDir ?? path.join(os.homedir(), '.claude');
+}
 /**
  * `claude logout` は ~/.claude.json の hasCompletedOnboarding を含む
  * first-launch setup state をリセットする。Tsunagi は全タブ/タスクの
@@ -9,9 +16,10 @@ import * as path from 'path';
  * どこか1セッションで logout すると以降全タブでオンボーディングウィザード
  * （対話UIではなく初回セットアップ画面）が起動してしまい、--resume/--session-id
  * を前提にした自動起動フローが止まる。claude 起動直前にこのフラグだけ補正する。
+ * configDir はタブが使う Claude プロファイルの CLAUDE_CONFIG_DIR（未指定は ~/.claude.json）。
  */
-export async function ensureClaudeOnboardingCompleted() {
-    const configPath = path.join(os.homedir(), '.claude.json');
+export async function ensureClaudeOnboardingCompleted(configDir) {
+    const configPath = claudeJsonPath(configDir);
     let raw;
     try {
         raw = await fs.readFile(configPath, 'utf-8');
@@ -42,16 +50,17 @@ export async function ensureClaudeOnboardingCompleted() {
         await fs.rm(tmpPath, { force: true }).catch(() => { });
     }
 }
-const USER_SETTINGS_DIR = path.join(os.homedir(), '.claude');
 const USER_SETTINGS_FILE = 'settings.json';
+/** 監視中の設定ディレクトリ（同じディレクトリを二重に監視しない） */
+const watchedSettingsDirs = new Set();
 /**
  * ローカルLLMタブで /model の一覧から「ローカルLLM」を Enter で選ぶと、Claude Code は同じモデルへの
  * 切り替えとみなして PreModelSwitch フックを通さずに ~/.claude/settings.json の model に
  * 中継口の名前（localModelAlias）を保存する。そのままだと通常の Claude タブがその名前で起動して
- * 壊れるため取り除く。
+ * 壊れるため取り除く。configDir はタブが使う Claude プロファイルの CLAUDE_CONFIG_DIR。
  */
-export async function removeLocalModelFromUserSettings(localModelAlias) {
-    const settingsPath = path.join(USER_SETTINGS_DIR, USER_SETTINGS_FILE);
+export async function removeLocalModelFromUserSettings(localModelAlias, configDir) {
+    const settingsPath = path.join(userSettingsDir(configDir), USER_SETTINGS_FILE);
     let settings;
     try {
         settings = JSON.parse(await fs.readFile(settingsPath, 'utf-8'));
@@ -72,21 +81,31 @@ export async function removeLocalModelFromUserSettings(localModelAlias) {
     }
 }
 /**
- * ~/.claude/settings.json の変更を監視し、中継口の名前が保存されたらすぐ取り除く。
+ * settings.json の変更を監視し、中継口の名前が保存されたらすぐ取り除く。
  * Claude Code は tmp ファイル経由で置き換えることがあるため、ファイルではなくディレクトリを監視する。
+ * configDir は Claude プロファイルの CLAUDE_CONFIG_DIR（未指定は外側 Terminal の設定 or ~/.claude）。
  */
-export function watchUserSettingsForLocalModel(localModelAlias) {
+export function watchUserSettingsForLocalModel(localModelAlias, configDir) {
+    const effectiveDir = configDir ?? process.env.CLAUDE_CONFIG_DIR;
+    const dir = userSettingsDir(effectiveDir);
+    if (watchedSettingsDirs.has(dir))
+        return;
     let watcher;
     try {
-        watcher = watch(USER_SETTINGS_DIR, (_event, filename) => {
-            if (filename === USER_SETTINGS_FILE)
-                void removeLocalModelFromUserSettings(localModelAlias);
+        watcher = watch(dir, (_event, filename) => {
+            if (filename === USER_SETTINGS_FILE) {
+                void removeLocalModelFromUserSettings(localModelAlias, effectiveDir);
+            }
         });
     }
     catch {
         // ~/.claude がまだない（claude 未実行）場合は監視しない。起動前の補正で対応する
         return;
     }
-    watcher.on('error', () => watcher.close());
+    watchedSettingsDirs.add(dir);
+    watcher.on('error', () => {
+        watcher.close();
+        watchedSettingsDirs.delete(dir);
+    });
     watcher.unref();
 }

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

@@ -0,0 +1,49 @@
+import type { ClaudeAuthStatus, ClaudeProfile } from '@minimalcorp/tsunagi-shared';
+/**
+ * タブで使う Claude プロファイルの割り当てを保存する予約キー。値はプロファイルの slug か
+ * DEFAULT_CLAUDE_PROFILE。環境変数と同じ global → owner → repo の継承で解決し、PTY 起動時に
+ * CLAUDE_CONFIG_DIR へ変換する（resolveClaudeProfileEnv）。
+ */
+export declare const CLAUDE_PROFILE_ENV_KEY = "TSUNAGI_CLAUDE_PROFILE";
+/** システム既定（CLAUDE_CONFIG_DIR を付けず ~/.claude を使う） */
+export declare const DEFAULT_CLAUDE_PROFILE = "default";
+/**
+ * Claude Code が /login のログインより優先する認証情報の環境変数。
+ * プロファイルを選んだタブでは、外側 Terminal から継承した値も取り除く（残るとプロファイルの
+ * ログインではなくこちらが使われるため）。
+ */
+export declare const CLAUDE_AUTH_ENV_KEYS: string[];
+/** 汎用の環境変数として登録させないキー（認証は Claude プロファイルで扱う） */
+export declare const RESERVED_ENV_KEYS: string[];
+export declare function getClaudeProfilesDir(): string;
+/** プロファイルの CLAUDE_CONFIG_DIR。システム既定は undefined（~/.claude） */
+export declare function getClaudeProfileConfigDir(slug: string): string | undefined;
+/** 空白を `-` にし、小文字にする（macOS のファイルシステムは大文字小文字を区別しないため） */
+export declare function toClaudeProfileSlug(name: string): string;
+/** プロファイル名の検証。問題があればエラーメッセージを返す */
+export declare function validateClaudeProfileName(name: string): string | null;
+export declare function listClaudeProfiles(): Promise<ClaudeProfile[]>;
+export declare function claudeProfileExists(slug: string): Promise<boolean>;
+export declare function createClaudeProfile(name: string): Promise<ClaudeProfile>;
+/**
+ * プロファイルを削除する。ログイン情報（macOS は Keychain）を残さないよう先に logout し、
+ * このプロファイルを割り当てていたスコープは割り当てを外して親の設定を継承させる。
+ */
+export declare function deleteClaudeProfile(slug: string): Promise<void>;
+/** `claude auth status --json` でプロファイルのログイン状態を取得する */
+export declare function getClaudeAuthStatus(slug: string): Promise<ClaudeAuthStatus>;
+/** ログイン用 PTY に書き込むコマンド */
+export declare function buildClaudeLoginCommand(): string;
+/** ログイン用 PTY の環境変数（PtyManager.createSession の env / unsetKeys） */
+export declare function claudeLoginPtyEnv(slug: string): {
+    env: Record<string, string>;
+    unsetKeys: string[];
+};
+/**
+ * 継承解決済みの環境変数に含まれるプロファイル割り当てを CLAUDE_CONFIG_DIR に変換する。
+ * 予約キー自体は PTY に渡さない。
+ */
+export declare function resolveClaudeProfileEnv(env: Record<string, string>): {
+    env: Record<string, string>;
+    unsetKeys: string[];
+};

package/dist/server/lib/claude-profiles.js

@@ -0,0 +1,168 @@
+import { execFile } from 'child_process';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { promisify } from 'util';
+import { prisma } from './db.js';
+import { getTsunagiDataDir } from './data-path.js';
+const execFileAsync = promisify(execFile);
+/**
+ * タブで使う Claude プロファイルの割り当てを保存する予約キー。値はプロファイルの slug か
+ * DEFAULT_CLAUDE_PROFILE。環境変数と同じ global → owner → repo の継承で解決し、PTY 起動時に
+ * CLAUDE_CONFIG_DIR へ変換する（resolveClaudeProfileEnv）。
+ */
+export const CLAUDE_PROFILE_ENV_KEY = 'TSUNAGI_CLAUDE_PROFILE';
+/** システム既定（CLAUDE_CONFIG_DIR を付けず ~/.claude を使う） */
+export const DEFAULT_CLAUDE_PROFILE = 'default';
+/**
+ * Claude Code が /login のログインより優先する認証情報の環境変数。
+ * プロファイルを選んだタブでは、外側 Terminal から継承した値も取り除く（残るとプロファイルの
+ * ログインではなくこちらが使われるため）。
+ */
+export const CLAUDE_AUTH_ENV_KEYS = ['ANTHROPIC_API_KEY', 'CLAUDE_CODE_OAUTH_TOKEN'];
+/** 汎用の環境変数として登録させないキー（認証は Claude プロファイルで扱う） */
+export const RESERVED_ENV_KEYS = [
+    CLAUDE_PROFILE_ENV_KEY,
+    'CLAUDE_CONFIG_DIR',
+    ...CLAUDE_AUTH_ENV_KEYS,
+];
+const PROFILE_NAME_PATTERN = /^[A-Za-z0-9 _-]+$/;
+export function getClaudeProfilesDir() {
+    return path.join(getTsunagiDataDir(), 'claude-profiles');
+}
+/** プロファイルの CLAUDE_CONFIG_DIR。システム既定は undefined（~/.claude） */
+export function getClaudeProfileConfigDir(slug) {
+    if (slug === DEFAULT_CLAUDE_PROFILE)
+        return undefined;
+    return path.join(getClaudeProfilesDir(), slug);
+}
+/** 空白を `-` にし、小文字にする（macOS のファイルシステムは大文字小文字を区別しないため） */
+export function toClaudeProfileSlug(name) {
+    return name.trim().replace(/\s+/g, '-').toLowerCase();
+}
+/** プロファイル名の検証。問題があればエラーメッセージを返す */
+export function validateClaudeProfileName(name) {
+    const trimmed = name.trim();
+    if (!trimmed)
+        return 'Name is required';
+    if (!PROFILE_NAME_PATTERN.test(trimmed)) {
+        return 'Use only letters, numbers, spaces, "-" and "_"';
+    }
+    if (toClaudeProfileSlug(trimmed) === DEFAULT_CLAUDE_PROFILE) {
+        return `"${DEFAULT_CLAUDE_PROFILE}" is reserved`;
+    }
+    return null;
+}
+export async function listClaudeProfiles() {
+    const rows = await prisma.claudeProfile.findMany({ orderBy: { createdAt: 'asc' } });
+    return rows.map((row) => ({
+        slug: row.slug,
+        name: row.name,
+        configDir: path.join(getClaudeProfilesDir(), row.slug),
+    }));
+}
+export async function claudeProfileExists(slug) {
+    if (slug === DEFAULT_CLAUDE_PROFILE)
+        return true;
+    return (await prisma.claudeProfile.count({ where: { slug } })) > 0;
+}
+export async function createClaudeProfile(name) {
+    const error = validateClaudeProfileName(name);
+    if (error)
+        throw new Error(error);
+    const trimmed = name.trim();
+    const slug = toClaudeProfileSlug(trimmed);
+    if (await claudeProfileExists(slug)) {
+        throw new Error(`Profile "${slug}" already exists`);
+    }
+    const configDir = path.join(getClaudeProfilesDir(), slug);
+    await fs.mkdir(configDir, { recursive: true });
+    await prisma.claudeProfile.create({ data: { slug, name: trimmed } });
+    return { slug, name: trimmed, configDir };
+}
+/**
+ * プロファイルを削除する。ログイン情報（macOS は Keychain）を残さないよう先に logout し、
+ * このプロファイルを割り当てていたスコープは割り当てを外して親の設定を継承させる。
+ */
+export async function deleteClaudeProfile(slug) {
+    const configDir = getClaudeProfileConfigDir(slug);
+    if (!configDir)
+        throw new Error('The system default profile cannot be deleted');
+    await runClaude(['auth', 'logout'], configDir).catch(() => undefined);
+    await prisma.environmentVariable.deleteMany({
+        where: { key: CLAUDE_PROFILE_ENV_KEY, value: slug },
+    });
+    await prisma.claudeProfile.delete({ where: { slug } });
+    await fs.rm(configDir, { recursive: true, force: true });
+}
+/**
+ * claude を実行するときの環境変数。プロファイルのログインを見るよう CLAUDE_CONFIG_DIR を付け、
+ * ログインより優先される認証情報の環境変数は取り除く。システム既定は外側 Terminal の環境のまま
+ * （普段ターミナルで claude を使うときと同じ）。
+ */
+function claudeEnv(configDir) {
+    const env = { ...process.env };
+    if (configDir) {
+        env.CLAUDE_CONFIG_DIR = configDir;
+        for (const key of CLAUDE_AUTH_ENV_KEYS)
+            delete env[key];
+    }
+    return env;
+}
+async function runClaude(args, configDir) {
+    const { stdout } = await execFileAsync('claude', args, {
+        env: claudeEnv(configDir),
+        timeout: 15_000,
+    });
+    return stdout;
+}
+/** `claude auth status --json` でプロファイルのログイン状態を取得する */
+export async function getClaudeAuthStatus(slug) {
+    try {
+        const raw = JSON.parse(await runClaude(['auth', 'status', '--json'], getClaudeProfileConfigDir(slug)));
+        const str = (v) => (typeof v === 'string' ? v : undefined);
+        return {
+            loggedIn: raw.loggedIn === true,
+            authMethod: str(raw.authMethod),
+            email: str(raw.email),
+            orgName: str(raw.orgName),
+            subscriptionType: str(raw.subscriptionType),
+        };
+    }
+    catch (err) {
+        // claude auth status は未ログイン時に非 0 で終了するが、stdout には JSON が出る
+        const stdout = err.stdout;
+        if (stdout) {
+            try {
+                const raw = JSON.parse(stdout);
+                return { loggedIn: raw.loggedIn === true, authMethod: raw.authMethod };
+            }
+            catch {
+                // fallthrough
+            }
+        }
+        return { loggedIn: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+/** ログイン用 PTY に書き込むコマンド */
+export function buildClaudeLoginCommand() {
+    return 'claude auth login';
+}
+/** ログイン用 PTY の環境変数（PtyManager.createSession の env / unsetKeys） */
+export function claudeLoginPtyEnv(slug) {
+    const configDir = getClaudeProfileConfigDir(slug);
+    if (!configDir)
+        return { env: {}, unsetKeys: [] };
+    return { env: { CLAUDE_CONFIG_DIR: configDir }, unsetKeys: CLAUDE_AUTH_ENV_KEYS };
+}
+/**
+ * 継承解決済みの環境変数に含まれるプロファイル割り当てを CLAUDE_CONFIG_DIR に変換する。
+ * 予約キー自体は PTY に渡さない。
+ */
+export function resolveClaudeProfileEnv(env) {
+    const { [CLAUDE_PROFILE_ENV_KEY]: slug, ...rest } = env;
+    const configDir = slug ? getClaudeProfileConfigDir(slug) : undefined;
+    // システム既定: 外側 Terminal の環境のまま（普段ターミナルで claude を使うときと同じ）
+    if (!configDir)
+        return { env: rest, unsetKeys: [] };
+    return { env: { ...rest, CLAUDE_CONFIG_DIR: configDir }, unsetKeys: CLAUDE_AUTH_ENV_KEYS };
+}

package/dist/server/lib/pty-env-sync.d.ts

@@ -0,0 +1,12 @@
+import type { Server as SocketIOServer } from 'socket.io';
+/** 起動時に一度呼ぶ。反映待ちの PTY を定期的に確認する */
+export declare function initPtyEnvSync(server: SocketIOServer): void;
+/**
+ * tsunagi の環境変数（Claude プロファイルの割り当て・プロファイル削除を含む）を変更した後に呼ぶ。
+ * 起動中の PTY ごとに環境変数を解決し直し、作成時と違えば反映待ちにする。
+ */
+export declare function notifyEnvChanged(): Promise<void>;
+/** 反映待ちの PTY を、ユーザー操作で今すぐ作り直す */
+export declare function respawnSessionNow(sessionId: string): Promise<boolean>;
+/** join したクライアントに現在の反映待ち状態を伝える */
+export declare function getEnvPending(sessionId: string): boolean;

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>;