@minimalcorp/tsunagi 0.1.11 → 0.1.13

package/.next/standalone/apps/web/package.json

@@ -5,9 +5,9 @@
   "description": "Next.js UI for tsunagi",
   "type": "module",
   "scripts": {
-    "dev": "next dev -p 2791",
+    "dev": "next dev -p 2792",
     "build": "next build",
-    "start": "next start -p 2791",
+    "start": "next start -p 2792",
     "lint": "eslint",
     "type-check": "tsc --noEmit"
   },

package/dist/cli.js

@@ -181,16 +181,18 @@ function verifyArtifact(p, label) {
 }
 verifyArtifact(FASTIFY_ENTRY_JS, 'Fastify server artifact');
 verifyArtifact(NEXT_STANDALONE_ENTRY, 'Next.js standalone artifact');
+// Fastify が単一の公開ポート。Next.js は内部ポートで動かし Fastify からプロキシする。
 const PORT = process.env.PORT ?? '2791';
+const NEXT_PORT = '2792';
 const fastifyChild = spawn(process.execPath, [FASTIFY_ENTRY_JS], {
     stdio: ['inherit', 'pipe', 'pipe'],
     cwd: PACKAGE_ROOT,
-    env: { ...process.env, NODE_ENV: 'production' },
+    env: { ...process.env, NODE_ENV: 'production', PORT, TSUNAGI_NEXT_PORT: NEXT_PORT },
 });
 const nextChild = spawn(process.execPath, [NEXT_STANDALONE_ENTRY], {
     stdio: ['inherit', 'pipe', 'pipe'],
     cwd: path.dirname(NEXT_STANDALONE_ENTRY),
-    env: { ...process.env, PORT, NODE_ENV: 'production', HOSTNAME: '0.0.0.0' },
+    env: { ...process.env, PORT: NEXT_PORT, NODE_ENV: 'production', HOSTNAME: '0.0.0.0' },
 });
 const docsServer = startDocsServer();
 // ---------------------------------------------------------------------------
