@react-grab/claude-code 0.1.0-beta.11 → 0.1.0-beta.12

package/dist/cli.cjs

@@ -7877,7 +7877,7 @@ async function fkill(inputs, options = {}) {
   }
 }
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var VERSION = "0.1.0-beta.10";
+var VERSION = "0.1.0-beta.11";
 var checkIfRelayServerIsRunning = async (port, token) => {
   try {
     const healthUrl = token ? `http://localhost:${port}/health?${RELAY_TOKEN_PARAM}=${encodeURIComponent(token)}` : `http://localhost:${port}/health`;

package/dist/cli.js

@@ -7849,7 +7849,7 @@ async function fkill(inputs, options = {}) {
   }
 }
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-var VERSION = "0.1.0-beta.10";
+var VERSION = "0.1.0-beta.11";
 var checkIfRelayServerIsRunning = async (port, token) => {
   try {
     const healthUrl = token ? `http://localhost:${port}/health?${RELAY_TOKEN_PARAM}=${encodeURIComponent(token)}` : `http://localhost:${port}/health`;

package/dist/client.global.js

@@ -1,2 +1,449 @@
-var ReactGrabClaudeCode=(function(exports){'use strict';var q=4722,x=3e3,D="token",G=(i={})=>{let n=i.serverUrl??`ws://localhost:${q}`,c=i.autoReconnect??true,E=i.reconnectIntervalMs??x,h=i.token,s=null,f=false,A=[],C=null,t=null,o=null,w=false,y=new Set,g=new Set,r=new Set,d=()=>{!c||C||w||(C=setTimeout(()=>{C=null,p().catch(()=>{});},E));},l=e=>{try{let a=JSON.parse(e.data);if(a.type==="handlers"&&a.handlers){A=a.handlers;for(let S of g)S(A);}for(let S of y)S(a);}catch{}},p=()=>s?.readyState===WebSocket.OPEN?Promise.resolve():t||(w=false,t=new Promise((e,a)=>{o=a;let S=h?`${n}?${D}=${encodeURIComponent(h)}`:n;s=new WebSocket(S),s.onopen=()=>{t=null,o=null,f=true;for(let P of r)P(true);e();},s.onmessage=l,s.onclose=()=>{o&&(o(new Error("WebSocket connection closed")),o=null),t=null,f=false,A=[];for(let P of g)P(A);for(let P of r)P(false);d();},s.onerror=()=>{t=null,o=null,f=false,a(new Error("WebSocket connection failed"));};}),t),v=()=>{w=true,C&&(clearTimeout(C),C=null),o&&(o(new Error("Connection aborted")),o=null),t=null,s?.close(),s=null,f=false,A=[];},m=()=>f,R=e=>s?.readyState===WebSocket.OPEN?(s.send(JSON.stringify(e)),true):false;return {connect:p,disconnect:v,isConnected:m,sendAgentRequest:(e,a)=>R({type:"agent-request",agentId:e,sessionId:a.sessionId,context:a}),abortAgent:(e,a)=>{R({type:"agent-abort",agentId:e,sessionId:a});},undoAgent:(e,a)=>R({type:"agent-undo",agentId:e,sessionId:a}),redoAgent:(e,a)=>R({type:"agent-redo",agentId:e,sessionId:a}),onMessage:e=>(y.add(e),()=>y.delete(e)),onHandlersChange:e=>(g.add(e),()=>g.delete(e)),onConnectionChange:e=>(r.add(e),queueMicrotask(()=>{r.has(e)&&e(f);}),()=>r.delete(e)),getAvailableHandlers:()=>A}},I=i=>{let{relayClient:n,agentId:c}=i,E=async()=>{if(!n.isConnected())try{await n.connect();}catch{return  false}return n.getAvailableHandlers().includes(c)},h=async function*(t,o){if(o.aborted)throw new DOMException("Aborted","AbortError");yield "Connecting\u2026";let w=t.sessionId??`session-${Date.now()}-${Math.random().toString(36).slice(2)}`,y={...t,sessionId:w},g=[],r=null,d=null,l=false,p=null,v=()=>{n.abortAgent(c,w),l=true,r&&(r({value:void 0,done:true}),r=null,d=null);};o.addEventListener("abort",v);let m=u=>{!u&&!l&&(p="Relay connection lost",l=true,d&&(d(new Error(p)),r=null,d=null));},R=n.onConnectionChange(m),M=n.onMessage(u=>{if(u.sessionId===w)if(u.type==="agent-status"&&u.content){if(g.push(u.content),r){let b=g.shift();b!==void 0&&(r({value:b,done:false}),r=null,d=null);}}else u.type==="agent-done"?(l=true,r&&(r({value:void 0,done:true}),r=null,d=null)):u.type==="agent-error"&&(p=u.content??"Unknown error",l=true,d&&(d(new Error(p)),r=null,d=null));});if(!n.isConnected())throw R(),M(),o.removeEventListener("abort",v),new Error("Relay connection is not open");if(!n.sendAgentRequest(c,y))throw R(),M(),o.removeEventListener("abort",v),new Error("Failed to send agent request: connection not open");try{for(;;){if(g.length>0){let b=g.shift();b!==void 0&&(yield b);continue}if(l||o.aborted)break;let u=await new Promise((b,L)=>{r=b,d=L;});if(u.done)break;yield u.value;}if(p)throw new Error(p)}finally{o.removeEventListener("abort",v),R(),M();}},s=async t=>{n.abortAgent(c,t);},f=t=>new Promise((o,w)=>{let y=false,g=()=>{y||(y=true,r(),d());},r=n.onMessage(l=>{l.sessionId===t&&(g(),l.type==="agent-done"?o():l.type==="agent-error"&&w(new Error(l.content??"Operation failed")));}),d=n.onConnectionChange(l=>{l||(g(),w(new Error("Connection lost while waiting for operation response")));});});return {send:h,abort:s,undo:async()=>{let t=`undo-${c}-${Date.now()}-${Math.random().toString(36).slice(2)}`;if(!n.undoAgent(c,t))throw new Error("Failed to send undo request: connection not open");return f(t)},redo:async()=>{let t=`redo-${c}-${Date.now()}-${Math.random().toString(36).slice(2)}`;if(!n.redoAgent(c,t))throw new Error("Failed to send redo request: connection not open");return f(t)},checkConnection:E,supportsResume:true,supportsFollowUp:true}},_=null,k=()=>typeof window>"u"?null:window.__REACT_GRAB_RELAY__?(_=window.__REACT_GRAB_RELAY__,_):(_||(_=G(),window.__REACT_GRAB_RELAY__=_),_);var O="claude-code",T=i=>typeof i=="object"&&i!==null&&"registerPlugin"in i,Y=(i={})=>{let n=i.relayClient??k();if(!n)throw new Error("RelayClient is required in browser environments");return I({relayClient:n,agentId:O})},N=async()=>{if(typeof window>"u")return;let i=k();if(!i)return;try{await i.connect();}catch{return}let n=I({relayClient:i,agentId:O}),c=s=>{let f={provider:n,storage:sessionStorage},A={name:"claude-code-agent",actions:[{id:"edit-with-claude-code",label:"Edit with Claude",shortcut:"Enter",onAction:C=>{C.enterPromptMode?.(f);},agent:f}]};s.registerPlugin(A);},E=window.__REACT_GRAB__;if(T(E)){c(E);return}window.addEventListener("react-grab:init",s=>{s instanceof CustomEvent&&T(s.detail)&&c(s.detail);},{once:true});let h=window.__REACT_GRAB__;T(h)&&c(h);};N();
-exports.attachAgent=N;exports.createClaudeAgentProvider=Y;return exports;})({});
+var ReactGrabClaudeCode = (function (exports) {
+  'use strict';
+
+  // ../relay/dist/client.js
+  var DEFAULT_RELAY_PORT = 4722;
+  var DEFAULT_RECONNECT_INTERVAL_MS = 3e3;
+  var RELAY_TOKEN_PARAM = "token";
+  var createRelayClient = (options = {}) => {
+    const serverUrl = options.serverUrl ?? `ws://localhost:${DEFAULT_RELAY_PORT}`;
+    const autoReconnect = options.autoReconnect ?? true;
+    const reconnectIntervalMs = options.reconnectIntervalMs ?? DEFAULT_RECONNECT_INTERVAL_MS;
+    const token = options.token;
+    let webSocketConnection = null;
+    let isConnectedState = false;
+    let availableHandlers = [];
+    let reconnectTimeoutId = null;
+    let pendingConnectionPromise = null;
+    let pendingConnectionReject = null;
+    let isIntentionalDisconnect = false;
+    const messageCallbacks = /* @__PURE__ */ new Set();
+    const handlersChangeCallbacks = /* @__PURE__ */ new Set();
+    const connectionChangeCallbacks = /* @__PURE__ */ new Set();
+    const scheduleReconnect = () => {
+      if (!autoReconnect || reconnectTimeoutId || isIntentionalDisconnect) return;
+      reconnectTimeoutId = setTimeout(() => {
+        reconnectTimeoutId = null;
+        connect().catch(() => {
+        });
+      }, reconnectIntervalMs);
+    };
+    const handleMessage = (event) => {
+      try {
+        const message = JSON.parse(event.data);
+        if (message.type === "handlers" && message.handlers) {
+          availableHandlers = message.handlers;
+          for (const callback of handlersChangeCallbacks) {
+            callback(availableHandlers);
+          }
+        }
+        for (const callback of messageCallbacks) {
+          callback(message);
+        }
+      } catch {
+      }
+    };
+    const connect = () => {
+      if (webSocketConnection?.readyState === WebSocket.OPEN) {
+        return Promise.resolve();
+      }
+      if (pendingConnectionPromise) {
+        return pendingConnectionPromise;
+      }
+      isIntentionalDisconnect = false;
+      pendingConnectionPromise = new Promise((resolve, reject) => {
+        pendingConnectionReject = reject;
+        const connectionUrl = token ? `${serverUrl}?${RELAY_TOKEN_PARAM}=${encodeURIComponent(token)}` : serverUrl;
+        webSocketConnection = new WebSocket(connectionUrl);
+        webSocketConnection.onopen = () => {
+          pendingConnectionPromise = null;
+          pendingConnectionReject = null;
+          isConnectedState = true;
+          for (const callback of connectionChangeCallbacks) {
+            callback(true);
+          }
+          resolve();
+        };
+        webSocketConnection.onmessage = handleMessage;
+        webSocketConnection.onclose = () => {
+          if (pendingConnectionReject) {
+            pendingConnectionReject(new Error("WebSocket connection closed"));
+            pendingConnectionReject = null;
+          }
+          pendingConnectionPromise = null;
+          isConnectedState = false;
+          availableHandlers = [];
+          for (const callback of handlersChangeCallbacks) {
+            callback(availableHandlers);
+          }
+          for (const callback of connectionChangeCallbacks) {
+            callback(false);
+          }
+          scheduleReconnect();
+        };
+        webSocketConnection.onerror = () => {
+          pendingConnectionPromise = null;
+          pendingConnectionReject = null;
+          isConnectedState = false;
+          reject(new Error("WebSocket connection failed"));
+        };
+      });
+      return pendingConnectionPromise;
+    };
+    const disconnect = () => {
+      isIntentionalDisconnect = true;
+      if (reconnectTimeoutId) {
+        clearTimeout(reconnectTimeoutId);
+        reconnectTimeoutId = null;
+      }
+      if (pendingConnectionReject) {
+        pendingConnectionReject(new Error("Connection aborted"));
+        pendingConnectionReject = null;
+      }
+      pendingConnectionPromise = null;
+      webSocketConnection?.close();
+      webSocketConnection = null;
+      isConnectedState = false;
+      availableHandlers = [];
+    };
+    const isConnected = () => isConnectedState;
+    const sendMessage = (message) => {
+      if (webSocketConnection?.readyState === WebSocket.OPEN) {
+        webSocketConnection.send(JSON.stringify(message));
+        return true;
+      }
+      return false;
+    };
+    const sendAgentRequest = (agentId, context) => {
+      return sendMessage({
+        type: "agent-request",
+        agentId,
+        sessionId: context.sessionId,
+        context
+      });
+    };
+    const abortAgent = (agentId, sessionId) => {
+      sendMessage({
+        type: "agent-abort",
+        agentId,
+        sessionId
+      });
+    };
+    const undoAgent = (agentId, sessionId) => {
+      return sendMessage({
+        type: "agent-undo",
+        agentId,
+        sessionId
+      });
+    };
+    const redoAgent = (agentId, sessionId) => {
+      return sendMessage({
+        type: "agent-redo",
+        agentId,
+        sessionId
+      });
+    };
+    const onMessage = (callback) => {
+      messageCallbacks.add(callback);
+      return () => messageCallbacks.delete(callback);
+    };
+    const onHandlersChange = (callback) => {
+      handlersChangeCallbacks.add(callback);
+      return () => handlersChangeCallbacks.delete(callback);
+    };
+    const onConnectionChange = (callback) => {
+      connectionChangeCallbacks.add(callback);
+      queueMicrotask(() => {
+        if (connectionChangeCallbacks.has(callback)) {
+          callback(isConnectedState);
+        }
+      });
+      return () => connectionChangeCallbacks.delete(callback);
+    };
+    const getAvailableHandlers = () => availableHandlers;
+    return {
+      connect,
+      disconnect,
+      isConnected,
+      sendAgentRequest,
+      abortAgent,
+      undoAgent,
+      redoAgent,
+      onMessage,
+      onHandlersChange,
+      onConnectionChange,
+      getAvailableHandlers
+    };
+  };
+  var createRelayAgentProvider = (options) => {
+    const { relayClient, agentId } = options;
+    const checkConnection = async () => {
+      if (!relayClient.isConnected()) {
+        try {
+          await relayClient.connect();
+        } catch {
+          return false;
+        }
+      }
+      return relayClient.getAvailableHandlers().includes(agentId);
+    };
+    const send = async function* (context, signal) {
+      if (signal.aborted) {
+        throw new DOMException("Aborted", "AbortError");
+      }
+      yield "Connecting\u2026";
+      const sessionId = context.sessionId ?? `session-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+      const contextWithSession = {
+        ...context,
+        sessionId
+      };
+      const messageQueue = [];
+      let resolveNextMessage = null;
+      let rejectNextMessage = null;
+      let isDone = false;
+      let errorMessage = null;
+      const handleAbort = () => {
+        relayClient.abortAgent(agentId, sessionId);
+        isDone = true;
+        if (resolveNextMessage) {
+          resolveNextMessage({ value: void 0, done: true });
+          resolveNextMessage = null;
+          rejectNextMessage = null;
+        }
+      };
+      signal.addEventListener("abort", handleAbort);
+      const handleConnectionChange = (connected) => {
+        if (!connected && !isDone) {
+          errorMessage = "Relay connection lost";
+          isDone = true;
+          if (rejectNextMessage) {
+            rejectNextMessage(new Error(errorMessage));
+            resolveNextMessage = null;
+            rejectNextMessage = null;
+          }
+        }
+      };
+      const unsubscribeConnection = relayClient.onConnectionChange(
+        handleConnectionChange
+      );
+      const unsubscribeMessage = relayClient.onMessage((message) => {
+        if (message.sessionId !== sessionId) return;
+        if (message.type === "agent-status" && message.content) {
+          messageQueue.push(message.content);
+          if (resolveNextMessage) {
+            const nextMessage = messageQueue.shift();
+            if (nextMessage !== void 0) {
+              resolveNextMessage({ value: nextMessage, done: false });
+              resolveNextMessage = null;
+              rejectNextMessage = null;
+            }
+          }
+        } else if (message.type === "agent-done") {
+          isDone = true;
+          if (resolveNextMessage) {
+            resolveNextMessage({ value: void 0, done: true });
+            resolveNextMessage = null;
+            rejectNextMessage = null;
+          }
+        } else if (message.type === "agent-error") {
+          errorMessage = message.content ?? "Unknown error";
+          isDone = true;
+          if (rejectNextMessage) {
+            rejectNextMessage(new Error(errorMessage));
+            resolveNextMessage = null;
+            rejectNextMessage = null;
+          }
+        }
+      });
+      if (!relayClient.isConnected()) {
+        unsubscribeConnection();
+        unsubscribeMessage();
+        signal.removeEventListener("abort", handleAbort);
+        throw new Error("Relay connection is not open");
+      }
+      const didSendRequest = relayClient.sendAgentRequest(
+        agentId,
+        contextWithSession
+      );
+      if (!didSendRequest) {
+        unsubscribeConnection();
+        unsubscribeMessage();
+        signal.removeEventListener("abort", handleAbort);
+        throw new Error("Failed to send agent request: connection not open");
+      }
+      try {
+        while (true) {
+          if (messageQueue.length > 0) {
+            const next = messageQueue.shift();
+            if (next !== void 0) {
+              yield next;
+            }
+            continue;
+          }
+          if (isDone || signal.aborted) {
+            break;
+          }
+          const result = await new Promise(
+            (resolve, reject) => {
+              resolveNextMessage = resolve;
+              rejectNextMessage = reject;
+            }
+          );
+          if (result.done) break;
+          yield result.value;
+        }
+        if (errorMessage) {
+          throw new Error(errorMessage);
+        }
+      } finally {
+        signal.removeEventListener("abort", handleAbort);
+        unsubscribeConnection();
+        unsubscribeMessage();
+      }
+    };
+    const abort = async (sessionId) => {
+      relayClient.abortAgent(agentId, sessionId);
+    };
+    const waitForOperationResponse = (sessionId) => {
+      return new Promise((resolve, reject) => {
+        let didCleanup = false;
+        const cleanup = () => {
+          if (didCleanup) return;
+          didCleanup = true;
+          unsubscribeMessage();
+          unsubscribeConnection();
+        };
+        const unsubscribeMessage = relayClient.onMessage((message) => {
+          if (message.sessionId !== sessionId) return;
+          cleanup();
+          if (message.type === "agent-done") {
+            resolve();
+          } else if (message.type === "agent-error") {
+            reject(new Error(message.content ?? "Operation failed"));
+          }
+        });
+        const unsubscribeConnection = relayClient.onConnectionChange(
+          (connected) => {
+            if (!connected) {
+              cleanup();
+              reject(
+                new Error("Connection lost while waiting for operation response")
+              );
+            }
+          }
+        );
+      });
+    };
+    const undo = async () => {
+      const sessionId = `undo-${agentId}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+      const didSend = relayClient.undoAgent(agentId, sessionId);
+      if (!didSend) {
+        throw new Error("Failed to send undo request: connection not open");
+      }
+      return waitForOperationResponse(sessionId);
+    };
+    const redo = async () => {
+      const sessionId = `redo-${agentId}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+      const didSend = relayClient.redoAgent(agentId, sessionId);
+      if (!didSend) {
+        throw new Error("Failed to send redo request: connection not open");
+      }
+      return waitForOperationResponse(sessionId);
+    };
+    return {
+      send,
+      abort,
+      undo,
+      redo,
+      checkConnection,
+      supportsResume: true,
+      supportsFollowUp: true
+    };
+  };
+  var defaultRelayClient = null;
+  var getDefaultRelayClient = () => {
+    if (typeof window === "undefined") {
+      return null;
+    }
+    if (window.__REACT_GRAB_RELAY__) {
+      defaultRelayClient = window.__REACT_GRAB_RELAY__;
+      return defaultRelayClient;
+    }
+    if (!defaultRelayClient) {
+      defaultRelayClient = createRelayClient();
+      window.__REACT_GRAB_RELAY__ = defaultRelayClient;
+    }
+    return defaultRelayClient;
+  };
+
+  // src/client.ts
+  var AGENT_ID = "claude-code";
+  var isReactGrabApi = (value) => typeof value === "object" && value !== null && "registerPlugin" in value;
+  var createClaudeAgentProvider = (providerOptions = {}) => {
+    const relayClient = providerOptions.relayClient ?? getDefaultRelayClient();
+    if (!relayClient) {
+      throw new Error("RelayClient is required in browser environments");
+    }
+    return createRelayAgentProvider({
+      relayClient,
+      agentId: AGENT_ID
+    });
+  };
+  var attachAgent = async () => {
+    if (typeof window === "undefined") return;
+    const relayClient = getDefaultRelayClient();
+    if (!relayClient) return;
+    try {
+      await relayClient.connect();
+    } catch {
+      return;
+    }
+    const provider = createRelayAgentProvider({
+      relayClient,
+      agentId: AGENT_ID
+    });
+    const attach = (api) => {
+      const agent = { provider, storage: sessionStorage };
+      const plugin = {
+        name: "claude-code-agent",
+        actions: [
+          {
+            id: "edit-with-claude-code",
+            label: "Edit with Claude",
+            shortcut: "Enter",
+            onAction: (actionContext) => {
+              actionContext.enterPromptMode?.(agent);
+            },
+            agent
+          }
+        ]
+      };
+      api.registerPlugin(plugin);
+    };
+    const existingApi = window.__REACT_GRAB__;
+    if (isReactGrabApi(existingApi)) {
+      attach(existingApi);
+      return;
+    }
+    window.addEventListener(
+      "react-grab:init",
+      (event) => {
+        if (!(event instanceof CustomEvent)) return;
+        if (!isReactGrabApi(event.detail)) return;
+        attach(event.detail);
+      },
+      { once: true }
+    );
+    const apiAfterListener = window.__REACT_GRAB__;
+    if (isReactGrabApi(apiAfterListener)) {
+      attach(apiAfterListener);
+    }
+  };
+  attachAgent();
+
+  exports.attachAgent = attachAgent;
+  exports.createClaudeAgentProvider = createClaudeAgentProvider;
+
+  return exports;
+
+})({});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-grab/claude-code",
-  "version": "0.1.0-beta.11",
+  "version": "0.1.0-beta.12",
   "type": "module",
   "bin": {
     "react-grab-claude-code": "./dist/cli.cjs"
@@ -26,12 +26,12 @@
   "devDependencies": {
     "@types/node": "^22.10.7",
     "tsup": "^8.4.0",
-    "@react-grab/utils": "0.1.0-beta.11"
+    "@react-grab/utils": "0.1.0-beta.12"
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.1.0",
-    "@react-grab/relay": "0.1.0-beta.11",
-    "react-grab": "0.1.0-beta.11"
+    "@react-grab/relay": "0.1.0-beta.12",
+    "react-grab": "0.1.0-beta.12"
   },
   "scripts": {
     "dev": "tsup --watch",