@tapicker/bridge 1.0.0

package/dist/protocol/schema.d.ts

@@ -0,0 +1,149 @@
+import { z } from 'zod';
+export declare const MessageEnvelopeSchema: z.ZodObject<{
+    id: z.ZodString;
+    time: z.ZodNumber;
+    type: z.ZodString;
+    data: z.ZodOptional<z.ZodUnknown>;
+    cb: z.ZodOptional<z.ZodLiteral<false>>;
+}, z.core.$strict>;
+export type MessageEnvelope = z.infer<typeof MessageEnvelopeSchema>;
+export declare const SafeResultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    data: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
+export type SafeResult = z.infer<typeof SafeResultSchema>;
+export declare const ExtensionHelloInputSchema: z.ZodObject<{
+    clientId: z.ZodUUID;
+    clientName: z.ZodString;
+    credential: z.ZodOptional<z.ZodString>;
+    extensionVersion: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type ExtensionHelloInput = z.infer<typeof ExtensionHelloInputSchema>;
+export declare const ExtensionPairInputSchema: z.ZodObject<{
+    clientId: z.ZodUUID;
+    clientName: z.ZodString;
+    pairingCode: z.ZodString;
+}, z.core.$strict>;
+export type ExtensionPairInput = z.infer<typeof ExtensionPairInputSchema>;
+export declare const BridgeHelloDataSchema: z.ZodObject<{
+    accepted: z.ZodBoolean;
+    requiresPairing: z.ZodBoolean;
+    bridgeVersion: z.ZodString;
+    protocolVersion: z.ZodLiteral<1>;
+    capabilities: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const BridgePairDataSchema: z.ZodObject<{
+    accepted: z.ZodLiteral<true>;
+    clientId: z.ZodUUID;
+    credential: z.ZodString;
+}, z.core.$strict>;
+export declare const TabTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"active">;
+}, z.core.$strict>, z.ZodObject<{
+    mode: z.ZodLiteral<"new">;
+}, z.core.$strict>, z.ZodObject<{
+    mode: z.ZodLiteral<"id">;
+    tabId: z.ZodNumber;
+}, z.core.$strict>], "mode">;
+export declare const WorkflowStartInputSchema: z.ZodObject<{
+    workflowId: z.ZodString;
+    args: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tab: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"active">;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"new">;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"id">;
+        tabId: z.ZodNumber;
+    }, z.core.$strict>], "mode">>;
+}, z.core.$strict>;
+export type WorkflowStartInput = z.infer<typeof WorkflowStartInputSchema>;
+export declare const WorkflowControlInputSchema: z.ZodObject<{
+    workflowId: z.ZodString;
+}, z.core.$strict>;
+export type WorkflowControlInput = z.infer<typeof WorkflowControlInputSchema>;
+export declare const DataInputSchema: z.ZodObject<{
+    tableId: z.ZodString;
+}, z.core.$strict>;
+export type DataInput = z.infer<typeof DataInputSchema>;
+export declare const WorkflowLifecycleStateSchema: z.ZodEnum<{
+    running: "running";
+    paused: "paused";
+    stopping: "stopping";
+    completed: "completed";
+    stopped: "stopped";
+    failed: "failed";
+}>;
+export declare const WorkflowStatusDataSchema: z.ZodObject<{
+    workflowId: z.ZodString;
+    state: z.ZodEnum<{
+        running: "running";
+        paused: "paused";
+        stopping: "stopping";
+        completed: "completed";
+        stopped: "stopped";
+        failed: "failed";
+    }>;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type WorkflowStatusData = z.infer<typeof WorkflowStatusDataSchema>;
+export declare const WorkflowStatusEventSchema: z.ZodObject<{
+    workflowId: z.ZodString;
+    state: z.ZodEnum<{
+        running: "running";
+        paused: "paused";
+        stopping: "stopping";
+        completed: "completed";
+        stopped: "stopped";
+        failed: "failed";
+    }>;
+    updatedAt: z.ZodISODateTime;
+    clientId: z.ZodUUID;
+}, z.core.$strict>;
+export type WorkflowStatusEvent = z.infer<typeof WorkflowStatusEventSchema>;
+export declare const WorkflowWatchRequestSchema: z.ZodObject<{
+    clientId: z.ZodOptional<z.ZodUUID>;
+    input: z.ZodObject<{
+        workflowId: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type WorkflowWatchRequest = z.infer<typeof WorkflowWatchRequestSchema>;
+export declare const WorkflowStartResultSchema: z.ZodObject<{
+    clientId: z.ZodUUID;
+    workflowId: z.ZodString;
+    workflowName: z.ZodString;
+    state: z.ZodOptional<z.ZodEnum<{
+        accepted: "accepted";
+        running: "running";
+        starting: "starting";
+    }>>;
+}, z.core.$strict>;
+export type WorkflowStartResult = z.infer<typeof WorkflowStartResultSchema>;
+export declare function createEnvelope<TData>(type: string, data: TData, options?: {
+    id?: string;
+    callback?: boolean;
+}): MessageEnvelope;
+export declare function parseEnvelope(data: unknown): {
+    success: false;
+    error: Error;
+    data?: undefined;
+} | {
+    success: true;
+    data: {
+        id: string;
+        time: number;
+        type: string;
+        data?: unknown;
+        cb?: false | undefined;
+    };
+    error?: undefined;
+};
+//# sourceMappingURL=schema.d.ts.map

package/dist/protocol/schema.js

@@ -0,0 +1,155 @@
+import { z } from 'zod';
+import { randomUUID } from 'node:crypto';
+import { PROTOCOL_VERSION } from '../constants.js';
+export const MessageEnvelopeSchema = z
+    .object({
+    id: z.string().min(1),
+    time: z.number().int().nonnegative(),
+    type: z.string().min(1),
+    data: z.unknown().optional(),
+    cb: z.literal(false).optional(),
+})
+    .strict();
+export const SafeResultSchema = z.union([
+    z
+        .object({
+        ok: z.literal(true),
+        data: z.unknown().optional(),
+    })
+        .strict(),
+    z
+        .object({
+        ok: z.literal(false),
+        error: z
+            .object({
+            code: z.string().min(1),
+            message: z.string(),
+            details: z.unknown().optional(),
+        })
+            .strict(),
+    })
+        .strict(),
+]);
+export const ExtensionHelloInputSchema = z
+    .object({
+    clientId: z.uuid(),
+    clientName: z.string().trim().min(1).max(80),
+    credential: z.string().min(1).optional(),
+    extensionVersion: z.string().min(1).optional(),
+    capabilities: z.array(z.string().min(1)).default([]),
+})
+    .strict();
+export const ExtensionPairInputSchema = z
+    .object({
+    clientId: z.uuid(),
+    clientName: z.string().trim().min(1).max(80),
+    pairingCode: z.string().regex(/^\d{4}$/),
+})
+    .strict();
+export const BridgeHelloDataSchema = z
+    .object({
+    accepted: z.boolean(),
+    requiresPairing: z.boolean(),
+    bridgeVersion: z.string().min(1),
+    protocolVersion: z.literal(PROTOCOL_VERSION),
+    capabilities: z.array(z.string().min(1)),
+})
+    .strict();
+export const BridgePairDataSchema = z
+    .object({
+    accepted: z.literal(true),
+    clientId: z.uuid(),
+    credential: z.string().min(1),
+})
+    .strict();
+export const TabTargetSchema = z.discriminatedUnion('mode', [
+    z.object({ mode: z.literal('active') }).strict(),
+    z.object({ mode: z.literal('new') }).strict(),
+    z.object({ mode: z.literal('id'), tabId: z.number().int().positive() }).strict(),
+]);
+export const WorkflowStartInputSchema = z
+    .object({
+    workflowId: z.string().min(1),
+    args: z.record(z.string(), z.unknown()).default({}),
+    tab: TabTargetSchema.default({ mode: 'active' }),
+})
+    .strict();
+export const WorkflowControlInputSchema = z
+    .object({
+    workflowId: z.string().min(1),
+})
+    .strict();
+export const DataInputSchema = z
+    .object({
+    tableId: z.string().trim().min(1).max(128),
+})
+    .strict();
+export const WorkflowLifecycleStateSchema = z.enum(['running', 'paused', 'stopping', 'completed', 'stopped', 'failed']);
+export const WorkflowStatusDataSchema = z
+    .object({
+    workflowId: z.string().min(1),
+    state: WorkflowLifecycleStateSchema,
+    updatedAt: z.iso.datetime(),
+})
+    .strict();
+export const WorkflowStatusEventSchema = z
+    .object({
+    clientId: z.uuid(),
+    ...WorkflowStatusDataSchema.shape,
+})
+    .strict();
+export const WorkflowWatchRequestSchema = z
+    .object({
+    clientId: z.uuid().optional(),
+    input: WorkflowControlInputSchema,
+})
+    .strict();
+export const WorkflowStartResultSchema = z
+    .object({
+    clientId: z.uuid(),
+    workflowId: z.string().min(1),
+    workflowName: z.string().min(1),
+    state: z.enum(['accepted', 'starting', 'running']).optional(),
+})
+    .strict();
+export function createEnvelope(type, data, options = {}) {
+    const envelope = {
+        id: options.id ?? randomUUID(),
+        time: Date.now(),
+        type,
+        data,
+    };
+    if (options.callback === false) {
+        envelope.cb = false;
+    }
+    return envelope;
+}
+export function parseEnvelope(data) {
+    let value = data;
+    if (Buffer.isBuffer(value)) {
+        value = value.toString('utf8');
+    }
+    if (typeof value === 'string') {
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            return {
+                success: false,
+                error: new Error('WebSocket message is not valid JSON'),
+            };
+        }
+    }
+    const result = MessageEnvelopeSchema.safeParse(value);
+    if (!result.success) {
+        return {
+            success: false,
+            error: result.error,
+        };
+    }
+    return {
+        success: true,
+        data: result.data,
+    };
+}
+//# sourceMappingURL=schema.js.map

package/dist/server.d.ts

@@ -0,0 +1,63 @@
+import { BridgeService } from './bridge/bridge-service.js';
+export type BridgeTlsOptions = {
+    key: string;
+    cert: string;
+};
+export type BridgeServerOptions = {
+    host?: string;
+    port?: number;
+    portMax?: number;
+    token?: string;
+    corsOrigins?: string[];
+    tls?: BridgeTlsOptions;
+    pairingCode?: string;
+    dataDir?: string;
+};
+export declare class BridgeServer {
+    readonly bridgeId: `${string}-${string}-${string}-${string}-${string}`;
+    readonly bridge: BridgeService;
+    private readonly host;
+    private readonly requestedPort?;
+    private readonly portMax;
+    private readonly token?;
+    private readonly corsOrigins;
+    private readonly tls?;
+    private readonly mcpHandler;
+    private readonly mcpNodeHandler;
+    private readonly validateLocalMcpHost;
+    private server;
+    private webSocketServer;
+    private port;
+    private readonly workflowSubscriptions;
+    constructor(options?: BridgeServerOptions);
+    getPairingCode(): string | undefined;
+    refreshPairingCode(): string;
+    start(): Promise<{
+        host: string;
+        port: number;
+        httpUrl: string;
+        wsUrl: string;
+        workflowWatchWsUrl: string;
+        mcpUrl: string;
+    }>;
+    close(): Promise<void>;
+    getAddress(): {
+        host: string;
+        port: number;
+        httpUrl: string;
+        wsUrl: string;
+        workflowWatchWsUrl: string;
+        mcpUrl: string;
+    };
+    private getPorts;
+    private createRuntime;
+    private handleRequest;
+    private assertAuthorized;
+    private attachWorkflowWatcher;
+    private sendWorkflowWatchResult;
+    private publishWorkflowStatus;
+    private getOrigin;
+    private applyCors;
+    private sendJson;
+}
+//# sourceMappingURL=server.d.ts.map