@akiojin/gwt 4.10.0 → 4.11.6

package/src/utils/npmRegistry.ts

@@ -0,0 +1,249 @@
+/**
+ * npm Registry API utilities for fetching package versions
+ */
+
+export interface VersionInfo {
+  version: string;
+  isPrerelease: boolean;
+  publishedAt?: string;
+}
+
+export type VersionSelection = "installed" | "latest" | string;
+
+interface NpmRegistryResponse {
+  "dist-tags"?: Record<string, string>;
+  time?: Record<string, string>;
+  versions?: Record<string, unknown>;
+}
+
+const DEFAULT_TIMEOUT_MS = 3000;
+const DEFAULT_LIMIT = 10;
+
+/**
+ * Check if a version string is a prerelease version
+ */
+function isPrerelease(version: string): boolean {
+  // Prerelease versions contain - followed by alpha, beta, rc, canary, next, etc.
+  return /-(alpha|beta|rc|canary|next|dev|pre)\b/i.test(version);
+}
+
+/**
+ * Fetch package versions from npm registry
+ * Returns the latest N versions sorted by publish date (newest first)
+ */
+export async function fetchPackageVersions(
+  packageName: string,
+  limit: number = DEFAULT_LIMIT,
+  timeoutMs: number = DEFAULT_TIMEOUT_MS,
+): Promise<VersionInfo[]> {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+    const response = await fetch(
+      `https://registry.npmjs.org/${encodeURIComponent(packageName)}`,
+      {
+        signal: controller.signal,
+        headers: {
+          Accept: "application/json",
+        },
+      },
+    );
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      return [];
+    }
+
+    const data = (await response.json()) as NpmRegistryResponse;
+
+    if (!data.versions || !data.time) {
+      return [];
+    }
+
+    // Get all versions with their publish times
+    const versionsWithTime: Array<{
+      version: string;
+      publishedAt: string;
+    }> = [];
+
+    for (const version of Object.keys(data.versions)) {
+      const publishedAt = data.time[version];
+      if (publishedAt) {
+        versionsWithTime.push({ version, publishedAt });
+      }
+    }
+
+    // Sort by publish date (newest first)
+    versionsWithTime.sort((a, b) => {
+      const dateA = new Date(a.publishedAt).getTime();
+      const dateB = new Date(b.publishedAt).getTime();
+      return dateB - dateA;
+    });
+
+    // Take the top N versions
+    const topVersions = versionsWithTime.slice(0, limit);
+
+    // Convert to VersionInfo
+    return topVersions.map((v) => ({
+      version: v.version,
+      isPrerelease: isPrerelease(v.version),
+      publishedAt: v.publishedAt,
+    }));
+  } catch {
+    // Return empty array on any error (network, timeout, parse error, etc.)
+    return [];
+  }
+}
+
+/**
+ * Parse a package command to extract package name and version
+ * Examples:
+ *   "@anthropic-ai/claude-code" -> { packageName: "@anthropic-ai/claude-code", version: null }
+ *   "@anthropic-ai/claude-code@latest" -> { packageName: "@anthropic-ai/claude-code", version: "latest" }
+ *   "@anthropic-ai/claude-code@1.0.3" -> { packageName: "@anthropic-ai/claude-code", version: "1.0.3" }
+ *   "opencode-ai@latest" -> { packageName: "opencode-ai", version: "latest" }
+ */
+export function parsePackageCommand(command: string): {
+  packageName: string;
+  version: string | null;
+} {
+  // Handle scoped packages (@scope/name@version)
+  if (command.startsWith("@")) {
+    // Find the second @ which separates version
+    const firstSlash = command.indexOf("/");
+    if (firstSlash === -1) {
+      // Invalid scoped package format
+      return { packageName: command, version: null };
+    }
+    const afterScope = command.substring(firstSlash + 1);
+    const atIndex = afterScope.indexOf("@");
+    if (atIndex === -1) {
+      return { packageName: command, version: null };
+    }
+    const packageName = command.substring(0, firstSlash + 1 + atIndex);
+    const version = afterScope.substring(atIndex + 1);
+    return { packageName, version };
+  }
+
+  // Handle non-scoped packages (name@version)
+  const atIndex = command.indexOf("@");
+  if (atIndex === -1) {
+    return { packageName: command, version: null };
+  }
+  const packageName = command.substring(0, atIndex);
+  const version = command.substring(atIndex + 1);
+  return { packageName, version };
+}
+
+/**
+ * Resolve version selection to a bunx-compatible suffix
+ * Examples:
+ *   "installed" -> "" (use bunx default/cached version)
+ *   "latest" -> "@latest"
+ *   "1.0.3" -> "@1.0.3"
+ *   undefined -> "" (use bunx default/cached version)
+ */
+export function resolveVersionSuffix(version?: VersionSelection): string {
+  if (!version || version === "installed") {
+    return "";
+  }
+  return `@${version}`;
+}
+
+export interface GlobalPackageInfo {
+  name: string;
+  version: string;
+}
+
+export interface GlobalPackagesResult {
+  path: string | null;
+  packages: GlobalPackageInfo[];
+}
+
+/**
+ * Parse the output of `bun pm ls -g` command
+ * Example output:
+ *   /root/.bun/install/global node_modules (17)
+ *   ├── @anthropic-ai/claude-code@2.0.76
+ *   └── @openai/codex@0.77.0
+ */
+export function parseGlobalPackagesOutput(
+  output: string,
+): GlobalPackagesResult {
+  const lines = output.trim().split("\n");
+  if (lines.length === 0 || !lines[0]) {
+    return { path: null, packages: [] };
+  }
+
+  // Parse the first line to get the path
+  // Format: "/path/to/global node_modules (N)"
+  const firstLine = lines[0];
+  const pathMatch = firstLine.match(/^(.+?)\s+node_modules\s+\(\d+\)$/);
+  const path = pathMatch?.[1] ?? null;
+
+  // Parse package lines
+  const packages: GlobalPackageInfo[] = [];
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+
+    // Remove tree characters (├── └── │)
+    const cleaned = line.replace(/^[├└│─\s]+/, "").trim();
+    if (!cleaned) continue;
+
+    // Parse package@version format
+    // Handle scoped packages like @anthropic-ai/claude-code@2.0.76
+    const lastAtIndex = cleaned.lastIndexOf("@");
+    if (lastAtIndex <= 0) continue; // No version or invalid format
+
+    const name = cleaned.substring(0, lastAtIndex);
+    const version = cleaned.substring(lastAtIndex + 1);
+
+    if (name && version) {
+      packages.push({ name, version });
+    }
+  }
+
+  return { path, packages };
+}
+
+export interface InstalledPackageInfo {
+  version: string;
+  path: string;
+}
+
+/**
+ * Get information about a globally installed package
+ * Returns null if the package is not installed
+ */
+export async function getInstalledPackageInfo(
+  packageName: string,
+): Promise<InstalledPackageInfo | null> {
+  try {
+    const { execa } = await import("execa");
+    const result = await execa("bun", ["pm", "ls", "-g"], {
+      timeout: 5000,
+      reject: false,
+    });
+
+    if (result.exitCode !== 0 || !result.stdout) {
+      return null;
+    }
+
+    const parsed = parseGlobalPackagesOutput(result.stdout);
+    const pkg = parsed.packages.find((p) => p.name === packageName);
+
+    if (!pkg || !parsed.path) {
+      return null;
+    }
+
+    return {
+      version: pkg.version,
+      path: `${parsed.path}/node_modules/${packageName}`,
+    };
+  } catch {
+    return null;
+  }
+}

