@oomol-lab/open-connector 1.9.0 → 1.9.1

package/src/server/api/transit-file-routes.js

@@ -0,0 +1,49 @@
+import { Hono } from "hono";
+import { TransitFileError } from "../files/transit-file-store.js";
+import { jsonError } from "./http-utils.js";
+function handleTransitFileError(context, error) {
+    if (error instanceof TransitFileError) {
+        return jsonError(context, error.status, error.code, error.message);
+    }
+    throw error;
+}
+/** Transit file upload, retrieval and deletion routes. */
+export function createTransitFileRoutes({ transitFiles, uploadTransitFile }) {
+    const app = new Hono();
+    app.post("/files", async (context) => {
+        try {
+            if (uploadTransitFile) {
+                return context.json(await uploadTransitFile(context.req.raw));
+            }
+            const form = await context.req.raw.formData();
+            const file = form.get("file");
+            if (!(file instanceof File)) {
+                return jsonError(context, 400, "invalid_input", "file is required.");
+            }
+            const upload = await transitFiles.create(file);
+            return context.json(upload);
+        }
+        catch (error) {
+            return handleTransitFileError(context, error);
+        }
+    });
+    app.get("/files/:fileId", async (context) => {
+        try {
+            return await transitFiles.response(context.req.param("fileId"));
+        }
+        catch (error) {
+            return handleTransitFileError(context, error);
+        }
+    });
+    app.delete("/files/:fileId", async (context) => {
+        try {
+            const fileId = context.req.param("fileId");
+            const deleted = await transitFiles.delete(fileId);
+            return context.json({ fileId, deleted });
+        }
+        catch (error) {
+            return handleTransitFileError(context, error);
+        }
+    });
+    return app;
+}

package/src/server/api/trigger-routes.d.ts

@@ -0,0 +1,15 @@
+import type { CatalogStore } from "../../catalog-store.ts";
+import type { ActionPolicySnapshot } from "../../core/action-policy.ts";
+import type { TriggerMaintenance } from "../../triggers/maintenance.ts";
+import type { TriggerRunner } from "../../triggers/trigger-runner.ts";
+import type { Context } from "hono";
+import { Hono } from "hono";
+export interface TriggerRoutesOptions {
+    catalog: CatalogStore;
+    triggers?: TriggerRunner;
+    triggerMaintenance?: TriggerMaintenance;
+    getPolicySnapshot: (context: Context) => Promise<ActionPolicySnapshot>;
+    readConnectionName?: (context: Context, body?: Record<string, unknown>) => string | undefined;
+}
+/** Trigger execution and subscription management routes. */
+export declare function createTriggerRoutes({ catalog, triggers, triggerMaintenance, getPolicySnapshot, readConnectionName, }: TriggerRoutesOptions): Hono;

package/src/server/api/trigger-routes.js

@@ -0,0 +1,48 @@
+import { Hono } from "hono";
+import { optionalString } from "../../core/cast.js";
+import { readRuntimeGrant } from "./auth.js";
+import { HttpRequestError, readConnectionName as defaultReadConnectionName, readJsonBody } from "./http-utils.js";
+import { serializeRuntimeTriggerPermissions, writeRuntimeSuccess } from "./runtime-api.js";
+/** Trigger execution and subscription management routes. */
+export function createTriggerRoutes({ catalog, triggers, triggerMaintenance, getPolicySnapshot, readConnectionName = defaultReadConnectionName, }) {
+    const app = new Hono();
+    app.get("/v1/providers/:service/trigger-permissions", (context) => {
+        const service = context.req.param("service");
+        const provider = catalog.providers.find((item) => item.service === service);
+        if (!provider)
+            throw new HttpRequestError("provider_not_found", "Provider not found.", 404);
+        return writeRuntimeSuccess(context, serializeRuntimeTriggerPermissions(provider));
+    });
+    app.post("/v1/providers/:service/triggers/:triggerId/execute", async (context) => {
+        if (!triggers)
+            throw new HttpRequestError("trigger_not_supported", "Trigger execution is unavailable.", 501);
+        const { readTriggerRequest } = await import("../../triggers/request.js");
+        const request = readTriggerRequest(await readJsonBody(context, 160 * 1024));
+        const signal = AbortSignal.any([context.req.raw.signal, AbortSignal.timeout(45_000)]);
+        const result = await triggers.run({
+            service: context.req.param("service"),
+            triggerId: context.req.param("triggerId"),
+            request,
+            connectionName: readConnectionName(context),
+            connectionId: optionalString(context.req.header("x-oo-connector-app-id")),
+            policy: await getPolicySnapshot(context),
+            grant: readRuntimeGrant(context),
+            signal,
+        });
+        return writeRuntimeSuccess(context, result);
+    });
+    app.get("/api/trigger-subscriptions", async (context) => context.json((await triggerMaintenance?.list()) ?? []));
+    app.post("/api/trigger-subscriptions/:id/cancel", async (context) => {
+        if (!triggerMaintenance)
+            throw new HttpRequestError("trigger_not_supported", "Trigger subscriptions are unavailable.", 501);
+        await triggerMaintenance.cancel(context.req.param("id"), context.req.raw.signal);
+        return context.json({ ok: true });
+    });
+    app.post("/api/trigger-subscriptions/:id/abandon", async (context) => {
+        if (!triggerMaintenance)
+            throw new HttpRequestError("trigger_not_supported", "Trigger subscriptions are unavailable.", 501);
+        await triggerMaintenance.abandon(context.req.param("id"), context.req.raw.signal);
+        return context.json({ ok: true });
+    });
+    return app;
+}

