@akiojin/gwt 4.9.1 → 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/index.ts

@@ -1,10 +1,11 @@
 /**
- * Session module - unified session management for AI tools
+ * Session module - unified session management for coding agents
  *
- * This module provides session detection and management for various AI CLI tools:
+ * This module provides session detection and management for various coding agents:
  * - Claude Code
  * - Codex CLI
  * - Gemini CLI
+ * - OpenCode
  */
 
 // Type exports
@@ -14,6 +15,7 @@ export type {
   ClaudeSessionInfo,
   CodexSessionInfo,
   GeminiSessionInfo,
+  OpenCodeSessionInfo,
 } from "./types.js";
 
 // Common utilities
@@ -40,3 +42,9 @@ export {
   findLatestGeminiSession,
   findLatestGeminiSessionId,
 } from "./parsers/gemini.js";
+
+// OpenCode parser
+export {
+  findLatestOpenCodeSession,
+  findLatestOpenCodeSessionId,
+} from "./parsers/opencode.js";

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/session/parsers/index.ts

@@ -23,3 +23,9 @@ export {
   findLatestGeminiSession,
   findLatestGeminiSessionId,
 } from "./gemini.js";
+
+// OpenCode
+export {
+  findLatestOpenCodeSession,
+  findLatestOpenCodeSessionId,
+} from "./opencode.js";

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

@@ -0,0 +1,110 @@
+/**
+ * OpenCode session parser
+ *
+ * Handles session detection for OpenCode.
+ * Session files are stored in ~/.local/share/opencode/storage/session/[projectID]/[sessionID].json
+ * Session JSON contains: id, projectID, directory (cwd), title, created, updated, etc.
+ */
+
+import path from "node:path";
+import { homedir } from "node:os";
+
+import type { OpenCodeSessionInfo, SessionSearchOptions } from "../types.js";
+import {
+  collectFilesIterative,
+  matchesCwd,
+  readSessionInfoFromFile,
+} from "../common.js";
+
+/**
+ * Returns the OpenCode session directory
+ * OpenCode stores sessions in: ~/.local/share/opencode/storage/session/[projectID]/[sessionID].json
+ */
+function getOpenCodeSessionDir(): string {
+  return path.join(
+    homedir(),
+    ".local",
+    "share",
+    "opencode",
+    "storage",
+    "session",
+  );
+}
+
+/**
+ * Finds the latest OpenCode session with optional time filtering and cwd matching.
+ *
+ * @param options - Search options including time filters and cwd matching
+ * @returns Session info with ID and modification time, or null if not found
+ */
+export async function findLatestOpenCodeSession(
+  options: SessionSearchOptions = {},
+): Promise<OpenCodeSessionInfo | null> {
+  // OpenCode stores sessions under ~/.local/share/opencode/storage/session/[projectID]/
+  const baseDir = getOpenCodeSessionDir();
+  const files = await collectFilesIterative(
+    baseDir,
+    (name) => name.endsWith(".json") || name.endsWith(".jsonl"),
+  );
+  if (!files.length) return null;
+
+  // Apply time filters
+  let pool = files;
+  const sinceVal = options.since;
+  if (sinceVal !== undefined) {
+    pool = pool.filter((f) => f.mtime >= sinceVal);
+  }
+  const untilVal = options.until;
+  if (untilVal !== undefined) {
+    pool = pool.filter((f) => f.mtime <= untilVal);
+  }
+  if (!pool.length) return null;
+
+  // Sort by preference or mtime
+  const ref = options.preferClosestTo;
+  const window = options.windowMs ?? 30 * 60 * 1000;
+  pool = pool.slice().sort((a, b) => {
+    if (typeof ref === "number") {
+      const da = Math.abs(a.mtime - ref);
+      const db = Math.abs(b.mtime - ref);
+      if (da === db) return b.mtime - a.mtime;
+      if (da <= window || db <= window) return da - db;
+    }
+    return b.mtime - a.mtime;
+  });
+
+  for (const file of pool) {
+    const info = await readSessionInfoFromFile(file.fullPath);
+    if (!info.id) continue;
+    if (options.cwd) {
+      if (matchesCwd(info.cwd, options.cwd)) {
+        return { id: info.id, mtime: file.mtime };
+      }
+      continue;
+    }
+    return { id: info.id, mtime: file.mtime };
+  }
+
+  return null;
+}
+
+/**
+ * Finds the latest OpenCode session ID.
+ * @param cwd - The working directory to find sessions for (used as fallback if options.cwd not set)
+ * @param options - Search options including time filters and cwd matching
+ * @returns Session ID string or null if not found
+ */
+export async function findLatestOpenCodeSessionId(
+  cwd: string,
+  options: SessionSearchOptions = {},
+): Promise<string | null> {
+  const searchOptions: SessionSearchOptions = { cwd: options.cwd ?? cwd };
+  if (options.since !== undefined) searchOptions.since = options.since;
+  if (options.until !== undefined) searchOptions.until = options.until;
+  if (options.preferClosestTo !== undefined)
+    searchOptions.preferClosestTo = options.preferClosestTo;
+  if (options.windowMs !== undefined) searchOptions.windowMs = options.windowMs;
+
+  const found = await findLatestOpenCodeSession(searchOptions);
+  return found?.id ?? null;
+}

package/src/utils/session/types.ts

@@ -40,3 +40,8 @@ export type CodexSessionInfo = SessionInfo;
  * Gemini CLI session info
  */
 export type GeminiSessionInfo = SessionInfo;
+
+/**
+ * OpenCode session info
+ */
+export type OpenCodeSessionInfo = SessionInfo;

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>