@tongil_kim/clautunnel 1.5.1 → 1.6.1

package/dist/index.js

@@ -1021,6 +1021,9 @@ import * as os2 from "os";
 import { unstable_v2_createSession, unstable_v2_resumeSession } from "@anthropic-ai/claude-agent-sdk";
 import { v4 as uuidv4 } from "uuid";
 var MAX_TOOL_CONTENT = 1e4;
+var COMPACT_FALLBACK_GRACE_MS = 40;
+var COMPACT_QUEUED_DISPATCH_DELAY_MS = 40;
+var COMPACT_STALE_RESULT_GUARD_MS = COMPACT_FALLBACK_GRACE_MS + COMPACT_QUEUED_DISPATCH_DELAY_MS;
 var UNSUPPORTED_COMMANDS = /* @__PURE__ */ new Set([
   "keybindings-help",
   "help",
@@ -1058,6 +1061,20 @@ var SdkSession = class extends EventEmitter2 {
   pendingPrompt = null;
   // Tracks prompt during a resume attempt — used to auto-retry with a fresh session on failure
   resumeAttemptPrompt = null;
+  // Tracks whether the current in-flight prompt is a manual /compact command.
+  awaitingCompactCompletionFallback = false;
+  // Monotonic counter for turn ordering.
+  turnGeneration = 0;
+  // Generation of the current in-flight turn.
+  activeTurnGeneration = 0;
+  // Timestamp when the current in-flight turn started.
+  activeTurnStartedAtMs = 0;
+  // Generation whose late result should be ignored after compact fallback.
+  compactLateResultSuppressedGeneration = null;
+  // Timer used to defer compact completion fallback in case result arrives.
+  compactCompletionFallbackTimer = null;
+  // Timer used to dispatch queued prompt shortly after compact fallback.
+  deferredQueuedPromptTimer = null;
   constructor(options) {
     super();
     this.options = options;
@@ -1203,6 +1220,10 @@ var SdkSession = class extends EventEmitter2 {
     this.currentPermissionMode = mode;
     if (modeChanged) {
       this.clearPendingInteractionState("Session reconfigured");
+      this.clearCompactCompletionFallbackTimer();
+      this.clearDeferredQueuedPromptTimer();
+      this.awaitingCompactCompletionFallback = false;
+      this.clearCompactLateResultSuppression();
       if (this.v2Session) {
         this.v2Session.close();
         this.v2Session = null;
@@ -1337,7 +1358,26 @@ var SdkSession = class extends EventEmitter2 {
         });
         this.emit("commands-updated", this.cachedCommands);
       }
+    } else if (message.type === "system" && "subtype" in message && message.subtype === "status" && "status" in message && message.status === null && this.awaitingCompactCompletionFallback && this.isProcessing) {
+      this.scheduleCompactCompletionFallback();
+    } else if (message.type === "system" && "subtype" in message && message.subtype === "compact_boundary" && this.awaitingCompactCompletionFallback && this.isProcessing) {
+      this.scheduleCompactCompletionFallback();
+    } else if (message.type === "auth_status") {
+      const authMsg = message;
+      if (authMsg.error) {
+        this.emit("auth-error", {
+          errorCode: "authentication_failed",
+          message: authMsg.error
+        });
+      }
     } else if (message.type === "assistant") {
+      const assistantError = message.error;
+      if (assistantError) {
+        this.emit("auth-error", {
+          errorCode: assistantError,
+          message: assistantError
+        });
+      }
       if (message.message?.content) {
         for (const block of message.message.content) {
           if ("type" in block && block.type === "text" && "text" in block) {
@@ -1374,6 +1414,10 @@ var SdkSession = class extends EventEmitter2 {
         }
       }
     } else if (message.type === "result") {
+      this.clearCompactCompletionFallbackTimer();
+      if (this.shouldIgnoreLateCompactResult()) {
+        return;
+      }
       if (!this.currentAssistantResponse.trim() && "result" in message && message.result) {
         const resultText = String(message.result);
         this.emit("output", resultText);
@@ -1383,14 +1427,8 @@ var SdkSession = class extends EventEmitter2 {
         this.conversationHistory.push({ role: "assistant", content: this.currentAssistantResponse.trim() });
       }
       this.currentAssistantResponse = "";
-      this.isProcessing = false;
-      const queued = this.pendingPrompt;
-      if (queued) {
-        this.pendingPrompt = null;
-        this.sendPrompt(queued.prompt, queued.attachments);
-      } else {
-        this.emit("complete");
-      }
+      this.awaitingCompactCompletionFallback = false;
+      this.completeCurrentTurn();
     } else if (message.type === "tool_progress") {
       if ("tool_name" in message) {
         this.emit("output", `
@@ -1410,6 +1448,14 @@ var SdkSession = class extends EventEmitter2 {
       this.emit("request-queued");
       return;
     }
+    this.clearCompactCompletionFallbackTimer();
+    this.clearDeferredQueuedPromptTimer();
+    this.awaitingCompactCompletionFallback = /^\/compact(?:\s|$)/.test(prompt2.trim());
+    this.activeTurnGeneration = ++this.turnGeneration;
+    this.activeTurnStartedAtMs = Date.now();
+    if (this.compactLateResultSuppressedGeneration !== null && this.activeTurnGeneration > this.compactLateResultSuppressedGeneration + 1) {
+      this.clearCompactLateResultSuppression();
+    }
     this.isProcessing = true;
     this.currentAssistantResponse = "";
     if (prompt2.trim()) {
@@ -1480,6 +1526,9 @@ ${contextLines.join("\n")}
 `);
       }
       this.isProcessing = false;
+      this.clearCompactCompletionFallbackTimer();
+      this.clearDeferredQueuedPromptTimer();
+      this.awaitingCompactCompletionFallback = false;
     }
   }
   /**
@@ -1507,6 +1556,8 @@ ${contextLines.join("\n")}
   }
   cancel() {
     this.clearPendingInteractionState("Session cancelled");
+    this.clearCompactCompletionFallbackTimer();
+    this.clearDeferredQueuedPromptTimer();
     if (this.v2Session) {
       this.v2Session.close();
       this.v2Session = null;
@@ -1514,6 +1565,8 @@ ${contextLines.join("\n")}
     }
     this.isProcessing = false;
     this.pendingPrompt = null;
+    this.awaitingCompactCompletionFallback = false;
+    this.clearCompactLateResultSuppression();
   }
   getSessionId() {
     return this.sessionId;
@@ -1531,6 +1584,10 @@ ${contextLines.join("\n")}
     this.sessionId = sessionId;
     this.isProcessing = false;
     this.pendingPrompt = null;
+    this.clearCompactCompletionFallbackTimer();
+    this.clearDeferredQueuedPromptTimer();
+    this.awaitingCompactCompletionFallback = false;
+    this.clearCompactLateResultSuppression();
     this.conversationHistory = [];
     this.emit("session-resumed", sessionId);
   }
@@ -1550,6 +1607,8 @@ ${contextLines.join("\n")}
     if (model === this.currentModel) return;
     this.currentModel = model;
     this.clearPendingInteractionState("Session reconfigured");
+    this.clearCompactCompletionFallbackTimer();
+    this.clearDeferredQueuedPromptTimer();
     if (this.v2Session) {
       this.v2Session.close();
       this.v2Session = null;
@@ -1557,9 +1616,13 @@ ${contextLines.join("\n")}
       this.sessionId = null;
       this.isProcessing = false;
       this.pendingPrompt = null;
+      this.awaitingCompactCompletionFallback = false;
+      this.clearCompactLateResultSuppression();
       this.pendingContextTransfer = true;
     } else if (this.sessionId) {
       this.sessionId = null;
+      this.awaitingCompactCompletionFallback = false;
+      this.clearCompactLateResultSuppression();
       this.pendingContextTransfer = true;
     }
     this.emit("model", model);
@@ -1572,6 +1635,8 @@ ${contextLines.join("\n")}
   }
   clearHistory() {
     this.conversationHistory = [];
+    this.clearCompactCompletionFallbackTimer();
+    this.clearDeferredQueuedPromptTimer();
     if (this.v2Session) {
       this.v2Session.close();
       this.v2Session = null;
@@ -1580,6 +1645,72 @@ ${contextLines.join("\n")}
     this.sessionId = null;
     this.isProcessing = false;
     this.pendingPrompt = null;
+    this.awaitingCompactCompletionFallback = false;
+    this.clearCompactLateResultSuppression();
+  }
+  completeCompactCommandFallback() {
+    this.clearCompactCompletionFallbackTimer();
+    this.awaitingCompactCompletionFallback = false;
+    this.compactLateResultSuppressedGeneration = this.activeTurnGeneration;
+    this.currentAssistantResponse = "";
+    this.completeCurrentTurn(COMPACT_QUEUED_DISPATCH_DELAY_MS);
+  }
+  scheduleCompactCompletionFallback() {
+    if (this.compactCompletionFallbackTimer) return;
+    this.compactCompletionFallbackTimer = setTimeout(() => {
+      this.compactCompletionFallbackTimer = null;
+      if (this.awaitingCompactCompletionFallback && this.isProcessing) {
+        this.completeCompactCommandFallback();
+      }
+    }, COMPACT_FALLBACK_GRACE_MS);
+  }
+  clearCompactCompletionFallbackTimer() {
+    if (this.compactCompletionFallbackTimer) {
+      clearTimeout(this.compactCompletionFallbackTimer);
+      this.compactCompletionFallbackTimer = null;
+    }
+  }
+  clearDeferredQueuedPromptTimer() {
+    if (this.deferredQueuedPromptTimer) {
+      clearTimeout(this.deferredQueuedPromptTimer);
+      this.deferredQueuedPromptTimer = null;
+    }
+  }
+  clearCompactLateResultSuppression() {
+    this.compactLateResultSuppressedGeneration = null;
+  }
+  shouldIgnoreLateCompactResult() {
+    const suppressedGeneration = this.compactLateResultSuppressedGeneration;
+    if (suppressedGeneration === null) return false;
+    this.clearCompactLateResultSuppression();
+    if (this.activeTurnGeneration === suppressedGeneration) return true;
+    if (this.activeTurnGeneration === suppressedGeneration + 1) {
+      const elapsedSinceTurnStart = Date.now() - this.activeTurnStartedAtMs;
+      return elapsedSinceTurnStart <= COMPACT_STALE_RESULT_GUARD_MS;
+    }
+    return false;
+  }
+  completeCurrentTurn(deferQueuedDispatchMs = 0) {
+    if (!this.isProcessing) return;
+    this.isProcessing = false;
+    if (!this.pendingPrompt) {
+      this.emit("complete");
+      return;
+    }
+    if (deferQueuedDispatchMs > 0) {
+      this.clearDeferredQueuedPromptTimer();
+      this.deferredQueuedPromptTimer = setTimeout(() => {
+        this.deferredQueuedPromptTimer = null;
+        const deferred = this.pendingPrompt;
+        if (!deferred || this.isProcessing) return;
+        this.pendingPrompt = null;
+        this.sendPrompt(deferred.prompt, deferred.attachments);
+      }, deferQueuedDispatchMs);
+      return;
+    }
+    const queued = this.pendingPrompt;
+    this.pendingPrompt = null;
+    this.sendPrompt(queued.prompt, queued.attachments);
   }
   clearPendingInteractionState(reason) {
     if (this.pendingAnswerRequest) {
@@ -2121,6 +2252,28 @@ var Daemon = class extends EventEmitter3 {
     this.sdkSession.on("error", (error) => {
       this.emit("error", error);
     });
+    this.sdkSession.on("auth-error", async (errorInfo) => {
+      const errorMessages = {
+        "authentication_failed": 'Claude CLI authentication expired. Please run "claude login" on the host machine.',
+        "billing_error": "Billing error. Please check your Anthropic account billing status.",
+        "rate_limit": "Rate limit reached. Please wait a moment and try again.",
+        "server_error": "Anthropic API server error. Please try again later."
+      };
+      const displayMessage = errorMessages[errorInfo.errorCode] || `API error: ${errorInfo.message}`;
+      if (this.options.hybrid !== false) {
+        process.stdout.write(`
+[Error] ${displayMessage}
+`);
+      }
+      this.emit("error", new Error(displayMessage));
+      if (this.realtimeClient) {
+        try {
+          await this.realtimeClient.broadcastError(displayMessage, errorInfo.errorCode);
+          await this.realtimeClient.broadcastComplete();
+        } catch {
+        }
+      }
+    });
     this.sdkSession.on("commands-updated", async () => {
       await this.broadcastCommands();
     });
@@ -2847,9 +3000,24 @@ var MobileServerManager = class {
     let needsInstall = false;
     try {
       execSync2("which ngrok", { stdio: "pipe" });
+      try {
+        const configOutput = execSync2("ngrok config check", {
+          stdio: "pipe",
+          timeout: 5e3
+        }).toString();
+        if (!configOutput.toLowerCase().includes("valid")) {
+          issues.push(
+            "ngrok authtoken is not configured.\n  1. Sign up at https://ngrok.com\n  2. Copy your authtoken from https://dashboard.ngrok.com/get-started/your-authtoken\n  3. Run: ngrok config add-authtoken <your-token>"
+          );
+        }
+      } catch {
+        issues.push(
+          "ngrok authtoken is not configured.\n  1. Sign up at https://ngrok.com\n  2. Copy your authtoken from https://dashboard.ngrok.com/get-started/your-authtoken\n  3. Run: ngrok config add-authtoken <your-token>"
+        );
+      }
     } catch {
       issues.push(
-        "ngrok is not installed.\n  Install: brew install ngrok\n  Sign up: https://ngrok.com\n  Auth:    ngrok config add-authtoken <your-token>"
+        "ngrok is not installed.\n  Install: brew install ngrok\n  Then configure your account:\n  1. Sign up at https://ngrok.com\n  2. Copy your authtoken from https://dashboard.ngrok.com/get-started/your-authtoken\n  3. Run: ngrok config add-authtoken <your-token>"
       );
     }
     const nodeModulesPath = join5(this.mobileProjectPath, "node_modules");
@@ -2956,26 +3124,51 @@ var MobileServerManager = class {
   async startNgrok() {
     this.ensureLogDir();
     this.ngrokLogStream = createWriteStream(join5(this.logDir, "ngrok.log"));
+    let stderrData = "";
     this.ngrokProcess = spawn2("ngrok", ["http", String(this.expoPort)], {
       stdio: ["ignore", "pipe", "pipe"],
       detached: false
     });
     this.ngrokProcess.stdout?.pipe(this.ngrokLogStream);
-    this.ngrokProcess.stderr?.pipe(this.ngrokLogStream);
+    this.ngrokProcess.stderr?.on("data", (chunk) => {
+      stderrData += chunk.toString();
+      this.ngrokLogStream?.write(chunk);
+    });
     this.ngrokProcess.on("error", () => {
     });
     for (let i = 0; i < 10; i++) {
       await this.sleep(1e3);
+      if (this.ngrokProcess.exitCode !== null) {
+        break;
+      }
       const url = await this.getNgrokTunnelUrl();
       if (url) {
         this.tunnelUrl = url;
         return url;
       }
     }
+    this.ngrokError = this.diagnoseNgrokFailure(stderrData);
     this.killProcess(this.ngrokProcess);
     this.ngrokProcess = null;
     return null;
   }
+  /** Last ngrok error diagnosis (available after startNgrok fails) */
+  ngrokError = null;
+  diagnoseNgrokFailure(stderr) {
+    const lower = stderr.toLowerCase();
+    if (lower.includes("authtoken") || lower.includes("err_ngrok_105") || lower.includes("authentication")) {
+      return "ngrok authentication failed.\n  Your authtoken may be invalid or expired.\n  1. Get a new token at https://dashboard.ngrok.com/get-started/your-authtoken\n  2. Run: ngrok config add-authtoken <your-token>";
+    }
+    if (lower.includes("tunnel session limit") || lower.includes("err_ngrok_108")) {
+      return "ngrok free plan session limit reached.\n  Free accounts allow 1 tunnel at a time.\n  Close other ngrok tunnels or upgrade your plan at https://ngrok.com/pricing";
+    }
+    if (lower.includes("tcp dial") || lower.includes("connection refused")) {
+      return `ngrok could not connect to localhost:${this.expoPort}.
+  This is usually a timing issue \u2014 the tunnel started before Expo was ready.`;
+    }
+    return `ngrok tunnel failed to start.
+  Check logs for details: ${join5(this.logDir, "ngrok.log")}`;
+  }
   async startExpo(tunnelUrl) {
     this.ensureLogDir();
     this.expoLogStream = createWriteStream(join5(this.logDir, "expo.log"));
@@ -3066,7 +3259,7 @@ var MobileServerManager = class {
     this.onProgress("Starting ngrok tunnel...");
     const tunnelUrl = await this.startNgrok();
     if (!tunnelUrl) {
-      return { started: false, error: "Failed to start ngrok tunnel" };
+      return { started: false, error: this.ngrokError ?? "Failed to start ngrok tunnel" };
     }
     this.onProgress("Starting Expo server...");
     const expoStarted = await this.startExpo(tunnelUrl);
@@ -3234,6 +3427,52 @@ function removePidFileUnchecked(pidFile) {
   }
 }
 
+// src/utils/claude-auth.ts
+import { execSync as execSync3 } from "child_process";
+function checkClaudeCliAuth() {
+  try {
+    const output = execSync3("claude auth status --json", {
+      encoding: "utf-8",
+      timeout: 1e4,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const status = JSON.parse(output.trim());
+    if (status.loggedIn === true) {
+      return {
+        loggedIn: true,
+        authMethod: status.authMethod,
+        apiProvider: status.apiProvider
+      };
+    }
+    return { loggedIn: false, failure: "not_logged_in" };
+  } catch (error) {
+    const execError = error;
+    if (execError.stdout) {
+      try {
+        const stdout = typeof execError.stdout === "string" ? execError.stdout : execError.stdout.toString("utf-8");
+        const status = JSON.parse(stdout.trim());
+        if (status.loggedIn === true) {
+          return {
+            loggedIn: true,
+            authMethod: status.authMethod,
+            apiProvider: status.apiProvider
+          };
+        }
+        return { loggedIn: false, failure: "not_logged_in" };
+      } catch {
+      }
+    }
+    const message = execError.message ?? String(error);
+    if (message.includes("command not found") || message.includes("ENOENT") || message.includes("not recognized")) {
+      return { loggedIn: false, failure: "cli_not_found" };
+    }
+    if (message.includes("Unknown command") || message.includes("unknown command") || message.includes("Invalid subcommand") || message.includes("invalid subcommand")) {
+      return { loggedIn: false, failure: "subcommand_not_supported" };
+    }
+    return { loggedIn: false, failure: "unknown" };
+  }
+}
+
 // src/commands/start.ts
 if (typeof globalThis.WebSocket === "undefined") {
   globalThis.WebSocket = WebSocket;
@@ -3282,6 +3521,36 @@ function createStartCommand() {
         }
       });
       spinner.update(`Authenticated as ${user.email}...`);
+      spinner.update("Checking Claude CLI auth...");
+      const claudeAuth = checkClaudeCliAuth();
+      if (!claudeAuth.loggedIn) {
+        switch (claudeAuth.failure) {
+          case "cli_not_found":
+            spinner.fail("Claude CLI not found");
+            logger.error("Claude Code CLI is not installed or not in PATH.");
+            logger.error("Install it first: https://docs.anthropic.com/en/docs/claude-code");
+            removePidFile();
+            process.exit(1);
+            break;
+          case "subcommand_not_supported":
+            spinner.update('Claude CLI auth check skipped (CLI version does not support "auth status")');
+            logger.warn('Could not verify Claude CLI auth \u2014 your CLI version may not support "claude auth status".');
+            logger.warn('If sessions fail to start, try updating Claude Code and running "claude login".');
+            break;
+          case "not_logged_in":
+            spinner.fail("Claude CLI is not logged in");
+            logger.error("Claude Code requires authentication to use the Anthropic API.");
+            logger.error('Run "claude login" first, then try "clautunnel start" again.');
+            removePidFile();
+            process.exit(1);
+            break;
+          default:
+            spinner.update("Claude CLI auth check inconclusive");
+            logger.warn("Could not verify Claude CLI authentication (unexpected error).");
+            logger.warn('If sessions fail to start, run "claude login" and try again.');
+            break;
+        }
+      }
       let fdaStatus = null;
       if (isMacOS()) {
         spinner.stop();