@akiojin/gwt 2.0.0

package/src/web/server/pty/manager.ts

@@ -0,0 +1,189 @@
+/**
+ * PTY Manager
+ *
+ * AI Toolセッションの疑似端末(PTY)を管理します。
+ * node-ptyを使用してプロセスをスポーンし、WebSocketを通じて入出力を中継します。
+ */
+
+import * as pty from "node-pty";
+import type { IPty } from "node-pty";
+import { randomUUID } from "node:crypto";
+import type { AIToolSession } from "../../../types/api.js";
+
+export interface PTYInstance {
+  ptyProcess: IPty;
+  session: AIToolSession;
+}
+
+/**
+ * PTYマネージャー - セッションとPTYプロセスのライフサイクル管理
+ */
+export class PTYManager {
+  private instances: Map<string, PTYInstance> = new Map();
+
+  /**
+   * 新しいPTYセッションを作成
+   */
+  public spawn(
+    toolType: "claude-code" | "codex-cli" | "custom",
+    worktreePath: string,
+    mode: "normal" | "continue" | "resume",
+    toolName?: string | null,
+    cols = 80,
+    rows = 24,
+  ): { sessionId: string; session: AIToolSession } {
+    const sessionId = randomUUID();
+
+    // AI Toolコマンドを構築
+    const command = this.buildCommand(toolType, mode, toolName);
+    const args = this.buildArgs(toolType, mode);
+
+    // PTYプロセスをスポーン
+    const ptyProcess = pty.spawn(command, args, {
+      name: "xterm-256color",
+      cols,
+      rows,
+      cwd: worktreePath,
+      env: {
+        ...process.env,
+        TERM: "xterm-256color",
+        COLORTERM: "truecolor",
+      },
+    });
+
+    const session: AIToolSession = {
+      sessionId,
+      toolType,
+      toolName: toolName || null,
+      mode,
+      worktreePath,
+      ptyPid: ptyProcess.pid,
+      websocketId: null,
+      status: "pending",
+      startedAt: new Date().toISOString(),
+      endedAt: null,
+      exitCode: null,
+      errorMessage: null,
+    };
+
+    this.instances.set(sessionId, { ptyProcess, session });
+
+    return { sessionId, session };
+  }
+
+  /**
+   * セッションIDからPTYインスタンスを取得
+   */
+  public get(sessionId: string): PTYInstance | undefined {
+    return this.instances.get(sessionId);
+  }
+
+  /**
+   * セッションを削除
+   */
+  public delete(sessionId: string): boolean {
+    const instance = this.instances.get(sessionId);
+    if (!instance) {
+      return false;
+    }
+
+    // PTYプロセスを終了
+    try {
+      instance.ptyProcess.kill();
+    } catch {
+      // プロセスが既に終了している場合は無視
+    }
+
+    this.instances.delete(sessionId);
+    return true;
+  }
+
+  /**
+   * セッションのステータスを更新
+   */
+  public updateStatus(
+    sessionId: string,
+    status: AIToolSession["status"],
+    exitCode?: number,
+    errorMessage?: string,
+  ): boolean {
+    const instance = this.instances.get(sessionId);
+    if (!instance) {
+      return false;
+    }
+
+    instance.session.status = status;
+    if (exitCode !== undefined) {
+      instance.session.exitCode = exitCode;
+    }
+    if (errorMessage !== undefined) {
+      instance.session.errorMessage = errorMessage;
+    }
+    if (status === "completed" || status === "failed") {
+      instance.session.endedAt = new Date().toISOString();
+    }
+
+    return true;
+  }
+
+  /**
+   * すべてのセッション一覧を取得
+   */
+  public list(): AIToolSession[] {
+    return Array.from(this.instances.values()).map((inst) => inst.session);
+  }
+
+  /**
+   * AI Toolのコマンドを構築
+   */
+  private buildCommand(
+    toolType: "claude-code" | "codex-cli" | "custom",
+    mode: "normal" | "continue" | "resume",
+    toolName?: string | null,
+  ): string {
+    if (toolType === "custom" && toolName) {
+      // カスタムツールは別途config.jsonから取得する必要があるが、
+      // ここでは簡易実装としてtoolNameをそのままコマンドとして使用
+      return toolName;
+    }
+
+    if (toolType === "codex-cli") {
+      return "codex";
+    }
+
+    // claude-code
+    return "claude";
+  }
+
+  /**
+   * AI Toolの引数を構築
+   */
+  private buildArgs(
+    toolType: "claude-code" | "codex-cli" | "custom",
+    mode: "normal" | "continue" | "resume",
+  ): string[] {
+    if (toolType === "custom") {
+      // カスタムツールの引数は別途config.jsonから取得
+      return [];
+    }
+
+    if (toolType === "codex-cli") {
+      if (mode === "continue") {
+        return ["--continue"];
+      }
+      if (mode === "resume") {
+        return ["--resume"];
+      }
+      return [];
+    }
+
+    // claude-code
+    if (mode === "continue") {
+      return ["--continue"];
+    }
+    if (mode === "resume") {
+      return ["--resume"];
+    }
+    return [];
+  }
+}