package/src/utils/prompt.ts

@@ -95,7 +95,7 @@ async function runReadlinePrompt<T>(
 }
 
 /**
- * Wait for Enter using the same terminal streams as Ink.
+ * Wait for Enter using the same terminal streams as the CLI UI.
  * Falls back to no-op on non-interactive stdin to avoid blocking pipelines.
  */
 export async function waitForEnter(promptMessage: string): Promise<void> {

package/src/utils/session/parsers/codex.ts

@@ -63,6 +63,8 @@ export async function findLatestCodexSession(
     return b.mtime - a.mtime;
   });
 
+  let fallbackMissingCwd: CodexSessionInfo | null = null;
+
   for (const file of ordered) {
     // Priority 1: Extract session ID from filename (most reliable for Codex)
     const filenameMatch = path.basename(file.fullPath).match(UUID_REGEX);
@@ -74,6 +76,9 @@ export async function findLatestCodexSession(
         if (matchesCwd(info.cwd, options.cwd)) {
           return { id: sessionId, mtime: file.mtime };
         }
+        if (!info.cwd && !fallbackMissingCwd) {
+          fallbackMissingCwd = { id: sessionId, mtime: file.mtime };
+        }
         continue; // cwd doesn't match, try next file
       }
       return { id: sessionId, mtime: file.mtime };
@@ -86,12 +91,15 @@ export async function findLatestCodexSession(
       if (matchesCwd(info.cwd, options.cwd)) {
         return { id: info.id, mtime: file.mtime };
       }
+      if (!info.cwd && !fallbackMissingCwd) {
+        fallbackMissingCwd = { id: info.id, mtime: file.mtime };
+      }
       continue;
     }
     return { id: info.id, mtime: file.mtime };
   }
 
