@palettelab/sdk 0.1.15 → 0.1.17

package/dist/index.js

@@ -21,8 +21,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   DataRoomClient: () => DataRoomClient,
+  Link: () => Link,
   OrganizationClient: () => OrganizationClient,
   PaletteApiError: () => PaletteApiError,
+  PaletteAppRouter: () => PaletteAppRouter,
   PlatformCtx: () => PlatformCtx,
   PluginProvider: () => PluginProvider,
   StorageClient: () => StorageClient,
@@ -33,8 +35,10 @@ __export(src_exports, {
   createPaletteClient: () => createPaletteClient,
   createSandboxBridge: () => createSandboxBridge,
   dataRooms: () => dataRooms,
+  disconnectConnection: () => disconnectConnection,
   errorFromResponse: () => errorFromResponse,
   getBaseUrl: () => getBaseUrl,
+  getConnections: () => getConnections,
   getInstallConfig: () => getInstallConfig,
   hasAllPermissions: () => hasAllPermissions,
   hasAnyPermission: () => hasAnyPermission,
@@ -42,15 +46,22 @@ __export(src_exports, {
   isPaletteApiError: () => isPaletteApiError,
   isSandboxRuntime: () => isSandboxRuntime,
   normalizePaletteLanguage: () => normalizePaletteLanguage,
+  notFound: () => notFound,
+  requireConnection: () => requireConnection,
   setBaseUrl: () => setBaseUrl,
+  startConnection: () => startConnection,
   translate: () => translate,
   updateInstallConfig: () => updateInstallConfig,
   uploadToSignedUrl: () => uploadToSignedUrl,
+  useParams: () => useParams,
+  usePathname: () => usePathname,
   usePlatform: () => usePlatform,
   usePluginChat: () => usePluginChat,
   usePluginDataRooms: () => usePluginDataRooms,
   usePluginTasks: () => usePluginTasks,
   usePluginTranslations: () => usePluginTranslations,
+  useRouter: () => useRouter,
+  useSearchParams: () => useSearchParams,
   withPluginProvider: () => withPluginProvider
 });
 module.exports = __toCommonJS(src_exports);
@@ -167,6 +178,32 @@ async function updateInstallConfig(pluginId, config) {
   return res.json();
 }
 
+// src/connections.ts
+async function getConnections(pluginId) {
+  const res = await apiFetch(`/api/v1/app-installs/${encodeURIComponent(pluginId)}/connections`);
+  return res.json();
+}
+async function startConnection(pluginId, connectionId) {
+  const res = await apiFetch(
+    `/api/v1/app-installs/${encodeURIComponent(pluginId)}/connections/${encodeURIComponent(connectionId)}/authorize`,
+    { method: "POST" }
+  );
+  return res.json();
+}
+async function disconnectConnection(pluginId, connectionId) {
+  await apiFetch(
+    `/api/v1/app-installs/${encodeURIComponent(pluginId)}/connections/${encodeURIComponent(connectionId)}`,
+    { method: "DELETE" }
+  );
+}
+async function requireConnection(pluginId, connectionId) {
+  const connection = (await getConnections(pluginId)).find((item) => item.id === connectionId);
+  if (!connection || !["connected", "expiring"].includes(connection.status)) {
+    throw new Error(`Palette connection is not configured: ${connectionId}`);
+  }
+  return connection;
+}
+
 // src/test-utils.tsx
 var import_react2 = require("react");
 
@@ -228,6 +265,7 @@ function createMockPlatformContext(overrides = {}) {
     apiFetch: async () => new Response(JSON.stringify({}), { status: 200 }),
     navigate: () => {
     },
+    routePath: "/",
     showToast: () => {
     },
     ...overrides
@@ -641,6 +679,28 @@ function createPaletteClient(ctx) {
         return updateInstallConfig(resolved, values);
       }
     },
+    connections: {
+      list: (pluginId = ctx?.pluginId ?? "") => {
+        const resolved = pluginId || defaultPluginId2();
+        if (!resolved) throw new Error("pluginId is required to read connections");
+        return getConnections(resolved);
+      },
+      connect: (connectionId, pluginId = ctx?.pluginId ?? "") => {
+        const resolved = pluginId || defaultPluginId2();
+        if (!resolved) throw new Error("pluginId is required to start a connection");
+        return startConnection(resolved, connectionId);
+      },
+      disconnect: (connectionId, pluginId = ctx?.pluginId ?? "") => {
+        const resolved = pluginId || defaultPluginId2();
+        if (!resolved) throw new Error("pluginId is required to disconnect a connection");
+        return disconnectConnection(resolved, connectionId);
+      },
+      require: (connectionId, pluginId = ctx?.pluginId ?? "") => {
+        const resolved = pluginId || defaultPluginId2();
+        if (!resolved) throw new Error("pluginId is required to require a connection");
+        return requireConnection(resolved, connectionId);
+      }
+    },
     permissions: {
       has: (permission) => ctx ? hasPermission(ctx, permission) : false,
       hasAny: (permissions) => ctx ? hasAnyPermission(ctx, permissions) : false,
@@ -717,14 +777,207 @@ function usePluginTranslations(resources, options = {}) {
   };
 }
 
-// src/hooks/use-plugin-tasks.ts
+// src/router.tsx
 var import_react4 = require("react");
+var RouterCtx = (0, import_react4.createContext)(null);
+var NOT_FOUND = /* @__PURE__ */ Symbol.for("palette.router.not-found");
+function notFound() {
+  throw Object.assign(new Error("Palette route not found"), { code: NOT_FOUND });
+}
+function normalizePath(path) {
+  const clean = String(path || "/").split("#")[0].split("?")[0] || "/";
+  return `/${clean.replace(/^\/+/, "").replace(/\/+$/, "")}`.replace(/^\/$/, "/");
+}
+function splitPath(path) {
+  return normalizePath(path).split("/").filter(Boolean).map(decodeURIComponent);
+}
+function routeScore(route) {
+  if (typeof route.score === "number") return route.score;
+  return route.segments.reduce((score, segment) => {
+    if (segment.kind === "static") return score + 10;
+    if (segment.kind === "dynamic") return score + 5;
+    return score + (segment.optional ? 1 : 2);
+  }, route.segments.length);
+}
+function matchRoute(route, path) {
+  const parts = splitPath(path);
+  const params = {};
+  let index = 0;
+  for (const segment of route.segments) {
+    if (segment.kind === "catchAll") {
+      const rest = parts.slice(index);
+      if (!segment.optional && rest.length === 0) return null;
+      params[segment.name] = rest;
+      index = parts.length;
+      break;
+    }
+    const value = parts[index];
+    if (value === void 0) return null;
+    if (segment.kind === "static") {
+      if (value !== segment.value) return null;
+    } else {
+      params[segment.name] = value;
+    }
+    index += 1;
+  }
+  return index === parts.length ? params : null;
+}
+function currentPluginPath(pluginId, routePath) {
+  if (routePath) return normalizePath(routePath);
+  if (typeof window === "undefined") return "/";
+  const path = window.location.pathname;
+  if (pluginId) {
+    const prefix = `/apps/${pluginId}`;
+    if (path === prefix) return "/";
+    if (path.startsWith(`${prefix}/`)) return normalizePath(path.slice(prefix.length));
+  }
+  return normalizePath(path);
+}
+function currentSearchParams() {
+  if (typeof window === "undefined") return new URLSearchParams();
+  return new URLSearchParams(window.location.search);
+}
+var PaletteRouteErrorBoundary = class extends import_react4.Component {
+  constructor() {
+    super(...arguments);
+    this.state = { error: null };
+    this.reset = () => this.setState({ error: null });
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(_error, _info) {
+  }
+  render() {
+    const error = this.state.error;
+    if (!error) return this.props.children;
+    if (error.code === NOT_FOUND && this.props.notFound) {
+      return (0, import_react4.createElement)(this.props.notFound);
+    }
+    if (this.props.fallback) {
+      return (0, import_react4.createElement)(this.props.fallback, { error, reset: this.reset });
+    }
+    throw error;
+  }
+};
+function renderRoute(route) {
+  const page = (0, import_react4.createElement)(route.page);
+  const wrapped = (route.layouts || []).reduceRight(
+    (children, Layout) => (0, import_react4.createElement)(Layout, null, children),
+    page
+  );
+  return (0, import_react4.createElement)(
+    PaletteRouteErrorBoundary,
+    { fallback: route.error, notFound: route.notFound },
+    wrapped
+  );
+}
+function PaletteAppRouter({
+  routes,
+  notFound: NotFound
+}) {
+  const platform = usePlatform();
+  const [location, setLocation] = (0, import_react4.useState)(() => ({
+    pathname: currentPluginPath(platform.pluginId, platform.routePath),
+    searchParams: currentSearchParams()
+  }));
+  (0, import_react4.useEffect)(() => {
+    setLocation({
+      pathname: currentPluginPath(platform.pluginId, platform.routePath),
+      searchParams: currentSearchParams()
+    });
+  }, [platform.pluginId, platform.routePath]);
+  (0, import_react4.useEffect)(() => {
+    const sync = () => setLocation({
+      pathname: currentPluginPath(platform.pluginId, platform.routePath),
+      searchParams: currentSearchParams()
+    });
+    window.addEventListener("popstate", sync);
+    return () => window.removeEventListener("popstate", sync);
+  }, [platform.pluginId, platform.routePath]);
+  const sortedRoutes = (0, import_react4.useMemo)(
+    () => [...routes].sort((a, b) => routeScore(b) - routeScore(a)),
+    [routes]
+  );
+  const matched = (0, import_react4.useMemo)(() => {
+    for (const route of sortedRoutes) {
+      const params = matchRoute(route, location.pathname);
+      if (params) return { route, params };
+    }
+    return null;
+  }, [location.pathname, sortedRoutes]);
+  const navigate = (0, import_react4.useCallback)((target, replace = false) => {
+    const [pathPart, queryPart = ""] = String(target || "/").split("?");
+    const pathname = normalizePath(pathPart);
+    const next = `${pathname}${queryPart ? `?${queryPart}` : ""}`;
+    setLocation({ pathname, searchParams: new URLSearchParams(queryPart) });
+    const currentPath = typeof window === "undefined" ? "" : window.location.pathname;
+    const inPalettePath = platform.pluginId && (currentPath.startsWith(`/apps/${platform.pluginId}`) || platform.routePath !== void 0);
+    const osPath = inPalettePath && platform.pluginId ? `/apps/${platform.pluginId}${pathname === "/" ? "" : pathname}${queryPart ? `?${queryPart}` : ""}` : next;
+    if (replace && typeof window !== "undefined") window.history.replaceState(null, "", osPath);
+    else platform.navigate(osPath);
+  }, [platform]);
+  const state = (0, import_react4.useMemo)(() => ({
+    pathname: location.pathname,
+    searchParams: location.searchParams,
+    params: matched?.params || {},
+    push: (path) => navigate(path, false),
+    replace: (path) => navigate(path, true)
+  }), [location.pathname, location.searchParams, matched?.params, navigate]);
+  const content = matched ? renderRoute(matched.route) : NotFound ? (0, import_react4.createElement)(NotFound) : (0, import_react4.createElement)("div", null, "Page not found");
+  return (0, import_react4.createElement)(RouterCtx.Provider, { value: state }, content);
+}
+function useRouterState() {
+  const value = (0, import_react4.useContext)(RouterCtx);
+  if (!value) throw new Error("Palette app router hooks must be used inside PaletteAppRouter");
+  return value;
+}
+function useRouter() {
+  const { push, replace } = useRouterState();
+  return { push, replace, back: () => window.history.back(), forward: () => window.history.forward() };
+}
+function usePathname() {
+  return useRouterState().pathname;
+}
+function useSearchParams() {
+  return useRouterState().searchParams;
+}
+function useParams() {
+  return useRouterState().params;
+}
+function Link({
+  href,
+  replace,
+  onClick,
+  children,
+  ...props
+}) {
+  const router = useRouter();
+  return (0, import_react4.createElement)(
+    "a",
+    {
+      ...props,
+      href,
+      onClick: (event) => {
+        onClick?.(event);
+        if (event.defaultPrevented || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
+        event.preventDefault();
+        if (replace) router.replace(href);
+        else router.push(href);
+      }
+    },
+    children
+  );
+}
+
+// src/hooks/use-plugin-tasks.ts
+var import_react5 = require("react");
 function usePluginTasks(agentId) {
   const { apiFetch: apiFetch2 } = usePlatform();
-  const [tasks, setTasks] = (0, import_react4.useState)([]);
-  const [stats, setStats] = (0, import_react4.useState)(null);
-  const [loading, setLoading] = (0, import_react4.useState)(true);
-  const fetchTasks = (0, import_react4.useCallback)(async () => {
+  const [tasks, setTasks] = (0, import_react5.useState)([]);
+  const [stats, setStats] = (0, import_react5.useState)(null);
+  const [loading, setLoading] = (0, import_react5.useState)(true);
+  const fetchTasks = (0, import_react5.useCallback)(async () => {
     try {
       const params = new URLSearchParams();
       if (agentId) params.set("agent_id", String(agentId));
@@ -733,18 +986,18 @@ function usePluginTasks(agentId) {
     } catch {
     }
   }, [apiFetch2, agentId]);
-  const fetchStats = (0, import_react4.useCallback)(async () => {
+  const fetchStats = (0, import_react5.useCallback)(async () => {
     try {
       const res = await apiFetch2("/api/v1/tasks/stats");
       setStats(await res.json());
     } catch {
     }
   }, [apiFetch2]);
-  (0, import_react4.useEffect)(() => {
+  (0, import_react5.useEffect)(() => {
     setLoading(true);
     Promise.all([fetchTasks(), fetchStats()]).finally(() => setLoading(false));
   }, [fetchTasks, fetchStats]);
-  const createTask = (0, import_react4.useCallback)(async (payload) => {
+  const createTask = (0, import_react5.useCallback)(async (payload) => {
     const res = await apiFetch2("/api/v1/tasks", {
       method: "POST",
       body: JSON.stringify(payload)
@@ -753,7 +1006,7 @@ function usePluginTasks(agentId) {
     await Promise.all([fetchTasks(), fetchStats()]);
     return task;
   }, [apiFetch2, fetchTasks, fetchStats]);
-  const updateTask = (0, import_react4.useCallback)(async (taskId, payload) => {
+  const updateTask = (0, import_react5.useCallback)(async (taskId, payload) => {
     const res = await apiFetch2(`/api/v1/tasks/${taskId}`, {
       method: "PATCH",
       body: JSON.stringify(payload)
@@ -762,7 +1015,7 @@ function usePluginTasks(agentId) {
     await Promise.all([fetchTasks(), fetchStats()]);
     return task;
   }, [apiFetch2, fetchTasks, fetchStats]);
-  const deleteTask = (0, import_react4.useCallback)(async (taskId) => {
+  const deleteTask = (0, import_react5.useCallback)(async (taskId) => {
     await apiFetch2(`/api/v1/tasks/${taskId}`, { method: "DELETE" });
     await Promise.all([fetchTasks(), fetchStats()]);
   }, [apiFetch2, fetchTasks, fetchStats]);
@@ -770,23 +1023,23 @@ function usePluginTasks(agentId) {
 }
 
 // src/hooks/use-plugin-data-rooms.ts
-var import_react5 = require("react");
+var import_react6 = require("react");
 function usePluginDataRooms() {
   const { apiFetch: apiFetch2 } = usePlatform();
-  const [rooms, setRooms] = (0, import_react5.useState)([]);
-  const [loading, setLoading] = (0, import_react5.useState)(true);
-  const fetchRooms = (0, import_react5.useCallback)(async () => {
+  const [rooms, setRooms] = (0, import_react6.useState)([]);
+  const [loading, setLoading] = (0, import_react6.useState)(true);
+  const fetchRooms = (0, import_react6.useCallback)(async () => {
     try {
       const res = await apiFetch2("/api/v1/data-rooms");
       setRooms(await res.json());
     } catch {
     }
   }, [apiFetch2]);
-  (0, import_react5.useEffect)(() => {
+  (0, import_react6.useEffect)(() => {
     setLoading(true);
     fetchRooms().finally(() => setLoading(false));
   }, [fetchRooms]);
-  const fetchFolder = (0, import_react5.useCallback)(async (roomId, folderId) => {
+  const fetchFolder = (0, import_react6.useCallback)(async (roomId, folderId) => {
     const path = folderId ? `/api/v1/data-rooms/${roomId}/folders/${folderId}` : `/api/v1/data-rooms/${roomId}`;
     const res = await apiFetch2(path);
     return res.json();
@@ -795,19 +1048,19 @@ function usePluginDataRooms() {
 }
 
 // src/hooks/use-plugin-chat.ts
-var import_react6 = require("react");
+var import_react7 = require("react");
 function usePluginChat(agentId) {
   const { apiFetch: apiFetch2 } = usePlatform();
-  const [threads, setThreads] = (0, import_react6.useState)([]);
-  const [messages, setMessages] = (0, import_react6.useState)([]);
-  const [streaming, setStreaming] = (0, import_react6.useState)(false);
-  const [activeThreadId, setActiveThreadId] = (0, import_react6.useState)(null);
-  const abortRef = (0, import_react6.useRef)(null);
-  const fetchThreads = (0, import_react6.useCallback)(async () => {
+  const [threads, setThreads] = (0, import_react7.useState)([]);
+  const [messages, setMessages] = (0, import_react7.useState)([]);
+  const [streaming, setStreaming] = (0, import_react7.useState)(false);
+  const [activeThreadId, setActiveThreadId] = (0, import_react7.useState)(null);
+  const abortRef = (0, import_react7.useRef)(null);
+  const fetchThreads = (0, import_react7.useCallback)(async () => {
     const res = await apiFetch2(`/api/v1/chat/${agentId}/threads`);
     setThreads(await res.json());
   }, [apiFetch2, agentId]);
-  const createThread = (0, import_react6.useCallback)(async () => {
+  const createThread = (0, import_react7.useCallback)(async () => {
     const res = await apiFetch2(`/api/v1/chat/${agentId}/threads`, { method: "POST" });
     const thread = await res.json();
     setActiveThreadId(thread.id);
@@ -815,13 +1068,13 @@ function usePluginChat(agentId) {
     await fetchThreads();
     return thread;
   }, [apiFetch2, agentId, fetchThreads]);
-  const fetchMessages = (0, import_react6.useCallback)(async (threadId) => {
+  const fetchMessages = (0, import_react7.useCallback)(async (threadId) => {
     const res = await apiFetch2(`/api/v1/chat/threads/${threadId}/messages`);
     const msgs = await res.json();
     setMessages(msgs);
     setActiveThreadId(threadId);
   }, [apiFetch2]);
-  const sendMessage = (0, import_react6.useCallback)(async (threadId, content) => {
+  const sendMessage = (0, import_react7.useCallback)(async (threadId, content) => {
     setStreaming(true);
     abortRef.current = new AbortController();
     const userMsg = {
@@ -889,7 +1142,7 @@ function usePluginChat(agentId) {
       abortRef.current = null;
     }
   }, []);
-  const stopStreaming = (0, import_react6.useCallback)(() => {
+  const stopStreaming = (0, import_react7.useCallback)(() => {
     abortRef.current?.abort();
   }, []);
   return {
@@ -907,8 +1160,10 @@ function usePluginChat(agentId) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DataRoomClient,
+  Link,
   OrganizationClient,
   PaletteApiError,
+  PaletteAppRouter,
   PlatformCtx,
   PluginProvider,
   StorageClient,
@@ -919,8 +1174,10 @@ function usePluginChat(agentId) {
   createPaletteClient,
   createSandboxBridge,
   dataRooms,
+  disconnectConnection,
   errorFromResponse,
   getBaseUrl,
+  getConnections,
   getInstallConfig,
   hasAllPermissions,
   hasAnyPermission,
@@ -928,14 +1185,21 @@ function usePluginChat(agentId) {
   isPaletteApiError,
   isSandboxRuntime,
   normalizePaletteLanguage,
+  notFound,
+  requireConnection,
   setBaseUrl,
+  startConnection,
   translate,
   updateInstallConfig,
   uploadToSignedUrl,
+  useParams,
+  usePathname,
   usePlatform,
   usePluginChat,
   usePluginDataRooms,
   usePluginTasks,
   usePluginTranslations,
+  useRouter,
+  useSearchParams,
   withPluginProvider
 });