@react-grab/amp 0.0.82

package/dist/client.cjs

@@ -0,0 +1,173 @@
+'use strict';
+
+// src/constants.ts
+var DEFAULT_PORT = 9567;
+var CONNECTION_CHECK_TTL_MS = 5e3;
+
+// src/client.ts
+var DEFAULT_SERVER_URL = `http://localhost:${DEFAULT_PORT}`;
+var STORAGE_KEY = "react-grab:agent-sessions";
+var parseSSEEvent = (eventBlock) => {
+  let eventType = "";
+  let data = "";
+  for (const line of eventBlock.split("\n")) {
+    if (line.startsWith("event:")) eventType = line.slice(6).trim();
+    else if (line.startsWith("data:")) data = line.slice(5).trim();
+  }
+  return { eventType, data };
+};
+async function* streamSSE(stream, signal) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let aborted = false;
+  const onAbort = () => {
+    aborted = true;
+    reader.cancel().catch(() => {
+    });
+  };
+  signal.addEventListener("abort", onAbort);
+  try {
+    if (signal.aborted) {
+      throw new DOMException("Aborted", "AbortError");
+    }
+    while (true) {
+      const result = await reader.read();
+      if (aborted || signal.aborted) {
+        throw new DOMException("Aborted", "AbortError");
+      }
+      const { done, value } = result;
+      if (value) buffer += decoder.decode(value, { stream: true });
+      let boundary;
+      while ((boundary = buffer.indexOf("\n\n")) !== -1) {
+        const { eventType, data } = parseSSEEvent(buffer.slice(0, boundary));
+        buffer = buffer.slice(boundary + 2);
+        if (eventType === "done") return;
+        if (eventType === "error") throw new Error(data || "Agent error");
+        if (data) yield data;
+      }
+      if (done) break;
+    }
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+async function* streamFromServer(serverUrl, context, signal) {
+  const sessionId = context.sessionId;
+  const handleAbort = () => {
+    if (sessionId) {
+      fetch(`${serverUrl}/abort/${sessionId}`, { method: "POST" }).catch(
+        () => {
+        }
+      );
+    }
+  };
+  signal.addEventListener("abort", handleAbort);
+  try {
+    const response = await fetch(`${serverUrl}/agent`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(context),
+      signal
+    });
+    if (!response.ok) {
+      throw new Error(`Server error: ${response.status}`);
+    }
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    yield* streamSSE(response.body, signal);
+  } finally {
+    signal.removeEventListener("abort", handleAbort);
+  }
+}
+var createAmpAgentProvider = (providerOptions = {}) => {
+  const { serverUrl = DEFAULT_SERVER_URL, getOptions } = providerOptions;
+  let connectionCache = null;
+  const mergeOptions = (contextOptions) => ({
+    ...getOptions?.() ?? {},
+    ...contextOptions ?? {}
+  });
+  return {
+    send: async function* (context, signal) {
+      const mergedContext = {
+        ...context,
+        options: mergeOptions(context.options)
+      };
+      yield* streamFromServer(serverUrl, mergedContext, signal);
+    },
+    resume: async function* (sessionId, signal, storage) {
+      const savedSessions = storage.getItem(STORAGE_KEY);
+      if (!savedSessions) {
+        throw new Error("No sessions to resume");
+      }
+      const sessionsObject = JSON.parse(savedSessions);
+      const session = sessionsObject[sessionId];
+      if (!session) {
+        throw new Error(`Session ${sessionId} not found`);
+      }
+      const context = session.context;
+      const mergedContext = {
+        ...context,
+        options: mergeOptions(context.options)
+      };
+      yield "Resuming...";
+      yield* streamFromServer(serverUrl, mergedContext, signal);
+    },
+    supportsResume: true,
+    supportsFollowUp: true,
+    checkConnection: async () => {
+      const now = Date.now();
+      if (connectionCache && now - connectionCache.timestamp < CONNECTION_CHECK_TTL_MS) {
+        return connectionCache.result;
+      }
+      try {
+        const response = await fetch(`${serverUrl}/health`, { method: "GET" });
+        const result = response.ok;
+        connectionCache = { result, timestamp: now };
+        return result;
+      } catch {
+        connectionCache = { result: false, timestamp: now };
+        return false;
+      }
+    },
+    abort: async (sessionId) => {
+      try {
+        await fetch(`${serverUrl}/abort/${sessionId}`, { method: "POST" });
+      } catch {
+      }
+    }
+  };
+};
+var attachAgent = async () => {
+  if (typeof window === "undefined") return;
+  const provider = createAmpAgentProvider();
+  const attach = (api2) => {
+    api2.setAgent({ provider, storage: sessionStorage });
+  };
+  const api = window.__REACT_GRAB__;
+  if (api) {
+    attach(api);
+    return;
+  }
+  window.addEventListener(
+    "react-grab:init",
+    (event) => {
+      const customEvent = event;
+      attach(customEvent.detail);
+    },
+    { once: true }
+  );
+  const apiAfterListener = window.__REACT_GRAB__;
+  if (apiAfterListener) {
+    attach(apiAfterListener);
+  }
+};
+attachAgent();
+
+exports.attachAgent = attachAgent;
+exports.createAmpAgentProvider = createAmpAgentProvider;

