@minimalcorp/tsunagi 0.1.44 → 0.1.46

package/dist/server/lib/services/task-service.d.ts

@@ -22,8 +22,8 @@ export interface CreateTaskParams {
     status?: Task['status'];
 }
 export declare class TaskServiceError extends Error {
-    code: 'REPO_NOT_FOUND' | 'BRANCH_DUPLICATE' | 'TASK_NOT_FOUND' | 'IDENTIFIER_REQUIRED' | 'INTERNAL_ERROR';
-    constructor(message: string, code: 'REPO_NOT_FOUND' | 'BRANCH_DUPLICATE' | 'TASK_NOT_FOUND' | 'IDENTIFIER_REQUIRED' | 'INTERNAL_ERROR');
+    code: 'REPO_NOT_FOUND' | 'BRANCH_DUPLICATE' | 'INVALID_BRANCH' | 'WORKTREE_CREATION_FAILED' | 'TASK_NOT_FOUND' | 'IDENTIFIER_REQUIRED' | 'INTERNAL_ERROR';
+    constructor(message: string, code: 'REPO_NOT_FOUND' | 'BRANCH_DUPLICATE' | 'INVALID_BRANCH' | 'WORKTREE_CREATION_FAILED' | 'TASK_NOT_FOUND' | 'IDENTIFIER_REQUIRED' | 'INTERNAL_ERROR');
 }
 /**
  * id / session_id / cwd からタスクを解決する
@@ -42,11 +42,19 @@ export declare function listTasks(filter?: {
  * タスクを取得（identifier で解決）
  */
 export declare function getTask(identifier: TaskIdentifier): Promise<Task>;