@@ -213,7 +215,6 @@ nextChild.stderr?.on('data', (data) => {
 // ---------------------------------------------------------------------------
 // Ready detection via /health polling
 // ---------------------------------------------------------------------------
-const SERVER_PORT = 2792;
 const POLL_INTERVAL_MS = 300;
 function pollHealth(port) {
     return new Promise((resolve) => {
@@ -235,7 +236,8 @@ function pollHealth(port) {
         poll();
     });
 }
-Promise.all([pollHealth(SERVER_PORT), pollHealth(Number(PORT))]).then(() => {
+// Fastify(PORT) と Next(NEXT_PORT) は各々 /health を持つ。各プロセスを直接叩く。
+Promise.all([pollHealth(Number(PORT)), pollHealth(Number(NEXT_PORT))]).then(() => {
     spinner.stop();
     console.log(TSUNAGI_AA);
     const url = `http://localhost:${PORT}`;

package/dist/server/basic-auth.d.ts

@@ -0,0 +1,10 @@
+import type { IncomingHttpHeaders } from 'node:http';
+export interface BasicAuth {
+    /** クライアントへ返す WWW-Authenticate ヘッダ値 */
+    readonly challenge: string;
+    /** Authorization ヘッダが想定値と一致するか（定数時間比較） */
+    isValidHeader(header: string | undefined): boolean;
+    /** リクエストを通してよいか（認証成功 or ローカル内部連携の免除） */
+    isAuthorized(headers: IncomingHttpHeaders, url: string | undefined, remoteAddress: string | undefined): boolean;
+}
+export declare function createBasicAuth(env?: NodeJS.ProcessEnv): BasicAuth | null;

package/dist/server/basic-auth.js

@@ -0,0 +1,53 @@
+import crypto from 'node:crypto';
+/**
+ * Basic 認証。`TSUNAGI_BASIC_AUTH_USER` と `TSUNAGI_BASIC_AUTH_PASSWORD` が
+ * 両方設定されているときだけ有効化する（cloudflared 等で外部公開する際の保護）。
+ *
+ * 単一ポート集約の都合上、cloudflared はアプリと同じ `localhost` から Fastify へ
+ * 接続するため、外部アクセスもローカルの内部連携も IP 上は loopback に見える。
+ * そこで「外部 = Cloudflare 経由」を Cloudflare が付与するヘッダで判別し、外部からは
+ * すべて認証必須にしつつ、ローカルマシン上の Claude Code プラグイン連携
+ * (hooks / MCP) や cli の死活監視だけは認証なしで通す。
+ */
+// ローカルからのみ認証を免除する内部連携エンドポイント。外部(cloudflared)からは
+// これらであっても認証必須にする。
+const LOCAL_EXEMPT_PREFIXES = ['/health', '/api/hooks', '/api/internal', '/api/mcp'];
+const LOOPBACK_ADDRESSES = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1']);
+export function createBasicAuth(env = process.env) {
+    const user = env.TSUNAGI_BASIC_AUTH_USER;
+    const password = env.TSUNAGI_BASIC_AUTH_PASSWORD;
+    if (!user || !password)
+        return null;
+    const expected = `Basic ${Buffer.from(`${user}:${password}`).toString('base64')}`;
+    const expectedBuf = Buffer.from(expected);
+    const isValidHeader = (header) => {
+        if (!header)
+            return false;
+        const given = Buffer.from(header);
+        // 長さが異なると timingSafeEqual が throw するため先にガード（長さ差のみ漏れる）。
+        return given.length === expectedBuf.length && crypto.timingSafeEqual(given, expectedBuf);
+    };
+    // Cloudflare(cloudflared)経由のリクエストには Cloudflare が必ず付与するヘッダが付く。
+    // Cloudflare はクライアント指定の cf-connecting-ip を上書きするため、外部からは
+    // 「ローカルに偽装」できない。
+    const isViaCloudflare = (headers) => Boolean(headers['cf-connecting-ip'] || headers['cf-ray'] || headers['x-forwarded-for']);
+    const isLoopback = (remoteAddress) => !!remoteAddress && LOOPBACK_ADDRESSES.has(remoteAddress);
+    const isLocalExemptPath = (url) => {
+        const path = (url ?? '').split('?')[0];
+        return LOCAL_EXEMPT_PREFIXES.some((p) => path === p || path.startsWith(`${p}/`));
+    };
+    return {
+        challenge: 'Basic realm="tsunagi", charset="UTF-8"',
+        isValidHeader,
+        isAuthorized(headers, url, remoteAddress) {
+            if (isValidHeader(headers['authorization']))
+                return true;
+            // 認証情報が無くても、loopback かつ Cloudflare 経由でない（=同一マシン直結の）
+            // 内部連携エンドポイントだけは許可する。
+            if (isLoopback(remoteAddress) && !isViaCloudflare(headers) && isLocalExemptPath(url)) {
+                return true;
+            }
+            return false;
+        },
+    };
+}

package/dist/server/index.js

@@ -1,5 +1,7 @@
+import net from 'node:net';
 import Fastify from 'fastify';
 import fastifyCors from '@fastify/cors';
+import httpProxy from '@fastify/http-proxy';
 import { Server as SocketIOServer } from 'socket.io';
 import { tasksRoutes } from './routes/tasks.js';
 import { reposRoutes } from './routes/repos.js';
@@ -13,12 +15,19 @@ import { hooksRoutes } from './routes/hooks.js';
 import { mcpRoutes } from './routes/mcp.js';
 import { terminalRoutes } from './routes/terminal.js';
 import { editorRoutes } from './routes/editor.js';
-const PORT = 2792;
+import { createBasicAuth } from './basic-auth.js';
+// Fastify は単一の公開エンドポイント。Next.js は内部ポートで動かしプロキシする。
+const PORT = Number(process.env.PORT) || 2791;
+const NEXT_PORT = Number(process.env.TSUNAGI_NEXT_PORT) || 2792;
 const extraOrigins = (process.env.TSUNAGI_EXTRA_CORS_ORIGINS ?? '')
     .split(',')
     .map((s) => s.trim())
     .filter(Boolean);
-const corsOrigins = ['http://localhost:2791', ...extraOrigins];
+// 本番(cloudflared 等)は同一オリジンで CORS 不要。dev は Next を 2792 で直接開く
+// ため、その origin からの cross-origin リクエストを許可する。
+const corsOrigins = [`http://localhost:${NEXT_PORT}`, ...extraOrigins];
+// TSUNAGI_BASIC_AUTH_USER / TSUNAGI_BASIC_AUTH_PASSWORD が両方ある時だけ有効。
+const basicAuth = createBasicAuth();
 async function start() {
     const fastify = Fastify({
         logger: {
@@ -29,9 +38,31 @@ async function start() {
         origin: corsOrigins,
         methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
     });
+    // Basic 認証（有効時のみ）。CORS の後に登録することで preflight(OPTIONS) は
+    // @fastify/cors が先に応答し、認証で弾かれない。
+    if (basicAuth) {
+        fastify.addHook('onRequest', async (request, reply) => {
+            if (basicAuth.isAuthorized(request.headers, request.url, request.socket.remoteAddress)) {
+                return;
+            }
+            reply
+                .header('WWW-Authenticate', basicAuth.challenge)
+                .code(401)
+                .send('Authentication required');
+            return reply;
+        });
+    }
     const io = new SocketIOServer(fastify.server, {
-        transports: ['websocket'],
+        // polling を許可しておく。iOS Safari/Chrome(WebKit) は Basic 認証のキャッシュ
+        // 資格情報を WebSocket ハンドシェイクには付与しない既知の挙動があり、WS のみだと
+        // 認証付き公開時に iOS 端末から接続できず "connecting..." のまま固まる。polling は
+        // XHR なので Authorization が乗り、認証を通過できる（デスクトップは WS に自動昇格）。
+        transports: ['polling', 'websocket'],
         cors: { origin: corsOrigins },
+        // Basic 認証（有効時）。polling は XHR、WS はハンドシェイクの Authorization を検証する。
+        allowRequest: basicAuth
+            ? (req, callback) => callback(null, basicAuth.isAuthorized(req.headers, req.url, req.socket.remoteAddress))
+            : undefined,
         // 死んだ接続（スリープ・ネットワーク断等）を早めに検出して、ぶら下がった socket が
         // 保持する PTY の onData/onExit ハンドラを早く解放する。既定 (25s/20s) では検出までに
         // 最大 ~45s かかり、その間ゾンビ socket がリスナーを溜め込み出力が多重化する。
@@ -52,6 +83,52 @@ async function start() {
     await fastify.register(mcpRoutes, { prefix: '/api' });
     await fastify.register(terminalRoutes, { prefix: '/api' });
     await fastify.register(editorRoutes, { prefix: '/api' });
+    // catch-all リバースプロキシ: /api・/socket.io・/health 以外を内部 Next.js へ転送。
+    // - /api/* と /health は上で定義済みルートが wildcard より優先される。
+    // - /socket.io は Socket.IO が HTTP サーバ層で先取りするためここには来ない。
+    // - websocket は false。HMR は下の透過リレーで、Socket.IO は engine.io が終端する。
+    // - OPTIONS は除外。@fastify/cors が `OPTIONS *` を登録済みで、proxy が同じ
+    //   `OPTIONS /*` を登録すると "Method 'OPTIONS' already declared" で起動失敗する。
+    //   preflight は cors が処理するため proxy 側で OPTIONS を扱う必要はない。
+    await fastify.register(httpProxy, {
+        upstream: `http://localhost:${NEXT_PORT}`,
+        prefix: '/',
+        websocket: false,
+        httpMethods: ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT'],
+    });
+    // 開発時のみ: Next.js の HMR(WebSocket = /_next/webpack-hmr) を 2791 経由でも
+    // 使えるよう透過 TCP リレーする。これにより dev も本番と同じく単一ポート(2791)で
+    // 完結し、HMR / API / Socket.IO がすべて同一オリジンで動く。
+    //
+    // 注意: @fastify/http-proxy の websocket:true は upgrade を Fastify router 経由で
+    // ディスパッチするため、/socket.io の upgrade まで catch-all ルートが拾い例外を
+    // 投げる（Socket.IO 接続毎にエラーログ）。そのため WS は自前で /_next/webpack-hmr
+    // だけを対象にし、/socket.io には一切触れず engine.io に委ねる。
+    // 本番(standalone Next)は HMR が無いので何もしない。
+    if (process.env.NODE_ENV !== 'production') {
+        fastify.server.on('upgrade', (req, socket, head) => {
+            if (!req.url?.startsWith('/_next/webpack-hmr'))
+                return;
+            if (basicAuth && !basicAuth.isAuthorized(req.headers, req.url, req.socket.remoteAddress)) {
+                socket.destroy();
+                return;
+            }
+            const upstream = net.connect(NEXT_PORT, '127.0.0.1', () => {
+                upstream.write(`${req.method} ${req.url} HTTP/1.1\r\n`);
+                const raw = req.rawHeaders;
+                for (let i = 0; i < raw.length; i += 2) {
+                    upstream.write(`${raw[i]}: ${raw[i + 1]}\r\n`);
+                }
+                upstream.write('\r\n');
+                if (head?.length)
+                    upstream.write(head);
+                socket.pipe(upstream);
+                upstream.pipe(socket);
+            });
+            upstream.on('error', () => socket.destroy());
+            socket.on('error', () => upstream.destroy());
+        });
+    }
     await fastify.listen({ port: PORT, host: '0.0.0.0' });
     console.log(`Fastify server running on port ${PORT}`);
     const shutdown = async (signal) => {

package/dist/server/routes/terminal.js

@@ -13,14 +13,19 @@ export async function terminalRoutes(fastify) {
         let dataHandlerDispose = null;
         let exitHandlerDispose = null;
         // join: roomに参加する。
-        // - mode='subscribe': status-changed / todos-updated のブロードキャスト受信のみ。
-        //   PTY IO は接続しない。タスク一覧 / プランナーの購読 hook 用。PTY が未起動でも参加できる。
-        // - mode='terminal'（既定）: PTY の入出力を接続する。TerminalView 用。
-        socket.on('join', ({ room, mode = 'terminal' }) => {
+        // - mode='terminal': PTY の入出力を接続する。TerminalView 用。明示指定が必須。
+        // - mode='subscribe'（既定。mode 省略・不明値もここに含む）: status-changed /
+        //   todos-updated のブロードキャスト受信のみ。PTY IO は接続しない。
+        //   タスク一覧 / プランナーの購読 hook 用。PTY が未起動でも参加できる。
+        socket.on('join', ({ room, mode }) => {
             const sessionId = room.startsWith('tab:') ? room.slice(4) : room;
-            // 購読のみ: room メンバーシップだけ付与して終了。PTY ハンドラ・input/resize は登録せず、
-            // boundSessionId もセットしない（disconnect 時に他人のセッションへ GC を仕掛けないため）。
-            if (mode === 'subscribe') {
+            // PTY バインドは mode==='terminal' を明示した socket のみ。
+            // mode 省略・不明な値はすべて購読扱いにし、PTY IO を絶対に接続しない。
+            // （購読 hook の join が mode 省略で誤って PTY バインドし、input/onData/exit
+            //   ハンドラ登録や GC 干渉で入力多重化を招く事故を構造的に防ぐ）
+            // 購読のみ: room メンバーシップだけ付与して終了。boundSessionId もセットしない
+            // （disconnect 時に他人のセッションへ GC を仕掛けないため）。
+            if (mode !== 'terminal') {
                 socket.join(room);
                 return;
             }
@@ -42,6 +47,14 @@ export async function terminalRoutes(fastify) {
             socket.join(room);
             // 接続確立 → GCタイマーをキャンセル
             ptyManager.cancelGc(sessionId);
+            // この socket を PTY の所有者(active socket)にする。input の書き込みは所有者の
+            // socket からのみ許可し（下記 input ハンドラのゲート参照）、複数 socket が同一 PTY に
+            // バインドしても 1 キーストロークが多重書き込みされないことを構造的に保証する。
+            const prevOwner = ptyManager.getActiveSocket(sessionId);
+            if (prevOwner && prevOwner !== socket.id) {
+                console.log(`[terminal] session ${sessionId}: owner ${prevOwner} -> ${socket.id} (previous terminal socket still bound)`);
+            }
+            ptyManager.setActiveSocket(sessionId, socket.id);
             const { pty: ptyProcess } = session;
             const isReused = session.scrollback.length > 0;
             // リングバッファの内容を一括送信（再接続時の画面復元）
@@ -95,11 +108,14 @@ export async function terminalRoutes(fastify) {
                     }
                 }
             });
-            // input イベント: PTYへ書き込み + アクティブソケット追跡
+            // input イベント: 所有者 socket からの入力のみ PTY へ書き込む。
+            // ゾンビ/非所有 socket（再接続前の旧 socket・誤バインド socket 等）からの重複 input は
+            // 破棄し、1 キーストロークの多重書き込み（例: /clear が連続入力される）を防ぐ。
             socket.on('input', ({ sessionId: sid, data }) => {
                 if (sid !== sessionId)
                     return;
-                ptyManager.setActiveSocket(sessionId, socket.id);
+                if (ptyManager.getActiveSocket(sessionId) !== socket.id)
+                    return;
                 ptyProcess.write(data);
             });
         });
@@ -116,8 +132,14 @@ export async function terminalRoutes(fastify) {
             dataHandlerDispose?.();
             exitHandlerDispose?.();
             if (boundSessionId) {
+                // 所有者だった socket の切断時のみ GC をスケジュールする。
+                // 再接続で新しい socket が既に所有者になっている場合や、ゾンビ/非所有 socket の
+                // 遅延切断では GC を張らない（現役セッションが誤って GC 対象になるのを防ぐ）。
+                const wasOwner = ptyManager.getActiveSocket(boundSessionId) === socket.id;
                 ptyManager.clearActiveSocket(boundSessionId, socket.id);
-                ptyManager.scheduleGc(boundSessionId);
+                if (wasOwner) {
+                    ptyManager.scheduleGc(boundSessionId);
+                }
             }
         });
     });