@cosmoops/connect-sdk 0.2.0 → 0.6.0

package/dist/types/client/components/app-shell.d.ts

@@ -0,0 +1,115 @@
+import { type ReactNode } from "react";
+import { type ConnectLinkRenderer, type ConnectNav } from "./nav.js";
+import type { ThemeMode } from "../../types.js";
+export interface ConnectAppShellProps {
+    /** This service's name, in the `cosmo·ops VOICE` lockup. See `ConnectLogo`. */
+    name: string;
+    /** This service's glyph, drawn on the CosmoOps badge. Falls back to the Connect rings. */
+    icon?: ReactNode;
+    /** Where the lockup links. Defaults to `/`. */
+    homeHref?: string;
+    /** The sidebar's destinations - items, sections, or a mix. See `ConnectNav`. */
+    nav: ConnectNav;
+    /** Current path. Pass `usePathname()` in Next; see `ConnectSideNavProps.activePath`. */
+    activePath?: string;
+    /** See `ConnectLinkRenderer` - how this app renders a link. Defaults to a plain `<a>`. */
+    renderLink?: ConnectLinkRenderer;
+    /**
+     * Page heading in the top bar. A string renders as the page's `<h1>`, so
+     * don't also put one at the top of the page; pass a node for breadcrumbs or
+     * anything else.
+     */
+    title?: ReactNode;
+    /** Your own controls in the top bar, left of the Connect ones. */
+    headerActions?: ReactNode;
+    /** Extra content pinned to the bottom of the sidebar, above the fold-away. */
+    sidebarFooter?: ReactNode;
+    /** Rendered below `children`, inside the scrolling content pane. */
+    footer?: ReactNode;
+    /** Start the rail collapsed. Ignored when `collapsed` is supplied. */
+    defaultCollapsed?: boolean;
+    /** Drive the rail yourself. Supply `onCollapsedChange` with it. */
+    collapsed?: boolean;
+    onCollapsedChange?: (collapsed: boolean) => void;
+    /** Remove the collapse control and pin the rail expanded. */
+    collapsible?: boolean;
+    /** The app launcher in the top bar. On by default. */
+    showAppsGrid?: boolean;
+    /** "Continue with Connect" / "Create account" in the top bar when signed out. On by default. */
+    showAuthButtons?: boolean;
+    /** Passed to `ConnectUserMenu` - the SDK has no theme provider, so this is host-controlled. */
+    theme?: ThemeMode;
+    onThemeChange?: (theme: ThemeMode) => void;
+    /**
+     * Wrap `children` in `ConnectAccessGate` - suspended, no plan, onboarding
+     * pending, payment due, decided once for the whole app. **On by default**,
+     * because the shell is exactly the "wrap your app content once" place that
+     * gate asks for, and an app that mounts a shell and forgets the gate is an
+     * app that lets a suspended workspace keep working.
+     *
+     * The chrome is never gated: the sidebar, the lockup, the user menu and
+     * sign-out stay reachable in every blocked state, so a blocked customer can
+     * always get to the page that unblocks them.
+     *
+     * Routes flagged `gateExempt` on their nav item render outside it - see
+     * `ConnectNavItem.gateExempt` and `gateExemptRoutes`.
+     */
+    gate?: boolean;
+    /**
+     * Extra ungated paths, on top of the ones flagged `gateExempt` in `nav`.
+     * For a route that is not in the sidebar at all - a `/checkout/callback`,
+     * say. Prefix-matched, same as the nav's active resolution.
+     */
+    gateExemptRoutes?: string[];
+    className?: string;
+    /** Classes on the scrolling content pane - override the default max-width and padding here. */
+    contentClassName?: string;
+    children: ReactNode;
+}
+/**
+ * The application frame every CosmoOps service platform runs inside: a
+ * collapsible sidebar, a top bar carrying the app launcher and the account
+ * menu, and your pages in the middle.
+ *
+ * This is the piece each partner was otherwise writing by hand, and writing
+ * slightly differently - which is how a family of services stops looking like
+ * one product. Everything that should be identical across platforms (the
+ * lockup, the rail geometry, the active-route treatment, the launcher, the
+ * account menu, the access gate) lives here; everything that genuinely
+ * differs is a prop:
+ *
+ * ```tsx
+ * "use client";
+ * import Link from "next/link";
+ * import { usePathname } from "next/navigation";
+ * import { ConnectAppShell } from "@cosmoops/connect-sdk/client";
+ * import { LayoutDashboard, Truck } from "lucide-react";
+ *
+ * export function Shell({ children }: { children: React.ReactNode }) {
+ *   return (
+ *     <ConnectAppShell
+ *       name="Dispatch"
+ *       icon={<Truck />}
+ *       activePath={usePathname()}
+ *       renderLink={(props) => <Link {...props} />}
+ *       nav={[
+ *         { label: "Overview", href: "/", icon: <LayoutDashboard className="size-5" /> },
+ *         { label: "Plans", href: "/plans", icon: <Truck className="size-5" />, gateExempt: true },
+ *       ]}
+ *     >
+ *       {children}
+ *     </ConnectAppShell>
+ *   );
+ * }
+ * ```
+ *
+ * There is no `isSignedIn` branch anywhere in here, and there should be none
+ * in yours: the auth buttons render nothing once a session exists, the user
+ * menu renders nothing without one, and the launcher renders nothing when
+ * signed out. The swap happens inside the components.
+ *
+ * It renders no provider of its own - mount `ConnectProvider` above it, once,
+ * so a page with a shell, a plan table and a usage meter still makes one
+ * session read.
+ */
+export declare function ConnectAppShell({ name, icon, homeHref, nav, activePath, renderLink, title, headerActions, sidebarFooter, footer, defaultCollapsed, collapsed: controlledCollapsed, onCollapsedChange, collapsible, showAppsGrid, showAuthButtons, theme, onThemeChange, gate, gateExemptRoutes, className, contentClassName, children, }: ConnectAppShellProps): import("react").JSX.Element;