package/src/web/server/routes/branches.ts

@@ -0,0 +1,126 @@
+/**
+ * Branch Routes
+ *
+ * ブランチ関連のREST APIエンドポイント。
+ */
+
+import type { FastifyInstance } from "fastify";
+import {
+  listBranches,
+  getBranchByName,
+  syncBranchState,
+} from "../services/branches.js";
+import type {
+  ApiResponse,
+  Branch,
+  BranchSyncRequest,
+  BranchSyncResult,
+} from "../../../types/api.js";
+
+/**
+ * ブランチ関連のルートを登録
+ */
+export async function registerBranchRoutes(
+  fastify: FastifyInstance,
+): Promise<void> {
+  // GET /api/branches - すべてのブランチ一覧を取得
+  fastify.get<{ Reply: ApiResponse<Branch[]> }>(
+    "/api/branches",
+    async (request, reply) => {
+      try {
+        const branches = await listBranches();
+        return { success: true, data: branches };
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        reply.code(500);
+        return {
+          success: false,
+          error: "Failed to fetch branches",
+          details: errorMsg,
+        };
+      }
+    },
+  );
+
+  // GET /api/branches/:branchName - 特定のブランチ情報を取得
+  fastify.get<{
+    Params: { branchName: string };
+    Reply: ApiResponse<Branch>;
+  }>("/api/branches/:branchName", async (request, reply) => {
+    try {
+      const { branchName } = request.params;
+      const decodedBranchName = decodeURIComponent(branchName);
+
+      const branch = await getBranchByName(decodedBranchName);
+      if (!branch) {
+        reply.code(404);
+        return {
+          success: false,
+          error: "Branch not found",
+          details: `Branch ${decodedBranchName} does not exist`,
+        };
+      }
+
+      return { success: true, data: branch };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      reply.code(500);
+      return {
+        success: false,
+        error: "Failed to fetch branch",
+        details: errorMsg,
+      };
+    }
+  });
+
+  // POST /api/branches/:branchName/sync - Fetch & fast-forward pull
+  fastify.post<{
+    Params: { branchName: string };
+    Body: BranchSyncRequest;
+    Reply: ApiResponse<BranchSyncResult>;
+  }>("/api/branches/:branchName/sync", async (request, reply) => {
+    const { branchName } = request.params;
+    const decodedBranchName = decodeURIComponent(branchName);
+    const { worktreePath } = request.body;
+
+    if (!worktreePath) {
+      reply.code(400);
+      return {
+        success: false,
+        error: "worktreePath is required",
+        details: null,
+      };
+    }
+
+    try {
+      const result = await syncBranchState(decodedBranchName, worktreePath);
+      return { success: true, data: result };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("Branch not found")) {
+        reply.code(404);
+        return {
+          success: false,
+          error: "Branch not found",
+          details: message,
+        };
+      }
+
+      if (message.includes("Worktree path is required")) {
+        reply.code(400);
+        return {
+          success: false,
+          error: "Invalid request",
+          details: message,
+        };
+      }
+
+      reply.code(500);
+      return {
+        success: false,
+        error: "Failed to sync branch",
+        details: message,
+      };
+    }
+  });
+}

