@akiojin/gwt 2.12.1 → 2.14.0

package/src/codex.ts

@@ -3,10 +3,7 @@ import chalk from "chalk";
 import { platform } from "os";
 import { existsSync } from "fs";
 import { createChildStdio, getTerminalStreams } from "./utils/terminal.js";
-import {
-  findLatestCodexSession,
-  waitForCodexSessionId,
-} from "./utils/session.js";
+import { findLatestCodexSession } from "./utils/session.js";
 
 const CODEX_CLI_PACKAGE = "@openai/codex@latest";
 
@@ -85,11 +82,9 @@ export async function launchCodexCLI(
       options.sessionId && options.sessionId.trim().length > 0
         ? options.sessionId.trim()
         : null;
-
-    // Start polling session files immediately to catch the session created right after launch.
-    const sessionProbe = waitForCodexSessionId({ startedAt, cwd: worktreePath }).catch(
-      () => null,
-    );
+    const usedExplicitSessionId =
+      Boolean(resumeSessionId) &&
+      (options.mode === "continue" || options.mode === "resume");
 
     switch (options.mode) {
       case "continue":
@@ -141,15 +136,23 @@ export async function launchCodexCLI(
 
     const childStdio = createChildStdio();
 
-    const env = { ...process.env, ...(options.envOverrides ?? {}) };
+    const env = Object.fromEntries(
+      Object.entries({
+        ...process.env,
+        ...(options.envOverrides ?? {}),
+      }).filter(
+        (entry): entry is [string, string] => typeof entry[1] === "string",
+      ),
+    );
 
     try {
-      const execChild = async (child: any) => {
+      const execChild = async (child: Promise<unknown>) => {
         try {
           await child;
-        } catch (execError: any) {
+        } catch (execError: unknown) {
           // Treat SIGINT/SIGTERM as normal exit (user pressed Ctrl+C)
-          if (execError.signal === "SIGINT" || execError.signal === "SIGTERM") {
+          const signal = (execError as { signal?: unknown })?.signal;
+          if (signal === "SIGINT" || signal === "SIGTERM") {
             return;
           }
           throw execError;
@@ -163,7 +166,7 @@ export async function launchCodexCLI(
         stdout: childStdio.stdout,
         stderr: childStdio.stderr,
         env,
-      } as any);
+      });
       await execChild(child);
     } finally {
       childStdio.cleanup();
@@ -181,10 +184,13 @@ export async function launchCodexCLI(
         windowMs: 10 * 60 * 1000,
         cwd: worktreePath,
       });
-      // Priority: latest on disk > resumeSessionId
-      capturedSessionId = latest?.id ?? resumeSessionId ?? null;
+      const detectedSessionId = latest?.id ?? null;
+      // When we explicitly resumed a specific session, keep that ID as the source of truth.
+      capturedSessionId = usedExplicitSessionId
+        ? resumeSessionId
+        : detectedSessionId;
     } catch {
-      capturedSessionId = resumeSessionId ?? null;
+      capturedSessionId = usedExplicitSessionId ? resumeSessionId : null;
     }
 
     if (capturedSessionId) {
@@ -201,11 +207,13 @@ export async function launchCodexCLI(
     }
 
     return capturedSessionId ? { sessionId: capturedSessionId } : {};
-  } catch (error: any) {
+  } catch (error: unknown) {
+    const err = error as NodeJS.ErrnoException;
+    const details = error instanceof Error ? error.message : String(error);
     const errorMessage =
-      error.code === "ENOENT"
+      err.code === "ENOENT"
         ? "bunx command not found. Please ensure Bun is installed so Codex CLI can run via bunx."
-        : `Failed to launch Codex CLI: ${error.message || "Unknown error"}`;
+        : `Failed to launch Codex CLI: ${details || "Unknown error"}`;
 
     if (platform() === "win32") {
       console.error(chalk.red("\n💡 Windows troubleshooting tips:"));
@@ -234,8 +242,9 @@ export async function isCodexAvailable(): Promise<boolean> {
   try {
     await execa("bunx", [CODEX_CLI_PACKAGE, "--help"]);
     return true;
-  } catch (error: any) {
-    if (error.code === "ENOENT") {
+  } catch (error: unknown) {
+    const err = error as NodeJS.ErrnoException;
+    if (err.code === "ENOENT") {
       console.error(chalk.yellow("\n⚠️  bunx command not found"));
     }
     return false;

package/src/config/builtin-tools.ts

@@ -5,6 +5,10 @@
  */
 
 import type { CustomAITool } from "../types/tools.js";
+import {
+  CLAUDE_PERMISSION_SKIP_ARGS,
+  CODEX_DEFAULT_ARGS,
+} from "../shared/aiToolConstants.js";
 
 /**
  * Claude Code のビルトイン定義
@@ -19,7 +23,7 @@ export const CLAUDE_CODE_TOOL: CustomAITool = {
     continue: ["-c"],
     resume: ["-r"],
   },
-  permissionSkipArgs: ["--yes"],
+  permissionSkipArgs: Array.from(CLAUDE_PERMISSION_SKIP_ARGS),
 };
 
 /**
@@ -30,7 +34,7 @@ export const CODEX_CLI_TOOL: CustomAITool = {
   displayName: "Codex",
   type: "bunx",
   command: "@openai/codex@latest",
-  defaultArgs: ["--auto-approve", "--verbose"],
+  defaultArgs: Array.from(CODEX_DEFAULT_ARGS),
   modeArgs: {
     normal: [],
     continue: ["resume", "--last"],

package/src/config/shared-env.ts

@@ -0,0 +1,139 @@
+/**
+ * Shared environment variable helpers.
+ *
+ * 管理画面やサーバー側の設定ロジックから共通で利用する
+ * 環境変数スキーマ/バリデーション/マージ処理を集約する。
+ */
+
+const ENV_KEY_PATTERN = /^[A-Z0-9_]+$/;
+const MAX_KEY_LENGTH = 100;
+const MAX_VALUE_LENGTH = 500;
+
+const DEFAULT_BOOTSTRAP_ENV_KEYS = [
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_API_KEY_PATH",
+  "ANTHROPIC_API_BASE",
+  "OPENAI_API_KEY",
+  "OPENAI_BASE_URL",
+  "OPENAI_API_BASE",
+  "OPENAI_ORG_ID",
+  "OPENAI_PROJECT",
+  "OPENAI_API_TYPE",
+  "OPENAI_API_VERSION",
+  "GITHUB_TOKEN",
+  "GH_TOKEN",
+  "GITLAB_TOKEN",
+  "AZURE_OPENAI_API_KEY",
+  "AZURE_OPENAI_ENDPOINT",
+] as const;
+
+export type EnvironmentRecord = Record<string, string>;
+
+/**
+ * 環境変数キーが有効かどうかを判定。
+ */
+export function isValidEnvKey(key: string): boolean {
+  if (!key || typeof key !== "string") {
+    return false;
+  }
+  if (key.length === 0 || key.length > MAX_KEY_LENGTH) {
+    return false;
+  }
+  return ENV_KEY_PATTERN.test(key);
+}
+
+/**
+ * 許容されるキー長を取得。
+ */
+export function getEnvConstraints(): {
+  maxKeyLength: number;
+  maxValueLength: number;
+} {
+  return {
+    maxKeyLength: MAX_KEY_LENGTH,
+    maxValueLength: MAX_VALUE_LENGTH,
+  };
+}
+
+/**
+ * 任意のレコードをサニタイズして string -> string のみに整形する。
+ */
+export function sanitizeEnvRecord(
+  record?: Record<string, unknown>,
+): EnvironmentRecord {
+  if (!record || typeof record !== "object") {
+    return {};
+  }
+  const result: EnvironmentRecord = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (value === undefined || value === null) {
+      continue;
+    }
+    result[key] = String(value);
+  }
+  return result;
+}
+
+/**
+ * envレコードを検証し、フォーマットが不正な場合は例外を投げる。
+ */
+export function validateEnvRecord(record: EnvironmentRecord): void {
+  for (const [key, value] of Object.entries(record)) {
+    if (!isValidEnvKey(key)) {
+      throw new Error(
+        `Invalid environment variable key: "${key}". Use 1-${MAX_KEY_LENGTH} characters (A-Z, 0-9, underscore).`,
+      );
+    }
+    if (value.length === 0) {
+      throw new Error(`Environment variable "${key}" must not be empty.`);
+    }
+    if (value.length > MAX_VALUE_LENGTH) {
+      throw new Error(
+        `Environment variable "${key}" exceeds the maximum length (${MAX_VALUE_LENGTH}).`,
+      );
+    }
+  }
+}
+
+/**
+ * 起動時にOSから読み取って取り込みたい環境変数キー一覧を返す。
+ * CLAUDE_WORKTREE_BOOTSTRAP_ENV_KEYS=KEY1,KEY2 で上書き可能。
+ */
+export function getBootstrapEnvKeys(): string[] {
+  const override = process.env.CLAUDE_WORKTREE_BOOTSTRAP_ENV_KEYS;
+  if (!override) {
+    return [...DEFAULT_BOOTSTRAP_ENV_KEYS];
+  }
+  return override
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean)
+    .map((entry) => entry.toUpperCase());
+}
+
+/**
+ * 現在のenvレコードへ、指定されたキーのみOS環境変数から補完する。
+ */
+export function mergeWithBootstrapEnv(
+  current: EnvironmentRecord,
+  sourceEnv: NodeJS.ProcessEnv,
+  keys: string[] = getBootstrapEnvKeys(),
+): { merged: EnvironmentRecord; addedKeys: string[] } {
+  const merged: EnvironmentRecord = { ...current };
+  const addedKeys: string[] = [];
+
+  for (const key of keys) {
+    if (merged[key] !== undefined) {
+      continue; // 既に設定済み
+    }
+    const value = sourceEnv[key];
+    if (typeof value === "string" && value.length > 0) {
+      merged[key] = value;
+      addedKeys.push(key);
+    }
+  }
+
+  return { merged, addedKeys };
+}
+
+export { ENV_KEY_PATTERN };

package/src/gemini.ts

@@ -50,6 +50,9 @@ export async function launchGeminiCLI(
       options.sessionId && options.sessionId.trim().length > 0
         ? options.sessionId.trim()
         : null;
+    const usedExplicitSessionId =
+      Boolean(resumeSessionId) &&
+      (options.mode === "continue" || options.mode === "resume");
 
     const buildArgs = (useResumeId: boolean) => {
       const a: string[] = [];
@@ -59,12 +62,6 @@ export async function launchGeminiCLI(
 
       switch (options.mode) {
         case "continue":
-          if (useResumeId && resumeSessionId) {
-            a.push("--resume", resumeSessionId);
-          } else {
-            a.push("--resume");
-          }
-          break;
         case "resume":
           if (useResumeId && resumeSessionId) {
             a.push("--resume", resumeSessionId);
@@ -123,10 +120,14 @@ export async function launchGeminiCLI(
     }
     terminal.exitRawMode();
 
-    const baseEnv = {
-      ...process.env,
-      ...(options.envOverrides ?? {}),
-    };
+    const baseEnv = Object.fromEntries(
+      Object.entries({
+        ...process.env,
+        ...(options.envOverrides ?? {}),
+      }).filter(
+        (entry): entry is [string, string] => typeof entry[1] === "string",
+      ),
+    );
 
     const childStdio = createChildStdio();
 
@@ -156,7 +157,9 @@ export async function launchGeminiCLI(
       }
     };
 
-    const runGemini = async (runArgs: string[]): Promise<string | undefined> => {
+    const runGemini = async (
+      runArgs: string[],
+    ): Promise<string | undefined> => {
       // Capture stdout while passing through to terminal
       // Store chunks to extract session ID after process exits
       const outputChunks: string[] = [];
@@ -169,7 +172,7 @@ export async function launchGeminiCLI(
           stdout: "pipe",
           stderr: childStdio.stderr,
           env: baseEnv,
-        } as any);
+        });
 
         // Pass stdout through to terminal while capturing
         child.stdout?.on("data", (chunk: Buffer) => {
@@ -203,6 +206,7 @@ export async function launchGeminiCLI(
     };
 
     let output: string | undefined;
+    let fellBackToLatest = false;
     try {
       // Try with explicit session ID first (if any), then fallback to --resume (latest) once
       try {
@@ -212,6 +216,7 @@ export async function launchGeminiCLI(
           (options.mode === "resume" || options.mode === "continue") &&
           resumeSessionId;
         if (shouldRetry) {
+          fellBackToLatest = true;
           console.log(
             chalk.yellow(
               `   ⚠️  Failed to resume session ${resumeSessionId}. Retrying with latest session...`,
@@ -229,17 +234,22 @@ export async function launchGeminiCLI(
     // Extract session ID from Gemini's exit summary output
     extractSessionId(output);
 
-    // Fallback to file-based detection if stdout capture failed
+    const explicitResumeSucceeded = usedExplicitSessionId && !fellBackToLatest;
+
+    // If we explicitly resumed a specific session (and did not fall back), keep that ID.
+    if (explicitResumeSucceeded) {
+      capturedSessionId = resumeSessionId;
+    }
+
+    // Fallback to file-based detection if stdout capture failed (and we don't have an explicit-resume ID)
     if (!capturedSessionId) {
       try {
         capturedSessionId =
           (await findLatestGeminiSessionId(worktreePath, {
             cwd: worktreePath,
-          })) ??
-          resumeSessionId ??
-          null;
+          })) ?? null;
       } catch {
-        capturedSessionId = resumeSessionId ?? null;
+        capturedSessionId = null;
       }
     }
 
@@ -257,11 +267,12 @@ export async function launchGeminiCLI(
     }
 
     return capturedSessionId ? { sessionId: capturedSessionId } : {};
-  } catch (error: any) {
+  } catch (error: unknown) {
     const hasLocalGemini = await isGeminiCommandAvailable();
     let errorMessage: string;
+    const err = error as NodeJS.ErrnoException;
 
-    if (error.code === "ENOENT") {
+    if (err.code === "ENOENT") {
       if (hasLocalGemini) {
         errorMessage =
           "gemini command not found. Please ensure Gemini CLI is properly installed.";
@@ -270,7 +281,8 @@ export async function launchGeminiCLI(
           "bunx command not found. Please ensure Bun is installed so Gemini CLI can run via bunx.";
       }
     } else {
-      errorMessage = `Failed to launch Gemini CLI: ${error.message || "Unknown error"}`;
+      const details = error instanceof Error ? error.message : String(error);
+      errorMessage = `Failed to launch Gemini CLI: ${details || "Unknown error"}`;
     }
 
     if (process.platform === "win32") {
@@ -331,8 +343,9 @@ export async function isGeminiCLIAvailable(): Promise<boolean> {
   try {
     await execa("bunx", [GEMINI_CLI_PACKAGE, "--version"], { shell: true });
     return true;
-  } catch (error: any) {
-    if (error.code === "ENOENT") {
+  } catch (error: unknown) {
+    const err = error as NodeJS.ErrnoException;
+    if (err.code === "ENOENT") {
       console.error(chalk.yellow("\n⚠️  bunx command not found"));
       console.error(
         chalk.gray(

package/src/index.ts

@@ -33,6 +33,8 @@ import {
   getTerminalStreams,
   waitForUserAcknowledgement,
 } from "./utils/terminal.js";
+import { resolveWebUiPort, isPortInUse } from "./utils/webui.js";
+import { createLogger } from "./logging/logger.js";
 import { getToolById, getSharedEnvironment } from "./config/tools.js";
 import { launchCustomAITool } from "./launcher.js";
 import { saveSession, loadSession } from "./config/index.js";
@@ -55,6 +57,9 @@ const ERROR_PROMPT = chalk.yellow(
   "Review the error details, then press Enter to continue.",
 );
 
+// Category: cli
+const appLogger = createLogger({ category: "cli" });
+
 async function waitForErrorAcknowledgement(): Promise<void> {
   await waitForUserAcknowledgement(ERROR_PROMPT);
 }
@@ -64,14 +69,17 @@ async function waitForErrorAcknowledgement(): Promise<void> {
  */
 function printError(message: string): void {
   console.error(chalk.red(`❌ ${message}`));
+  appLogger.error({ message });
 }
 
 function printInfo(message: string): void {
   console.log(chalk.blue(`ℹ️  ${message}`));
+  appLogger.info({ message });
 }
 
 function printWarning(message: string): void {
   console.warn(chalk.yellow(`⚠️  ${message}`));
+  appLogger.warn({ message });
 }
 
 type GitStepResult<T> = { ok: true; value: T } | { ok: false };
@@ -545,12 +553,12 @@ export async function handleAIToolWorkflow(
       { skipHistory: true },
     );
 
-    // Lookup saved session ID for continue/resume
+    // Lookup saved session ID for Continue (auto attach)
     let resumeSessionId: string | null =
       selectedSessionId && selectedSessionId.length > 0
         ? selectedSessionId
         : null;
-    if (mode === "continue" || mode === "resume") {
+    if (mode === "continue") {
       const existingSession = await loadSession(repoRoot);
       const history = existingSession?.history ?? [];
 
@@ -693,14 +701,15 @@ export async function handleAIToolWorkflow(
 
     if (!finalSessionId && tool === "claude-code") {
       try {
-        finalSessionId = (await findLatestClaudeSessionId(worktreePath)) ?? null;
+        finalSessionId =
+          (await findLatestClaudeSessionId(worktreePath)) ?? null;
       } catch {
         finalSessionId = null;
       }
     }
     const finishedAt = Date.now();
 
-    if (tool === "codex-cli") {
+    if (!finalSessionId && tool === "codex-cli") {
       try {
         const latest = await findLatestCodexSession({
           since: launchStartedAt - 60_000,
@@ -715,7 +724,7 @@ export async function handleAIToolWorkflow(
       } catch {
         // ignore fallback failure
       }
-    } else if (tool === "claude-code") {
+    } else if (!finalSessionId && tool === "claude-code") {
       try {
         const latestClaude = await findLatestClaudeSession(worktreePath, {
           since: launchStartedAt - 60_000,
@@ -729,7 +738,7 @@ export async function handleAIToolWorkflow(
       } catch {
         // ignore
       }
-    } else if (tool === "gemini-cli") {
+    } else if (!finalSessionId && tool === "gemini-cli") {
       try {
         const latestGemini = await findLatestGeminiSession(worktreePath, {
           since: launchStartedAt - 60_000,
@@ -867,7 +876,52 @@ export async function main(): Promise<void> {
     process.exit(1);
   }
 
-  await runInteractiveLoop();
+  // Start Web UI server in background (skip if port is in use)
+  const port = resolveWebUiPort();
+  const portInUse = await isPortInUse(port);
+  let webServerHandlePromise: Promise<{
+    close: () => Promise<void>;
+  } | null> | null = null;
+  if (portInUse) {
+    printWarning(`Port ${port} is already in use. Skipping Web UI server.`);
+  } else {
+    const { startWebServer } = await import("./web/server/index.js");
+    webServerHandlePromise = startWebServer({ background: true }).catch(
+      (err) => {
+        appLogger.warn({ err }, "Web UI server failed to start");
+        return null;
+      },
+    );
+    printInfo(`Web UI available at http://localhost:${port}`);
+  }
+
+  try {
+    await runInteractiveLoop();
+  } finally {
+    if (webServerHandlePromise) {
+      const shutdownTimeoutMs = 2000;
+      const handleOrTimeout = await Promise.race([
+        webServerHandlePromise,
+        new Promise<"timeout">((resolve) => {
+          const timer = setTimeout(() => resolve("timeout"), shutdownTimeoutMs);
+          timer.unref?.();
+        }),
+      ]);
+
+      if (handleOrTimeout === "timeout") {
+        appLogger.warn(
+          { timeoutMs: shutdownTimeoutMs },
+          "Web UI server startup did not finish before shutdown timeout; skipping stop",
+        );
+      } else if (handleOrTimeout) {
+        try {
+          await handleOrTimeout.close();
+        } catch (err) {
+          appLogger.warn({ err }, "Web UI server failed to stop");
+        }
+      }
+    }
+  }
 }
 
 // Run the application if this module is executed directly

package/src/logging/logger.ts

@@ -0,0 +1,82 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import pino, { type LoggerOptions, type Logger } from "pino";
+import { pruneOldLogs } from "./rotation.js";
+
+type Category = "cli" | "server" | "worker" | string;
+
+export interface LoggerConfig {
+  level?: string;
+  logDir?: string;
+  filename?: string;
+  category?: Category;
+  base?: Record<string, unknown>;
+  keepDays?: number;
+  /** For tests or sync writes use pino.destination sync */
+  sync?: boolean;
+}
+
+/**
+ * Create a pino logger with unified structure and category field.
+ * - Writes to a single file stream (no per-component files)
+ * - Adds `category` to each log record
+ * - Prunes files older than keepDays at startup
+ */
+export function createLogger(config: LoggerConfig = {}): Logger {
+  const level = config.level ?? process.env.LOG_LEVEL ?? "info";
+  const cwdBase = path.basename(process.cwd()) || "workspace";
+  const defaultLogDir = path.join(os.homedir(), ".gwt", "logs", cwdBase);
+  const logDir = config.logDir ?? defaultLogDir;
+  const filename = config.filename ?? `${formatDate(new Date())}.jsonl`;
+  const category = config.category ?? "default";
+  const keepDays = config.keepDays ?? 7;
+
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+
+  // Startup rotation
+  pruneOldLogs(logDir, keepDays);
+
+  const destination = path.join(logDir, filename);
+
+  const options: LoggerOptions = {
+    level,
+    base: {
+      category,
+      ...(config.base ?? {}),
+    },
+    timestamp: pino.stdTimeFunctions.isoTime,
+  };
+
+  if (config.sync) {
+    const destinationStream = pino.destination({
+      dest: destination,
+      sync: true,
+    });
+    return pino(options, destinationStream);
+  }
+
+  const transport = pino.transport({
+    targets: [
+      {
+        target: "pino/file",
+        options: { destination, mkdir: true, append: true },
+        level,
+      },
+    ],
+  });
+
+  return pino(options, transport);
+}
+
+/** Convenience logger for quick use (category defaults to "default"). */
+export const logger = createLogger();
+
+export function formatDate(date: Date): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}

package/src/logging/rotation.ts

@@ -0,0 +1,25 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * Delete log files older than `keepDays` from the given directory.
+ * This is called at startup to enforce 7-day retention without size limits.
+ */
+export function pruneOldLogs(logDir: string, keepDays = 7): void {
+  if (!fs.existsSync(logDir)) return;
+
+  const cutoff = Date.now() - keepDays * 24 * 60 * 60 * 1000;
+
+  for (const entry of fs.readdirSync(logDir)) {
+    const full = path.join(logDir, entry);
+    try {
+      const stat = fs.statSync(full);
+      if (!stat.isFile()) continue;
+      if (stat.mtime.getTime() < cutoff) {
+        fs.unlinkSync(full);
+      }
+    } catch {
+      // Ignore individual file errors to avoid breaking startup
+    }
+  }
+}