@sinas/sdk 0.2.3 → 0.5.0

package/dist/index.cjs

@@ -32,19 +32,26 @@ var src_exports = {};
 __export(src_exports, {
   SinasAuthError: () => SinasAuthError,
   SinasClient: () => SinasClient,
+  SinasClientAuth: () => SinasClientAuth,
   SinasError: () => SinasError,
   SinasNotFoundError: () => SinasNotFoundError,
   SinasPermissionError: () => SinasPermissionError,
   SinasProvider: () => SinasProvider,
   SinasTimeoutError: () => SinasTimeoutError,
   approveToolCall: () => approveToolCall,
+  checkPermissions: () => checkPermissions,
   createChat: () => createChat,
   executeFunction: () => executeFunction,
   executeQuery: () => executeQuery,
   generateFileUrl: () => generateFileUrl,
   getChat: () => getChat,
+  getInfo: () => getInfo,
+  getMe: () => getMe,
   listCollections: () => listCollections,
   listFiles: () => listFiles,
+  login: () => login,
+  logout: () => logout,
+  refresh: () => refresh,
   sendMessage: () => sendMessage,
   stateDelete: () => stateDelete,
   stateGet: () => stateGet,
@@ -53,12 +60,14 @@ __export(src_exports, {
   streamFromChannel: () => streamFromChannel,
   streamMessage: () => streamMessage,
   uploadFile: () => uploadFile,
+  useAuth: () => useAuth,
   useChat: () => useChat,
   useClient: () => useClient,
   useExecute: () => useExecute,
   useQuery: () => useQuery,
   useSinas: () => useSinas,
-  useStateStore: () => useStateStore
+  useStateStore: () => useStateStore,
+  verifyOTP: () => verifyOTP
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -96,16 +105,131 @@ var SinasTimeoutError = class extends SinasError {
   }
 };
 
+// src/client/auth.ts
+function trimBase(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+async function authFetch(baseUrl, path, init = {}, accessToken) {
+  const headers = new Headers(init.headers);
+  if (!headers.has("Content-Type") && init.body !== void 0) {
+    headers.set("Content-Type", "application/json");
+  }
+  if (accessToken) headers.set("Authorization", `Bearer ${accessToken}`);
+  const res = await fetch(`${trimBase(baseUrl)}${path}`, { ...init, headers });
+  if (res.ok || res.status === 204) return res;
+  let detail = res.statusText;
+  try {
+    const body = await res.clone().json();
+    detail = body.detail || body.message || detail;
+  } catch {
+  }
+  if (res.status === 401) throw new SinasAuthError(detail);
+  if (res.status === 403) throw new SinasPermissionError(detail);
+  if (res.status === 404) throw new SinasNotFoundError(detail);
+  throw new SinasError(detail, res.status, detail);
+}
+async function getInfo(baseUrl) {
+  const res = await authFetch(baseUrl, "/info");
+  return await res.json();
+}
+async function login(baseUrl, request) {
+  const res = await authFetch(baseUrl, "/auth/login", {
+    method: "POST",
+    body: JSON.stringify(request)
+  });
+  return await res.json();
+}
+async function verifyOTP(baseUrl, request) {
+  const res = await authFetch(baseUrl, "/auth/verify-otp", {
+    method: "POST",
+    body: JSON.stringify(request)
+  });
+  return await res.json();
+}
+async function refresh(baseUrl, refreshToken) {
+  const res = await authFetch(baseUrl, "/auth/refresh", {
+    method: "POST",
+    body: JSON.stringify({ refresh_token: refreshToken })
+  });
+  return await res.json();
+}
+async function logout(baseUrl, refreshToken) {
+  try {
+    await authFetch(baseUrl, "/auth/logout", {
+      method: "POST",
+      body: JSON.stringify({ refresh_token: refreshToken })
+    });
+  } catch (e) {
+    if (e instanceof SinasNotFoundError) return;
+    throw e;
+  }
+}
+async function getMe(baseUrl, accessToken) {
+  const res = await authFetch(baseUrl, "/auth/me", { method: "GET" }, accessToken);
+  return await res.json();
+}
+async function checkPermissions(baseUrl, accessToken, request) {
+  const res = await authFetch(
+    baseUrl,
+    "/auth/check-permissions",
+    {
+      method: "POST",
+      body: JSON.stringify({ logic: "AND", ...request })
+    },
+    accessToken
+  );
+  return await res.json();
+}
+
 // src/client/SinasClient.ts
+function hasWindow() {
+  return typeof window !== "undefined";
+}
+function trim(url) {
+  return url.replace(/\/+$/, "");
+}
+var SinasClientAuth = class {
+  constructor(client) {
+    this.client = client;
+  }
+  getInfo() {
+    return getInfo(this.client.requireBaseUrl());
+  }
+  login(request) {
+    return login(this.client.requireBaseUrl(), request);
+  }
+  verifyOTP(request) {
+    return verifyOTP(this.client.requireBaseUrl(), request);
+  }
+  refresh(refreshToken) {
+    return refresh(this.client.requireBaseUrl(), refreshToken);
+  }
+  logout(refreshToken) {
+    return logout(this.client.requireBaseUrl(), refreshToken);
+  }
+  getMe() {
+    const token = this.client.getAccessToken();
+    if (!token) throw new SinasAuthError("No access token available");
+    return getMe(this.client.requireBaseUrl(), token);
+  }
+  checkPermissions(request) {
+    const token = this.client.getAccessToken();
+    if (!token) throw new SinasAuthError("No access token available");
+    return checkPermissions(this.client.requireBaseUrl(), token, request);
+  }
+};
 var SinasClient = class {
-  constructor(config) {
-    this.configOverride = config;
+  constructor(options = {}) {
+    this.refreshInFlight = null;
+    this.options = options;
+    this.auth = new SinasClientAuth(this);
   }
+  // ─── Config / base URL ───
   getConfig() {
-    const config = this.configOverride || window.__SINAS_CONFIG__;
+    const config = this.options.config || (hasWindow() ? window.__SINAS_CONFIG__ : void 0);
     if (!config) {
       return {
-        apiBase: "",
+        apiBase: this.options.baseUrl ? `${trim(this.options.baseUrl)}/api/v1` : "",
         component: { namespace: "", name: "", version: "" },
         resources: {
           enabledAgents: [],
@@ -122,12 +246,56 @@ var SinasClient = class {
   getInput() {
     return this.getConfig().input || {};
   }
+  /** Workspace base URL (root of the Sinas instance). Throws if unset. */
+  requireBaseUrl() {
+    const url = this.getBaseUrl();
+    if (!url) {
+      throw new SinasError(
+        "No baseUrl configured. Construct with `new SinasClient({ baseUrl })` for standalone use.",
+        0
+      );
+    }
+    return url;
+  }
+  getBaseUrl() {
+    if (this.options.baseUrl) return trim(this.options.baseUrl);
+    const apiBase = this.getConfig().apiBase;
+    if (!apiBase) return null;
+    return trim(apiBase).replace(/\/api\/v1$/, "");
+  }
+  // ─── Tokens ───
+  getAccessToken() {
+    if (this.options.getAccessToken) return this.options.getAccessToken();
+    if (hasWindow()) return window.__SINAS_AUTH_TOKEN__ ?? null;
+    return null;
+  }
+  getRefreshToken() {
+    return this.options.getRefreshToken ? this.options.getRefreshToken() : null;
+  }
+  async tryRefresh() {
+    const refreshToken = this.getRefreshToken();
+    if (!refreshToken) return null;
+    if (this.refreshInFlight) return this.refreshInFlight;
+    const baseUrl = this.getBaseUrl();
+    if (!baseUrl) return null;
+    this.refreshInFlight = (async () => {
+      try {
+        const resp = await refresh(baseUrl, refreshToken);
+        this.options.onTokenRefresh?.(resp.access_token);
+        return resp.access_token;
+      } catch {
+        return null;
+      } finally {
+        this.refreshInFlight = null;
+      }
+    })();
+    return this.refreshInFlight;
+  }
+  // ─── Headers / proxy ───
   getAuthHeaders() {
-    const token = window.__SINAS_AUTH_TOKEN__;
+    const token = this.getAccessToken();
     const headers = { "Content-Type": "application/json" };
-    if (token) {
-      headers["Authorization"] = `Bearer ${token}`;
-    }
+    if (token) headers["Authorization"] = `Bearer ${token}`;
     return headers;
   }
   getProxyBase() {
@@ -135,7 +303,8 @@ var SinasClient = class {
     const comp = config.component;
     return `${config.apiBase}/components/${comp.namespace}/${comp.name}/proxy`;
   }
-  async fetch(url, options = {}) {
+  // ─── Fetch with refresh-on-401 ───
+  async fetch(url, options = {}, _retried = false) {
     const res = await fetch(url, {
       ...options,
       headers: {
@@ -143,15 +312,18 @@ var SinasClient = class {
         ...options.headers || {}
       }
     });
-    if (!res.ok) {
-      const body = await res.json().catch(() => ({ detail: res.statusText }));
-      const message = body.detail || body.message || res.statusText;
-      if (res.status === 401) throw new SinasAuthError(message);
-      if (res.status === 403) throw new SinasPermissionError(message);
-      if (res.status === 404) throw new SinasNotFoundError(message);
-      throw new SinasError(message, res.status);
+    if (res.ok || res.status === 204) return res;
+    if (res.status === 401 && !_retried) {
+      const newToken = await this.tryRefresh();
+      if (newToken) return this.fetch(url, options, true);
+      this.options.onUnauthenticated?.();
     }
-    return res;
+    const body = await res.json().catch(() => ({ detail: res.statusText }));
+    const message = body.detail || body.message || res.statusText;
+    if (res.status === 401) throw new SinasAuthError(message);
+    if (res.status === 403) throw new SinasPermissionError(message);
+    if (res.status === 404) throw new SinasNotFoundError(message);
+    throw new SinasError(message, res.status);
   }
 };
 
@@ -475,8 +647,14 @@ var import_react2 = __toESM(require("react"), 1);
 // src/hooks/context.ts
 var import_react = __toESM(require("react"), 1);
 var SinasContext = import_react.default.createContext(null);
-function SinasProvider({ client, children }) {
-  const value = import_react.default.useMemo(() => client || new SinasClient(), [client]);
+function SinasProvider({ client, options, children }) {
+  const value = import_react.default.useMemo(
+    () => client || new SinasClient(options),
+    // We intentionally only re-create when `client` reference changes; `options`
+    // is expected to be a stable object (callbacks reading from localStorage).
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [client]
+  );
   return import_react.default.createElement(SinasContext.Provider, { value }, children);
 }
 function useClient() {
@@ -656,8 +834,6 @@ function useChat(agentRef, options) {
   const abortRef = import_react5.default.useRef(null);
   const chatIdRef = import_react5.default.useRef(chatId);
   chatIdRef.current = chatId;
-  const activeAssistantIdRef = import_react5.default.useRef("");
-  const activeToolCallMsgIdRef = import_react5.default.useRef("");
   import_react5.default.useEffect(() => {
     if (!options?.chatId) return;
     let cancelled = false;
@@ -687,24 +863,34 @@ function useChat(agentRef, options) {
   const handleStreamChunks = import_react5.default.useCallback(
     (chunk) => {
       if (chunk.event === "message") {
-        try {
-          const parsed = JSON.parse(chunk.data);
-          if (parsed.content) {
-            const targetId = activeAssistantIdRef.current;
-            setMessages(
-              (prev) => prev.map(
-                (m) => m.id === targetId ? { ...m, content: (m.content || "") + parsed.content } : m
-              )
-            );
+        const newContent = (() => {
+          try {
+            const parsed = JSON.parse(chunk.data);
+            return parsed.content || "";
+          } catch {
+            return chunk.data;
           }
-        } catch {
-          const targetId = activeAssistantIdRef.current;
-          setMessages(
-            (prev) => prev.map(
-              (m) => m.id === targetId ? { ...m, content: (m.content || "") + chunk.data } : m
-            )
-          );
-        }
+        })();
+        if (!newContent) return;
+        setMessages((prev) => {
+          const last = prev[prev.length - 1];
+          if (last && last.role === "assistant" && !last.toolCalls && last.streaming) {
+            const next = [...prev];
+            next[next.length - 1] = { ...last, content: (last.content || "") + newContent };
+            return next;
+          }
+          return [...prev, {
+            id: `tmp-text-${Date.now()}`,
+            chatId: chatIdRef.current || "",
+            role: "assistant",
+            content: newContent,
+            toolCalls: null,
+            toolCallId: null,
+            name: null,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            streaming: true
+          }];
+        });
       } else if (chunk.event === "tool_start") {
         try {
           const parsed = JSON.parse(chunk.data);
@@ -712,35 +898,29 @@ function useChat(agentRef, options) {
             ...prev,
             { toolCallId: parsed.tool_call_id, name: parsed.name, description: parsed.description, status: "running" }
           ]);
-          const placeholderId = activeAssistantIdRef.current;
-          const toolCallMsg = {
-            id: `tmp-tc-${parsed.tool_call_id}`,
-            chatId: chatIdRef.current || "",
-            role: "assistant",
-            content: null,
-            toolCalls: [{
-              id: parsed.tool_call_id,
-              type: "function",
-              function: { name: parsed.name, arguments: parsed.arguments || "{}" },
-              description: parsed.description
-            }],
-            toolCallId: null,
-            name: null,
-            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-            streaming: true
-          };
           setMessages((prev) => {
-            const alreadyExists = prev.some(
-              (m) => m.toolCalls?.some((tc) => tc.id === parsed.tool_call_id)
-            );
-            if (alreadyExists) return prev;
-            const idx = prev.findIndex((m) => m.id === placeholderId);
-            if (idx >= 0) {
-              const next = [...prev];
-              next.splice(idx, 0, toolCallMsg);
-              return next;
+            if (prev.some((m) => m.toolCalls?.some((tc) => tc.id === parsed.tool_call_id))) {
+              return prev;
             }
-            return [...prev, toolCallMsg];
+            const next = prev.map(
+              (m, i) => i === prev.length - 1 && m.streaming && m.role === "assistant" && !m.toolCalls ? { ...m, streaming: false } : m
+            );
+            return [...next, {
+              id: `tmp-tc-${parsed.tool_call_id}`,
+              chatId: chatIdRef.current || "",
+              role: "assistant",
+              content: null,
+              toolCalls: [{
+                id: parsed.tool_call_id,
+                type: "function",
+                function: { name: parsed.name, arguments: parsed.arguments || "{}" },
+                description: parsed.description
+              }],
+              toolCallId: null,
+              name: null,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              streaming: true
+            }];
           });
         } catch {
         }
@@ -842,20 +1022,6 @@ function useChat(agentRef, options) {
           createdAt: (/* @__PURE__ */ new Date()).toISOString()
         };
         setMessages((prev) => [...prev, userMsg]);
-        const assistantId = `tmp-assistant-${Date.now()}`;
-        activeAssistantIdRef.current = assistantId;
-        const assistantMsg = {
-          id: assistantId,
-          chatId: activeChatId,
-          role: "assistant",
-          content: "",
-          toolCalls: null,
-          toolCallId: null,
-          name: null,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          streaming: true
-        };
-        setMessages((prev) => [...prev, assistantMsg]);
         const controller = streamMessage(
           client,
           activeChatId,
@@ -864,11 +1030,6 @@ function useChat(agentRef, options) {
           () => {
             setStreaming(false);
             setToolStatus([]);
-            setMessages(
-              (prev) => prev.filter(
-                (m) => !(m.streaming && m.role === "assistant" && !m.content && !m.toolCalls)
-              )
-            );
             refreshMessages(activeChatId);
           },
           (err) => {
@@ -890,22 +1051,6 @@ function useChat(agentRef, options) {
       setPendingApprovals((prev) => prev.filter((a) => a.toolCallId !== toolCallId));
       setStreaming(true);
       setError(null);
-      const assistantId = `tmp-resume-${Date.now()}`;
-      activeAssistantIdRef.current = assistantId;
-      if (approved) {
-        const assistantMsg = {
-          id: assistantId,
-          chatId: currentChatId,
-          role: "assistant",
-          content: "",
-          toolCalls: null,
-          toolCallId: null,
-          name: null,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          streaming: true
-        };
-        setMessages((prev) => [...prev, assistantMsg]);
-      }
       (async () => {
         try {
           const result = await approveToolCall(client, currentChatId, toolCallId, approved);
@@ -984,23 +1129,105 @@ function useSinas() {
     useChat
   };
 }
+
+// src/hooks/useAuth.ts
+var import_react6 = __toESM(require("react"), 1);
+function useAuth(options = {}) {
+  const { autoRefresh = true } = options;
+  const client = useClient();
+  const [status, setStatus] = import_react6.default.useState("loading");
+  const [user, setUser] = import_react6.default.useState(null);
+  const [info, setInfo] = import_react6.default.useState(null);
+  const [error, setError] = import_react6.default.useState(null);
+  const refresh2 = import_react6.default.useCallback(async () => {
+    setError(null);
+    try {
+      const [infoResp, meResp] = await Promise.all([
+        client.auth.getInfo().catch(() => null),
+        client.getAccessToken() ? client.auth.getMe().catch(() => null) : Promise.resolve(null)
+      ]);
+      if (infoResp) setInfo(infoResp);
+      if (meResp) {
+        setUser(meResp);
+        setStatus("authenticated");
+      } else {
+        setUser(null);
+        setStatus("unauthenticated");
+      }
+    } catch (e) {
+      setError(e instanceof Error ? e.message : String(e));
+      setStatus("unauthenticated");
+    }
+  }, [client]);
+  import_react6.default.useEffect(() => {
+    if (autoRefresh) void refresh2();
+  }, [autoRefresh, refresh2]);
+  const login2 = import_react6.default.useCallback(
+    async (email, password) => {
+      setError(null);
+      try {
+        return await client.auth.login({ email, password });
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        setError(msg);
+        throw e;
+      }
+    },
+    [client]
+  );
+  const verifyOTP2 = import_react6.default.useCallback(
+    async (sessionId, otpCode) => {
+      setError(null);
+      try {
+        return await client.auth.verifyOTP({ session_id: sessionId, otp_code: otpCode });
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        setError(msg);
+        throw e;
+      }
+    },
+    [client]
+  );
+  const logout2 = import_react6.default.useCallback(
+    async (refreshToken) => {
+      if (refreshToken) {
+        try {
+          await client.auth.logout(refreshToken);
+        } catch (e) {
+          if (!(e instanceof SinasAuthError)) throw e;
+        }
+      }
+      setUser(null);
+      setStatus("unauthenticated");
+    },
+    [client]
+  );
+  return { status, user, info, error, refresh: refresh2, login: login2, verifyOTP: verifyOTP2, logout: logout2 };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SinasAuthError,
   SinasClient,
+  SinasClientAuth,
   SinasError,
   SinasNotFoundError,
   SinasPermissionError,
   SinasProvider,
   SinasTimeoutError,
   approveToolCall,
+  checkPermissions,
   createChat,
   executeFunction,
   executeQuery,
   generateFileUrl,
   getChat,
+  getInfo,
+  getMe,
   listCollections,
   listFiles,
+  login,
+  logout,
+  refresh,
   sendMessage,
   stateDelete,
   stateGet,
@@ -1009,11 +1236,13 @@ function useSinas() {
   streamFromChannel,
   streamMessage,
   uploadFile,
+  useAuth,
   useChat,
   useClient,
   useExecute,
   useQuery,
   useSinas,
-  useStateStore
+  useStateStore,
+  verifyOTP
 });
 //# sourceMappingURL=index.cjs.map