package/src/web/server/routes/config.ts

@@ -0,0 +1,220 @@
+/**
+ * Config Routes
+ */
+
+import type { FastifyInstance } from "fastify";
+import { loadToolsConfig, saveToolsConfig } from "../../../config/tools.js";
+import {
+  loadEnvHistory,
+  recordEnvHistory,
+} from "../../../config/env-history.js";
+import type {
+  ApiResponse,
+  ConfigPayload,
+  CustomAITool as ApiCustomAITool,
+  EnvironmentHistoryEntry,
+  EnvironmentVariable,
+} from "../../../types/api.js";
+import type { CustomAITool as FileCustomAITool } from "../../../types/tools.js";
+import { getImportedEnvKeys } from "../env/importer.js";
+
+function normalizeEnv(
+  env: Record<string, string> | undefined,
+  importedKeys: Set<string>,
+  history: EnvironmentHistoryEntry[],
+): EnvironmentVariable[] {
+  if (!env) {
+    return [];
+  }
+
+  const lastUpdated = new Map<string, string | null>();
+  for (const entry of history) {
+    lastUpdated.set(entry.key, entry.timestamp ?? null);
+  }
+
+  return Object.entries(env).map(([key, value]) => {
+    const variable: EnvironmentVariable = {
+      key,
+      value,
+      lastUpdated: lastUpdated.get(key) ?? null,
+    };
+
+    if (importedKeys.has(key)) {
+      variable.importedFromOs = true;
+    }
+
+    return variable;
+  });
+}
+
+function envArrayToRecord(
+  env?: EnvironmentVariable[] | null,
+): Record<string, string> {
+  if (!env) {
+    return {};
+  }
+
+  const record: Record<string, string> = {};
+  for (const variable of env) {
+    if (!variable.key) continue;
+    record[variable.key] = variable.value;
+  }
+  return record;
+}
+
+function toApiTool(
+  tool: FileCustomAITool,
+  history: EnvironmentHistoryEntry[],
+  importedKeys: Set<string>,
+): ApiCustomAITool {
+  return {
+    id: tool.id,
+    displayName: tool.displayName,
+    icon: tool.icon ?? null,
+    command: tool.command,
+    executionType: tool.type,
+    defaultArgs: tool.defaultArgs ?? null,
+    modeArgs: tool.modeArgs,
+    permissionSkipArgs: tool.permissionSkipArgs ?? null,
+    env: normalizeEnv(tool.env, importedKeys, history),
+    description: null,
+    createdAt: null,
+    updatedAt: null,
+  };
+}
+
+function toFileTool(tool: ApiCustomAITool): FileCustomAITool {
+  const envRecord = envArrayToRecord(tool.env);
+  const fileTool: FileCustomAITool = {
+    id: tool.id,
+    displayName: tool.displayName,
+    type: tool.executionType,
+    command: tool.command,
+    modeArgs: tool.modeArgs,
+  };
+
+  if (tool.icon) {
+    fileTool.icon = tool.icon;
+  }
+  if (tool.defaultArgs && tool.defaultArgs.length > 0) {
+    fileTool.defaultArgs = tool.defaultArgs;
+  }
+  if (tool.permissionSkipArgs && tool.permissionSkipArgs.length > 0) {
+    fileTool.permissionSkipArgs = tool.permissionSkipArgs;
+  }
+  if (Object.keys(envRecord).length > 0) {
+    fileTool.env = envRecord;
+  }
+
+  return fileTool;
+}
+
+function diffEnvHistory(
+  previous: Record<string, string>,
+  next: Record<string, string>,
+  source: EnvironmentHistoryEntry["source"],
+): EnvironmentHistoryEntry[] {
+  const entries: EnvironmentHistoryEntry[] = [];
+  const timestamp = new Date().toISOString();
+
+  for (const [key, value] of Object.entries(next)) {
+    if (!(key in previous)) {
+      entries.push({ key, action: "add", source, timestamp });
+    } else if (previous[key] !== value) {
+      entries.push({ key, action: "update", source, timestamp });
+    }
+  }
+
+  for (const key of Object.keys(previous)) {
+    if (!(key in next)) {
+      entries.push({ key, action: "delete", source, timestamp });
+    }
+  }
+
+  return entries;
+}
+
+export async function registerConfigRoutes(
+  fastify: FastifyInstance,
+): Promise<void> {
+  fastify.get<{ Reply: ApiResponse<ConfigPayload> }>(
+    "/api/config",
+    async (request, reply) => {
+      try {
+        const config = await loadToolsConfig();
+        const history = await loadEnvHistory();
+        const importedSet = new Set(getImportedEnvKeys());
+
+        return {
+          success: true,
+          data: {
+            version: config.version,
+            updatedAt: config.updatedAt ?? null,
+            env: normalizeEnv(config.env, importedSet, history),
+            history,
+            tools: config.customTools.map((tool) =>
+              toApiTool(tool, history, importedSet),
+            ),
+          },
+        } satisfies ApiResponse<ConfigPayload>;
+      } catch (error) {
+        request.log.error({ err: error }, "Failed to load custom tool config");
+        reply.code(500);
+        return {
+          success: false,
+          error: "Failed to load config",
+          details: error instanceof Error ? error.message : String(error),
+        };
+      }
+    },
+  );
+
+  fastify.put<{
+    Body: ConfigPayload;
+    Reply: ApiResponse<ConfigPayload>;
+  }>("/api/config", async (request, reply) => {
+    try {
+      const payload = request.body;
+      const existing = await loadToolsConfig();
+      const nextEnvRecord = envArrayToRecord(payload.env);
+      const envHistory = diffEnvHistory(
+        existing.env ?? {},
+        nextEnvRecord,
+        "ui",
+      );
+
+      await saveToolsConfig({
+        version: payload.version || existing.version,
+        env: nextEnvRecord,
+        customTools: payload.tools.map(toFileTool),
+      });
+
+      if (envHistory.length) {
+        await recordEnvHistory(envHistory);
+      }
+
+      const history = await loadEnvHistory();
+      const importedSet = new Set(getImportedEnvKeys());
+
+      return {
+        success: true,
+        data: {
+          version: payload.version || existing.version,
+          updatedAt: new Date().toISOString(),
+          env: normalizeEnv(nextEnvRecord, importedSet, history),
+          history,
+          tools: payload.tools,
+        },
+      } satisfies ApiResponse<ConfigPayload>;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      request.log.error({ err: error }, "Failed to update config");
+      reply.code(500);
+      return {
+        success: false,
+        error: "Failed to update config",
+        details: errorMsg,
+      };
+    }
+  });
+}