-  return null;
+  return fallbackMissingCwd;
 }
 
 /**

package/src/utils/terminal.ts

@@ -214,6 +214,30 @@ export function resetTerminalModes(
   }
 }
 
+export function writeTerminalLine(
+  message: string,
+  stream: "stdout" | "stderr" = "stdout",
+): void {
+  const terminal = getTerminalStreams();
+  const target = stream === "stderr" ? terminal.stderr : terminal.stdout;
+  const payload = message.endsWith("\n") ? message : `${message}\n`;
+
+  if (target && typeof target.write === "function") {
+    try {
+      target.write(payload);
+      return;
+    } catch {
+      // Ignore write errors and fall back to console.
+    }
+  }
+
+  if (stream === "stderr") {
+    console.error(message);
+  } else {
+    console.log(message);
+  }
+}
+
 /**
  * Creates stdio settings for launching a child process.
  *

package/src/utils.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { describe, it, expect } from "bun:test";
 import { getPackageVersion } from "./utils";
 import { readFile } from "fs/promises";
 import path from "node:path";

package/src/utils.ts

@@ -1,7 +1,6 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { access, readFile } from "fs/promises";
-import { existsSync } from "fs";
+import { readFile } from "fs/promises";
 export function getCurrentDirname(): string {
   return path.dirname(fileURLToPath(import.meta.url));
 }
@@ -16,17 +15,51 @@ export class AppError extends Error {
   }
 }
 
+/**
+ * Global cleanup callback for terminal restoration.
+ * This is called before exit to restore terminal state.
+ */
+let cleanupCallback: (() => void) | null = null;
+
+/**
+ * Registers a cleanup callback to be called on exit.
+ * Used for terminal state restoration.
+ */
+export function registerExitCleanup(callback: () => void): void {
+  cleanupCallback = callback;
+}
+
+/**
+ * Clears the registered cleanup callback.
+ */
+export function clearExitCleanup(): void {
+  cleanupCallback = null;
+}
+
+/**
+ * Performs cleanup and exits the process.
+ * Ensures terminal is restored before exiting.
+ */
+function performCleanupAndExit(exitCode: number): void {
+  try {
+    cleanupCallback?.();
+  } catch {
+    // Ignore cleanup errors to ensure exit completes
+  }
+  process.exit(exitCode);
+}
+
 export function setupExitHandlers(): void {
   // Handle Ctrl+C gracefully
   process.on("SIGINT", () => {
     console.log("\n\n👋 Goodbye!");
-    process.exit(0);
+    performCleanupAndExit(0);
   });
 
   // Handle other termination signals
   process.on("SIGTERM", () => {
     console.log("\n\n👋 Goodbye!");
-    process.exit(0);
+    performCleanupAndExit(0);
   });
 }
 