package/dist/types/client/components/integrations-modal.d.ts

@@ -0,0 +1,21 @@
+export interface ConnectIntegrationsModalProps {
+    /** Extra classes on the trigger button. */
+    className?: string;
+    /** Trigger label, both visible and for screen readers. */
+    label?: string;
+}
+/**
+ * A grid of every Composio-hosted toolkit this organization can connect -
+ * Google Calendar, Slack, Twitter/X, whatever a platform admin enabled in
+ * Connect's own Console. Each tile carries its own connect/reconnect/
+ * disconnect action and its own pending state, independent of every other
+ * tile - see the doc comment on `pendingSlug` below for why that matters.
+ *
+ * Not optimistic: a tile stays whatever it already was after "Connect" is
+ * pressed, because the connection isn't settled until Composio's webhook
+ * confirms it - `mutateResource` here only ever gets as far as `pending`
+ * before the browser navigates away to complete the provider's OAuth screen.
+ *
+ * Renders nothing when signed out, same as `ConnectAppsGrid`.
+ */
+export declare function ConnectIntegrationsModal({ className, label }: ConnectIntegrationsModalProps): import("react").JSX.Element | null;

package/dist/types/client/components/motion.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from "react";
+export { m, AnimatePresence } from "motion/react";
+/** HeroUI's --ease-out-quart, transcribed for motion transitions. */
+export declare const EASE_OUT_QUART: readonly [0.165, 0.84, 0.44, 1];
+export declare const ENTER: {
+    readonly duration: 0.3;
+    readonly ease: readonly [0.165, 0.84, 0.44, 1];
+};
+export declare const METER_SPRING: {
+    readonly type: "spring";
+    readonly stiffness: 170;
+    readonly damping: 26;
+};
+/**
+ * Per-component motion root. domAnimation keeps the feature bundle small,
+ * `strict` restricts rendering to `m.*` components, and reducedMotion="user"
+ * drops transform animation (keeping opacity) under prefers-reduced-motion -
+ * the same contract HeroUI's own `motion-reduce` styles follow.
+ */
+export declare function MotionProvider({ children }: Readonly<{
+    children: ReactNode;
+}>): import("react").JSX.Element;

package/dist/types/client/components/nav.d.ts