package/src/web/server/routes/index.ts

@@ -0,0 +1,37 @@
+/**
+ * REST API Routes
+ *
+ * すべてのREST APIエンドポイントを登録します。
+ * 仕様: specs/SPEC-d5e56259/contracts/rest-api.yaml
+ */
+
+import type { FastifyInstance } from "fastify";
+import type { PTYManager } from "../pty/manager.js";
+import { registerBranchRoutes } from "./branches.js";
+import { registerWorktreeRoutes } from "./worktrees.js";
+import { registerSessionRoutes } from "./sessions.js";
+import { registerConfigRoutes } from "./config.js";
+import type { HealthResponse } from "../../../types/api.js";
+
+/**
+ * すべてのルートを登録
+ */
+export async function registerRoutes(
+  fastify: FastifyInstance,
+  ptyManager: PTYManager,
+): Promise<void> {
+  // ヘルスチェック
+  fastify.get<{ Reply: HealthResponse }>("/api/health", async () => {
+    return {
+      success: true,
+      status: "ok",
+      timestamp: new Date().toISOString(),
+    };
+  });
+
+  // 各エンドポイントグループを登録
+  await registerBranchRoutes(fastify);
+  await registerWorktreeRoutes(fastify);
+  await registerSessionRoutes(fastify, ptyManager);
+  await registerConfigRoutes(fastify);
+}