package/src/server/connect-app.d.ts

@@ -22,6 +22,7 @@ export interface ConnectAppOptions {
     secretCodec: ISecretCodec;
     adminToken?: string;
     runtimeToken?: string;
+    requireRuntimeAuth?: boolean;
     allowedCustomOAuth?: string[];
     verifyRuntimeJwt?: RuntimeJwtVerifier;
     actionPolicy?: ActionPolicyService;

package/src/server/connect-app.js

@@ -117,6 +117,7 @@ export async function createConnectApp(options) {
             auth: {
                 adminToken: options.adminToken,
                 runtimeToken: options.runtimeToken,
+                requireRuntimeAuth: options.requireRuntimeAuth,
                 hasRuntimeTokens: hasStoredRuntimeTokens,
                 resolveRuntimeToken: (token) => runtimeTokens.resolveToken(token),
                 verifyRuntimeJwt: options.verifyRuntimeJwt,
@@ -131,7 +132,8 @@ export async function createConnectApp(options) {
             serveDocumentation: options.serveDocumentation,
             oauthCloseDelaySeconds: options.oauthCloseDelaySeconds,
         }).createApp(),
-        runtimeAuthConfigured: Boolean(options.runtimeToken) ||
+        runtimeAuthConfigured: Boolean(options.requireRuntimeAuth) ||
+            Boolean(options.runtimeToken) ||
             Boolean(options.verifyRuntimeJwt) ||
             (options.computeRuntimeAuthConfigured === false ? false : await hasStoredRuntimeTokens()),
     };

package/src/server/connect-server.d.ts

@@ -4,6 +4,8 @@ import type { ActionSearchIndexProvider } from "../core/action-search.ts";
 import type { ProviderHttpDispatchOptions } from "../core/provider-http-dispatch.ts";
 import type { RuntimeLogger, TransitFileUpload } from "../core/types.ts";
 import type { MarketplaceService } from "../marketplace/marketplace-service.ts";
+import type { OAuthClientConfigService } from "../oauth/oauth-client-config-service.ts";
+import type { OAuthFlowService } from "../oauth/oauth-flow-service.ts";
 import type { IProviderLoader } from "../providers/provider-loader.ts";
 import type { SaasExecutionService } from "../saas/saas-execution-service.ts";
 import type { SaasOAuthService } from "../saas/saas-oauth-service.ts";
@@ -17,8 +19,6 @@ import type { IRuntimePolicyStore } from "./storage/runtime-policy-store.ts";
 import type { RuntimeTokenService } from "./storage/runtime-token-service.ts";
 import { Hono } from "hono";
 import { ActionPolicyService } from "../core/action-policy.ts";
-import { OAuthClientConfigService } from "../oauth/oauth-client-config-service.ts";
-import { OAuthFlowService } from "../oauth/oauth-flow-service.ts";
 import { ActionRunner } from "./actions/action-runner.ts";
 /**
  * Import and evaluate the modules the /mcp and /docs routes defer to their first request. The Node server never
@@ -69,58 +69,7 @@ export declare class ConnectServer {
     private readonly actionSearch;
     private readonly actionPolicy;
     private readonly proxyRunner;
-    private readonly policySnapshots;
+    private readonly getPolicySnapshot;
     constructor(options: IConnectServerOptions);
     createApp(): Hono;
-    private listProviderSummaries;
-    private configureMarketplace;
-    private getMarketplaceDiscovery;
-    private writeMarketplaceError;
-    private deleteMarketplace;
-    private updateProviderPreference;
-    private getRuntimeProviderSetup;
-    private getProvider;
-    private createTransitFile;
-    private getTransitFile;
-    private deleteTransitFile;
-    private handleTransitFileError;
-    private getAction;
-    private listRuns;
-    private getRun;
-    private searchApiActions;
-    private getActionMarkdown;
-    private listRuntimeProviders;
-    private listRuntimeActions;
-    private searchRuntimeActions;
-    private serializeSearchResults;
-    private getRuntimeAction;
-    private getRuntimeTriggerPermissions;
-    private executeRuntimeTrigger;
-    private createRuntimeActionRun;
-    private executeRuntimeAction;
-    private createRuntimeProxyRequest;
-    private listRuntimeApps;
-    private listRuntimeAppsByService;
-    private listAuthenticatedRuntimeApps;
-    private filterAllowedConnections;
-    private handleMcp;
-    private rejectMcpMethod;
-    private listConnections;
-    private upsertConnection;
-    private disconnect;
-    private createOAuthAuthorization;
-    private listRuntimeTokens;
-    private createRuntimeToken;
-    private updateRuntimeToken;
-    private revokeRuntimeToken;
-    private getRuntimePolicy;
-    private updateRuntimePolicy;
-    private listOAuthConfigs;
-    private upsertOAuthConfig;
-    private deleteOAuthConfig;
-    private completeOAuth;
-    private writeConnectionResult;
-    private writeOAuthResult;
-    private getPolicySnapshot;
-    private loadPolicySnapshot;
 }