+/**
+ * 新規タスクのブランチ名を検証する（worktree 作成に失敗する値を事前に弾く）
+ */
+export declare function validateNewTaskBranch(owner: string, repo: string, branch: string): Promise<void>;
 /**
  * タスクを作成
+ *
+ * worktree 作成に成功した場合のみタスクを登録する（worktree の無いタスクを作らない）。
+ * fetch 失敗時はローカルの参照で worktree を作成し、warnings で通知する。
  */
 export declare function createTask(params: CreateTaskParams, options?: ServiceOptions): Promise<{
     task: Task;
+    warnings: string[];
 }>;
 /**
  * タスクを更新（identifier で解決）

package/dist/server/lib/services/task-service.js

@@ -5,7 +5,7 @@ import * as os from 'os';
 import * as taskRepo from '../repositories/task.js';
 import * as repoRepo from '../repositories/repository.js';
 import * as worktreeManager from '../worktree-manager.js';
-import { normalizeBranchName } from '../branch-utils.js';
+import { normalizeBranchName, validateBranchName } from '../branch-utils.js';
 import { prisma } from '../db.js';
 export class TaskServiceError extends Error {
     code;
@@ -90,73 +90,104 @@ export async function getTask(identifier) {
     }
     return task;
 }
+/**
+ * 新規タスクのブランチ名を検証する（worktree 作成に失敗する値を事前に弾く）
+ */
+export async function validateNewTaskBranch(owner, repo, branch) {
+    const invalidReason = validateBranchName(branch);
+    if (invalidReason || !(await worktreeManager.isValidBranchRef(branch))) {
+        throw new TaskServiceError(`Invalid branch name "${branch}": ${invalidReason ?? 'rejected by git check-ref-format'}`, 'INVALID_BRANCH');
+    }
+    const existingTasks = await taskRepo.getTasks({ owner, repo, includeDeleted: false });
+    const duplicateTask = existingTasks.find((task) => task.branch === branch);
+    if (duplicateTask) {
+        throw new TaskServiceError(`Branch "${branch}" already exists. Task "${duplicateTask.title}" (ID: ${duplicateTask.id}) is already using this branch.`, 'BRANCH_DUPLICATE');
+    }
+    // "/" は "-" に正規化されるため、別名のブランチでも worktree ディレクトリが衝突しうる
+    if (await worktreeManager.worktreeExists(owner, repo, branch)) {
+        throw new TaskServiceError(`Worktree directory "${normalizeBranchName(branch)}" already exists. Use a different branch name.`, 'BRANCH_DUPLICATE');
+    }
+}
 /**
  * タスクを作成
+ *
+ * worktree 作成に成功した場合のみタスクを登録する（worktree の無いタスクを作らない）。
+ * fetch 失敗時はローカルの参照で worktree を作成し、warnings で通知する。
  */
 export async function createTask(params, options) {
     const { title, description = '', owner, repo, baseBranch: baseBranchInput, effort, order, status = 'backlog', } = params;
+    const warnings = [];
     // リポジトリ存在チェック
     const repository = await repoRepo.getRepo(owner, repo);
     if (!repository) {
         throw new TaskServiceError('Repository not found. Please clone the repository first.', 'REPO_NOT_FOUND');
     }
-    // baseBranch解決
-    const baseBranch = baseBranchInput || (await worktreeManager.getDefaultBranch(owner, repo));
     // branch名の解決（未指定の場合はtitleから自動生成）
     const branch = params.branch || generateBranchName(title);
-    // ブランチ名重複チェック
-    const existingTasks = await taskRepo.getTasks({ includeDeleted: false });
-    const duplicateTask = existingTasks.find((task) => task.owner === owner && task.repo === repo && task.branch === branch);
-    if (duplicateTask) {
-        throw new TaskServiceError(`Branch "${branch}" already exists. Task "${duplicateTask.title}" (ID: ${duplicateTask.id}) is already using this branch.`, 'BRANCH_DUPLICATE');
-    }
-    // 1. order解決 + bumpOrder + DB登録をアトミックに実行
-    const newTask = await prisma.$transaction(async (tx) => {
-        let resolvedOrder;
-        if (order !== undefined) {
-            resolvedOrder = order;
-            await taskRepo.bumpOrder(resolvedOrder, undefined, tx);
-        }
-        else {
-            const result = await tx.task.aggregate({
-                where: { owner, repo, deletedAt: null },
-                _max: { order: true },
-            });
-            resolvedOrder = (result._max.order ?? -1) + 1;
-        }
-        return await taskRepo.createTask({
-            title,
-            description,
-            status,
-            owner,
-            repo,
-            branch,
-            baseBranch,
-            repoId: repository.id,
-            worktreeStatus: 'pending',
-            effort,
-            order: resolvedOrder,
-        }, tx);
-    });
-    // 3. worktree作成
+    await validateNewTaskBranch(owner, repo, branch);
+    // 1. fetch（失敗してもローカルの参照で続行する）
     try {
         await worktreeManager.fetchRemote(owner, repo);
+    }
+    catch (error) {
+        console.warn('Failed to fetch remote:', error);
+        warnings.push('Failed to fetch from remote. The worktree was created from local refs; update it once the network is available.');
+    }
+    // baseBranch解決
+    const baseBranch = baseBranchInput || (await worktreeManager.getDefaultBranch(owner, repo));
+    // 2. worktree作成（失敗したらタスクは作らない）
+    try {
         await worktreeManager.createWorktree(owner, repo, branch, baseBranch);
-        await taskRepo.updateTask(newTask.id, { worktreeStatus: 'created' });
     }
     catch (error) {
         console.error('Failed to create worktree:', error);
-        await taskRepo.updateTask(newTask.id, { worktreeStatus: 'error' });
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new TaskServiceError(`Failed to create worktree: ${reason}`, 'WORKTREE_CREATION_FAILED');
     }
-    // 初期Tabは作らない。タブはユーザーがタスク詳細で起動先（Claude / Ollama 等）を選んで作る
-    // 4. 更新後のタスクを取得
-    const updatedTask = await taskRepo.getTask(newTask.id);
-    if (!updatedTask) {
-        throw new TaskServiceError('Failed to retrieve created task', 'INTERNAL_ERROR');
+    // 3. order解決 + bumpOrder + DB登録をアトミックに実行（失敗したら worktree を削除）
+    let newTask;
+    try {
+        newTask = await prisma.$transaction(async (tx) => {
+            let resolvedOrder;
+            if (order !== undefined) {
+                resolvedOrder = order;
+                await taskRepo.bumpOrder(resolvedOrder, undefined, tx);
+            }
+            else {
+                const result = await tx.task.aggregate({
+                    where: { owner, repo, deletedAt: null },
+                    _max: { order: true },
+                });
+                resolvedOrder = (result._max.order ?? -1) + 1;
+            }
+            return await taskRepo.createTask({
+                title,
+                description,
+                status,
+                owner,
+                repo,
+                branch,
+                baseBranch,
+                repoId: repository.id,
+                effort,
+                order: resolvedOrder,
+            }, tx);
+        });
+    }
+    catch (error) {
+        // force=false: 既存のローカルブランチを流用した場合に削除しないよう、ブランチは残す
+        try {
+            await worktreeManager.removeWorktree(owner, repo, branch);
+        }
+        catch (cleanupError) {
+            console.error('Failed to remove worktree after task creation failure:', cleanupError);
+        }
+        throw error;
     }
-    // 5. Socket.IO通知
-    options?.io?.emit('task:created', { task: updatedTask });
-    return { task: updatedTask };
+    // 初期Tabは作らない。タブはユーザーがタスク詳細で起動先（Claude / Ollama 等）を選んで作る
+    // 4. Socket.IO通知
+    options?.io?.emit('task:created', { task: newTask, warnings });
+    return { task: newTask, warnings };
 }
 /**
  * タスクを更新（identifier で解決）

package/dist/server/lib/worktree-manager.d.ts

@@ -12,6 +12,8 @@ export declare function getRemoteBranches(owner: string, repo: string): Promise<
 export declare function isEmptyRepo(owner: string, repo: string): Promise<boolean>;
 export declare function isUnbornWorktree(worktreePath: string): Promise<boolean>;
 export declare function getDefaultBranch(owner: string, repo: string): Promise<string>;
+export declare function isValidBranchRef(branch: string): Promise<boolean>;
+export declare function worktreeExists(owner: string, repo: string, branch: string): Promise<boolean>;
 export declare function createWorktree(owner: string, repo: string, branch: string, baseBranch?: string): Promise<{
     worktreePath: string;
 }>;

package/dist/server/lib/worktree-manager.js

@@ -169,6 +169,28 @@ export async function getDefaultBranch(owner, repo) {
         return branches[0] || 'main';
     }
 }
+// git 自身のルールでブランチ名として有効か判定（最終判定用）
+// --branch はカレントのリポジトリ探索を伴い cwd 次第で失敗するため、refs/heads/ 形式で判定する
+// （"-" 始まり・"@"・"HEAD" は validateBranchName 側で弾く）
+export async function isValidBranchRef(branch) {
+    try {
+        await simpleGit().raw(['check-ref-format', `refs/heads/${branch}`]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// worktreeディレクトリが存在するか確認
+export async function worktreeExists(owner, repo, branch) {
+    try {
+        await fs.access(getWorktreePath(owner, repo, branch));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 // worktreeを作成
 export async function createWorktree(owner, repo, branch, baseBranch) {
     const bareRepoPath = await ensureBareRepository(owner, repo);

package/dist/server/routes/mcp.js

@@ -93,7 +93,7 @@ function createMcpServer(io) {
             },
             {
                 name: 'tsunagi_create_task',
-                description: 'タスクを作成する。worktree作成・初期タブ作成・Socket.IO通知を含むフル作成フロー。branchを省略するとtitleから自動生成される。',
+                description: 'タスクを作成する。worktree作成・初期タブ作成・Socket.IO通知を含むフル作成フロー。branchを省略するとtitleから自動生成される。worktree作成に失敗した場合（gitで不正なブランチ名等）はタスクは作成されない。',
                 inputSchema: {
                     type: 'object',
                     required: ['owner', 'repo', 'title'],
@@ -231,7 +231,12 @@ function createMcpServer(io) {
                         branch,
                         baseBranch,
                     }, { io });
-                    return { content: [{ type: 'text', text: JSON.stringify(result.task, null, 2) }] };
+                    return {
+                        content: [
+                            { type: 'text', text: JSON.stringify(result.task, null, 2) },
+                            ...result.warnings.map((warning) => ({ type: 'text', text: `Warning: ${warning}` })),
+                        ],
+                    };
                 }
                 case 'tsunagi_update_task': {
                     const { id, session_id, cwd, title, description, status, effort, order, baseBranch, pullRequestUrl, } = (args ?? {});

package/dist/server/routes/repos.js

@@ -215,39 +215,44 @@ export async function reposRoutes(fastify) {
                     fastify.log.warn(cleanupError, 'Failed to cleanup bare repository after clone failure');
                 }
             };
-            const sshUrl = `git@github.com:${owner}/${repo}.git`;
             const isHttpsUrl = normalizedUrl.startsWith('http');
+            const protocol = isHttpsUrl ? 'HTTPS' : 'SSH';
+            const altProtocol = isHttpsUrl ? 'SSH' : 'HTTPS';
+            // 認証エラー時にもう一方の方式で試し直すためのURL
+            const altUrl = isHttpsUrl
+                ? `git@github.com:${owner}/${repo}.git`
+                : `https://github.com/${owner}/${repo}.git`;
             let clonedUrl = normalizedUrl;
             try {
                 await worktreeManager.initBareRepository(owner, repo, normalizedUrl);
             }
             catch (error) {
                 await cleanupBareRepo();
-                // private repository を HTTPS で clone するには認証が必要。
-                // tsunagi は SSH agent 前提で動くため、認証エラーなら SSH で自動的に試し直す。
-                if (!isHttpsUrl || !isGitAuthError(error))
+                // 認証手段は環境により異なる（SSH鍵のみ / HTTPS + credential helper のみ 等）。
+                // 認証エラーならもう一方の方式で自動的に試し直す。
+                if (!isGitAuthError(error))
                     throw error;
-                fastify.log.info({ owner, repo }, 'HTTPS clone failed with an auth error, retrying over SSH');
+                fastify.log.info({ owner, repo }, `${protocol} clone failed with an auth error, retrying over ${altProtocol}`);
                 try {
-                    await worktreeManager.initBareRepository(owner, repo, sshUrl);
-                    clonedUrl = sshUrl;
+                    await worktreeManager.initBareRepository(owner, repo, altUrl);
+                    clonedUrl = altUrl;
                 }
-                catch (sshError) {
+                catch (altError) {
                     await cleanupBareRepo();
-                    const httpsMessage = error instanceof Error ? error.message : String(error);
-                    const sshMessage = sshError instanceof Error ? sshError.message : String(sshError);
+                    const message = error instanceof Error ? error.message : String(error);
+                    const altMessage = altError instanceof Error ? altError.message : String(altError);
                     throw new Error(`Failed to clone ${owner}/${repo}. ` +
-                        `HTTPS では認証情報が無いため失敗し、SSH でも失敗しました。` +
-                        `SSH鍵(ssh-agent)を設定するか、リポジトリへのアクセス権を確認してください。\n` +
-                        `HTTPS: ${httpsMessage.trim()}\nSSH: ${sshMessage.trim()}`);
+                        `HTTPS・SSH のどちらでも認証に失敗しました。` +
+                        `SSH鍵(ssh-agent)または git の credential helper を設定するか、リポジトリへのアクセス権を確認してください。\n` +
+                        `${protocol}: ${message.trim()}\n${altProtocol}: ${altMessage.trim()}`);
                 }
             }
             const newRepo = await createRepo({ owner, repo, cloneUrl: clonedUrl });
             return reply.status(200).send({
                 data: {
                     repository: { ...newRepo, bareRepoPath },
-                    // HTTPSで認証できずSSHで clone し直した場合、UI側で利用者に知らせる
-                    fallbackToSsh: clonedUrl !== normalizedUrl,
+                    // 認証できず別方式で clone し直した場合、UI側で利用者に知らせる
+                    fallbackProtocol: clonedUrl !== normalizedUrl ? altProtocol.toLowerCase() : null,
                 },
             });
         }

package/dist/server/routes/tasks.js

@@ -2,7 +2,13 @@ import { v4 as uuidv4 } from 'uuid';
 import * as taskRepo from '../lib/repositories/task.js';
 import * as worktreeManager from '../lib/worktree-manager.js';
 import { ptyManager } from '../pty-manager.js';
-import { listTasks, createTask, getTask, updateTask, deleteTask, TaskServiceError, } from '../lib/services/task-service.js';
+import { listTasks, createTask, getTask, updateTask, deleteTask, validateNewTaskBranch, TaskServiceError, } from '../lib/services/task-service.js';
+const CREATE_ERROR_STATUS = {
+    REPO_NOT_FOUND: 404,
+    BRANCH_DUPLICATE: 409,
+    INVALID_BRANCH: 400,
+    WORKTREE_CREATION_FAILED: 422,
+};
 export async function tasksRoutes(fastify) {
     const io = fastify.io;
     // POST /tasks/validate
@@ -17,22 +23,16 @@ export async function tasksRoutes(fastify) {
                     ],
                 });
             }
-            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.`,
-                        },
-                    ],
-                });
-            }
+            await validateNewTaskBranch(owner, repo, branch);
             return reply.status(200).send({ valid: true });
         }
         catch (error) {
+            if (error instanceof TaskServiceError) {
+                return reply.status(error.code === 'BRANCH_DUPLICATE' ? 409 : 400).send({
+                    valid: false,
+                    errors: [{ field: 'branch', message: error.message }],
+                });
+            }
             fastify.log.error(error, 'POST /tasks/validate error');
             return reply.status(500).send({
                 valid: false,
@@ -128,11 +128,11 @@ export async function tasksRoutes(fastify) {
         }
         try {
             const result = await createTask({ title, description, owner, repo, branch, baseBranch, effort, order }, { io });
-            return reply.status(201).send({ data: { task: result.task } });
+            return reply.status(201).send({ data: { task: result.task, warnings: result.warnings } });
         }
         catch (error) {
             if (error instanceof TaskServiceError) {
-                const statusCode = error.code === 'REPO_NOT_FOUND' ? 404 : error.code === 'BRANCH_DUPLICATE' ? 409 : 500;
+                const statusCode = CREATE_ERROR_STATUS[error.code] ?? 500;
                 return reply.status(statusCode).send({
                     errors: [{ field: 'global', message: error.message }],
                 });
@@ -146,7 +146,8 @@ export async function tasksRoutes(fastify) {
         try {
             const { id } = request.params;
             const task = await getTask({ id });
-            return reply.status(200).send({ data: { task } });
+            const worktreeExists = await worktreeManager.worktreeExists(task.owner, task.repo, task.branch);
+            return reply.status(200).send({ data: { task, worktreeExists } });
         }
         catch (error) {
             if (error instanceof TaskServiceError && error.code === 'TASK_NOT_FOUND') {
@@ -243,10 +244,8 @@ export async function tasksRoutes(fastify) {
             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);
-            }
+            // worktreeが存在しない場合は checkRebaseNeeded が false を返す
+            const needsRebase = await worktreeManager.checkRebaseNeeded(task.owner, task.repo, task.branch, task.baseBranch);
             return reply.status(200).send({ data: { needsRebase } });
         }
         catch (error) {
@@ -263,8 +262,8 @@ export async function tasksRoutes(fastify) {
             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' });
+            if (!(await worktreeManager.worktreeExists(task.owner, task.repo, task.branch))) {
+                return reply.status(400).send({ error: 'Worktree not found' });
             }
             const isClaudeRunning = task.tabs.some((tab) => tab.status === 'running');
             if (isClaudeRunning) {

package/dist/server/routes/terminal.js

@@ -227,11 +227,16 @@ export async function terminalRoutes(fastify) {
         let workingDir = tab
             ? getWorktreePath(tab.task.owner, tab.task.repo, tab.task.branch)
             : (cwd ?? defaultDir);
-        // cwd が存在するか確認、なければデフォルトにフォールバック
+        // cwd が存在するか確認。Task のタブは worktree 必須（無ければ起動しない）、
+        // それ以外はデフォルトにフォールバック
         try {
             await fs.access(workingDir);
         }
         catch {
+            if (tab) {
+                fastify.log.warn({ sessionId, workingDir }, 'worktree does not exist');
+                return reply.status(409).send({ error: `Worktree not found at ${workingDir}` });
+            }
             fastify.log.warn({ sessionId, workingDir }, 'cwd does not exist, falling back to default');
             workingDir = defaultDir;
         }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@minimalcorp/tsunagi",
-  "version": "0.1.44",
+  "version": "0.1.46",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@minimalcorp/tsunagi",
-      "version": "0.1.44",
+      "version": "0.1.46",
       "license": "SEE LICENSE IN LICENSE",
       "os": [
         "darwin",
@@ -1500,9 +1500,9 @@
       }
     },
     "node_modules/bundle-name": {
-      "version": "4.1.0",
-      "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.0.tgz",
-      "integrity": "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==",
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/bundle-name/-/bundle-name-4.1.1.tgz",
+      "integrity": "sha512-DdH81/zPLVS11EUgWq3tEu/xn+EzljlMYooDNdzWEnFha3R3NBMpMV1UqYIpjYHV/SgpFKMIX1Oh7o06SjM/oA==",
       "license": "MIT",
       "dependencies": {
         "run-applescript": "^7.0.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minimalcorp/tsunagi",
-  "version": "0.1.44",
+  "version": "0.1.46",
   "description": "Multi-repo GitHub project management with Claude AI integration, designed for visualizing and controlling AI-driven development locally.",
   "keywords": [
     "tsunagi",