happy-coder 0.9.0-0 → 0.9.0-2

package/dist/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 var chalk = require('chalk');
-var types$1 = require('./types-D8nxJTr8.cjs');
+var types$1 = require('./types-a-nJyP-e.cjs');
 var node_crypto = require('node:crypto');
 var node_child_process = require('node:child_process');
 var node_path = require('node:path');
@@ -1623,11 +1623,20 @@ class PermissionHandler {
   pendingRequests = /* @__PURE__ */ new Map();
   session;
   allowedTools = /* @__PURE__ */ new Set();
+  allowedBashLiterals = /* @__PURE__ */ new Set();
+  allowedBashPrefixes = /* @__PURE__ */ new Set();
   permissionMode = "default";
+  onPermissionRequestCallback;
   constructor(session) {
     this.session = session;
     this.setupClientHandler();
   }
+  /**
+   * Set callback to trigger when permission request is made
+   */
+  setOnPermissionRequest(callback) {
+    this.onPermissionRequestCallback = callback;
+  }
   handleModeChange(mode) {
     this.permissionMode = mode;
   }
@@ -1636,7 +1645,13 @@ class PermissionHandler {
    */
   handlePermissionResponse(response, pending) {
     if (response.allowTools && response.allowTools.length > 0) {
-      response.allowTools.forEach((tool) => this.allowedTools.add(tool));
+      response.allowTools.forEach((tool) => {
+        if (tool.startsWith("Bash(") || tool === "Bash") {
+          this.parseBashPermission(tool);
+        } else {
+          this.allowedTools.add(tool);
+        }
+      });
     }
     if (response.mode) {
       this.permissionMode = response.mode;
@@ -1663,7 +1678,19 @@ class PermissionHandler {
    * Creates the canCallTool callback for the SDK
    */
   handleToolCall = async (toolName, input, mode, options) => {
-    if (this.allowedTools.has(toolName)) {
+    if (toolName === "Bash") {
+      const inputObj = input;
+      if (inputObj?.command) {
+        if (this.allowedBashLiterals.has(inputObj.command)) {
+          return { behavior: "allow", updatedInput: input };
+        }
+        for (const prefix of this.allowedBashPrefixes) {
+          if (inputObj.command.startsWith(prefix)) {
+            return { behavior: "allow", updatedInput: input };
+          }
+        }
+      }
+    } else if (this.allowedTools.has(toolName)) {
       return { behavior: "allow", updatedInput: input };
     }
     const descriptor = getToolDescriptor(toolName);
@@ -1705,6 +1732,9 @@ class PermissionHandler {
         toolName,
         input
       });
+      if (this.onPermissionRequestCallback) {
+        this.onPermissionRequestCallback(id);
+      }
       this.session.api.push().sendToAllDevices(
         "Permission Request",
         `Claude wants to ${getToolName(toolName)}`,
@@ -1729,6 +1759,26 @@ class PermissionHandler {
       types$1.logger.debug(`Permission request sent for tool call ${id}: ${toolName}`);
     });
   }
+  /**
+   * Parses Bash permission strings into literal and prefix sets
+   */
+  parseBashPermission(permission) {
+    if (permission === "Bash") {
+      return;
+    }
+    const bashPattern = /^Bash\((.+?)\)$/;
+    const match = permission.match(bashPattern);
+    if (!match) {
+      return;
+    }
+    const command = match[1];
+    if (command.endsWith(":*")) {
+      const prefix = command.slice(0, -2);
+      this.allowedBashPrefixes.add(prefix);
+    } else {
+      this.allowedBashLiterals.add(command);
+    }
+  }
   /**
    * Resolves tool call ID based on tool name and input
    */
@@ -1797,6 +1847,9 @@ class PermissionHandler {
   reset() {
     this.toolCalls = [];
     this.responses.clear();
+    this.allowedTools.clear();
+    this.allowedBashLiterals.clear();
+    this.allowedBashPrefixes.clear();
     for (const [, pending] of this.pendingRequests.entries()) {
       pending.reject(new Error("Session reset"));
     }
@@ -2203,6 +2256,136 @@ class SDKToLogConverter {
   }
 }
 
+class OutgoingMessageQueue {
+  constructor(sendFunction) {
+    this.sendFunction = sendFunction;
+  }
+  queue = [];
+  nextId = 1;
+  lock = new types$1.AsyncLock();
+  processTimer;
+  delayTimers = /* @__PURE__ */ new Map();
+  /**
+   * Add message to queue
+   */
+  enqueue(logMessage, options) {
+    this.lock.inLock(async () => {
+      const item = {
+        id: this.nextId++,
+        logMessage,
+        delayed: !!options?.delay,
+        delayMs: options?.delay || 0,
+        toolCallIds: options?.toolCallIds,
+        released: !options?.delay,
+        // Not delayed = already released
+        sent: false
+      };
+      this.queue.push(item);
+      if (item.delayed) {
+        const timer = setTimeout(() => {
+          this.releaseItem(item.id);
+        }, item.delayMs);
+        this.delayTimers.set(item.id, timer);
+      }
+    });
+    this.scheduleProcessing();
+  }
+  /**
+   * Release specific item by ID
+   */
+  async releaseItem(itemId) {
+    await this.lock.inLock(async () => {
+      const item = this.queue.find((i) => i.id === itemId);
+      if (item && !item.released) {
+        item.released = true;
+        const timer = this.delayTimers.get(itemId);
+        if (timer) {
+          clearTimeout(timer);
+          this.delayTimers.delete(itemId);
+        }
+      }
+    });
+    this.scheduleProcessing();
+  }
+  /**
+   * Release all messages with specific tool call ID
+   */
+  async releaseToolCall(toolCallId) {
+    await this.lock.inLock(async () => {
+      for (const item of this.queue) {
+        if (item.toolCallIds?.includes(toolCallId) && !item.released) {
+          item.released = true;
+          const timer = this.delayTimers.get(item.id);
+          if (timer) {
+            clearTimeout(timer);
+            this.delayTimers.delete(item.id);
+          }
+        }
+      }
+    });
+    this.scheduleProcessing();
+  }
+  /**
+   * Process queue - send messages in ID order that are released
+   */
+  async processQueue() {
+    await this.lock.inLock(async () => {
+      this.queue.sort((a, b) => a.id - b.id);
+      while (this.queue.length > 0) {
+        const item = this.queue[0];
+        if (!item.released) {
+          break;
+        }
+        if (!item.sent) {
+          if (item.logMessage.type !== "system") {
+            this.sendFunction(item.logMessage);
+          }
+          item.sent = true;
+        }
+        this.queue.shift();
+      }
+    });
+  }
+  /**
+   * Flush all messages immediately (for cleanup)
+   */
+  async flush() {
+    await this.lock.inLock(async () => {
+      for (const timer of this.delayTimers.values()) {
+        clearTimeout(timer);
+      }
+      this.delayTimers.clear();
+      for (const item of this.queue) {
+        item.released = true;
+      }
+      await this.processQueue();
+    });
+  }
+  /**
+   * Schedule processing on next tick
+   */
+  scheduleProcessing() {
+    if (this.processTimer) {
+      clearTimeout(this.processTimer);
+    }
+    this.processTimer = setTimeout(() => {
+      this.processQueue();
+    }, 0);
+  }
+  /**
+   * Cleanup timers and resources
+   */
+  destroy() {
+    if (this.processTimer) {
+      clearTimeout(this.processTimer);
+    }
+    for (const timer of this.delayTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.delayTimers.clear();
+  }
+}
+
 async function claudeRemoteLauncher(session) {
   types$1.logger.debug("[claudeRemoteLauncher] Starting remote launcher");
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
@@ -2260,6 +2443,12 @@ async function claudeRemoteLauncher(session) {
   session.client.setHandler("abort", doAbort);
   session.client.setHandler("switch", doSwitch);
   const permissionHandler = new PermissionHandler(session);
+  const messageQueue = new OutgoingMessageQueue(
+    (logMessage) => session.client.sendClaudeSessionMessage(logMessage)
+  );
+  permissionHandler.setOnPermissionRequest((toolCallId) => {
+    messageQueue.releaseToolCall(toolCallId);
+  });
   const sdkToLogConverter = new SDKToLogConverter({
     sessionId: session.sessionId || "unknown",
     cwd: session.path,
@@ -2298,6 +2487,7 @@ async function claudeRemoteLauncher(session) {
         for (let c of umessage.message.content) {
           if (c.type === "tool_result" && c.tool_use_id) {
             ongoingToolCalls.delete(c.tool_use_id);
+            messageQueue.releaseToolCall(c.tool_use_id);
           }
         }
       }
@@ -2359,9 +2549,28 @@ async function claudeRemoteLauncher(session) {
           }
         }
       }
-      if (logMessage.type !== "system") {
-        session.client.sendClaudeSessionMessage(logMessage);
+      if (logMessage.type === "assistant" && message.type === "assistant") {
+        const assistantMsg = message;
+        const toolCallIds = [];
+        if (assistantMsg.message.content && Array.isArray(assistantMsg.message.content)) {
+          for (const block of assistantMsg.message.content) {
+            if (block.type === "tool_use" && block.id) {
+              toolCallIds.push(block.id);
+            }
+          }
+        }
+        if (toolCallIds.length > 0) {
+          const isSidechain = assistantMsg.parent_tool_use_id !== void 0;
+          if (!isSidechain) {
+            messageQueue.enqueue(logMessage, {
+              delay: 250,
+              toolCallIds
+            });
+            return;
+          }
+        }
       }
+      messageQueue.enqueue(logMessage);
     }
     if (message.type === "assistant") {
       let umessage = message;
@@ -2370,7 +2579,7 @@ async function claudeRemoteLauncher(session) {
           if (c.type === "tool_use" && c.name === "Task" && c.input && typeof c.input.prompt === "string") {
             const logMessage2 = sdkToLogConverter.convertSidechainUserMessage(c.id, c.input.prompt);
             if (logMessage2) {
-              session.client.sendClaudeSessionMessage(logMessage2);
+              messageQueue.enqueue(logMessage2);
             }
           }
         }
@@ -2461,6 +2670,8 @@ async function claudeRemoteLauncher(session) {
           }
         }
         ongoingToolCalls.clear();
+        await messageQueue.flush();
+        messageQueue.destroy();
         abortController = null;
         abortFuture?.resolve(void 0);
         abortFuture = null;
@@ -2534,7 +2745,7 @@ async function loop(opts) {
 }
 
 var name = "happy-coder";
-var version = "0.9.0-0";
+var version = "0.9.0-2";
 var description = "Claude Code session sharing CLI";
 var author = "Kirill Dubovitskiy";
 var license = "MIT";

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import chalk from 'chalk';
-import { l as logger, b as backoff, d as delay, R as RawJSONLinesSchema, c as configuration, e as encodeBase64, f as encodeBase64Url, g as decodeBase64, A as ApiClient } from './types-CJU8o8xd.mjs';
+import { l as logger, b as backoff, d as delay, R as RawJSONLinesSchema, e as AsyncLock, c as configuration, f as encodeBase64, g as encodeBase64Url, h as decodeBase64, A as ApiClient } from './types-DJOX-XG-.mjs';
 import { randomUUID, randomBytes } from 'node:crypto';
 import { spawn, execSync } from 'node:child_process';
 import { resolve, join, dirname as dirname$1 } from 'node:path';
@@ -1602,11 +1602,20 @@ class PermissionHandler {
   pendingRequests = /* @__PURE__ */ new Map();
   session;
   allowedTools = /* @__PURE__ */ new Set();
+  allowedBashLiterals = /* @__PURE__ */ new Set();
+  allowedBashPrefixes = /* @__PURE__ */ new Set();
   permissionMode = "default";
+  onPermissionRequestCallback;
   constructor(session) {
     this.session = session;
     this.setupClientHandler();
   }
+  /**
+   * Set callback to trigger when permission request is made
+   */
+  setOnPermissionRequest(callback) {
+    this.onPermissionRequestCallback = callback;
+  }
   handleModeChange(mode) {
     this.permissionMode = mode;
   }
@@ -1615,7 +1624,13 @@ class PermissionHandler {
    */
   handlePermissionResponse(response, pending) {
     if (response.allowTools && response.allowTools.length > 0) {
-      response.allowTools.forEach((tool) => this.allowedTools.add(tool));
+      response.allowTools.forEach((tool) => {
+        if (tool.startsWith("Bash(") || tool === "Bash") {
+          this.parseBashPermission(tool);
+        } else {
+          this.allowedTools.add(tool);
+        }
+      });
     }
     if (response.mode) {
       this.permissionMode = response.mode;
@@ -1642,7 +1657,19 @@ class PermissionHandler {
    * Creates the canCallTool callback for the SDK
    */
   handleToolCall = async (toolName, input, mode, options) => {
-    if (this.allowedTools.has(toolName)) {
+    if (toolName === "Bash") {
+      const inputObj = input;
+      if (inputObj?.command) {
+        if (this.allowedBashLiterals.has(inputObj.command)) {
+          return { behavior: "allow", updatedInput: input };
+        }
+        for (const prefix of this.allowedBashPrefixes) {
+          if (inputObj.command.startsWith(prefix)) {
+            return { behavior: "allow", updatedInput: input };
+          }
+        }
+      }
+    } else if (this.allowedTools.has(toolName)) {
       return { behavior: "allow", updatedInput: input };
     }
     const descriptor = getToolDescriptor(toolName);
@@ -1684,6 +1711,9 @@ class PermissionHandler {
         toolName,
         input
       });
+      if (this.onPermissionRequestCallback) {
+        this.onPermissionRequestCallback(id);
+      }
       this.session.api.push().sendToAllDevices(
         "Permission Request",
         `Claude wants to ${getToolName(toolName)}`,
@@ -1708,6 +1738,26 @@ class PermissionHandler {
       logger.debug(`Permission request sent for tool call ${id}: ${toolName}`);
     });
   }
+  /**
+   * Parses Bash permission strings into literal and prefix sets
+   */
+  parseBashPermission(permission) {
+    if (permission === "Bash") {
+      return;
+    }
+    const bashPattern = /^Bash\((.+?)\)$/;
+    const match = permission.match(bashPattern);
+    if (!match) {
+      return;
+    }
+    const command = match[1];
+    if (command.endsWith(":*")) {
+      const prefix = command.slice(0, -2);
+      this.allowedBashPrefixes.add(prefix);
+    } else {
+      this.allowedBashLiterals.add(command);
+    }
+  }
   /**
    * Resolves tool call ID based on tool name and input
    */
@@ -1776,6 +1826,9 @@ class PermissionHandler {
   reset() {
     this.toolCalls = [];
     this.responses.clear();
+    this.allowedTools.clear();
+    this.allowedBashLiterals.clear();
+    this.allowedBashPrefixes.clear();
     for (const [, pending] of this.pendingRequests.entries()) {
       pending.reject(new Error("Session reset"));
     }
@@ -2182,6 +2235,136 @@ class SDKToLogConverter {
   }
 }
 
+class OutgoingMessageQueue {
+  constructor(sendFunction) {
+    this.sendFunction = sendFunction;
+  }
+  queue = [];
+  nextId = 1;
+  lock = new AsyncLock();
+  processTimer;
+  delayTimers = /* @__PURE__ */ new Map();
+  /**
+   * Add message to queue
+   */
+  enqueue(logMessage, options) {
+    this.lock.inLock(async () => {
+      const item = {
+        id: this.nextId++,
+        logMessage,
+        delayed: !!options?.delay,
+        delayMs: options?.delay || 0,
+        toolCallIds: options?.toolCallIds,
+        released: !options?.delay,
+        // Not delayed = already released
+        sent: false
+      };
+      this.queue.push(item);
+      if (item.delayed) {
+        const timer = setTimeout(() => {
+          this.releaseItem(item.id);
+        }, item.delayMs);
+        this.delayTimers.set(item.id, timer);
+      }
+    });
+    this.scheduleProcessing();
+  }
+  /**
+   * Release specific item by ID
+   */
+  async releaseItem(itemId) {
+    await this.lock.inLock(async () => {
+      const item = this.queue.find((i) => i.id === itemId);
+      if (item && !item.released) {
+        item.released = true;
+        const timer = this.delayTimers.get(itemId);
+        if (timer) {
+          clearTimeout(timer);
+          this.delayTimers.delete(itemId);
+        }
+      }
+    });
+    this.scheduleProcessing();
+  }
+  /**
+   * Release all messages with specific tool call ID
+   */
+  async releaseToolCall(toolCallId) {
+    await this.lock.inLock(async () => {
+      for (const item of this.queue) {
+        if (item.toolCallIds?.includes(toolCallId) && !item.released) {
+          item.released = true;
+          const timer = this.delayTimers.get(item.id);
+          if (timer) {
+            clearTimeout(timer);
+            this.delayTimers.delete(item.id);
+          }
+        }
+      }
+    });
+    this.scheduleProcessing();
+  }
+  /**
+   * Process queue - send messages in ID order that are released
+   */
+  async processQueue() {
+    await this.lock.inLock(async () => {
+      this.queue.sort((a, b) => a.id - b.id);
+      while (this.queue.length > 0) {
+        const item = this.queue[0];
+        if (!item.released) {
+          break;
+        }
+        if (!item.sent) {
+          if (item.logMessage.type !== "system") {
+            this.sendFunction(item.logMessage);
+          }
+          item.sent = true;
+        }
+        this.queue.shift();
+      }
+    });
+  }
+  /**
+   * Flush all messages immediately (for cleanup)
+   */
+  async flush() {
+    await this.lock.inLock(async () => {
+      for (const timer of this.delayTimers.values()) {
+        clearTimeout(timer);
+      }
+      this.delayTimers.clear();
+      for (const item of this.queue) {
+        item.released = true;
+      }
+      await this.processQueue();
+    });
+  }
+  /**
+   * Schedule processing on next tick
+   */
+  scheduleProcessing() {
+    if (this.processTimer) {
+      clearTimeout(this.processTimer);
+    }
+    this.processTimer = setTimeout(() => {
+      this.processQueue();
+    }, 0);
+  }
+  /**
+   * Cleanup timers and resources
+   */
+  destroy() {
+    if (this.processTimer) {
+      clearTimeout(this.processTimer);
+    }
+    for (const timer of this.delayTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.delayTimers.clear();
+  }
+}
+
 async function claudeRemoteLauncher(session) {
   logger.debug("[claudeRemoteLauncher] Starting remote launcher");
   const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
@@ -2239,6 +2422,12 @@ async function claudeRemoteLauncher(session) {
   session.client.setHandler("abort", doAbort);
   session.client.setHandler("switch", doSwitch);
   const permissionHandler = new PermissionHandler(session);
+  const messageQueue = new OutgoingMessageQueue(
+    (logMessage) => session.client.sendClaudeSessionMessage(logMessage)
+  );
+  permissionHandler.setOnPermissionRequest((toolCallId) => {
+    messageQueue.releaseToolCall(toolCallId);
+  });
   const sdkToLogConverter = new SDKToLogConverter({
     sessionId: session.sessionId || "unknown",
     cwd: session.path,
@@ -2277,6 +2466,7 @@ async function claudeRemoteLauncher(session) {
         for (let c of umessage.message.content) {
           if (c.type === "tool_result" && c.tool_use_id) {
             ongoingToolCalls.delete(c.tool_use_id);
+            messageQueue.releaseToolCall(c.tool_use_id);
           }
         }
       }
@@ -2338,9 +2528,28 @@ async function claudeRemoteLauncher(session) {
           }
         }
       }
-      if (logMessage.type !== "system") {
-        session.client.sendClaudeSessionMessage(logMessage);
+      if (logMessage.type === "assistant" && message.type === "assistant") {
+        const assistantMsg = message;
+        const toolCallIds = [];
+        if (assistantMsg.message.content && Array.isArray(assistantMsg.message.content)) {
+          for (const block of assistantMsg.message.content) {
+            if (block.type === "tool_use" && block.id) {
+              toolCallIds.push(block.id);
+            }
+          }
+        }
+        if (toolCallIds.length > 0) {
+          const isSidechain = assistantMsg.parent_tool_use_id !== void 0;
+          if (!isSidechain) {
+            messageQueue.enqueue(logMessage, {
+              delay: 250,
+              toolCallIds
+            });
+            return;
+          }
+        }
       }
+      messageQueue.enqueue(logMessage);
     }
     if (message.type === "assistant") {
       let umessage = message;
@@ -2349,7 +2558,7 @@ async function claudeRemoteLauncher(session) {
           if (c.type === "tool_use" && c.name === "Task" && c.input && typeof c.input.prompt === "string") {
             const logMessage2 = sdkToLogConverter.convertSidechainUserMessage(c.id, c.input.prompt);
             if (logMessage2) {
-              session.client.sendClaudeSessionMessage(logMessage2);
+              messageQueue.enqueue(logMessage2);
             }
           }
         }
@@ -2440,6 +2649,8 @@ async function claudeRemoteLauncher(session) {
           }
         }
         ongoingToolCalls.clear();
+        await messageQueue.flush();
+        messageQueue.destroy();
         abortController = null;
         abortFuture?.resolve(void 0);
         abortFuture = null;
@@ -2513,7 +2724,7 @@ async function loop(opts) {
 }
 
 var name = "happy-coder";
-var version = "0.9.0-0";
+var version = "0.9.0-2";
 var description = "Claude Code session sharing CLI";
 var author = "Kirill Dubovitskiy";
 var license = "MIT";

package/dist/lib.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var types = require('./types-D8nxJTr8.cjs');
+var types = require('./types-a-nJyP-e.cjs');
 require('axios');
 require('chalk');
 require('fs');

package/dist/lib.mjs

@@ -1,4 +1,4 @@
-export { A as ApiClient, a as ApiSessionClient, R as RawJSONLinesSchema, c as configuration, l as logger } from './types-CJU8o8xd.mjs';
+export { A as ApiClient, a as ApiSessionClient, R as RawJSONLinesSchema, c as configuration, l as logger } from './types-DJOX-XG-.mjs';
 import 'axios';
 import 'chalk';
 import 'fs';

package/dist/{types-CJU8o8xd.mjs → types-DJOX-XG-.mjs}

@@ -1317,4 +1317,4 @@ const RawJSONLinesSchema = z.discriminatedUnion("type", [
   }).passthrough()
 ]);
 
-export { ApiClient as A, RawJSONLinesSchema as R, ApiSessionClient as a, backoff as b, configuration as c, delay as d, encodeBase64 as e, encodeBase64Url as f, decodeBase64 as g, logger as l };
+export { ApiClient as A, RawJSONLinesSchema as R, ApiSessionClient as a, backoff as b, configuration as c, delay as d, AsyncLock as e, encodeBase64 as f, encodeBase64Url as g, decodeBase64 as h, logger as l };

package/dist/{types-D8nxJTr8.cjs → types-a-nJyP-e.cjs}

@@ -1321,6 +1321,7 @@ const RawJSONLinesSchema = z.z.discriminatedUnion("type", [
 
 exports.ApiClient = ApiClient;
 exports.ApiSessionClient = ApiSessionClient;
+exports.AsyncLock = AsyncLock;
 exports.RawJSONLinesSchema = RawJSONLinesSchema;
 exports.backoff = backoff;
 exports.configuration = configuration;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "happy-coder",
-  "version": "0.9.0-0",
+  "version": "0.9.0-2",
   "description": "Claude Code session sharing CLI",
   "author": "Kirill Dubovitskiy",
   "license": "MIT",