usemycontext 1.0.0 → 1.0.1

package/dist/react.d.cts

@@ -0,0 +1,49 @@
+import * as React from 'react';
+import { C as ClientOptions, d as ConnectState, U as UseMyContextClient, c as ConnectArgs } from './client-mXQsH2mZ.cjs';
+
+/** What the React hook returns: the live state + the client's bound methods. */
+interface UseMyContextReactValue {
+    /** The current connect state (re-renders on change). */
+    state: ConnectState;
+    /** Convenience: true iff `state === "connected"`. */
+    connected: boolean;
+    /** The held token when connected, else null. */
+    token: string | null;
+    /** The underlying framework-free client (the 7 wrappers live here). */
+    client: UseMyContextClient;
+    /** v1 TOKEN-IN connect. */
+    connect: (args: ConnectArgs) => Promise<ConnectState>;
+    /** Clear the token; -> `disconnected`. */
+    disconnect: () => void;
+}
+/**
+ * The React hook. Creates ONE stable client per component instance and
+ * subscribes to its state so the component re-renders on every transition.
+ */
+declare function useMyContextReact(options?: ClientOptions): UseMyContextReactValue;
+/** Props for the drop-in button. */
+interface ConnectMyContextProps {
+    /**
+     * v1 is TOKEN-IN: supply the user's token (the full browser-OAuth popup is
+     * v2). When given, the button calls `connect({ token })` on click.
+     */
+    token?: string;
+    /** Forwarded to the underlying client (endpoint / transport / storage). */
+    options?: ClientOptions;
+    /** Called after a successful connect. */
+    onConnect?: (state: ConnectState) => void;
+    /** Called when a connect fails. */
+    onError?: (error: unknown) => void;
+    /** Override the button label per state. */
+    label?: Partial<Record<ConnectState, string>>;
+    /** Extra class name(s) for the button. */
+    className?: string;
+}
+/**
+ * A zero-config connect button. Renders a single <button> whose label tracks the
+ * connect state; clicking it runs the v1 token-in connect. Unstyled beyond a
+ * stable class name (`umc-connect-button`) so the host owns the look.
+ */
+declare function ConnectMyContext(props: ConnectMyContextProps): React.ReactElement;
+
+export { ConnectMyContext, type ConnectMyContextProps, type UseMyContextReactValue, useMyContextReact };

package/dist/react.d.ts

@@ -0,0 +1,49 @@
+import * as React from 'react';
+import { C as ClientOptions, d as ConnectState, U as UseMyContextClient, c as ConnectArgs } from './client-mXQsH2mZ.js';
+
+/** What the React hook returns: the live state + the client's bound methods. */
+interface UseMyContextReactValue {
+    /** The current connect state (re-renders on change). */
+    state: ConnectState;
+    /** Convenience: true iff `state === "connected"`. */
+    connected: boolean;
+    /** The held token when connected, else null. */
+    token: string | null;
+    /** The underlying framework-free client (the 7 wrappers live here). */
+    client: UseMyContextClient;
+    /** v1 TOKEN-IN connect. */
+    connect: (args: ConnectArgs) => Promise<ConnectState>;
+    /** Clear the token; -> `disconnected`. */
+    disconnect: () => void;
+}
+/**
+ * The React hook. Creates ONE stable client per component instance and
+ * subscribes to its state so the component re-renders on every transition.
+ */
+declare function useMyContextReact(options?: ClientOptions): UseMyContextReactValue;
+/** Props for the drop-in button. */
+interface ConnectMyContextProps {
+    /**
+     * v1 is TOKEN-IN: supply the user's token (the full browser-OAuth popup is
+     * v2). When given, the button calls `connect({ token })` on click.
+     */
+    token?: string;
+    /** Forwarded to the underlying client (endpoint / transport / storage). */
+    options?: ClientOptions;
+    /** Called after a successful connect. */
+    onConnect?: (state: ConnectState) => void;
+    /** Called when a connect fails. */
+    onError?: (error: unknown) => void;
+    /** Override the button label per state. */
+    label?: Partial<Record<ConnectState, string>>;
+    /** Extra class name(s) for the button. */
+    className?: string;
+}
+/**
+ * A zero-config connect button. Renders a single <button> whose label tracks the
+ * connect state; clicking it runs the v1 token-in connect. Unstyled beyond a
+ * stable class name (`umc-connect-button`) so the host owns the look.
+ */
+declare function ConnectMyContext(props: ConnectMyContextProps): React.ReactElement;
+
+export { ConnectMyContext, type ConnectMyContextProps, type UseMyContextReactValue, useMyContextReact };