@@ -0,0 +1,110 @@
+import type { ReactNode } from "react";
+/**
+ * One destination in the shell's sidebar.
+ *
+ * `href` is a path in *your* app, not a Connect URL - the shell never
+ * routes anywhere itself, it hands `href` to `renderLink` and lets your
+ * router do the work.
+ */
+export interface ConnectNavItem {
+    label: string;
+    href: string;
+    /**
+     * A pre-rendered glyph, e.g. `<LayoutDashboard className="size-5" />`.
+     * Required in practice for anything in the primary rail: the collapsed rail
+     * is icon-only, and an item with no icon collapses to an empty box.
+     */
+    icon?: ReactNode;
+    /** Trailing content on the row - a count `<Chip>`, a status dot. Hidden while collapsed. */
+    badge?: ReactNode;
+    /**
+     * Match this route only when the path is exactly `href`, never as a prefix.
+     * `/` is always treated as exact regardless, since every path starts with it.
+     */
+    exact?: boolean;
+    /** Opens in a new tab, with a trailing arrow. For docs, status pages, anything outside the app. */
+    external?: boolean;
+    /** One level of children, revealed beneath the parent when the parent or a child is active. */
+    items?: ConnectNavItem[];
+    /**
+     * Leave this route *outside* `ConnectAccessGate` - see
+     * `ConnectAppShellProps.gate`. Declared here, next to the route it applies
+     * to, rather than as a second list somewhere else that has to be kept in
+     * step with this one.
+     */
+    gateExempt?: boolean;
+}
+/** A titled group of items. Untitled groups render as a plain divider-free block. */
+export interface ConnectNavSection {
+    title?: string;
+    items: ConnectNavItem[];
+}
+/**
+ * What `ConnectAppShell`/`ConnectSideNav` accept for `nav`: a flat list of
+ * items, a list of sections, or a mix. Consecutive bare items fold into one
+ * untitled section, so the common case is just an array of items.
+ */
+export type ConnectNav = ReadonlyArray<ConnectNavItem | ConnectNavSection>;
+/** Props the shell hands to `renderLink`. Spread them onto whatever your router's link component is. */
+export interface ConnectNavLinkProps {
+    href: string;
+    className: string;
+    children: ReactNode;
+    onClick?: () => void;
+    "aria-current"?: "page";
+    /**
+     * Always set, and the only name the link has while the rail is collapsed -
+     * spread it through rather than dropping it, or an icon-only rail reads as
+     * a column of unlabelled links.
+     */
+    "aria-label": string;
+    target?: string;
+    rel?: string;
+}
+/**
+ * How this app renders a link.
+ *
+ * The SDK ships into any React app and cannot import `next/link`,
+ * `react-router` or anything else framework-specific, so routing is a prop.
+ * The default is a plain `<a>`, which is correct but costs a full page load;
+ * an app with a client router should pass its own:
+ *
+ * ```tsx
+ * renderLink={(props) => <Link {...props} />}   // next/link
+ * ```
+ */
+export type ConnectLinkRenderer = (props: ConnectNavLinkProps) => ReactNode;
+/** Folds a mixed `ConnectNav` into sections, gathering consecutive bare items into one untitled group. */
+export declare function normalizeNav(nav: ConnectNav): ConnectNavSection[];
+/** Every item in the tree, parents and children alike, in render order. */
+export declare function flattenNav(nav: ConnectNav): ConnectNavItem[];
+/**
+ * `https://x.test/billing/?tab=1#top` -> `/billing`.
+ *
+ * Trailing slashes go too, so `/billing/` and `/billing` are the same route -
+ * they are, to every router, and treating them as different is how a nav item
+ * ends up unhighlighted on exactly one of the two URLs a user can arrive at.
+ */
+export declare function normalizePath(path: string): string;
+/**
+ * The href of the nav item the current path belongs to, or `null`.
+ *
+ * Longest prefix wins, so `/settings/billing` lights up Billing and not also
+ * its parent Settings - a plain `startsWith` over an unordered list lights up
+ * both, and the sidebar grows two highlights.
+ *
+ * External items never match: they leave the app, so no path inside it is
+ * ever "on" them.
+ */
+export declare function resolveActivePath(pathname: string, nav: ConnectNav): string | null;
+/**
+ * Whether `item` is the destination `resolveActivePath` picked.
+ *
+ * Not just `normalizePath(item.href) === activeHref`, which is the trap this
+ * exists to close: `normalizePath` strips the origin off an absolute URL, so
+ * an external item pointed at `https://docs.example.com` normalizes to `/` and
+ * lights up on every app's home route. External items are never active.
+ */
+export declare function isNavItemActive(item: ConnectNavItem, activeHref: string | null): boolean;
+/** Hrefs declared `gateExempt` - the routes `ConnectAppShell` renders outside its `ConnectAccessGate`. */
+export declare function gateExemptPaths(nav: ConnectNav): string[];

