@hyperdrive.bot/fleet-server 0.3.149 → 0.3.151

package/dist/server/server/config.js

@@ -233,6 +233,10 @@ function resolveIngestionConfig(input) {
         composio: {
             apiKey: env.PASEO_COMPOSIO_API_KEY?.trim() || undefined,
         },
+        selfHosted: {
+            url: env.PASEO_SELF_HOSTED_URL?.trim() || undefined,
+            token: env.PASEO_SELF_HOSTED_TOKEN?.trim() || undefined,
+        },
     };
 }
 function parseTrustedProxiesEnv(value) {

package/dist/server/server/ingestion/adapters.js

@@ -1,5 +1,6 @@
 import { createComposioGateway } from "./composio/gateway.js";
 import { createPipedreamGateway } from "./pipedream/gateway.js";
+import { createSelfHostedGateway } from "./self-hosted/gateway.js";
 /**
  * The adapter factory for every source kind.
  *
@@ -16,6 +17,7 @@ import { createPipedreamGateway } from "./pipedream/gateway.js";
 export const SOURCE_ADAPTERS = {
     pipedream: (deps) => createPipedreamGateway(deps.config.pipedream),
     composio: (deps) => createComposioGateway(deps.config.composio),
+    "self-hosted": (deps) => createSelfHostedGateway(deps.config.selfHosted),
 };
 /**
  * The gateway for one kind. Total by construction: SOURCE_ADAPTERS covers every

package/dist/server/server/ingestion/errors.d.ts

@@ -13,6 +13,10 @@
  *   COMPOSIO_OFFLINE      | 502        | Composio unreachable
  *   COMPOSIO_AUTH         | 502        | Composio rejected our platform credential
  *   COMPOSIO_ERROR        | 502        | Composio answered non-ok for any other reason
+ *   SELF_HOSTED_OFF       | 422        | no bridge URL/token, or the URL is malformed
+ *   SELF_HOSTED_OFFLINE   | 502        | the user's bridge is unreachable or timed out
+ *   SELF_HOSTED_AUTH      | 502        | the bridge rejected this daemon's bearer
+ *   SELF_HOSTED_ERROR     | 502        | the bridge answered non-ok, non-JSON or incomplete
  *   SOURCE_GONE           | 502        | a resource we cached was deleted upstream
  *   SOURCE_ERROR          | 502        | any other non-ok aggregator response
  *   FILTER_MISSING        | 404        | no such filter on THIS daemon
@@ -37,7 +41,7 @@
  * tell the caller to re-authenticate, which cannot fix anything, and would
  * blame the wrong party for an operator's misconfiguration.
  */
-export declare const INGESTION_ERROR_CODES: readonly ["PIPEDREAM_OFF", "COMPOSIO_OFF", "COMPOSIO_NEEDS_SETUP", "PIPEDREAM_OFFLINE", "PIPEDREAM_AUTH", "COMPOSIO_OFFLINE", "COMPOSIO_AUTH", "COMPOSIO_ERROR", "SOURCE_GONE", "SOURCE_ERROR", "FILTER_MISSING", "SOURCE_MISSING"];
+export declare const INGESTION_ERROR_CODES: readonly ["PIPEDREAM_OFF", "COMPOSIO_OFF", "COMPOSIO_NEEDS_SETUP", "PIPEDREAM_OFFLINE", "PIPEDREAM_AUTH", "COMPOSIO_OFFLINE", "COMPOSIO_AUTH", "COMPOSIO_ERROR", "SELF_HOSTED_OFF", "SELF_HOSTED_OFFLINE", "SELF_HOSTED_AUTH", "SELF_HOSTED_ERROR", "SOURCE_GONE", "SOURCE_ERROR", "FILTER_MISSING", "SOURCE_MISSING"];
 export type IngestionErrorCode = (typeof INGESTION_ERROR_CODES)[number];
 /** A domain error from the ingestion seam, with a message ready for a client. */
 export declare class IngestionError extends Error {

package/dist/server/server/ingestion/errors.js

@@ -13,6 +13,10 @@
  *   COMPOSIO_OFFLINE      | 502        | Composio unreachable
  *   COMPOSIO_AUTH         | 502        | Composio rejected our platform credential
  *   COMPOSIO_ERROR        | 502        | Composio answered non-ok for any other reason
+ *   SELF_HOSTED_OFF       | 422        | no bridge URL/token, or the URL is malformed
+ *   SELF_HOSTED_OFFLINE   | 502        | the user's bridge is unreachable or timed out
+ *   SELF_HOSTED_AUTH      | 502        | the bridge rejected this daemon's bearer
+ *   SELF_HOSTED_ERROR     | 502        | the bridge answered non-ok, non-JSON or incomplete
  *   SOURCE_GONE           | 502        | a resource we cached was deleted upstream
  *   SOURCE_ERROR          | 502        | any other non-ok aggregator response
  *   FILTER_MISSING        | 404        | no such filter on THIS daemon
@@ -46,6 +50,10 @@ export const INGESTION_ERROR_CODES = [
     "COMPOSIO_OFFLINE",
     "COMPOSIO_AUTH",
     "COMPOSIO_ERROR",
+    "SELF_HOSTED_OFF",
+    "SELF_HOSTED_OFFLINE",
+    "SELF_HOSTED_AUTH",
+    "SELF_HOSTED_ERROR",
     "SOURCE_GONE",
     "SOURCE_ERROR",
     "FILTER_MISSING",

package/dist/server/server/ingestion/health.js

@@ -22,6 +22,16 @@ const ERROR_CODE_STATUS = {
     COMPOSIO_OFFLINE: "degraded",
     COMPOSIO_AUTH: "revoked",
     COMPOSIO_ERROR: "degraded",
+    // Same split as the aggregators, for the same reason. OFF/OFFLINE/ERROR are
+    // states the next sweep may clear on its own; AUTH is not. For a vendor,
+    // AUTH means the user must re-authorize there; for a self-hosted bridge it
+    // means the bearer in this daemon's env no longer matches the one the bridge
+    // expects. Different cause, identical consequence: a human has to act, so
+    // reporting it as `degraded` would leave a dead source looking merely slow.
+    SELF_HOSTED_OFF: "degraded",
+    SELF_HOSTED_OFFLINE: "degraded",
+    SELF_HOSTED_AUTH: "revoked",
+    SELF_HOSTED_ERROR: "degraded",
     SOURCE_GONE: "revoked",
     SOURCE_ERROR: "degraded",
     // The 404 pair cannot arise from a health check: `checkSource` is only ever

package/dist/server/server/ingestion/self-hosted/gateway.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The self-hosted source gateway.
+ *
+ * Composio and Pipedream are aggregators someone else runs: paseo holds a
+ * platform credential and talks to a fixed base URL baked into the adapter.
+ * This adapter inverts that. The user runs the aggregator, tells paseo where it
+ * is, and paseo holds nothing but a bearer token for that one endpoint.
+ *
+ * That inversion is the whole point. Nothing in this file names an app, a
+ * vendor or a protocol beyond HTTP+JSON: the bridge on the other end decides
+ * what it fronts. WhatsApp-over-wacli is the first one, but a Matrix bridge, an
+ * IMAP box or a signal-cli would implement the same six routes and paseo would
+ * not learn a new word.
+ *
+ * WHAT THE BRIDGE OWES US (v1):
+ *
+ *   GET  {base}/v1/sources?query=&cursor=        -> SourcesResponse
+ *   POST {base}/v1/connect                       -> ConnectResponse
+ *   GET  {base}/v1/accounts?...                  -> AccountsResponse
+ *   GET  {base}/v1/items?...                     -> ItemsResponse
+ *   POST {base}/v1/mcp-target                    -> McpTargetResponse
+ *
+ * `listTriggerComponents` / `deployTrigger` are deliberately NOT implemented.
+ * They are optional on `SourceGateway`, and `service.ts` already answers
+ * `${kind} cannot deploy triggers` for a gateway that lacks them. A bridge that
+ * fronts a local daemon has nothing to deploy: it is already watching, or it is
+ * not running at all. Pretending otherwise would report a source as "watching"
+ * when nothing is.
+ *
+ * LEDGER IDENTITY IS OURS, NOT THE BRIDGE'S.
+ *
+ * The bridge returns `externalId` and a raw `payload`; `key` and `contentHash`
+ * are computed HERE with `fingerprint()`, byte-identically to the Composio
+ * adapter. A bridge that minted its own keys would be a second identity
+ * function for the same items, and an identity that disagrees with the ledger
+ * re-dispatches a backlog the user already cleared.
+ *
+ * Note what `key` deliberately does NOT include: `accountId`. Two accounts on
+ * the same underlying inbox (the read-only and read-write wacli pair, both
+ * linked to one WhatsApp number) see the SAME messages. Keying without the
+ * account makes that one ledger row handled once, which is the correct
+ * behaviour, and it also means re-pairing an account does not invalidate a
+ * backlog the user already worked through.
+ *
+ * CREDENTIALS.
+ *
+ * The bearer token never leaves this module, and `mcpTarget` results are per
+ * turn: they carry live headers minted by the bridge and are never persisted,
+ * cached or returned to a client. A `SourceItem` has no credential field and
+ * must never grow one - it is projected into `BackfillItem` and crosses the
+ * wire to the app.
+ */
+import type { SelfHostedConfig, SourceGateway } from "../types.js";
+export declare function createSelfHostedGateway(config?: SelfHostedConfig | undefined): SourceGateway;
+//# sourceMappingURL=gateway.d.ts.map

package/dist/server/server/ingestion/self-hosted/gateway.js

@@ -0,0 +1,295 @@
+/**
+ * The self-hosted source gateway.
+ *
+ * Composio and Pipedream are aggregators someone else runs: paseo holds a
+ * platform credential and talks to a fixed base URL baked into the adapter.
+ * This adapter inverts that. The user runs the aggregator, tells paseo where it
+ * is, and paseo holds nothing but a bearer token for that one endpoint.
+ *
+ * That inversion is the whole point. Nothing in this file names an app, a
+ * vendor or a protocol beyond HTTP+JSON: the bridge on the other end decides
+ * what it fronts. WhatsApp-over-wacli is the first one, but a Matrix bridge, an
+ * IMAP box or a signal-cli would implement the same six routes and paseo would
+ * not learn a new word.
+ *
+ * WHAT THE BRIDGE OWES US (v1):
+ *
+ *   GET  {base}/v1/sources?query=&cursor=        -> SourcesResponse
+ *   POST {base}/v1/connect                       -> ConnectResponse
+ *   GET  {base}/v1/accounts?...                  -> AccountsResponse
+ *   GET  {base}/v1/items?...                     -> ItemsResponse
+ *   POST {base}/v1/mcp-target                    -> McpTargetResponse
+ *
+ * `listTriggerComponents` / `deployTrigger` are deliberately NOT implemented.
+ * They are optional on `SourceGateway`, and `service.ts` already answers
+ * `${kind} cannot deploy triggers` for a gateway that lacks them. A bridge that
+ * fronts a local daemon has nothing to deploy: it is already watching, or it is
+ * not running at all. Pretending otherwise would report a source as "watching"
+ * when nothing is.
+ *
+ * LEDGER IDENTITY IS OURS, NOT THE BRIDGE'S.
+ *
+ * The bridge returns `externalId` and a raw `payload`; `key` and `contentHash`
+ * are computed HERE with `fingerprint()`, byte-identically to the Composio
+ * adapter. A bridge that minted its own keys would be a second identity
+ * function for the same items, and an identity that disagrees with the ledger
+ * re-dispatches a backlog the user already cleared.
+ *
+ * Note what `key` deliberately does NOT include: `accountId`. Two accounts on
+ * the same underlying inbox (the read-only and read-write wacli pair, both
+ * linked to one WhatsApp number) see the SAME messages. Keying without the
+ * account makes that one ledger row handled once, which is the correct
+ * behaviour, and it also means re-pairing an account does not invalidate a
+ * backlog the user already worked through.
+ *
+ * CREDENTIALS.
+ *
+ * The bearer token never leaves this module, and `mcpTarget` results are per
+ * turn: they carry live headers minted by the bridge and are never persisted,
+ * cached or returned to a client. A `SourceItem` has no credential field and
+ * must never grow one - it is projected into `BackfillItem` and crosses the
+ * wire to the app.
+ */
+import { IngestionError } from "../errors.js";
+import { fingerprint } from "../fingerprint.js";
+/** Hard ceiling on a bridge response body. A local bridge is not a reason to trust it. */
+const MAX_BODY_BYTES = 8 * 1024 * 1024;
+/** Per-request timeout. A wedged local daemon must not hang a paseo turn forever. */
+const REQUEST_TIMEOUT_MS = 30000;
+function notConfigured() {
+    throw new IngestionError("SELF_HOSTED_OFF", "This daemon has no self-hosted source bridge configured. Set PASEO_SELF_HOSTED_URL and PASEO_SELF_HOSTED_TOKEN.", 422);
+}
+/**
+ * Normalize the configured base so route joining is total.
+ *
+ * A trailing slash in the env var plus a leading slash in the route yields
+ * `//v1/sources`, which some servers route and some 404. Strip it once here
+ * rather than defending at five call sites.
+ */
+function normalizeBase(url) {
+    return url.replace(/\/+$/, "");
+}
+/**
+ * Reject a base URL that is not http(s).
+ *
+ * The URL comes from the user's own environment, so this is not a trust
+ * boundary against an attacker. It is a boundary against a typo: a `file:` or
+ * `data:` base would make `fetch` do something surprising rather than fail
+ * with a readable message.
+ */
+function assertHttpUrl(raw) {
+    let parsed;
+    try {
+        parsed = new URL(raw);
+    }
+    catch {
+        throw new IngestionError("SELF_HOSTED_OFF", `PASEO_SELF_HOSTED_URL is not a valid URL: ${raw}`, 422);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new IngestionError("SELF_HOSTED_OFF", `PASEO_SELF_HOSTED_URL must be http or https, got ${parsed.protocol}`, 422);
+    }
+    return parsed;
+}
+/** One catalogue page. Matches the Composio adapter's page size so the app's infinite scroll behaves identically. */
+const CATALOGUE_LIMIT = 20;
+function asString(value, fallback = "") {
+    return typeof value === "string" ? value : fallback;
+}
+/**
+ * Narrow a bridge's account status to the union the rest of the daemon reads.
+ *
+ * Anything unrecognized becomes "inactive" rather than throwing. A bridge that
+ * grows a new status must not take the whole sources list down with it, and
+ * "inactive" is the honest reading of "I do not know that this works".
+ */
+function asAccountStatus(value) {
+    return value === "active" || value === "pending" || value === "inactive" ? value : "inactive";
+}
+export function createSelfHostedGateway(config) {
+    // Tolerates an absent config on purpose. `hasConfiguredGateway` asks EVERY
+    // kind whether it is configured, so a gateway that throws when its block is
+    // missing does not fail its own kind: it takes the whole sources screen down
+    // with it. An absent block means exactly "no bridge here", which is what
+    // `configured: false` already says.
+    const rawUrl = config?.url?.trim();
+    const token = config?.token?.trim();
+    const configured = Boolean(rawUrl) && Boolean(token);
+    const base = rawUrl ? normalizeBase(rawUrl) : "";
+    /**
+     * One HTTP call to the bridge, with the error taxonomy applied once.
+     *
+     * The three failure shapes are kept apart on purpose, mirroring the Composio
+     * adapter: unreachable (the bridge is down or the URL is wrong), rejected
+     * (the token is wrong), and everything else. Collapsing them would send the
+     * next reader to restart a daemon when the real problem was a stale token.
+     */
+    async function call(method, route, init) {
+        if (!configured) {
+            notConfigured();
+        }
+        assertHttpUrl(base);
+        const url = new URL(`${base}${route}`);
+        for (const [key, value] of Object.entries(init?.query ?? {})) {
+            if (value === null || value === undefined) {
+                continue;
+            }
+            url.searchParams.set(key, String(value));
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => {
+            controller.abort();
+        }, REQUEST_TIMEOUT_MS);
+        let response;
+        try {
+            response = await fetch(url, {
+                method,
+                headers: {
+                    authorization: `Bearer ${token}`,
+                    accept: "application/json",
+                    ...(init?.body === undefined ? {} : { "content-type": "application/json" }),
+                },
+                ...(init?.body === undefined ? {} : { body: JSON.stringify(init.body) }),
+                signal: controller.signal,
+            });
+        }
+        catch (cause) {
+            const reason = cause instanceof Error && cause.name === "AbortError" ? "timed out" : "is unreachable";
+            throw new IngestionError("SELF_HOSTED_OFFLINE", `The self-hosted source bridge at ${base} ${reason}.`, 502);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        if (response.status === 401 || response.status === 403) {
+            throw new IngestionError("SELF_HOSTED_AUTH", `The self-hosted source bridge at ${base} rejected this daemon's token.`, 502);
+        }
+        const text = await response.text();
+        if (text.length > MAX_BODY_BYTES) {
+            throw new IngestionError("SELF_HOSTED_ERROR", `The self-hosted source bridge returned a body over ${MAX_BODY_BYTES} bytes for ${route}.`, 502);
+        }
+        if (!response.ok) {
+            throw new IngestionError("SELF_HOSTED_ERROR", `The self-hosted source bridge answered ${response.status} for ${route}.`, 502);
+        }
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            throw new IngestionError("SELF_HOSTED_ERROR", `The self-hosted source bridge returned a non-JSON body for ${route}.`, 502);
+        }
+    }
+    return {
+        get configured() {
+            return configured;
+        },
+        async listSources(query, cursor) {
+            const raw = await call("GET", "/v1/sources", { query: { query, cursor: cursor ?? null, limit: CATALOGUE_LIMIT } });
+            const items = (Array.isArray(raw.items) ? raw.items : [])
+                .filter((entry) => Boolean(entry) && typeof entry === "object")
+                .map((entry) => ({
+                slug: asString(entry.slug),
+                name: asString(entry.name),
+                imgSrc: asString(entry.imgSrc),
+                description: asString(entry.description),
+            }))
+                // A catalogue entry without a slug cannot be connected to, so it is not
+                // an entry. Dropping it beats rendering a row that errors on click.
+                .filter((entry) => entry.slug.length > 0);
+            return {
+                items,
+                nextCursor: typeof raw.nextCursor === "string" && raw.nextCursor.length > 0 ? raw.nextCursor : null,
+            };
+        },
+        async connect(externalUserId, appSlug) {
+            const raw = await call("POST", "/v1/connect", {
+                body: { externalUserId, appSlug },
+            });
+            const redirectUrl = asString(raw.redirectUrl);
+            if (redirectUrl.length === 0) {
+                throw new IngestionError("SELF_HOSTED_ERROR", `The self-hosted source bridge returned no redirectUrl for ${appSlug}.`, 502);
+            }
+            return {
+                redirectUrl,
+                expiresAt: typeof raw.expiresAt === "string" && raw.expiresAt.length > 0 ? raw.expiresAt : null,
+            };
+        },
+        async listAccounts(externalUserId, appSlug) {
+            const raw = await call("GET", "/v1/accounts", {
+                query: { externalUserId, appSlug },
+            });
+            return (Array.isArray(raw.accounts) ? raw.accounts : [])
+                .filter((account) => Boolean(account) && typeof account === "object")
+                .map((account) => ({
+                id: asString(account.id),
+                status: asAccountStatus(account.status),
+                // `label` answers "WHICH account", the question a connected row could
+                // not answer before it existed. A bridge that omits it gets null, not "".
+                label: typeof account.label === "string" && account.label.length > 0 ? account.label : null,
+            }))
+                .filter((account) => account.id.length > 0);
+        },
+        async listItems(input) {
+            const raw = await call("GET", "/v1/items", {
+                query: {
+                    externalUserId: input.externalUserId,
+                    appSlug: input.appSlug,
+                    accountId: input.accountId,
+                    sinceMs: input.sinceMs,
+                    cursor: input.cursor,
+                    limit: input.limit,
+                },
+            });
+            const items = [];
+            for (const entry of Array.isArray(raw.items) ? raw.items : []) {
+                if (!entry || typeof entry !== "object") {
+                    continue;
+                }
+                const externalId = asString(entry.externalId);
+                // No id means no stable ledger identity. Inventing one would re-dispatch
+                // the item on every read, so the item is dropped instead.
+                if (externalId.length === 0) {
+                    continue;
+                }
+                // An adapter that cannot date an item drops it rather than inventing a
+                // timestamp: the backfill window is evaluated against this value.
+                if (typeof entry.timestampMs !== "number" || !Number.isFinite(entry.timestampMs)) {
+                    continue;
+                }
+                const payload = entry.payload && typeof entry.payload === "object" && !Array.isArray(entry.payload)
+                    ? entry.payload
+                    : {};
+                items.push({
+                    key: fingerprint("self-hosted", input.appSlug, externalId),
+                    contentHash: fingerprint(JSON.stringify(payload)),
+                    timestampMs: entry.timestampMs,
+                    title: asString(entry.title, externalId),
+                    subtitle: asString(entry.subtitle),
+                    payload,
+                });
+            }
+            return {
+                items,
+                cursor: typeof raw.cursor === "string" && raw.cursor.length > 0 ? raw.cursor : null,
+            };
+        },
+        async mcpTarget(externalUserId, appSlug) {
+            const raw = await call("POST", "/v1/mcp-target", {
+                body: { externalUserId, appSlug },
+            });
+            const url = asString(raw.url);
+            if (url.length === 0) {
+                throw new IngestionError("SELF_HOSTED_ERROR", `The self-hosted source bridge returned no MCP url for ${appSlug}.`, 502);
+            }
+            const headers = {};
+            if (raw.headers && typeof raw.headers === "object" && !Array.isArray(raw.headers)) {
+                for (const [key, value] of Object.entries(raw.headers)) {
+                    if (typeof value === "string") {
+                        headers[key] = value;
+                    }
+                }
+            }
+            // Never cached. The headers are a live credential minted by the bridge for
+            // this turn; a cache here would widen their reach past the turn that needs them.
+            return { url, headers };
+        },
+    };
+}
+//# sourceMappingURL=gateway.js.map

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

@@ -14,7 +14,7 @@
  * `Record<SourceKind, ...>` registry in `adapters.ts` turns that silence into
  * a compile error.
  */
-export declare const SOURCE_CAPABLE_KINDS: readonly ["pipedream", "composio"];
+export declare const SOURCE_CAPABLE_KINDS: readonly ["pipedream", "composio", "self-hosted"];
 export type SourceKind = (typeof SOURCE_CAPABLE_KINDS)[number];
 /** Where to reach an aggregator's remote MCP server for a single agent turn. */
 export interface McpTarget {
@@ -101,9 +101,22 @@ export interface PipedreamConfig {
 export interface ComposioConfig {
     apiKey?: string | undefined;
 }
+/**
+ * Where this daemon's OWN source bridge lives, and the token that opens it.
+ *
+ * Unlike the aggregator configs above, both fields are user-supplied and
+ * user-hosted: paseo holds no platform credential for a self-hosted bridge, it
+ * holds a bearer for one endpoint the user runs. `configured` is false when
+ * either is missing, which is how the sources screen knows not to offer it.
+ */
+export interface SelfHostedConfig {
+    url?: string | undefined;
+    token?: string | undefined;
+}
 export interface IngestionConfig {
     pipedream: PipedreamConfig;
     composio: ComposioConfig;
+    selfHosted?: SelfHostedConfig | undefined;
 }
 /**
  * A single-field object on purpose: later stories add a logger here without

package/dist/server/server/ingestion/types.js

@@ -14,5 +14,5 @@
  * `Record<SourceKind, ...>` registry in `adapters.ts` turns that silence into
  * a compile error.
  */
-export const SOURCE_CAPABLE_KINDS = ["pipedream", "composio"];
+export const SOURCE_CAPABLE_KINDS = ["pipedream", "composio", "self-hosted"];
 //# sourceMappingURL=types.js.map