package/dist/client.d.cts

@@ -0,0 +1,27 @@
+import { init, AgentContext, AgentSessionStorage } from 'react-grab/core';
+export { AgentCompleteResult } from 'react-grab/core';
+
+interface AmpAgentOptions {
+    cwd?: string;
+}
+type AmpAgentContext = AgentContext<AmpAgentOptions>;
+interface AmpAgentProviderOptions {
+    serverUrl?: string;
+    getOptions?: () => Partial<AmpAgentOptions>;
+}
+declare const createAmpAgentProvider: (providerOptions?: AmpAgentProviderOptions) => {
+    send: (context: AmpAgentContext, signal: AbortSignal) => AsyncGenerator<string, void, unknown>;
+    resume: (sessionId: string, signal: AbortSignal, storage: AgentSessionStorage) => AsyncGenerator<string, void, unknown>;
+    supportsResume: boolean;
+    supportsFollowUp: boolean;
+    checkConnection: () => Promise<boolean>;
+    abort: (sessionId: string) => Promise<void>;
+};
+declare global {
+    interface Window {
+        __REACT_GRAB__?: ReturnType<typeof init>;
+    }
+}
+declare const attachAgent: () => Promise<void>;
+
+export { type AmpAgentOptions, attachAgent, createAmpAgentProvider };

package/dist/client.d.ts

@@ -0,0 +1,27 @@
+import { init, AgentContext, AgentSessionStorage } from 'react-grab/core';
+export { AgentCompleteResult } from 'react-grab/core';
+
+interface AmpAgentOptions {
+    cwd?: string;
+}
+type AmpAgentContext = AgentContext<AmpAgentOptions>;
+interface AmpAgentProviderOptions {
+    serverUrl?: string;
+    getOptions?: () => Partial<AmpAgentOptions>;
+}
+declare const createAmpAgentProvider: (providerOptions?: AmpAgentProviderOptions) => {
+    send: (context: AmpAgentContext, signal: AbortSignal) => AsyncGenerator<string, void, unknown>;
+    resume: (sessionId: string, signal: AbortSignal, storage: AgentSessionStorage) => AsyncGenerator<string, void, unknown>;
+    supportsResume: boolean;
+    supportsFollowUp: boolean;
+    checkConnection: () => Promise<boolean>;
+    abort: (sessionId: string) => Promise<void>;
+};
+declare global {
+    interface Window {
+        __REACT_GRAB__?: ReturnType<typeof init>;
+    }
+}
+declare const attachAgent: () => Promise<void>;
+
+export { type AmpAgentOptions, attachAgent, createAmpAgentProvider };

package/dist/client.global.js