package/dist/react.js

@@ -0,0 +1,503 @@
+import * as React from 'react';
+
+// src/react.tsx
+
+// src/jsonrpc.ts
+var UseMyContextError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UseMyContextError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var NotConnectedError = class extends UseMyContextError {
+  constructor(message = "Not connected. Call connect({ token }) first.") {
+    super(message);
+    this.name = "NotConnectedError";
+  }
+};
+var TokenExpiredError = class extends UseMyContextError {
+  constructor(message = "The connection token was rejected (expired or revoked).", wwwAuthenticate) {
+    super(message);
+    this.name = "TokenExpiredError";
+    this.wwwAuthenticate = wwwAuthenticate;
+  }
+};
+var ScopeDeniedError = class extends UseMyContextError {
+  constructor(message) {
+    super(message);
+    this.code = -32604;
+    this.name = "ScopeDeniedError";
+  }
+};
+var ToolCallError = class extends UseMyContextError {
+  constructor(message, code) {
+    super(message);
+    this.name = "ToolCallError";
+    this.code = code;
+  }
+};
+var TransportError = class extends UseMyContextError {
+  constructor(message) {
+    super(message);
+    this.name = "TransportError";
+  }
+};
+var nextId = 1;
+function initializeRequest() {
+  return {
+    jsonrpc: "2.0",
+    id: nextId++,
+    method: "initialize",
+    params: {
+      protocolVersion: "2025-06-18",
+      capabilities: {},
+      clientInfo: { name: "usemycontext-sdk", version: "0.1.0" }
+    }
+  };
+}
+function toolCallRequest(name, args) {
+  return {
+    jsonrpc: "2.0",
+    id: nextId++,
+    method: "tools/call",
+    params: { name, arguments: args }
+  };
+}
+function asJsonRpcResponse(body) {
+  if (body === null || typeof body !== "object") {
+    throw new TransportError("Membrane returned a non-object response body.");
+  }
+  const b = body;
+  if (b.jsonrpc !== "2.0") {
+    throw new TransportError("Membrane response was not JSON-RPC 2.0.");
+  }
+  return b;
+}
+function isScopeDenied(code) {
+  return code === -32604;
+}
+function resultText(result) {
+  for (const block of result.content ?? []) {
+    if (block.type === "text" && typeof block.text === "string") return block.text;
+  }
+  return "";
+}
+
+// src/machine.ts
+var INITIAL_STATE = "idle";
+function reduce(state, event) {
+  switch (event.type) {
+    case "CONNECT":
+      return state === "connecting" ? state : "connecting";
+    case "CONNECT_SUCCESS":
+      return state === "connecting" ? "connected" : state;
+    case "CONNECT_DECLINED":
+      return state === "connecting" ? "declined" : state;
+    case "ERROR":
+      return state === "connecting" ? "error" : state;
+    case "TOKEN_EXPIRED":
+      return state === "connecting" || state === "connected" ? "expired" : state;
+    case "DISCONNECT":
+      return state === "disconnected" ? state : "disconnected";
+    default: {
+      return state;
+    }
+  }
+}
+function isConnected(state) {
+  return state === "connected";
+}
+
+// src/storage.ts
+var DEFAULT_STORAGE_KEY = "usemycontext.token";
+function memoryStorage() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    get: (k) => map.has(k) ? map.get(k) : null,
+    set: (k, v) => void map.set(k, v),
+    remove: (k) => void map.delete(k)
+  };
+}
+function webStorage(store) {
+  return {
+    get: (k) => {
+      try {
+        return store.getItem(k);
+      } catch {
+        return null;
+      }
+    },
+    set: (k, v) => {
+      try {
+        store.setItem(k, v);
+      } catch {
+      }
+    },
+    remove: (k) => {
+      try {
+        store.removeItem(k);
+      } catch {
+      }
+    }
+  };
+}
+function resolveStorage(opt) {
+  if (opt === null) {
+    return { get: () => null, set: () => {
+    }, remove: () => {
+    } };
+  }
+  if (opt) return opt;
+  try {
+    if (typeof globalThis !== "undefined") {
+      const ls = globalThis.localStorage;
+      if (ls) {
+        const probe = "__umc_probe__";
+        ls.setItem(probe, "1");
+        ls.removeItem(probe);
+        return webStorage(ls);
+      }
+    }
+  } catch {
+  }
+  return memoryStorage();
+}
+
+// src/transport.ts
+var fetchTransport = async ({ url, token, body }) => {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      accept: "application/json",
+      authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify(body)
+  });
+  let parsed = null;
+  try {
+    parsed = await res.json();
+  } catch {
+    parsed = null;
+  }
+  return {
+    status: res.status,
+    body: parsed,
+    wwwAuthenticate: res.headers.get("www-authenticate")
+  };
+};
+
+// src/client.ts
+var DEFAULT_ENDPOINT = "https://mcp.usemycontext.ai/mcp";
+function useMyContext(options = {}) {
+  const endpoint = options.endpoint ?? DEFAULT_ENDPOINT;
+  const transport = options.transport ?? fetchTransport;
+  const storage = resolveStorage(options.storage);
+  const storageKey = options.storageKey ?? DEFAULT_STORAGE_KEY;
+  const listeners = /* @__PURE__ */ new Set();
+  let state = INITIAL_STATE;
+  let token = null;
+  const persisted = storage.get(storageKey);
+  if (persisted) {
+    token = persisted;
+    state = "connected";
+  }
+  function setState(next) {
+    if (next === state) return;
+    state = next;
+    options.onStateChange?.(state);
+    for (const l of listeners) l(state);
+  }
+  function dispatch(event) {
+    setState(reduce(state, event));
+  }
+  async function rpc(body) {
+    if (!token) throw new NotConnectedError();
+    let res;
+    try {
+      res = await transport({ url: endpoint, token, body });
+    } catch (e) {
+      throw new TransportError(
+        `Transport failed: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+    if (res.status === 401) {
+      dispatch({ type: "TOKEN_EXPIRED" });
+      throw new TokenExpiredError(void 0, res.wwwAuthenticate ?? void 0);
+    }
+    const parsed = asJsonRpcResponse(res.body);
+    if (parsed.error) {
+      if (isScopeDenied(parsed.error.code)) {
+        throw new ScopeDeniedError(parsed.error.message);
+      }
+      throw new ToolCallError(parsed.error.message, parsed.error.code);
+    }
+    return parsed.result;
+  }
+  async function callTool(name, args) {
+    if (!isConnected(state)) throw new NotConnectedError();
+    const result = await rpc(toolCallRequest(name, args));
+    if (result.isError) {
+      throw new ToolCallError(resultText(result) || `${name} failed.`);
+    }
+    return resultText(result);
+  }
+  return {
+    get state() {
+      return state;
+    },
+    get connected() {
+      return state === "connected";
+    },
+    get token() {
+      return state === "connected" ? token : null;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => void listeners.delete(listener);
+    },
+    async connect({ token: t }) {
+      if (typeof t !== "string" || t.length === 0) {
+        throw new UseMyContextConnectArgError();
+      }
+      dispatch({ type: "CONNECT" });
+      token = t;
+      try {
+        const res = await transport({ url: endpoint, token: t, body: initializeRequest() });
+        if (res.status === 401) {
+          token = null;
+          dispatch({ type: "TOKEN_EXPIRED" });
+          throw new TokenExpiredError(void 0, res.wwwAuthenticate ?? void 0);
+        }
+        const parsed = asJsonRpcResponse(res.body);
+        if (parsed.error) {
+          token = null;
+          dispatch({ type: "ERROR" });
+          throw new ToolCallError(parsed.error.message, parsed.error.code);
+        }
+        dispatch({ type: "CONNECT_SUCCESS" });
+        if (storage) storage.set(storageKey, t);
+        return state;
+      } catch (e) {
+        token = null;
+        if (!(e instanceof TokenExpiredError)) {
+          dispatch({ type: "ERROR" });
+          if (e instanceof TransportError || e instanceof ToolCallError) throw e;
+          throw new TransportError(
+            `Connect failed: ${e instanceof Error ? e.message : String(e)}`
+          );
+        }
+        throw e;
+      }
+    },
+    disconnect() {
+      token = null;
+      storage.remove(storageKey);
+      dispatch({ type: "DISCONNECT" });
+    },
+    // --- profile ---------------------------------------------------------
+    async profile() {
+      const text = await callTool("profile", {});
+      const facts = tryParseFacts(text);
+      if (facts) return { composite: text, facts };
+      return { composite: text };
+    },
+    // --- list_files / search_files (JSON array of FileMeta) --------------
+    async listFiles() {
+      return parseFileList(await callTool("list_files", {}));
+    },
+    async searchFiles(query) {
+      if (typeof query !== "string") throw new UseMyContextConnectArgError("search query must be a string");
+      return parseFileList(await callTool("search_files", { query }));
+    },
+    // --- get_file --------------------------------------------------------
+    async getFile(fileId) {
+      if (typeof fileId !== "string" || !fileId) {
+        throw new UseMyContextConnectArgError("fileId must be a non-empty string");
+      }
+      const text = await callTool("get_file", { fileId });
+      return { text, downloadUrl: parseDownloadUrl(text) };
+    },
+    // --- ask_docs --------------------------------------------------------
+    async ask(query, opts = {}) {
+      if (typeof query !== "string" || !query) {
+        throw new UseMyContextConnectArgError("ask query must be a non-empty string");
+      }
+      const args = { query };
+      if (typeof opts.k === "number") args.k = opts.k;
+      if (typeof opts.projectId === "string") args.projectId = opts.projectId;
+      const text = await callTool("ask_docs", args);
+      return { passages: parseAskPassages(text), text };
+    },
+    // --- suggest_update (the one write) ----------------------------------
+    async suggestUpdate(suggestion) {
+      if (typeof suggestion !== "string" || !suggestion.trim()) {
+        throw new UseMyContextConnectArgError("suggestion must be a non-empty string");
+      }
+      const text = await callTool("suggest_update", { suggestion });
+      const m = text.match(/\(id:\s*([^)]+)\)/);
+      return { id: m ? m[1].trim() : void 0, text };
+    },
+    // --- shared_context --------------------------------------------------
+    async sharedContext(from) {
+      const args = {};
+      if (typeof from === "string" && from) args.from = from;
+      const text = await callTool("shared_context", args);
+      return from ? parseSharedRead(text) : parseSharedList(text);
+    }
+  };
+}
+var UseMyContextConnectArgError = class extends UseMyContextError {
+  constructor(message = "connect() requires a non-empty token string.") {
+    super(message);
+    this.name = "UseMyContextConnectArgError";
+  }
+};
+function tryParseFacts(text) {
+  const trimmed = text.trimStart();
+  if (!trimmed.startsWith("{")) return void 0;
+  try {
+    const obj = JSON.parse(text);
+    if (Array.isArray(obj.facts)) return obj.facts.filter((f) => typeof f === "string");
+  } catch {
+  }
+  return void 0;
+}
+function parseFileList(text) {
+  try {
+    const arr = JSON.parse(text);
+    if (!Array.isArray(arr)) return [];
+    return arr.map((r) => {
+      const o = r ?? {};
+      return {
+        id: String(o.id ?? ""),
+        name: String(o.name ?? ""),
+        size: typeof o.size === "number" ? o.size : 0,
+        contentType: String(o.contentType ?? ""),
+        modified: String(o.modified ?? ""),
+        ...typeof o.status === "string" ? { status: o.status } : {}
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+function parseDownloadUrl(text) {
+  const m = text.match(/Download link[^:]*:\s*(\S+)/);
+  return m ? m[1] : void 0;
+}
+function parseAskPassages(text) {
+  if (/^No relevant passages/i.test(text.trimStart())) return [];
+  const blocks = text.split("\n\n");
+  const out = [];
+  for (const block of blocks) {
+    const nl = block.indexOf("\n");
+    const citation = nl === -1 ? block : block.slice(0, nl);
+    const body = nl === -1 ? "" : block.slice(nl + 1);
+    const m = citation.match(/^\[(\d+)\]\s*(.*)$/);
+    if (!m) continue;
+    const index = Number(m[1]);
+    const rest = m[2];
+    const parts = rest.split(" \xB7 ");
+    const passage = { index, text: body };
+    if (parts[0]) passage.file = parts[0].trim();
+    if (parts[1]) passage.scope = parts[1].trim();
+    const scoreM = rest.match(/score\s+([\d.]+)/);
+    if (scoreM) passage.score = Number(scoreM[1]);
+    out.push(passage);
+  }
+  return out;
+}
+function parseSharedList(text) {
+  if (/^No one has shared/i.test(text.trimStart())) {
+    return { mode: "list", shares: [], composite: null, text };
+  }
+  const shares = [];
+  for (const line of text.split("\n")) {
+    const m = line.match(/^-\s*(.*?)\s*\(from:\s*([^)]+)\)\s*$/);
+    if (m) shares.push({ ownerLabel: m[1].trim(), grantId: m[2].trim() });
+  }
+  return { mode: "list", shares, composite: null, text };
+}
+function parseSharedRead(text) {
+  if (/not available/i.test(text)) {
+    return { mode: "read", shares: [], composite: null, text };
+  }
+  const m = text.match(/^Shared context from [^:]*:\n\n([\s\S]*)$/);
+  const composite = m ? m[1] : text;
+  return { mode: "read", shares: [], composite, text };
+}
+
+// src/react.tsx
+function useMyContextReact(options = {}) {
+  const clientRef = React.useRef(null);
+  if (clientRef.current === null) {
+    clientRef.current = useMyContext(options);
+  }
+  const client = clientRef.current;
+  const [state, setState] = React.useState(client.state);
+  React.useEffect(() => {
+    setState(client.state);
+    const unsub = client.subscribe(setState);
+    return unsub;
+  }, [client]);
+  const connect = React.useCallback((args) => client.connect(args), [client]);
+  const disconnect = React.useCallback(() => client.disconnect(), [client]);
+  return {
+    state,
+    connected: state === "connected",
+    token: client.token,
+    client,
+    connect,
+    disconnect
+  };
+}
+var DEFAULT_LABELS = {
+  idle: "Connect my context",
+  connecting: "Connecting...",
+  connected: "Connected",
+  declined: "Connect my context",
+  expired: "Reconnect my context",
+  error: "Retry connect",
+  disconnected: "Connect my context"
+};
+function ConnectMyContext(props) {
+  const { token, options, onConnect, onError, label, className } = props;
+  const { state, connect, disconnect } = useMyContextReact(options);
+  const text = label && label[state] || DEFAULT_LABELS[state];
+  const busy = state === "connecting";
+  const isConnected2 = state === "connected";
+  const onClick = React.useCallback(async () => {
+    if (isConnected2) {
+      disconnect();
+      return;
+    }
+    if (!token) {
+      onError?.(new Error("ConnectMyContext: no `token` prop (v1 is token-in only)."));
+      return;
+    }
+    try {
+      const next = await connect({ token });
+      onConnect?.(next);
+    } catch (e) {
+      onError?.(e);
+    }
+  }, [isConnected2, disconnect, token, connect, onConnect, onError]);
+  return React.createElement(
+    "button",
+    {
+      type: "button",
+      className: ["umc-connect-button", className].filter(Boolean).join(" "),
+      "data-umc-state": state,
+      disabled: busy,
+      "aria-busy": busy || void 0,
+      onClick
+    },
+    isConnected2 ? "Disconnect" : text
+  );
+}
+
+export { ConnectMyContext, useMyContextReact };
+//# sourceMappingURL=react.js.map
+//# sourceMappingURL=react.js.map