package/src/web/client/src/components/CodingAgentLaunchModal.tsx

@@ -21,6 +21,7 @@ import { useStartSession } from "../hooks/useSessions";
 import { useCreateWorktree } from "../hooks/useWorktrees";
 import { useSyncBranch } from "../hooks/useBranches";
 import { ApiError } from "../lib/api";
+import { getAgentTailwindClass } from "@/lib/coding-agent-colors";
 
 const BUILTIN_AGENT_SUMMARIES: Record<string, AgentSummary> = {
   "claude-code": {
@@ -166,7 +167,7 @@ export function CodingAgentLaunchModal({
     branch.name.replace(/^origin\//, ""),
   );
   const divergenceInfo = branch.divergence ?? null;
-  const hasBlockingDivergence = Boolean(
+  const hasConflictingDivergence = Boolean(
     divergenceInfo && divergenceInfo.ahead > 0 && divergenceInfo.behind > 0,
   );
   const needsRemoteSync = Boolean(
@@ -174,7 +175,7 @@ export function CodingAgentLaunchModal({
     divergenceInfo &&
     divergenceInfo.behind > 0 &&
     divergenceInfo.ahead === 0 &&
-    !hasBlockingDivergence,
+    !hasConflictingDivergence,
   );
 
   useEffect(() => {
@@ -270,15 +271,6 @@ export function CodingAgentLaunchModal({
       });
       return;
     }
-    if (hasBlockingDivergence) {
-      setBanner({
-        type: "error",
-        message:
-          "Both remote and local have diverged. Resolve differences before launching.",
-      });
-      return;
-    }
-
     if (
       skipPermissions &&
       !window.confirm("Skip permission checks? This is risky.")
@@ -408,11 +400,11 @@ export function CodingAgentLaunchModal({
             </Alert>
           )}
 
-          {hasBlockingDivergence && (
+          {hasConflictingDivergence && (
             <Alert variant="warning">
               <AlertDescription>
-                Both remote and local have unresolved differences. Rebase/merge
-                before launching.
+                Both remote and local have unresolved differences. You can
+                launch, but resolving differences is recommended.
               </AlertDescription>
             </Alert>
           )}
@@ -430,7 +422,11 @@ export function CodingAgentLaunchModal({
                 </SelectTrigger>
                 <SelectContent>
                   {availableAgents.map((agent) => (
-                    <SelectItem key={agent.id} value={agent.id}>
+                    <SelectItem
+                      key={agent.id}
+                      value={agent.id}
+                      className={getAgentTailwindClass(agent.id)}
+                    >
                       {agent.label}
                     </SelectItem>
                   ))}
@@ -479,12 +475,7 @@ export function CodingAgentLaunchModal({
           <div className="flex flex-wrap gap-2">
             <Button
               onClick={handleStartSession}
-              disabled={
-                isStartingSession ||
-                !selectedAgent ||
-                hasBlockingDivergence ||
-                needsRemoteSync
-              }
+              disabled={isStartingSession || !selectedAgent || needsRemoteSync}
             >
               {isStartingSession ? "Launching..." : "Launch coding agent"}
             </Button>

package/src/web/client/src/components/branch-detail/BranchInfoCards.tsx

@@ -2,6 +2,10 @@ import React from "react";
 import { Card, CardHeader, CardContent } from "@/components/ui/card";
 import { Badge } from "@/components/ui/badge";
 import type { Branch, LastToolUsage } from "../../../../../types/api.js";
+import {
+  getAgentTailwindClass,
+  getAgentBgTailwindClass,
+} from "@/lib/coding-agent-colors";
 
 interface BranchInfoCardsProps {
   branch: Branch;
@@ -158,7 +162,10 @@ export function BranchInfoCards({
           </CardHeader>
           <CardContent>
             <div className="flex flex-wrap items-center gap-2 text-sm">
-              <Badge variant="outline">
+              <Badge
+                variant="outline"
+                className={`${getAgentTailwindClass(latestToolUsage.toolId)} ${getAgentBgTailwindClass(latestToolUsage.toolId)}`}
+              >
                 {renderToolUsage(latestToolUsage)}
               </Badge>
               <span className="text-muted-foreground">
@@ -169,6 +176,14 @@ export function BranchInfoCards({
                   @ {latestToolUsage.worktreePath}
                 </span>
               )}
+              {latestToolUsage.sessionId && (
+                <span className="text-xs text-muted-foreground">
+                  Session ID:{" "}
+                  <code className="rounded bg-muted px-1.5 py-0.5 font-mono">
+                    {latestToolUsage.sessionId}
+                  </code>
+                </span>
+              )}
             </div>
           </CardContent>
         </Card>

package/src/web/client/src/components/branch-detail/SessionHistoryTable.tsx

@@ -10,6 +10,10 @@ import {
   TableHead,
   TableCell,
 } from "@/components/ui/table";
+import {
+  getAgentTailwindClass,
+  normalizeAgentToToolId,
+} from "@/lib/coding-agent-colors";
 
 interface SessionInfo {
   sessionId: string;
@@ -131,7 +135,9 @@ export function SessionHistoryTable({
                         {SESSION_STATUS_LABEL[session.status]}
                       </Badge>
                     </TableCell>
-                    <TableCell className="font-medium">
+                    <TableCell
+                      className={`font-medium ${getAgentTailwindClass(normalizeAgentToToolId(session.agentType))}`}
+                    >
                       {agentLabel(session.agentType, session.agentName)}
                     </TableCell>
                     <TableCell>

package/src/web/client/src/components/branch-detail/ToolLauncher.tsx

@@ -13,6 +13,7 @@ import {
   SelectValue,
 } from "@/components/ui/select";
 import { cn } from "@/lib/utils";
+import { getAgentTailwindClass } from "@/lib/coding-agent-colors";
 import type { ApiCodingAgent, Branch } from "../../../../../types/api.js";
 
 type ToolMode = "normal" | "continue" | "resume";
@@ -45,7 +46,7 @@ interface ToolLauncherProps {
   isStartingSession: boolean;
   isSyncingBranch: boolean;
   needsRemoteSync: boolean;
-  hasBlockingDivergence: boolean;
+  hasConflictingDivergence: boolean;
   onToolChange: (toolId: string) => void;
   onModeChange: (mode: ToolMode) => void;
   onSkipPermissionsChange: (skip: boolean) => void;
@@ -88,7 +89,7 @@ export function ToolLauncher({
   isStartingSession,
   isSyncingBranch,
   needsRemoteSync,
-  hasBlockingDivergence,
+  hasConflictingDivergence,
   onToolChange,
   onModeChange,
   onSkipPermissionsChange,
@@ -170,7 +171,11 @@ export function ToolLauncher({
                   </SelectTrigger>
                   <SelectContent>
                     {availableTools.map((tool) => (
-                      <SelectItem key={tool.id} value={tool.id}>
+                      <SelectItem
+                        key={tool.id}
+                        value={tool.id}
+                        className={getAgentTailwindClass(tool.id)}
+                      >
                         {tool.label}
                       </SelectItem>
                     ))}
@@ -243,11 +248,12 @@ export function ToolLauncher({
               </Alert>
             )}
 
-            {hasBlockingDivergence && (
+            {hasConflictingDivergence && (
               <Alert variant="warning" data-testid="divergence-warning">
                 <AlertDescription>
                   <p>
-                    リモートとローカルの両方に未解決の差分があるため、起動をブロックしています。
+                    リモートとローカルの両方に未解決の差分があります。起動は可能ですが、
+                    衝突を避けるために差分の解消を推奨します。
                   </p>
                   <ul className="mt-2 list-inside list-disc text-xs text-muted-foreground">
                     <li>
@@ -266,7 +272,6 @@ export function ToolLauncher({
                 disabled={
                   isStartingSession ||
                   !selectedTool ||
-                  hasBlockingDivergence ||
                   needsRemoteSync ||
                   isSyncingBranch
                 }