@minimalcorp/tsunagi 0.0.4 → 0.1.0

package/dist/server/routes/tasks.js

@@ -1,68 +1,119 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tasksRoutes = tasksRoutes;
-const taskRepo = __importStar(require("../../src/lib/repositories/task.js"));
-const task_service_js_1 = require("../../src/lib/services/task-service.js");
-async function tasksRoutes(fastify) {
+import { v4 as uuidv4 } from 'uuid';
+import * as taskRepo from '../lib/repositories/task.js';
+import * as worktreeManager from '../lib/worktree-manager.js';
+import { listTasks, createTask, getTask, updateTask, deleteTask, TaskServiceError, } from '../lib/services/task-service.js';
+export async function tasksRoutes(fastify) {
     const io = fastify.io;
     // POST /tasks/validate
     fastify.post('/tasks/validate', async (request, reply) => {
-        const { title, owner, repo, branch } = request.body;
-        if (!title || !owner || !repo || !branch) {
-            return reply.status(400).send({
+        try {
+            const { title, owner, repo, branch } = request.body;
+            if (!title || !owner || !repo || !branch) {
+                return reply.status(400).send({
+                    valid: false,
+                    errors: [
+                        { field: 'global', message: 'Missing required fields: title, owner, repo, branch' },
+                    ],
+                });
+            }
+            const existingTasks = await taskRepo.getTasks({ includeDeleted: false });
+            const duplicateTask = existingTasks.find((task) => task.owner === owner && task.repo === repo && task.branch === branch);
+            if (duplicateTask) {
+                return reply.status(409).send({
+                    valid: false,
+                    errors: [
+                        {
+                            field: 'branch',
+                            message: `Branch "${branch}" already exists. Task "${duplicateTask.title}" (ID: ${duplicateTask.id}) is already using this branch.`,
+                        },
+                    ],
+                });
+            }
+            return reply.status(200).send({ valid: true });
+        }
+        catch (error) {
+            fastify.log.error(error, 'POST /tasks/validate error');
+            return reply.status(500).send({
                 valid: false,
-                errors: [
-                    { field: 'global', message: 'Missing required fields: title, owner, repo, branch' },
-                ],
+                errors: [{ field: 'global', message: 'Validation failed' }],
             });
         }
-        const existingTasks = await taskRepo.getTasks({ includeDeleted: false });
-        const duplicateTask = existingTasks.find((task) => task.owner === owner && task.repo === repo && task.branch === branch);
-        if (duplicateTask) {
-            return reply.status(409).send({
-                valid: false,
-                errors: [
-                    {
-                        field: 'branch',
-                        message: `Branch "${branch}" already exists. Task "${duplicateTask.title}" (ID: ${duplicateTask.id}) is already using this branch.`,
-                    },
-                ],
+    });
+    // POST /tasks/batch-delete
+    fastify.post('/tasks/batch-delete', async (request, reply) => {
+        try {
+            const daysAgo = request.body.daysAgo ?? 7;
+            if (typeof daysAgo !== 'number' || daysAgo < 0) {
+                return reply.status(400).send({ error: 'Invalid daysAgo parameter' });
+            }
+            const cutoffDate = new Date();
+            cutoffDate.setDate(cutoffDate.getDate() - daysAgo);
+            const targetTasks = await taskRepo.getTasks({
+                includeDeleted: false,
+                status: 'done',
+                updatedBefore: cutoffDate,
             });
+            const targetTaskIds = targetTasks.map((task) => task.id);
+            const totalCount = targetTaskIds.length;
+            const batchId = uuidv4();
+            const response = { data: { batchId, targetTaskIds, totalCount } };
+            // Background deletion
+            setImmediate(async () => {
+                const MAX_CONCURRENT = 8;
+                let index = 0;
+                const executing = [];
+                const deleteOne = async (task) => {
+                    try {
+                        const success = await taskRepo.deleteTask(task.id);
+                        if (success) {
+                            try {
+                                await worktreeManager.removeWorktree(task.owner, task.repo, task.branch, true);
+                            }
+                            catch (err) {
+                                fastify.log.error(err, `Failed to remove worktree for task ${task.id}`);
+                            }
+                        }
+                    }
+                    catch (err) {
+                        fastify.log.error(err, `Failed to delete task ${task.id}`);
+                    }
+                };
+                while (index < targetTasks.length) {
+                    while (index < targetTasks.length && executing.length < MAX_CONCURRENT) {
+                        const task = targetTasks[index++];
+                        const p = deleteOne(task).then(() => {
+                            executing.splice(executing.indexOf(p), 1);
+                        });
+                        executing.push(p);
+                    }
+                    if (executing.length > 0)
+                        await Promise.race(executing);
+                }
+                await Promise.all(executing);
+            });
+            return reply.status(200).send(response);
+        }
+        catch (error) {
+            fastify.log.error(error, 'POST /tasks/batch-delete error');
+            return reply.status(500).send({ error: 'Failed to batch delete tasks' });
+        }
+    });
+    // GET /tasks
+    fastify.get('/tasks', async (request, reply) => {
+        try {
+            const { status, owner, repo, includeDeleted } = request.query;
+            const tasks = await listTasks({
+                status: status || undefined,
+                owner: owner || undefined,
+                repo: repo || undefined,
+                includeDeleted: includeDeleted === 'true',
+            });
+            return reply.status(200).send({ data: { tasks } });
+        }
+        catch (error) {
+            fastify.log.error(error, 'GET /tasks error');
+            return reply.status(500).send({ error: 'Failed to fetch tasks' });
         }
-        return reply.status(200).send({ valid: true });
     });
     // POST /tasks
     fastify.post('/tasks', async (request, reply) => {
@@ -75,11 +126,11 @@ async function tasksRoutes(fastify) {
             });
         }
         try {
-            const result = await (0, task_service_js_1.createTask)({ title, description, owner, repo, branch, baseBranch, effort, order }, { io });
+            const result = await createTask({ title, description, owner, repo, branch, baseBranch, effort, order }, { io });
             return reply.status(201).send({ data: { task: result.task } });
         }
         catch (error) {
-            if (error instanceof task_service_js_1.TaskServiceError) {
+            if (error instanceof TaskServiceError) {
                 const statusCode = error.code === 'REPO_NOT_FOUND' ? 404 : error.code === 'BRANCH_DUPLICATE' ? 409 : 500;
                 return reply.status(statusCode).send({
                     errors: [{ field: 'global', message: error.message }],
@@ -89,4 +140,216 @@ async function tasksRoutes(fastify) {
             return reply.status(500).send({ error: 'Failed to create task' });
         }
     });
+    // GET /tasks/:id
+    fastify.get('/tasks/:id', async (request, reply) => {
+        try {
+            const { id } = request.params;
+            const task = await getTask({ id });
+            return reply.status(200).send({ data: { task } });
+        }
+        catch (error) {
+            if (error instanceof TaskServiceError && error.code === 'TASK_NOT_FOUND') {
+                return reply.status(404).send({ error: 'Task not found' });
+            }
+            fastify.log.error(error, 'GET /tasks/:id error');
+            return reply.status(500).send({ error: 'Failed to fetch task' });
+        }
+    });
+    // PUT /tasks/:id
+    fastify.put('/tasks/:id', async (request, reply) => {
+        try {
+            const { id } = request.params;
+            const updatedTask = await updateTask({ id }, request.body);
+            return reply.status(200).send({ data: { task: updatedTask } });
+        }
+        catch (error) {
+            if (error instanceof TaskServiceError && error.code === 'TASK_NOT_FOUND') {
+                return reply.status(404).send({ error: 'Task not found' });
+            }
+            fastify.log.error(error, 'PUT /tasks/:id error');
+            return reply.status(500).send({ error: 'Failed to update task' });
+        }
+    });
+    // DELETE /tasks/:id
+    fastify.delete('/tasks/:id', async (request, reply) => {
+        try {
+            const { id } = request.params;
+            await deleteTask({ id });
+            return reply.status(200).send({ data: { success: true } });
+        }
+        catch (error) {
+            if (error instanceof TaskServiceError && error.code === 'TASK_NOT_FOUND') {
+                return reply.status(404).send({ error: 'Task not found' });
+            }
+            fastify.log.error(error, 'DELETE /tasks/:id error');
+            return reply.status(500).send({ error: 'Failed to delete task' });
+        }
+    });
+    // PUT /tasks/:id/status
+    fastify.put('/tasks/:id/status', async (request, reply) => {
+        try {
+            const { id } = request.params;
+            const { status, pullRequestUrl } = request.body;
+            const validStatuses = [
+                'backlog',
+                'planning',
+                'coding',
+                'reviewing',
+                'done',
+            ];
+            if (!status || !validStatuses.includes(status)) {
+                return reply.status(400).send({
+                    error: `Invalid status. Must be one of: ${validStatuses.join(', ')}`,
+                });
+            }
+            const updatedTask = await taskRepo.transitionTaskStatus(id, status, {
+                pullRequestUrl,
+            });
+            if (!updatedTask) {
+                return reply.status(404).send({ error: 'Task not found' });
+            }
+            return reply.status(200).send({ data: { task: updatedTask } });
+        }
+        catch (error) {
+            fastify.log.error(error, 'PUT /tasks/:id/status error');
+            return reply.status(500).send({ error: 'Failed to update task status' });
+        }
+    });
+    // POST /tasks/:id/complete
+    fastify.post('/tasks/:id/complete', async (request, reply) => {
+        try {
+            const { id } = request.params;
+            const completedTask = await taskRepo.completeTask(id);
+            if (!completedTask) {
+                return reply.status(404).send({ error: 'Task not found' });
+            }
+            return reply.status(200).send({
+                data: { task: completedTask },
+                message: 'Task completed successfully',
+            });
+        }
+        catch (error) {
+            fastify.log.error(error, 'POST /tasks/:id/complete error');
+            const errorMessage = error instanceof Error ? error.message : 'Failed to complete task';
+            return reply.status(500).send({ error: errorMessage });
+        }
+    });
+    // GET /tasks/:id/needs-rebase
+    fastify.get('/tasks/:id/needs-rebase', async (request, reply) => {
+        try {
+            const { id } = request.params;
+            const task = await taskRepo.getTask(id);
+            if (!task) {
+                return reply.status(404).send({ error: 'Task not found' });
+            }
+            let needsRebase = false;
+            if (task.worktreeStatus === 'created') {
+                needsRebase = await worktreeManager.checkRebaseNeeded(task.owner, task.repo, task.branch, task.baseBranch);
+            }
+            return reply.status(200).send({ data: { needsRebase } });
+        }
+        catch (error) {
+            fastify.log.error(error, 'GET /tasks/:id/needs-rebase error');
+            return reply.status(500).send({ error: 'Failed to check rebase status' });
+        }
+    });
+    // POST /tasks/:id/rebase
+    fastify.post('/tasks/:id/rebase', async (request, reply) => {
+        try {
+            const { id } = request.params;
+            const { baseBranch } = request.body ?? {};
+            const task = await taskRepo.getTask(id);
+            if (!task) {
+                return reply.status(404).send({ error: 'Task not found' });
+            }
+            if (task.worktreeStatus !== 'created') {
+                return reply.status(400).send({ error: 'Worktree has not been created yet' });
+            }
+            const isClaudeRunning = task.tabs.some((tab) => tab.status === 'running');
+            if (isClaudeRunning) {
+                return reply.status(400).send({ error: 'Cannot rebase while Claude is running' });
+            }
+            const result = await worktreeManager.rebaseWorktree(task.owner, task.repo, task.branch, baseBranch);
+            if (result.success) {
+                return reply.status(200).send({
+                    data: { success: true, message: result.message },
+                });
+            }
+            else {
+                return reply.status(409).send({
+                    error: result.message,
+                    conflicts: result.conflicts,
+                });
+            }
+        }
+        catch (error) {
+            fastify.log.error(error, 'POST /tasks/:id/rebase error');
+            const errorMessage = error instanceof Error ? error.message : 'Failed to rebase worktree';
+            return reply.status(500).send({ error: errorMessage });
+        }
+    });
+    // GET /tasks/:id/tabs
+    fastify.get('/tasks/:id/tabs', async (request, reply) => {
+        try {
+            const { id: taskId } = request.params;
+            const task = await taskRepo.getTask(taskId);
+            if (!task) {
+                return reply.status(404).send({ error: 'Task not found' });
+            }
+            return reply.status(200).send({ data: { tabs: task.tabs || [] } });
+        }
+        catch (error) {
+            fastify.log.error(error, 'GET /tasks/:id/tabs error');
+            return reply.status(500).send({ error: 'Failed to fetch tabs' });
+        }
+    });
+    // POST /tasks/:id/tabs
+    fastify.post('/tasks/:id/tabs', async (request, reply) => {
+        try {
+            const { id: taskId } = request.params;
+            const task = await taskRepo.getTask(taskId);
+            if (!task) {
+                return reply.status(404).send({ error: 'Task not found' });
+            }
+            const newTab = await taskRepo.createTab(taskId);
+            if (!newTab) {
+                return reply.status(500).send({ error: 'Failed to create tab' });
+            }
+            return reply.status(201).send({ data: { tab: newTab } });
+        }
+        catch (error) {
+            fastify.log.error(error, 'POST /tasks/:id/tabs error');
+            return reply.status(500).send({ error: 'Failed to create tab' });
+        }
+    });
+    // PUT /tasks/:id/tabs/:tab_id
+    fastify.put('/tasks/:id/tabs/:tab_id', async (request, reply) => {
+        try {
+            const { id: taskId, tab_id } = request.params;
+            const updatedTab = await taskRepo.updateTab(taskId, tab_id, request.body);
+            if (!updatedTab) {
+                return reply.status(404).send({ error: 'Tab not found' });
+            }
+            return reply.status(200).send({ data: { tab: updatedTab } });
+        }
+        catch (error) {
+            fastify.log.error(error, 'PUT /tasks/:id/tabs/:tab_id error');
+            return reply.status(500).send({ error: 'Failed to update tab' });
+        }
+    });
+    // DELETE /tasks/:id/tabs/:tab_id
+    fastify.delete('/tasks/:id/tabs/:tab_id', async (request, reply) => {
+        try {
+            const { id: taskId, tab_id } = request.params;
+            const success = await taskRepo.deleteTab(taskId, tab_id);
+            if (!success) {
+                return reply.status(404).send({ error: 'Tab not found' });
+            }
+            return reply.status(200).send({ data: { success: true } });
+        }
+        catch (error) {
+            fastify.log.error(error, 'DELETE /tasks/:id/tabs/:tab_id error');
+            return reply.status(500).send({ error: 'Failed to delete tab' });
+        }
+    });
 }

package/dist/server/routes/terminal.d.ts

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

package/dist/server/routes/terminal.js

@@ -1,47 +1,11 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.terminalRoutes = terminalRoutes;
-const fs = __importStar(require("fs/promises"));
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
-const pty_manager_js_1 = require("../pty-manager.js");
-const db_js_1 = require("../../src/lib/db.js");
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { ptyManager } from '../pty-manager.js';
+import { prisma } from '../lib/db.js';
 // サーバーはプロジェクトルートから起動されるため process.cwd() でルートを取得
 const TSUNAGI_EDITOR_PATH = path.resolve(process.cwd(), 'scripts/monaco-editor.sh');
-async function terminalRoutes(fastify) {
+export async function terminalRoutes(fastify) {
     const io = fastify.io;
     // socket.io イベントハンドラ
     io.on('connection', (socket) => {
@@ -52,14 +16,14 @@ async function terminalRoutes(fastify) {
         socket.on('join', ({ room }) => {
             const sessionId = room.startsWith('tab:') ? room.slice(4) : room;
             boundSessionId = sessionId;
-            const session = pty_manager_js_1.ptyManager.getSession(sessionId);
+            const session = ptyManager.getSession(sessionId);
             if (!session) {
                 socket.emit('error', { message: `Session not found: ${sessionId}` });
                 return;
             }
             socket.join(room);
             // 接続確立 → GCタイマーをキャンセル
-            pty_manager_js_1.ptyManager.cancelGc(sessionId);
+            ptyManager.cancelGc(sessionId);
             const { pty: ptyProcess } = session;
             const isReused = session.scrollback.length > 0;
             // リングバッファの内容を一括送信（再接続時の画面復元）
@@ -86,14 +50,15 @@ async function terminalRoutes(fastify) {
                 io.to(room).emit('exit', { exitCode });
                 // Ctrl+C等でClaudeが強制終了した場合にclaudeStatusをidleにリセット
                 io.to(room).emit('status-changed', { sessionId, status: 'idle' });
-                fetch(`http://localhost:2791/api/internal/tabs/${sessionId}/status`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ status: 'idle' }),
-                }).catch(() => {
+                prisma.tab
+                    .updateMany({
+                    where: { tabId: sessionId },
+                    data: { status: 'idle' },
+                })
+                    .catch(() => {
                     /* DB更新失敗は無視 */
                 });
-                pty_manager_js_1.ptyManager.deleteSession(sessionId);
+                ptyManager.deleteSession(sessionId);
             });
             exitHandlerDispose = () => exitHandler.dispose();
             // resize イベント: PTYリサイズ
@@ -115,7 +80,7 @@ async function terminalRoutes(fastify) {
             socket.on('input', ({ sessionId: sid, data }) => {
                 if (sid !== sessionId)
                     return;
-                pty_manager_js_1.ptyManager.setActiveSocket(sessionId, socket.id);
+                ptyManager.setActiveSocket(sessionId, socket.id);
                 ptyProcess.write(data);
             });
         });
@@ -128,17 +93,17 @@ async function terminalRoutes(fastify) {
             dataHandlerDispose?.();
             exitHandlerDispose?.();
             if (boundSessionId) {
-                pty_manager_js_1.ptyManager.clearActiveSocket(boundSessionId, socket.id);
-                pty_manager_js_1.ptyManager.scheduleGc(boundSessionId);
+                ptyManager.clearActiveSocket(boundSessionId, socket.id);
+                ptyManager.scheduleGc(boundSessionId);
             }
         });
     });
-    // GET /api/terminal/sessions - セッション一覧（デバッグ用）
-    fastify.get('/api/terminal/sessions', async () => {
-        return { sessions: pty_manager_js_1.ptyManager.listSessions() };
+    // GET /terminal/sessions - セッション一覧（デバッグ用）
+    fastify.get('/terminal/sessions', async () => {
+        return { sessions: ptyManager.listSessions() };
     });
-    // POST /api/terminal/sessions - セッション作成（または既存セッション再利用）
-    fastify.post('/api/terminal/sessions', async (request, reply) => {
+    // POST /terminal/sessions - セッション作成（または既存セッション再利用）
+    fastify.post('/terminal/sessions', async (request, reply) => {
         const { cwd, env, sessionId: requestedSessionId, command } = request.body ?? {};
         const sessionId = requestedSessionId ?? crypto.randomUUID();
         const defaultDir = path.join(os.homedir(), '.tsunagi', 'workspaces');
@@ -154,7 +119,7 @@ async function terminalRoutes(fastify) {
         // デフォルトディレクトリが存在しない場合も作成する
         await fs.mkdir(workingDir, { recursive: true });
         // 既存セッションが生きていれば再利用
-        const existing = pty_manager_js_1.ptyManager.getSession(sessionId);
+        const existing = ptyManager.getSession(sessionId);
         if (existing) {
             fastify.log.info({ sessionId }, 'Reusing existing PTY session');
             return reply.status(200).send({ sessionId, reused: true });
@@ -163,7 +128,7 @@ async function terminalRoutes(fastify) {
             // DBからglobal環境変数を取得（有効なもののみ）
             const globalEnv = {};
             try {
-                const globalEnvVars = await db_js_1.prisma.environmentVariable.findMany({
+                const globalEnvVars = await prisma.environmentVariable.findMany({
                     where: { scope: 'global', enabled: true },
                 });
                 globalEnvVars.forEach((e) => {
@@ -182,7 +147,7 @@ async function terminalRoutes(fastify) {
                 TSUNAGI_SESSION_ID: sessionId,
             };
             const mergedEnv = { ...tsunagiDefaultEnv, ...globalEnv, ...env };
-            const session = pty_manager_js_1.ptyManager.createSession(sessionId, workingDir, mergedEnv);
+            const session = ptyManager.createSession(sessionId, workingDir, mergedEnv);
             // コマンドが指定されていればPTY起動後にシェルへ書き込む
             if (command) {
                 const cmd = command.endsWith('\n') ? command : command + '\n';
@@ -198,16 +163,16 @@ async function terminalRoutes(fastify) {
             return reply.status(500).send({ error: message });
         }
     });
-    // DELETE /api/terminal/sessions/:sessionId - セッション明示削除（PTY kill）
-    fastify.delete('/api/terminal/sessions/:sessionId', async (request, reply) => {
+    // DELETE /terminal/sessions/:sessionId - セッション明示削除（PTY kill）
+    fastify.delete('/terminal/sessions/:sessionId', async (request, reply) => {
         const { sessionId } = request.params;
-        pty_manager_js_1.ptyManager.deleteSession(sessionId);
+        ptyManager.deleteSession(sessionId);
         return reply.status(204).send();
     });
-    // GET /api/terminal/sessions/:sessionId/scrollback - リングバッファ内容をdump（デバッグ用）
-    fastify.get('/api/terminal/sessions/:sessionId/scrollback', async (request, reply) => {
+    // GET /terminal/sessions/:sessionId/scrollback - リングバッファ内容をdump（デバッグ用）
+    fastify.get('/terminal/sessions/:sessionId/scrollback', async (request, reply) => {
         const { sessionId } = request.params;
-        const session = pty_manager_js_1.ptyManager.getSession(sessionId);
+        const session = ptyManager.getSession(sessionId);
         if (!session) {
             return reply.status(404).send({ error: 'Session not found' });
         }

package/dist/server/routes/worktrees.d.ts

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