@tongil_kim/clautunnel 1.5.1 → 1.6.0

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();
     });
@@ -3234,6 +3387,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 +3481,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();