package/dist/types/client/components/side-nav.d.ts

@@ -0,0 +1,31 @@
+import { type ConnectLinkRenderer, type ConnectNav } from "./nav.js";
+/** A plain anchor - correct anywhere, and a full page load. See `ConnectLinkRenderer`. */
+export declare const defaultRenderLink: ConnectLinkRenderer;
+export interface ConnectSideNavProps {
+    /** Items, sections, or a mix - see `ConnectNav`. */
+    nav: ConnectNav;
+    /**
+     * The current path. Pass your router's own (`usePathname()` in Next) -
+     * without it the nav reads `window.location` and patches `history` to hear
+     * about client-side navigations, which works but is guesswork the router
+     * never has to do. See `useActivePath`.
+     */
+    activePath?: string;
+    /** See `ConnectLinkRenderer`. Defaults to a plain `<a>`. */
+    renderLink?: ConnectLinkRenderer;
+    /** Icon-only rail. Labels move into tooltips and children are hidden. */
+    collapsed?: boolean;
+    /** Called after any nav link is pressed - the mobile drawer closes itself with this. */
+    onNavigate?: () => void;
+    className?: string;
+}
+/**
+ * The sidebar's nav column on its own - sections, items, one level of
+ * children, and the active highlight.
+ *
+ * `ConnectAppShell` renders this inside its rail and its mobile drawer, and it
+ * is exported for a host that wants the shell's navigation without its
+ * chrome: the same items, the same active resolution, dropped into a layout
+ * you already have.
+ */
+export declare function ConnectSideNav({ nav, activePath, renderLink, collapsed, onNavigate, className, }: ConnectSideNavProps): import("react").JSX.Element;

package/dist/types/client/components/surfaces.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The one elevation model every panel inside a Connect modal follows.
+ *
+ * This exists because "just use `bg-surface`" is wrong here, and wrong in a
+ * way that is invisible until you look at the tokens. `Modal.Dialog` paints
+ * itself `bg-overlay`, and in the shared theme (`theme.css`) `--overlay` and
+ * `--surface` sit at the *same lightness* in both schemes - 100% against 100%
+ * in light, 21% against 21% in dark. A `bg-surface` panel dropped on a modal
+ * therefore has no fill contrast at all; only its border separates it from
+ * the dialog behind it.
+ *
+ * That is how the account modal ended up looking half-finished: the identity
+ * card used `bg-surface-secondary` and read as a solid block, while the
+ * destination tiles and the session list used `bg-surface` and read as
+ * hairline outlines floating on nothing. Same nesting depth, two different
+ * physical materials, for no reason a user could infer.
+ *
+ * Three levels, and nesting one inside another always steps the fill:
+ *
+ * - **L0 - the dialog itself.** `bg-overlay`, owned by HeroUI. Not ours.
+ * - **L1 - a panel on the dialog.** `PANEL_FILL` + `border-border`. The
+ *   identity card, each destination tile, the session list.
+ * - **L2 - a medallion inside a panel.** `bg-surface`, which is L0's value
+ *   and therefore reads as *inset* against L1 rather than raised. Light:
+ *   white on grey. Dark: near-black on charcoal. Both directions legible.
+ *
+ * The inversion at L2 is deliberate and is why this is written down. Reaching
+ * for a "lighter" fill one step down works in light mode and quietly fails in
+ * dark; stepping *back to the dialog's own value* is the trick that reads in
+ * both, because the contrast comes from the gap between L1 and L0 rather than
+ * from a direction of travel.
+ */
+export declare const PANEL_FILL = "bg-surface-secondary";
+/**
+ * The icon well shared by destination tiles and session rows: a 40px box
+ * holding a 20px glyph.
+ *
+ * Half the well, which is the point. Both surfaces used to run a `size-4`
+ * (16px) icon inside a `size-9` (36px) well - a 44% fill that reads as an
+ * icon someone forgot to finish, and the specific thing that made the
+ * Profile/Billing/Connect tiles look under-drawn. They also disagreed on
+ * shape (a circle in the tiles, a rounded square in the session rows) for
+ * what is the same component role, so the two surfaces never looked related.
+ *
+ * Pair with `ICON` on the glyph inside. Session rows override the well to
+ * `size-9` for density but keep the same `ICON`, so glyph size stays constant
+ * across the whole modal even where the well does not.
+ */
+export declare const MEDALLION = "size-10";
+/** The glyph inside a `MEDALLION`. Constant across every well in the modal - see `MEDALLION`. */
+export declare const ICON = "size-5";