package/src/web/server/routes/sessions.ts

@@ -0,0 +1,130 @@
+/**
+ * Session Routes
+ *
+ * AI Toolセッション関連のREST APIエンドポイント。
+ */
+
+import type { FastifyInstance } from "fastify";
+import type { PTYManager } from "../pty/manager.js";
+import type {
+  ApiResponse,
+  AIToolSession,
+  StartSessionRequest,
+} from "../../../types/api.js";
+
+/**
+ * セッション関連のルートを登録
+ */
+export async function registerSessionRoutes(
+  fastify: FastifyInstance,
+  ptyManager: PTYManager,
+): Promise<void> {
+  // GET /api/sessions - すべてのセッション一覧を取得
+  fastify.get<{ Reply: ApiResponse<AIToolSession[]> }>(
+    "/api/sessions",
+    async (request, reply) => {
+      try {
+        const sessions = ptyManager.list();
+        return { success: true, data: sessions };
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        reply.code(500);
+        return {
+          success: false,
+          error: "Failed to fetch sessions",
+          details: errorMsg,
+        };
+      }
+    },
+  );
+
+  // POST /api/sessions - 新しいセッションを開始
+  fastify.post<{
+    Body: StartSessionRequest;
+    Reply: ApiResponse<AIToolSession>;
+  }>("/api/sessions", async (request, reply) => {
+    try {
+      const { toolType, toolName, mode, worktreePath } = request.body;
+
+      const { session } = ptyManager.spawn(
+        toolType,
+        worktreePath,
+        mode,
+        toolName,
+      );
+
+      reply.code(201);
+      return { success: true, data: session };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      reply.code(500);
+      return {
+        success: false,
+        error: "Failed to start session",
+        details: errorMsg,
+      };
+    }
+  });
+
+  // GET /api/sessions/:sessionId - 特定のセッション情報を取得
+  fastify.get<{
+    Params: { sessionId: string };
+    Reply: ApiResponse<AIToolSession>;
+  }>("/api/sessions/:sessionId", async (request, reply) => {
+    try {
+      const { sessionId } = request.params;
+
+      const instance = ptyManager.get(sessionId);
+      if (!instance) {
+        reply.code(404);
+        return {
+          success: false,
+          error: "Session not found",
+          details: `Session ${sessionId} does not exist`,
+        };
+      }
+
+      return { success: true, data: instance.session };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      reply.code(500);
+      return {
+        success: false,
+        error: "Failed to fetch session",
+        details: errorMsg,
+      };
+    }
+  });
+
+  // DELETE /api/sessions/:sessionId - セッションを終了
+  fastify.delete<{
+    Params: { sessionId: string };
+    Reply:
+      | { success: true }
+      | { success: false; error: string; details?: string | null };
+  }>("/api/sessions/:sessionId", async (request, reply) => {
+    try {
+      const { sessionId } = request.params;
+
+      const deleted = ptyManager.delete(sessionId);
+      if (!deleted) {
+        reply.code(404);
+        return {
+          success: false,
+          error: "Session not found",
+          details: `Session ${sessionId} does not exist`,
+        };
+      }
+
+      return { success: true };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      reply.code(500);
+      return {
+        success: false,
+        error: "Failed to delete session",
+        details: errorMsg,
+      };
+    }
+  });
+}