@@ -0,0 +1,4 @@
+var ReactGrabAmp=(function(exports){'use strict';var u=`http://localhost:${9567}`,E="react-grab:agent-sessions",b=s=>{let e="",o="";for(let n of s.split(`
+`))n.startsWith("event:")?e=n.slice(6).trim():n.startsWith("data:")&&(o=n.slice(5).trim());return {eventType:e,data:o}};async function*y(s,e){let o=s.getReader(),n=new TextDecoder,r="",t=false,a=()=>{t=true,o.cancel().catch(()=>{});};e.addEventListener("abort",a);try{if(e.aborted)throw new DOMException("Aborted","AbortError");for(;;){let i=await o.read();if(t||e.aborted)throw new DOMException("Aborted","AbortError");let{done:A,value:l}=i;l&&(r+=n.decode(l,{stream:!0}));let c;for(;(c=r.indexOf(`
+
+`))!==-1;){let{eventType:p,data:d}=b(r.slice(0,c));if(r=r.slice(c+2),p==="done")return;if(p==="error")throw new Error(d||"Agent error");d&&(yield d);}if(A)break}}finally{e.removeEventListener("abort",a);try{o.releaseLock();}catch{}}}async function*m(s,e,o){let n=e.sessionId,r=()=>{n&&fetch(`${s}/abort/${n}`,{method:"POST"}).catch(()=>{});};o.addEventListener("abort",r);try{let t=await fetch(`${s}/agent`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(e),signal:o});if(!t.ok)throw new Error(`Server error: ${t.status}`);if(!t.body)throw new Error("No response body");yield*y(t.body,o);}finally{o.removeEventListener("abort",r);}}var h=(s={})=>{let{serverUrl:e=u,getOptions:o}=s,n=null,r=t=>({...o?.()??{},...t??{}});return {send:async function*(t,a){let i={...t,options:r(t.options)};yield*m(e,i,a);},resume:async function*(t,a,i){let A=i.getItem(E);if(!A)throw new Error("No sessions to resume");let c=JSON.parse(A)[t];if(!c)throw new Error(`Session ${t} not found`);let p=c.context,d={...p,options:r(p.options)};yield "Resuming...",yield*m(e,d,a);},supportsResume:true,supportsFollowUp:true,checkConnection:async()=>{let t=Date.now();if(n&&t-n.timestamp<5e3)return n.result;try{let i=(await fetch(`${e}/health`,{method:"GET"})).ok;return n={result:i,timestamp:t},i}catch{return n={result:false,timestamp:t},false}},abort:async t=>{try{await fetch(`${e}/abort/${t}`,{method:"POST"});}catch{}}}},w=async()=>{if(typeof window>"u")return;let s=h(),e=r=>{r.setAgent({provider:s,storage:sessionStorage});},o=window.__REACT_GRAB__;if(o){e(o);return}window.addEventListener("react-grab:init",r=>{e(r.detail);},{once:true});let n=window.__REACT_GRAB__;n&&e(n);};w();exports.attachAgent=w;exports.createAmpAgentProvider=h;return exports;})({});

package/dist/client.js

@@ -0,0 +1,170 @@
+// src/constants.ts
+var DEFAULT_PORT = 9567;
+var CONNECTION_CHECK_TTL_MS = 5e3;
+
+// src/client.ts
+var DEFAULT_SERVER_URL = `http://localhost:${DEFAULT_PORT}`;
+var STORAGE_KEY = "react-grab:agent-sessions";
+var parseSSEEvent = (eventBlock) => {
+  let eventType = "";
+  let data = "";
+  for (const line of eventBlock.split("\n")) {
+    if (line.startsWith("event:")) eventType = line.slice(6).trim();
+    else if (line.startsWith("data:")) data = line.slice(5).trim();
+  }
+  return { eventType, data };
+};
+async function* streamSSE(stream, signal) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let aborted = false;
+  const onAbort = () => {
+    aborted = true;
+    reader.cancel().catch(() => {
+    });
+  };
+  signal.addEventListener("abort", onAbort);
+  try {
+    if (signal.aborted) {
+      throw new DOMException("Aborted", "AbortError");
+    }
+    while (true) {
+      const result = await reader.read();
+      if (aborted || signal.aborted) {
+        throw new DOMException("Aborted", "AbortError");
+      }
+      const { done, value } = result;
+      if (value) buffer += decoder.decode(value, { stream: true });
+      let boundary;
+      while ((boundary = buffer.indexOf("\n\n")) !== -1) {
+        const { eventType, data } = parseSSEEvent(buffer.slice(0, boundary));
+        buffer = buffer.slice(boundary + 2);
+        if (eventType === "done") return;
+        if (eventType === "error") throw new Error(data || "Agent error");
+        if (data) yield data;
+      }
+      if (done) break;
+    }
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+async function* streamFromServer(serverUrl, context, signal) {
+  const sessionId = context.sessionId;
+  const handleAbort = () => {
+    if (sessionId) {
+      fetch(`${serverUrl}/abort/${sessionId}`, { method: "POST" }).catch(
+        () => {
+        }
+      );
+    }
+  };
+  signal.addEventListener("abort", handleAbort);
+  try {
+    const response = await fetch(`${serverUrl}/agent`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(context),
+      signal
+    });
+    if (!response.ok) {
+      throw new Error(`Server error: ${response.status}`);
+    }
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+    yield* streamSSE(response.body, signal);
+  } finally {
+    signal.removeEventListener("abort", handleAbort);
+  }
+}
+var createAmpAgentProvider = (providerOptions = {}) => {
+  const { serverUrl = DEFAULT_SERVER_URL, getOptions } = providerOptions;
+  let connectionCache = null;
+  const mergeOptions = (contextOptions) => ({
+    ...getOptions?.() ?? {},
+    ...contextOptions ?? {}
+  });
+  return {
+    send: async function* (context, signal) {
+      const mergedContext = {
+        ...context,
+        options: mergeOptions(context.options)
+      };
+      yield* streamFromServer(serverUrl, mergedContext, signal);
+    },
+    resume: async function* (sessionId, signal, storage) {
+      const savedSessions = storage.getItem(STORAGE_KEY);
+      if (!savedSessions) {
+        throw new Error("No sessions to resume");
+      }
+      const sessionsObject = JSON.parse(savedSessions);
+      const session = sessionsObject[sessionId];
+      if (!session) {
+        throw new Error(`Session ${sessionId} not found`);
+      }
+      const context = session.context;
+      const mergedContext = {
+        ...context,
+        options: mergeOptions(context.options)
+      };
+      yield "Resuming...";
+      yield* streamFromServer(serverUrl, mergedContext, signal);
+    },
+    supportsResume: true,
+    supportsFollowUp: true,
+    checkConnection: async () => {
+      const now = Date.now();
+      if (connectionCache && now - connectionCache.timestamp < CONNECTION_CHECK_TTL_MS) {
+        return connectionCache.result;
+      }
+      try {
+        const response = await fetch(`${serverUrl}/health`, { method: "GET" });
+        const result = response.ok;
+        connectionCache = { result, timestamp: now };
+        return result;
+      } catch {
+        connectionCache = { result: false, timestamp: now };
+        return false;
+      }
+    },
+    abort: async (sessionId) => {
+      try {
+        await fetch(`${serverUrl}/abort/${sessionId}`, { method: "POST" });
+      } catch {
+      }
+    }
+  };
+};
+var attachAgent = async () => {
+  if (typeof window === "undefined") return;
+  const provider = createAmpAgentProvider();
+  const attach = (api2) => {
+    api2.setAgent({ provider, storage: sessionStorage });
+  };
+  const api = window.__REACT_GRAB__;
+  if (api) {
+    attach(api);
+    return;
+  }
+  window.addEventListener(
+    "react-grab:init",
+    (event) => {
+      const customEvent = event;
+      attach(customEvent.detail);
+    },
+    { once: true }
+  );
+  const apiAfterListener = window.__REACT_GRAB__;
+  if (apiAfterListener) {
+    attach(apiAfterListener);
+  }
+};
+attachAgent();
+
+export { attachAgent, createAmpAgentProvider };

