@tongil_kim/clautunnel 1.3.6 → 1.4.1

package/README.md

@@ -1,6 +1,23 @@
 # ClauTunnel
 
-Remote monitoring and control for Claude Code CLI from your mobile device.
+[![npm version](https://img.shields.io/npm/v/@tongil_kim/clautunnel.svg)](https://www.npmjs.com/package/@tongil_kim/clautunnel)
+[![npm downloads](https://img.shields.io/npm/dw/@tongil_kim/clautunnel.svg)](https://www.npmjs.com/package/@tongil_kim/clautunnel)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.3-blue.svg)](https://www.typescriptlang.org/)
+[![Node.js](https://img.shields.io/badge/Node.js-18%2B-green.svg)](https://nodejs.org/)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/TongilKim/ClauTunnel/pulls)
+
+> **ClauTunnel** — Remote monitoring and control tool for **Claude Code CLI** from your mobile device. Stream terminal output in real-time, send input remotely, and get push notifications for task completion via iOS & Android.
+
+## Why ClauTunnel?
+
+Running Claude Code on your workstation but need to step away? ClauTunnel lets you keep the conversation going from your phone:
+
+- **Monitor long-running tasks** — Watch Claude Code terminal output in real-time from anywhere
+- **Send input remotely** — Respond to Claude's prompts and provide input from your mobile device
+- **Push notifications** — Get notified instantly when tasks complete, errors occur, or input is needed
+- **Background daemon mode** — Run ClauTunnel as a background service with automatic reconnection
+- **Sleep prevention** — Keep your Mac awake during long-running Claude Code sessions
 
 ## Installation
 
@@ -59,22 +76,27 @@ clautunnel stop
 
 ## Features
 
-- Real-time terminal output streaming to mobile
-- Send input from mobile to CLI
-- Push notifications for task completion, errors, and input prompts
-- Automatic reconnection with exponential backoff
-- Sleep prevention option for long-running tasks
+- **Real-time streaming** — Terminal output streamed to your mobile device instantly
+- **Remote input** — Send text input and commands from mobile to CLI
+- **Push notifications** — Alerts for task completion, errors, and input prompts
+- **Automatic reconnection** — Exponential backoff ensures reliable connections
+- **Sleep prevention** — Keep macOS awake during long-running tasks
+- **Daemon mode** — Run as a background service
+- **Multi-platform mobile** — Works on both iOS and Android via Expo
 
 ## Requirements
 
 - Node.js 18+
-- Claude Code CLI installed
+- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) installed
+- Supabase account (free tier works)
 
 ## Links
 
-- [GitHub Repository](https://github.com/TongilKim/clautunnel)
-- [Mobile App](https://github.com/TongilKim/clautunnel/tree/main/apps/mobile)
+- [GitHub Repository](https://github.com/TongilKim/ClauTunnel)
+- [Mobile App](https://github.com/TongilKim/ClauTunnel/tree/main/apps/mobile)
+- [npm Package](https://www.npmjs.com/package/@tongil_kim/clautunnel)
+- [Report Issues](https://github.com/TongilKim/ClauTunnel/issues)
 
 ## License
 
-MIT
+[MIT](https://github.com/TongilKim/ClauTunnel/blob/main/LICENSE)

package/dist/index.d.ts

@@ -83,6 +83,7 @@ declare class RealtimeClient extends EventEmitter {
     broadcastUserQuestion(questionData: UserQuestionData): Promise<void>;
     broadcastPermissionRequest(requestData: PermissionRequestData): Promise<void>;
     broadcastToolUse(toolUseData: ToolUseData): Promise<void>;
+    broadcastStatusResponse(isProcessing: boolean, isMessageQueued: boolean): Promise<void>;
     broadcastComplete(): Promise<void>;
     broadcastSessionTitle(title: string): Promise<void>;
     broadcastQueued(): Promise<void>;

package/dist/index.js

@@ -715,6 +715,27 @@ var RealtimeClient = class extends EventEmitter {
     }
     this.emit("broadcast", message);
   }
+  async broadcastStatusResponse(isProcessing, isMessageQueued) {
+    if (!this.outputChannel) {
+      throw new Error("Not connected");
+    }
+    if (!this.realtimeEnabled) {
+      return;
+    }
+    const message = {
+      type: "status-response",
+      isProcessing,
+      isMessageQueued,
+      timestamp: Date.now(),
+      seq: ++this.seq
+    };
+    await this.outputChannel.send({
+      type: "broadcast",
+      event: "output",
+      payload: message
+    });
+    this.emit("broadcast", message);
+  }
   async broadcastComplete() {
     if (!this.outputChannel) {
       throw new Error("Not connected");
@@ -988,6 +1009,8 @@ var SdkSession = class extends EventEmitter2 {
   currentAssistantResponse = "";
   // Queued prompt to send after current processing completes (last-one-wins)
   pendingPrompt = null;
+  // Tracks prompt during a resume attempt — used to auto-retry with a fresh session on failure
+  resumeAttemptPrompt = null;
   constructor(options) {
     super();
     this.options = options;
@@ -1164,6 +1187,24 @@ var SdkSession = class extends EventEmitter2 {
     }
     return this.v2Session;
   }
+  /**
+   * Clear session state and retry the saved resume prompt with a fresh session.
+   * Returns the saved prompt if a retry should happen, or null if not applicable.
+   */
+  consumeResumeAttempt() {
+    const savedPrompt = this.resumeAttemptPrompt;
+    if (!savedPrompt) return null;
+    this.resumeAttemptPrompt = null;
+    this.v2Session = null;
+    this.sessionId = null;
+    this.streamLoopRunning = false;
+    this.isProcessing = false;
+    if (this.conversationHistory.length > 0 && this.conversationHistory[this.conversationHistory.length - 1].role === "user") {
+      this.conversationHistory.pop();
+    }
+    this.emit("resume-failed");
+    return savedPrompt;
+  }
   /**
    * Background loop that processes messages from the V2 session stream.
    * Runs continuously for the lifetime of the session.
@@ -1171,6 +1212,7 @@ var SdkSession = class extends EventEmitter2 {
   async startStreamLoop() {
     if (this.streamLoopRunning || !this.v2Session) return;
     this.streamLoopRunning = true;
+    let retrying = false;
     try {
       while (this.v2Session && !this.v2Session["closed"]) {
         for await (const message of this.v2Session.stream()) {
@@ -1179,11 +1221,19 @@ var SdkSession = class extends EventEmitter2 {
       }
     } catch (error) {
       if (error.name !== "AbortError") {
-        this.emit("error", error);
+        const savedPrompt = this.consumeResumeAttempt();
+        if (savedPrompt) {
+          retrying = true;
+          this.sendPrompt(savedPrompt.prompt, savedPrompt.attachments).catch((retryErr) => {
+            this.emit("error", retryErr);
+          });
+        } else {
+          this.emit("error", error);
+        }
       }
     } finally {
       this.streamLoopRunning = false;
-      if (this.isProcessing) {
+      if (this.isProcessing && !retrying) {
         this.isProcessing = false;
         this.pendingPrompt = null;
         this.emit("complete");
@@ -1195,6 +1245,7 @@ var SdkSession = class extends EventEmitter2 {
    */
   processMessage(message) {
     if (message.type === "system" && "subtype" in message && message.subtype === "init") {
+      this.resumeAttemptPrompt = null;
       this.sessionId = message.session_id;
       this.emit("session-started", this.sessionId);
       if ("permissionMode" in message) {
@@ -1295,6 +1346,9 @@ var SdkSession = class extends EventEmitter2 {
       this.conversationHistory.push({ role: "user", content: prompt2 });
     }
     try {
+      if (this.sessionId && !this.v2Session) {
+        this.resumeAttemptPrompt = { prompt: prompt2, attachments };
+      }
       let finalPrompt = prompt2;
       if (this.pendingContextTransfer && this.conversationHistory.length > 1) {
         const previousHistory = this.conversationHistory.slice(0, -1);
@@ -1340,6 +1394,13 @@ ${contextLines.join("\n")}
       };
       await session.send(userMessage);
     } catch (error) {
+      if (error.name !== "AbortError") {
+        const savedPrompt = this.consumeResumeAttempt();
+        if (savedPrompt) {
+          await this.sendPrompt(savedPrompt.prompt, savedPrompt.attachments);
+          return;
+        }
+      }
       if (error.name === "AbortError") {
         this.emit("output", "\n[Cancelled]\n");
       } else {
@@ -1414,6 +1475,9 @@ ${contextLines.join("\n")}
   getPendingPermissionData() {
     return this.pendingPermissionData;
   }
+  hasPendingPrompt() {
+    return this.pendingPrompt !== null;
+  }
   async setModel(model) {
     if (model === this.currentModel) return;
     this.currentModel = model;
@@ -1968,6 +2032,20 @@ var Daemon = class extends EventEmitter3 {
     this.sdkSession.on("commands-updated", async () => {
       await this.broadcastCommands();
     });
+    this.sdkSession.on("resume-failed", async () => {
+      const msg = "[Could not resume previous session. Starting a new session instead.]";
+      if (this.options.hybrid !== false) {
+        process.stdout.write(`
+${msg}
+`);
+      }
+      if (this.realtimeClient) {
+        try {
+          await this.realtimeClient.broadcastSystem(msg);
+        } catch {
+        }
+      }
+    });
     this.sdkSession.on("session-started", async (sdkSessionId) => {
       if (!this.session) return;
       try {
@@ -2114,6 +2192,10 @@ ${confirmationMsg}
             if (pendingPermission) {
               await this.realtimeClient.broadcastPermissionRequest(pendingPermission);
             }
+            const isProcessing = this.sdkSession.isActive();
+            const isActivelyWorking = isProcessing && !pendingQuestion && !pendingPermission;
+            const isMessageQueued = this.sdkSession.hasPendingPrompt();
+            await this.realtimeClient.broadcastStatusResponse(isActivelyWorking, isMessageQueued);
           } catch {
           }
         }
@@ -2481,7 +2563,7 @@ async function restoreSession(supabase, config2) {
   if (!sessionTokens) {
     return null;
   }
-  const { error: sessionError } = await supabase.auth.setSession({
+  const { data: sessionData, error: sessionError } = await supabase.auth.setSession({
     access_token: sessionTokens.accessToken,
     refresh_token: sessionTokens.refreshToken
   });
@@ -2489,6 +2571,16 @@ async function restoreSession(supabase, config2) {
     config2.clearSessionTokens();
     return null;
   }
+  if (sessionData?.session) {
+    const newAccess = sessionData.session.access_token;
+    const newRefresh = sessionData.session.refresh_token;
+    if (newAccess !== sessionTokens.accessToken || newRefresh !== sessionTokens.refreshToken) {
+      config2.setSessionTokens({
+        accessToken: newAccess,
+        refreshToken: newRefresh
+      });
+    }
+  }
   const {
     data: { user },
     error: authError
@@ -3000,6 +3092,16 @@ function createStartCommand() {
         process.exit(1);
       }
       const { user } = session;
+      const {
+        data: { subscription: authSubscription }
+      } = supabase.auth.onAuthStateChange((event, authSession) => {
+        if (event === "TOKEN_REFRESHED" && authSession) {
+          config2.setSessionTokens({
+            accessToken: authSession.access_token,
+            refreshToken: authSession.refresh_token
+          });
+        }
+      });
       spinner.update(`Authenticated as ${user.email}...`);
       let fdaStatus = null;
       if (isMacOS()) {
@@ -3121,6 +3223,7 @@ function createStartCommand() {
             await machineClient.disconnect();
             machineClient = null;
           }
+          authSubscription.unsubscribe();
           console.log("[Cleanup] All sessions ended in database");
           await cleanup2();
         } catch (error) {