package/dist/types/client/index.d.ts

@@ -10,7 +10,7 @@
  * whatever theme the host service platform already configured, and one theme
  * change lands identically in all of them.
  */
-export { ConnectProvider, useConnect, useConnectUser, useConnectEntitlements, useConnectPlans, useConnectApps, useConnectAddonUsage, useConnectSessions, useConnectResource, CONNECT_APP_URL, } from "./provider.js";
+export { ConnectProvider, useConnect, useConnectUser, useConnectEntitlements, useConnectPlans, useConnectApps, useConnectAddonUsage, useConnectSessions, useConnectIntegrations, useConnectResource, CONNECT_APP_URL, } from "./provider.js";
 export type { ConnectProviderProps, ConnectContextValue, ConnectSession } from "./provider.js";
 export { blockingBlockers, normalizePlanFeatures } from "../helpers.js";
 export type { WirePlanFeature } from "../helpers.js";
@@ -25,8 +25,17 @@ export { ConnectUserMenu, ConnectManageSubscriptionButton, ConnectInvoicesButton
 export { ConnectAccountSessions } from "./components/account-sessions.js";
 export type { ConnectAccountSessionsProps } from "./components/account-sessions.js";
 export type { ConnectUserMenuProps } from "./components/user-menu.js";
+export { ConnectAppShell } from "./components/app-shell.js";
+export type { ConnectAppShellProps } from "./components/app-shell.js";
+export { ConnectSideNav } from "./components/side-nav.js";
+export type { ConnectSideNavProps } from "./components/side-nav.js";
+export { useActivePath } from "./use-active-path.js";
+export { normalizeNav, flattenNav, normalizePath, resolveActivePath, isNavItemActive, gateExemptPaths, } from "./components/nav.js";
+export type { ConnectNav, ConnectNavItem, ConnectNavSection, ConnectNavLinkProps, ConnectLinkRenderer, } from "./components/nav.js";
 export { ConnectAppsGrid } from "./components/apps-grid.js";
 export type { ConnectAppsGridProps } from "./components/apps-grid.js";
+export { ConnectIntegrationsModal } from "./components/integrations-modal.js";
+export type { ConnectIntegrationsModalProps } from "./components/integrations-modal.js";
 export { ConnectPlans } from "./components/plans.js";
 export type { ConnectPlansProps } from "./components/plans.js";
 export { ConnectSubscribeDialog } from "./components/subscribe-dialog.js";
@@ -35,6 +44,8 @@ export { ConnectSubscriptionGate, ConnectNoSubscriptionCard, ConnectSubscription
 export type { ConnectSubscriptionGateProps, ConnectNoSubscriptionCardProps, ConnectSubscriptionCardProps, ConnectTrialBannerProps, ConnectSubscriptionState, } from "./components/subscription.js";
 export { ConnectReadinessBanner, ConnectReadinessGate } from "./components/readiness.js";
 export type { ConnectReadinessBannerProps, ConnectReadinessGateProps } from "./components/readiness.js";
+export { ConnectAccessGate, useConnectAccessGate } from "./components/access-gate.js";
+export type { ConnectAccessGateProps, ConnectAccessGateState, ConnectAccessGateResult, } from "./components/access-gate.js";
 export { ConnectFeatureGate, useConnectFeature } from "./components/feature-gate.js";
 export type { ConnectFeatureGateProps } from "./components/feature-gate.js";
 export { ConnectUsageMeter } from "./components/usage-meter.js";

package/dist/types/client/provider.d.ts

@@ -1,5 +1,5 @@
 import type { ReactNode } from "react";
-import type { AddonUsageResponse, ConnectUser, OrganizationApp, PlansResponse, ReadinessResponse, ServiceRole, SessionsListResponse, SessionSubscription, SubscriptionResponse } from "../types.js";
+import type { AddonUsageResponse, ConnectUser, IntegrationsListResponse, OrganizationApp, PlansResponse, ReadinessResponse, ServiceRole, SessionsListResponse, SessionSubscription, SubscriptionResponse } from "../types.js";
 export declare const CONNECT_APP_URL = "https://connect.cosmoops.com";
 export interface ConnectSession {
     user: ConnectUser | null;
@@ -61,7 +61,7 @@ export interface ConnectContextValue {
 }
 export interface ConnectProviderProps {
     /**
-     * This service's public `client_id`, from its Setup tab in Connect.
+     * This service's public `client_id`, from its Integration tab in Connect.
      *
      * Not needed for the default sign-in flow: `signIn()` with no `redirectUri`
      * bounces the browser to your own `/signin` route, which already knows
@@ -87,6 +87,27 @@ export interface ConnectProviderProps {
      * child effects.
      */
     fetch?: (input: string, init?: RequestInit) => Promise<Response>;
+    /**
+     * Sign in a returning visitor automatically, with no click.
+     *
+     * When the first `/session` read comes back signed out, the browser is sent
+     * on one round trip to Connect with OIDC `prompt=none`. If they still have
+     * a Connect session and have authorised this app before, they come straight
+     * back signed in and never see a screen. If not, they come straight back
+     * signed out, with no error and nothing rendered differently - your normal
+     * signed-out UI just appears a beat later.
+     *
+     * **Off by default, and it is a real trade, not just caution.** It costs a
+     * full-page redirect on the first load of every signed-out visit - a brief
+     * flash on a marketing page, invisible on an app shell - so it belongs on
+     * apps whose visitors are overwhelmingly already Connect users. It is
+     * attempted at most once per tab (a `sessionStorage` marker), so a visitor
+     * who genuinely has no session does not bounce on every navigation.
+     *
+     * Requires `createConnectHandler` mounted at `basePath`; the redirect goes
+     * to your own `/signin`, which mints the `state` server-side.
+     */
+    silentSignIn?: boolean;
     children: ReactNode;
 }
 /**
@@ -103,7 +124,7 @@ export interface ConnectProviderProps {
  * </ConnectProvider>
  * ```
  */
-export declare function ConnectProvider({ clientId, basePath, redirectUri, appUrl, fetch: fetchImpl, children, }: ConnectProviderProps): import("react").JSX.Element;
+export declare function ConnectProvider({ clientId, basePath, redirectUri, appUrl, fetch: fetchImpl, silentSignIn, children, }: ConnectProviderProps): import("react").JSX.Element;
 export declare function useConnect(): ConnectContextValue;
 /** The signed-in user, or `null`. Sugar over `useConnect().session`. */
 export declare function useConnectUser(): ConnectUser | null;
@@ -174,6 +195,20 @@ export declare function useConnectApps(): {
      */
     refetch(): void;
 };
+/** Enabled Composio-hosted toolkits and this organization's connection status for each. */
+export declare function useConnectIntegrations(): {
+    data: IntegrationsListResponse | null;
+    isLoading: boolean;
+    error: string | null;
+    /**
+     * Forces a fresh read - the provider's cache clears the mutated path's
+     * entry on a successful `mutateResource` call, but nothing re-triggers
+     * this hook's own effect on its own (none of its dependencies change from
+     * a cache write nobody here observes). Call this right after a
+     * `mutateResource` you made against the same `path` completes.
+     */
+    refetch(): void;
+};
 /**
  * This Connect account's own login sessions - account-wide, not scoped to
  * this service, see `SessionsListResponse`'s doc comment. The component

package/dist/types/client/use-active-path.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The current path, from `activePath` when given and from the browser
+ * otherwise.
+ *
+ * Exported because a host building its own shell out of `ConnectSideNav`
+ * needs the same fallback the shell uses.
+ */
+export declare function useActivePath(activePath?: string): string;

package/dist/types/errors.d.ts

@@ -52,7 +52,7 @@ export declare class ConnectError extends Error {
      * guessing keys. These two are the exception: reaching them required
      * presenting a key whose hash matched, so you already hold it, and what you
      * need to know is that no retry and no scope change will fix this - the key
-     * has to be reissued from the service's Setup tab.
+     * has to be reissued from the service's Integration tab.
      *
      * Worth alerting on. It is the one failure that will not resolve itself and
      * takes down every call your integration makes.

package/dist/types/next/index.d.ts

@@ -81,6 +81,9 @@ export { handle as GET, handle as POST };
  * if (!session) redirect("/api/connect/signin?next=/dashboard");
  * ```
  *
+ * `requireConnectSession()` below is that exact check in one call, for the
+ * common case of "redirect if signed out."
+ *
  * Pass a `Request` to use it somewhere `next/headers` does not exist - a
  * framework-agnostic handler, a test, a custom server. Both forms take the
  * same path afterwards; the argument is only how the cookie is found.
@@ -92,11 +95,48 @@ export { handle as GET, handle as POST };
  *
  * Returns `null` for every failure - an expired session and a missing one both
  * mean "not signed in", and a page guard should not need a try/catch.
+ *
+ * **Memoized per request for the plain, zero-argument call** - the shape
+ * every page, layout and Server Action actually uses - via React's `cache()`.
+ * Passing an explicit `request`, `client` or `session` bypasses the cache
+ * and always makes a live call: those are for tests and non-ambient
+ * callers, where a fresh read every time is the point, not an oversight.
  */
 export declare function getConnectSession(request?: Request, options?: {
     client?: ConnectClient;
     session?: ConnectSessionStore;
 }): Promise<UserResponse | null>;
+/**
+ * `getConnectSession()`, minus the boilerplate of checking it and redirecting
+ * yourself:
+ *
+ * ```tsx
+ * // app/dashboard/page.tsx
+ * const session = await requireConnectSession();
+ * ```
+ *
+ * Redirects to `/signin` under the same `basePath` as `getConnectSession`'s
+ * default (`/api/connect`) when signed out - pass `signInPath` if you mounted
+ * the bridge somewhere else, and `next` to send the visitor back to where
+ * they were once they're signed in. Only sensible in a Server Component,
+ * Route Handler or Server Action, the same three places `redirect()` from
+ * `next/navigation` itself works.
+ *
+ * A thin wrapper, not a framework of its own - reach for `getConnectSession`
+ * plus your own check when "not signed in" isn't "redirect to sign-in"
+ * (an API route returning 401, say). Role and entitlement checks stay
+ * outside this function on purpose: `session.serviceRole.granted` and
+ * `connect.entitlements.*` are one line each on top of the session this
+ * already gives you, and where that line redirects (a plans page, a
+ * "forbidden" screen) is a decision only your app can make - see
+ * "Authentication & authorization" for the pattern.
+ */
+export declare function requireConnectSession(request?: Request, options?: {
+    client?: ConnectClient;
+    session?: ConnectSessionStore;
+    signInPath?: string;
+    next?: string;
+}): Promise<UserResponse>;
 export { createConnectHandler } from "../server/handler.js";
 export type { ConnectSessionStore } from "../server/handler.js";
 export { ConnectClient } from "../server/client.js";

package/dist/types/server/client.d.ts

@@ -6,13 +6,15 @@ import { BillingResource } from "./resources/billing.js";
 import { DriveResource } from "./resources/drive.js";
 import { EntitlementsResource } from "./resources/entitlements.js";
 import { IdentityResource } from "./resources/identity.js";
+import { IntegrationsResource } from "./resources/integrations.js";
 import { LogsResource } from "./resources/logs.js";
+import { AnalyticsResource } from "./resources/analytics.js";
 import { OtpResource } from "./resources/otp.js";
 import { SessionsResource } from "./resources/sessions.js";
 export declare const DEFAULT_BASE_URL = "https://connect.cosmoops.com";
 export interface ConnectClientOptions {
     /**
-     * The API key plaintext from this service's Setup tab, shown once at
+     * The API key plaintext from this service's Integration tab, shown once at
      * creation.
      *
      * One credential does three jobs: it is the `Authorization: Bearer` value
@@ -75,9 +77,13 @@ export declare class ConnectClient {
     readonly otp: OtpResource;
     /** Feature events into the Console's audit log, filterable to your service. */
     readonly logs: LogsResource;
+    /** Emit product events and read back this service's aggregated numbers. */
+    readonly analytics: AnalyticsResource;
     /** This Connect account's own login sessions - account-wide, not scoped to this service. Requires the `sessions:manage` scope. */
     readonly sessions: SessionsResource;
+    /** Composio-hosted third-party connections (Google Calendar, Slack, ...) an organization has connected. */
+    readonly integrations: IntegrationsResource;
     constructor(options: ConnectClientOptions);
 }
 /** Kept in step with `package.json` by `sdk.test.ts`. */
-export declare const SDK_VERSION = "0.1.0";
+export declare const SDK_VERSION = "0.6.0";

package/dist/types/server/index.d.ts

@@ -10,6 +10,21 @@ export type { ConnectClientOptions } from "./client.js";
 export { createConnectHandler } from "./handler.js";
 export type { ConnectHandlerOptions, ConnectSessionStore } from "./handler.js";
 export { createState } from "./resources/identity.js";
-export type { AuthorizeUrlInput, ExchangeCodeInput } from "./resources/identity.js";
-export type { UploadInput } from "./resources/drive.js";
+export type { AuthorizeUrlInput, ExchangeCodeInput, IdentityResource } from "./resources/identity.js";
+export type { UploadInput, DriveResource } from "./resources/drive.js";
 export type { FetchLike } from "./http.js";
+export type { AccessResource } from "./resources/access.js";
+export type { AppsResource } from "./resources/apps.js";
+export type { EntitlementsResource } from "./resources/entitlements.js";
+export type { BillingResource } from "./resources/billing.js";
+export type { AiResource } from "./resources/ai.js";
+export type { OtpResource } from "./resources/otp.js";
+export type { LogsResource } from "./resources/logs.js";
+export type { AnalyticsResource } from "./resources/analytics.js";
+export type { SessionsResource } from "./resources/sessions.js";
+export type { ExecuteIntegrationActionInput, IntegrationsResource } from "./resources/integrations.js";
+/**
+ * Webhook verification and a ready-made POST route. Server-only for the
+ * obvious reason: the signing secret must never reach a browser bundle.
+ */
+export { createConnectWebhookHandler, verifyConnectWebhook, type ConnectWebhookHandlers, type ConnectWebhookHandlerOptions, } from "./webhooks.js";

package/dist/types/server/resources/analytics.d.ts

@@ -0,0 +1,31 @@
+import { type TransportOptions } from "../http.js";
+import type { AnalyticsQuery, AnalyticsResponse, EmitEventInput, EmitEventsResponse } from "../../types.js";
+/**
+ * Your service's own analytics: emit product events, and read back the daily
+ * numbers Connect aggregates from them.
+ *
+ * There is no way to name a service in either call. The scope is always the one
+ * your API key belongs to - that is the endpoint's security model, not an
+ * omission.
+ */
+export declare class AnalyticsResource {
+    private readonly transport;
+    constructor(transport: TransportOptions);
+    /**
+     * Daily series for the requested metrics, up to 90 days.
+     *
+     * **Throws on failure**, unlike `emit` below. A read whose result you are
+     * about to render has to be able to say "I could not load"; silently
+     * returning an empty series would draw a chart of zeroes.
+     */
+    series(query: AnalyticsQuery): Promise<AnalyticsResponse>;
+    /**
+     * Never throws - the same judgement `LogsResource.write` makes, for the same
+     * reason: telemetry that takes down the code path it was observing is worse
+     * than a lost event. A failure is reported through `delivered`.
+     *
+     * Up to 50 events per call. Pass `sessionToken` on an event to attribute it
+     * to the signed-in user; without one it still lands, just unattributed.
+     */
+    emit(events: EmitEventInput[]): Promise<EmitEventsResponse>;
+}

package/dist/types/server/resources/identity.d.ts

@@ -4,8 +4,18 @@ export interface AuthorizeUrlInput {
     redirectUri: string;
     /** Fresh and random per request; check it matches on the way back. `createState()` makes one. */
     state: string;
-    /** `"create"` opens registration instead of sign-in, so one entry point serves both buttons. */
-    prompt?: "create";
+    /**
+     * `"create"` opens registration instead of sign-in, so one entry point
+     * serves both buttons.
+     *
+     * `"none"` is OIDC silent authentication: Connect answers from the
+     * visitor's existing session without showing them anything, returning a
+     * code if they are signed in and have already authorised this client, and
+     * `error=login_required`/`consent_required`/`interaction_required` if not.
+     * Use it to sign in a returning visitor with no click - never to *start* a
+     * sign-in, since by definition it will never show them a login screen.
+     */
+    prompt?: "create" | "none";
     /** Required only if this service enforces PKCE. */
     codeChallenge?: string;
 }