package/dist/server.cjs

@@ -0,0 +1,159 @@
+'use strict';
+
+var ampSdk = require('@sourcegraph/amp-sdk');
+var fkill = require('fkill');
+var hono = require('hono');
+var cors = require('hono/cors');
+var streaming = require('hono/streaming');
+var nodeServer = require('@hono/node-server');
+var pc = require('picocolors');
+var url = require('url');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fkill__default = /*#__PURE__*/_interopDefault(fkill);
+var pc__default = /*#__PURE__*/_interopDefault(pc);
+
+// src/server.ts
+
+// src/constants.ts
+var DEFAULT_PORT = 9567;
+var VERSION = "0.0.82";
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var threadMap = /* @__PURE__ */ new Map();
+var abortControllers = /* @__PURE__ */ new Map();
+var extractTextFromContent = (content) => {
+  return content.filter((item) => item.type === "text" && item.text).map((item) => item.text).join(" ").trim();
+};
+var createServer = () => {
+  const honoApplication = new hono.Hono();
+  honoApplication.use("*", cors.cors());
+  honoApplication.post("/agent", async (context) => {
+    const requestBody = await context.req.json();
+    const { content, prompt, options, sessionId } = requestBody;
+    const existingThread = sessionId ? threadMap.get(sessionId) : void 0;
+    const isFollowUp = Boolean(existingThread);
+    const userPrompt = isFollowUp ? prompt : `${prompt}
+
+${content}`;
+    return streaming.streamSSE(context, async (stream) => {
+      const abortController = new AbortController();
+      if (sessionId) {
+        abortControllers.set(sessionId, abortController);
+      }
+      const isAborted = () => abortController.signal.aborted;
+      try {
+        await stream.writeSSE({ data: "Thinking...", event: "status" });
+        const executeOptions = {
+          dangerouslyAllowAll: true
+        };
+        if (options?.cwd) {
+          executeOptions.cwd = options.cwd;
+        } else {
+          executeOptions.cwd = process.cwd();
+        }
+        if (isFollowUp && existingThread) {
+          executeOptions.continue = existingThread.threadId;
+        }
+        let capturedThreadId;
+        for await (const message of ampSdk.execute({
+          prompt: userPrompt,
+          options: executeOptions,
+          signal: abortController.signal
+        })) {
+          if (isAborted()) break;
+          switch (message.type) {
+            case "system":
+              if (message.subtype === "init") {
+                const systemMessage = message;
+                if (systemMessage.thread_id) {
+                  capturedThreadId = systemMessage.thread_id;
+                }
+                await stream.writeSSE({ data: "Session started...", event: "status" });
+              }
+              break;
+            case "assistant": {
+              const messageContent = message.message?.content;
+              if (messageContent && Array.isArray(messageContent)) {
+                const toolUse = messageContent.find((item) => item.type === "tool_use");
+                if (toolUse && "name" in toolUse) {
+                  await stream.writeSSE({
+                    data: `Using ${toolUse.name}...`,
+                    event: "status"
+                  });
+                } else {
+                  const textContent = extractTextFromContent(messageContent);
+                  if (textContent && !isAborted()) {
+                    await stream.writeSSE({ data: textContent, event: "status" });
+                  }
+                }
+              }
+              break;
+            }
+            case "result":
+              if (message.is_error) {
+                await stream.writeSSE({
+                  data: `Error: ${message.error || "Unknown error"}`,
+                  event: "error"
+                });
+              } else {
+                await stream.writeSSE({
+                  data: "Completed successfully",
+                  event: "status"
+                });
+              }
+              break;
+          }
+        }
+        if (sessionId && capturedThreadId && !isAborted()) {
+          threadMap.set(sessionId, { threadId: capturedThreadId });
+        }
+        if (!isAborted()) {
+          await stream.writeSSE({ data: "", event: "done" });
+        }
+      } catch (error) {
+        if (!isAborted()) {
+          const errorMessage = error instanceof Error ? error.message : "Unknown error";
+          await stream.writeSSE({
+            data: `Error: ${errorMessage}`,
+            event: "error"
+          });
+          await stream.writeSSE({ data: "", event: "done" });
+        }
+      } finally {
+        if (sessionId) {
+          abortControllers.delete(sessionId);
+        }
+      }
+    });
+  });
+  honoApplication.post("/abort/:sessionId", (context) => {
+    const { sessionId } = context.req.param();
+    const abortController = abortControllers.get(sessionId);
+    if (abortController) {
+      abortController.abort();
+      abortControllers.delete(sessionId);
+    }
+    return context.json({ status: "ok" });
+  });
+  honoApplication.get("/health", (context) => {
+    return context.json({ status: "ok", provider: "amp" });
+  });
+  return honoApplication;
+};
+var startServer = async (port = DEFAULT_PORT) => {
+  await fkill__default.default(`:${port}`, { force: true, silent: true }).catch(() => {
+  });
+  await sleep(100);
+  const honoApplication = createServer();
+  nodeServer.serve({ fetch: honoApplication.fetch, port });
+  console.log(`${pc__default.default.magenta("\u269B")} ${pc__default.default.bold("React Grab")} ${pc__default.default.gray(VERSION)} ${pc__default.default.dim("(Amp)")}`);
+  console.log(`- Local:    ${pc__default.default.cyan(`http://localhost:${port}`)}`);
+};
+if ((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('server.cjs', document.baseURI).href)) === url.pathToFileURL(process.argv[1]).href) {
+  startServer(DEFAULT_PORT).catch(console.error);
+}
+
+exports.createServer = createServer;
+exports.startServer = startServer;

package/dist/server.d.cts

@@ -0,0 +1,10 @@
+import * as hono_types from 'hono/types';
+import { Hono } from 'hono';
+
+interface AmpAgentOptions {
+    cwd?: string;
+}
+declare const createServer: () => Hono<hono_types.BlankEnv, hono_types.BlankSchema, "/">;
+declare const startServer: (port?: number) => Promise<void>;
+
+export { type AmpAgentOptions, createServer, startServer };

package/dist/server.d.ts

@@ -0,0 +1,10 @@
+import * as hono_types from 'hono/types';
+import { Hono } from 'hono';
+
+interface AmpAgentOptions {
+    cwd?: string;
+}
+declare const createServer: () => Hono<hono_types.BlankEnv, hono_types.BlankSchema, "/">;
+declare const startServer: (port?: number) => Promise<void>;
+
+export { type AmpAgentOptions, createServer, startServer };