@akiojin/gwt 2.11.1 → 2.12.1

package/src/qwen.ts

@@ -2,6 +2,7 @@ import { execa } from "execa";
 import chalk from "chalk";
 import { existsSync } from "fs";
 import { createChildStdio, getTerminalStreams } from "./utils/terminal.js";
+import { findLatestQwenSessionId } from "./utils/session.js";
 
 const QWEN_CLI_PACKAGE = "@qwen-code/qwen-code@latest";
 
@@ -23,8 +24,9 @@ export async function launchQwenCLI(
     extraArgs?: string[];
     envOverrides?: Record<string, string>;
     model?: string;
+    sessionId?: string | null;
   } = {},
-): Promise<void> {
+): Promise<{ sessionId?: string | null }> {
   const terminal = getTerminalStreams();
 
   try {
@@ -46,18 +48,26 @@ export async function launchQwenCLI(
     // Handle execution mode
     // Note: Qwen CLI doesn't have explicit continue/resume CLI options at startup.
     // Session management is done via /chat commands during interactive sessions.
+    const resumeSessionId =
+      options.sessionId && options.sessionId.trim().length > 0
+        ? options.sessionId.trim()
+        : null;
     switch (options.mode) {
       case "continue":
         console.log(
           chalk.cyan(
-            "   ⏭️  Starting session (use /chat resume in the CLI to continue)",
+            resumeSessionId
+              ? `   ⏭️  Starting session (then /chat resume ${resumeSessionId})`
+              : "   ⏭️  Starting session (use /chat resume in the CLI to continue)",
           ),
         );
         break;
       case "resume":
         console.log(
           chalk.cyan(
-            "   🔄 Starting session (use /chat resume in the CLI to continue)",
+            resumeSessionId
+              ? `   🔄 Starting session (then /chat resume ${resumeSessionId})`
+              : "   🔄 Starting session (use /chat resume in the CLI to continue)",
           ),
         );
         break;
@@ -80,6 +90,8 @@ export async function launchQwenCLI(
       args.push(...options.extraArgs);
     }
 
+    console.log(chalk.gray(`   📋 Args: ${args.join(" ")}`));
+
     terminal.exitRawMode();
 
     const baseEnv = {
@@ -93,10 +105,22 @@ export async function launchQwenCLI(
     const hasLocalQwen = await isQwenCommandAvailable();
 
     try {
+      const execChild = async (child: any) => {
+        try {
+          await child;
+        } catch (execError: any) {
+          // Treat SIGINT/SIGTERM as normal exit (user pressed Ctrl+C)
+          if (execError.signal === "SIGINT" || execError.signal === "SIGTERM") {
+            return;
+          }
+          throw execError;
+        }
+      };
+
       if (hasLocalQwen) {
         // Use locally installed qwen command
         console.log(chalk.green("   ✨ Using locally installed qwen command"));
-        await execa("qwen", args, {
+        const child = execa("qwen", args, {
           cwd: worktreePath,
           shell: true,
           stdin: childStdio.stdin,
@@ -104,6 +128,7 @@ export async function launchQwenCLI(
           stderr: childStdio.stderr,
           env: baseEnv,
         } as any);
+        await execChild(child);
       } else {
         // Fallback to bunx
         console.log(
@@ -118,7 +143,7 @@ export async function launchQwenCLI(
         console.log("");
         // Wait 2 seconds to let user read the message
         await new Promise((resolve) => setTimeout(resolve, 2000));
-        await execa("bunx", [QWEN_CLI_PACKAGE, ...args], {
+        const child = execa("bunx", [QWEN_CLI_PACKAGE, ...args], {
           cwd: worktreePath,
           shell: true,
           stdin: childStdio.stdin,
@@ -126,10 +151,36 @@ export async function launchQwenCLI(
           stderr: childStdio.stderr,
           env: baseEnv,
         } as any);
+        await execChild(child);
       }
     } finally {
       childStdio.cleanup();
     }
+
+    let capturedSessionId: string | null = null;
+    try {
+      capturedSessionId =
+        (await findLatestQwenSessionId(worktreePath)) ??
+        resumeSessionId ??
+        null;
+    } catch {
+      capturedSessionId = resumeSessionId ?? null;
+    }
+
+    if (capturedSessionId) {
+      console.log(chalk.cyan(`\n   🆔 Session tag: ${capturedSessionId}`));
+      console.log(
+        chalk.gray(`   Resume in Qwen CLI: /chat resume ${capturedSessionId}`),
+      );
+    } else {
+      console.log(
+        chalk.yellow(
+          "\n   ℹ️  Could not determine Qwen session tag automatically.",
+        ),
+      );
+    }
+
+    return capturedSessionId ? { sessionId: capturedSessionId } : {};
   } catch (error: any) {
     const hasLocalQwen = await isQwenCommandAvailable();
     let errorMessage: string;

package/src/utils/__tests__/prompt.test.ts

@@ -0,0 +1,89 @@
+import { PassThrough } from "node:stream";
+import { describe, expect, it, vi } from "vitest";
+
+// Shared mock target to avoid hoisting issues
+const terminalStreams: Record<string, unknown> = {};
+
+vi.mock("../terminal.js", () => ({
+  getTerminalStreams: () => terminalStreams,
+}));
+
+const withTimeout = <T>(promise: Promise<T>, ms = 500): Promise<T> =>
+  Promise.race([
+    promise,
+    new Promise<T>((_, reject) =>
+      setTimeout(() => reject(new Error("timeout")), ms),
+    ),
+  ]);
+
+describe("waitForEnter", () => {
+  it("uses terminal stdin/stdout and resolves after newline on TTY", async () => {
+    vi.resetModules();
+    for (const key of Object.keys(terminalStreams)) {
+      delete terminalStreams[key];
+    }
+
+    const stdin = new PassThrough() as unknown as NodeJS.ReadStream;
+    const stdout = new PassThrough() as unknown as NodeJS.WriteStream;
+    Object.defineProperty(stdin, "isTTY", { value: true });
+
+    let resumed = false;
+    let paused = false;
+    const originalResume = stdin.resume.bind(stdin);
+    const originalPause = stdin.pause.bind(stdin);
+    // Track resume/pause calls
+    stdin.resume = (() => {
+      resumed = true;
+      return originalResume();
+    }) as typeof stdin.resume;
+    stdin.pause = (() => {
+      paused = true;
+      return originalPause();
+    }) as typeof stdin.pause;
+
+    const exitRawMode = vi.fn();
+
+    Object.assign(terminalStreams, {
+      stdin,
+      stdout,
+      stderr: stdout,
+      usingFallback: false,
+      exitRawMode,
+    });
+
+    const { waitForEnter } = await import("../prompt.js");
+
+    const waiting = withTimeout(waitForEnter("prompt"), 200);
+    stdin.write("hello\n");
+
+    await expect(waiting).resolves.toBeUndefined();
+    expect(resumed).toBe(true);
+    expect(paused).toBe(true);
+    expect(exitRawMode).toHaveBeenCalled();
+  });
+
+  it("returns immediately on non-TTY stdin", async () => {
+    vi.resetModules();
+    for (const key of Object.keys(terminalStreams)) {
+      delete terminalStreams[key];
+    }
+
+    const stdin = new PassThrough() as unknown as NodeJS.ReadStream;
+    const stdout = new PassThrough() as unknown as NodeJS.WriteStream;
+    Object.defineProperty(stdin, "isTTY", { value: false });
+
+    Object.assign(terminalStreams, {
+      stdin,
+      stdout,
+      stderr: stdout,
+      usingFallback: false,
+      exitRawMode: vi.fn(),
+    });
+
+    const { waitForEnter } = await import("../prompt.js");
+
+    const start = Date.now();
+    await waitForEnter("prompt");
+    expect(Date.now() - start).toBeLessThan(50);
+  });
+});

package/src/utils/prompt.ts

@@ -0,0 +1,74 @@
+import readline from "node:readline";
+import { getTerminalStreams } from "./terminal.js";
+
+/**
+ * Wait for Enter using the same terminal streams as Ink.
+ * Falls back to no-op on non-interactive stdin to avoid blocking pipelines.
+ */
+export async function waitForEnter(promptMessage: string): Promise<void> {
+  const terminal = getTerminalStreams();
+  const stdin = terminal.stdin as NodeJS.ReadStream | undefined;
+  const stdout = terminal.stdout as NodeJS.WriteStream | undefined;
+
+  if (!stdin || typeof stdin.on !== "function" || !stdin.isTTY) {
+    return;
+  }
+
+  terminal.exitRawMode?.();
+
+  if (typeof stdin.resume === "function") {
+    stdin.resume();
+  }
+
+  if ((stdin as NodeJS.ReadStream & { isRaw?: boolean }).isRaw) {
+    try {
+      (stdin as NodeJS.ReadStream & { setRawMode?: (flag: boolean) => void }).setRawMode?.(false);
+    } catch {
+      // Ignore raw mode errors
+    }
+  }
+
+  await new Promise<void>((resolve) => {
+    const rl = readline.createInterface({ input: stdin, output: stdout });
+
+    const cleanup = () => {
+      rl.removeAllListeners();
+      rl.close();
+      const remover = (method: "off" | "removeListener") =>
+        (stdin as unknown as Record<string, (event: string, fn: () => void) => void>)[method]?.(
+          "end",
+          onEnd,
+        );
+      remover("off");
+      remover("removeListener");
+      const removerErr = (method: "off" | "removeListener") =>
+        (stdin as unknown as Record<string, (event: string, fn: () => void) => void>)[method]?.(
+          "error",
+          onEnd,
+        );
+      removerErr("off");
+      removerErr("removeListener");
+      if (typeof stdin.pause === "function") {
+        stdin.pause();
+      }
+    };
+
+    const onEnd = () => {
+      cleanup();
+      resolve();
+    };
+
+    rl.on("SIGINT", () => {
+      cleanup();
+      process.exit(0);
+    });
+
+    rl.question(`${promptMessage}\n`, () => {
+      cleanup();
+      resolve();
+    });
+
+    stdin.once("end", onEnd);
+    stdin.once("error", onEnd);
+  });
+}