@tapicker/bridge 1.0.0 → 1.1.0

package/dist/protocol/schema.js

@@ -30,12 +30,20 @@ export const SafeResultSchema = z.union([
     })
         .strict(),
 ]);
+const UserSummarySchema = z
+    .object({
+    id: z.string().min(1),
+    username: z.string().min(1),
+    plan: z.enum(['Free', 'Plus', 'Pro']),
+})
+    .strip();
 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(),
+    clientVersion: z.string().min(1).optional(),
+    user: UserSummarySchema.optional(),
     capabilities: z.array(z.string().min(1)).default([]),
 })
     .strict();
@@ -62,43 +70,415 @@ export const BridgePairDataSchema = z
     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(),
-]);
+const WorkflowPathIdSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .refine((id) => id !== '.' && id !== '..' && !/[/\\%?#\r\n\t]/.test(id), 'workflowId must be a single URL path segment')
+    .describe('Workflow ID returned by workflow_list.');
 export const WorkflowStartInputSchema = z
     .object({
-    workflowId: z.string().min(1),
-    args: z.record(z.string(), z.unknown()).default({}),
-    tab: TabTargetSchema.default({ mode: 'active' }),
+    workflowId: WorkflowPathIdSchema,
+    args: z
+        .object({
+        isClearData: z
+            .boolean()
+            .optional()
+            .describe('Set true to clear existing data in tables used by this Workflow and its enabled child Workflows.'),
+    })
+        .catchall(z.unknown())
+        .default({}),
 })
     .strict();
 export const WorkflowControlInputSchema = z
     .object({
+    workflowId: z.string().trim().min(1),
+})
+    .strict();
+export const WorkflowGuideInputSchema = z.object({ topic: z.string().trim().min(1).default('overview') }).strict();
+export const WorkflowSchemaInputSchema = z
+    .object({
+    nodeTypes: z
+        .array(z.string().min(1))
+        .min(1)
+        .optional()
+        .describe('Node types to use, such as NodeLoop and NodeExtractData. Omit for all supported business nodes.'),
+})
+    .strict();
+export const WorkflowValidateInputSchema = z
+    .object({
+    fragment: z
+        .unknown()
+        .nonoptional()
+        .describe('Parsed version 1 tapicker/nodes or tapicker/workflow document. Use workflow.schema for its shape.'),
+})
+    .strict();
+const CommandResultMetadata = { clientId: z.uuid() };
+export const WorkflowListInputSchema = z
+    .object({
+    scope: z.enum(['own', 'shared', 'pinned']).default('own'),
+    name: z.string().optional().describe('Substring filter on Workflow fullname.'),
+    host: z
+        .string()
+        .trim()
+        .min(1)
+        .max(128)
+        .optional()
+        .describe('Exact Workflow host filter, such as example.com or localhost:3000, without a scheme or path. Does not include * Workflows unless host is *.'),
+    page: z.number().int().min(1).max(Number.MAX_SAFE_INTEGER).default(1),
+    pageSize: z.number().int().min(1).max(100).default(20),
+})
+    .strict();
+export const WorkflowGetInputSchema = z.object({ workflowId: WorkflowPathIdSchema }).strict();
+export const WorkflowCreateInputSchema = z
+    .object({
+    name: z.string().trim().min(1).max(64),
+    intro: z.string().default(''),
+    href: z.string().default(''),
+    nodes: z.array(z.unknown()).min(1).describe('Workflow node tree to validate and save.'),
+})
+    .strict();
+export const WorkflowUpdateInputSchema = z
+    .object({
+    workflowId: WorkflowGetInputSchema.shape.workflowId,
+    revision: z
+        .number()
+        .int()
+        .positive()
+        .max(Number.MAX_SAFE_INTEGER)
+        .describe('Revision last read from workflow.get; reconcile conflicts before retrying.'),
+    name: z.string().trim().min(1).max(64).optional(),
+    intro: z.string().optional(),
+    href: z.string().optional(),
+    nodes: z.array(z.unknown()).min(1).optional().describe('Complete replacement node tree.'),
+})
+    .strict()
+    .refine((input) => ['name', 'intro', 'href', 'nodes'].some((key) => input[key] !== undefined), {
+    message: 'Provide at least one of name, intro, href or nodes',
+});
+const WorkflowSummarySchema = z
+    .object({
+    id: z.string().min(1),
+    fullname: z.string(),
+    intro: z.string(),
+    host: z.string(),
+    href: z.string(),
+    visibility: z.enum(['private', 'shared', 'public']),
+    permission: z.enum(['use', 'view', 'edit', 'manage']),
+    version: z.string().nullable(),
+    revision: z.number().int().positive().optional(),
+    deletedAt: z.string().nullable(),
+})
+    .strip();
+export const WorkflowListResultSchema = z
+    .object({
+    ...CommandResultMetadata,
+    scope: z.enum(['own', 'shared', 'pinned']),
+    page: z.number().int().positive(),
+    pageSize: z.number().int().min(1).max(100),
+    workflows: z.array(WorkflowSummarySchema).max(100),
+})
+    .strip();
+const WorkflowArgumentSchema = z
+    .object({
+    name: z.string().min(1).describe('Exact key to use in workflow.start args.'),
+    type: z.string().min(1),
+    label: z.string().optional(),
+    placeholder: z.string().optional(),
+    options: z.string().optional(),
+    required: z.boolean().optional(),
+    defaultValue: z.union([z.string(), z.number(), z.boolean()]).optional(),
+})
+    .strip();
+export const WorkflowGetResultSchema = z
+    .object({
+    ...CommandResultMetadata,
+    workflow: WorkflowSummarySchema.extend({
+        name: z.string(),
+        args: z.array(WorkflowArgumentSchema).describe('Available startup arguments for the saved Workflow.'),
+        nodes: z.array(z.record(z.string(), z.unknown())).describe('Saved nodes. Empty with use-only permission.'),
+        icon: z.string().nullable(),
+    }),
+})
+    .strip();
+export const WorkflowCreateResultSchema = z
+    .object({
+    ...CommandResultMetadata,
+    workflowId: z.string().min(1),
+    workflowName: z.string().min(1),
+    revision: z.number().int().positive().optional(),
+})
+    .strip();
+export const WorkflowUpdateResultSchema = z
+    .object({
+    ...CommandResultMetadata,
     workflowId: z.string().min(1),
+    revision: z.number().int().positive(),
+})
+    .strip();
+export const WorkflowGuideResultSchema = z
+    .object({
+    ...CommandResultMetadata,
+    topic: z.string().min(1),
+    content: z.string(),
+    references: z.array(z.object({ href: z.string().min(1), topic: z.string().min(1), anchor: z.string().optional() }).strip()),
+})
+    .strip();
+export const WorkflowSchemaResultSchema = z
+    .object({
+    ...CommandResultMetadata,
+    schema: z
+        .record(z.string(), z.unknown())
+        .describe('Draft 2020-12 JSON Schema for version 1 Workflow documents, including referenced definitions. Defaults are not inserted.'),
+})
+    .strip();
+export const WorkflowValidateResultSchema = z.discriminatedUnion('isValid', [
+    z
+        .object({
+        ...CommandResultMetadata,
+        isValid: z.literal(true).describe('Whether the document passed static configuration validation.'),
+        nodes: z
+            .array(z.looseObject({ id: z.string().min(1), type: z.string().min(1), config: z.record(z.string(), z.unknown()) }))
+            .min(1)
+            .optional()
+            .describe('Normalized node copies, returned when the input supplies nodes.'),
+    })
+        .strip(),
+    z
+        .object({
+        ...CommandResultMetadata,
+        isValid: z.literal(false).describe('Whether the document passed static configuration validation.'),
+        issues: z
+            .array(z
+            .object({
+            nodeId: z.string().optional(),
+            path: z.string(),
+            code: z.string().min(1),
+            message: z.string(),
+        })
+            .strip())
+            .min(1)
+            .describe('Configuration issues to fix using code, path, and optional nodeId before validating again.'),
+    })
+        .strip(),
+]);
+export const WorkflowLogLevelSchema = z.enum(['trace', 'debug', 'info', 'warn', 'error']);
+const LogIdSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+export const WorkflowLogsInputSchema = z
+    .object({
+    workflowId: z.string().trim().min(1),
+    levels: z.array(WorkflowLogLevelSchema).min(1).optional(),
+    limit: z.number().int().min(1).max(500).default(100),
+    before: LogIdSchema.optional(),
+    after: LogIdSchema.optional(),
+    runAt: z.iso.datetime().optional(),
+})
+    .strict()
+    .refine((input) => input.before === undefined || input.after === undefined, {
+    message: 'before and after are mutually exclusive',
+});
+export const WorkflowLogInputSchema = z
+    .object({
+    workflowId: z.string().trim().min(1),
+    logId: LogIdSchema,
+    runAt: z.iso.datetime().optional(),
 })
     .strict();
+export const WorkflowLogDataSchema = z
+    .object({
+    id: LogIdSchema,
+    workflowId: z.string().min(1),
+    timestamp: z.iso.datetime(),
+    level: WorkflowLogLevelSchema,
+    nodeId: z.string().optional(),
+    nodeType: z.string().optional(),
+    message: z.string(),
+    detailsText: z.string().optional(),
+    detailsTruncated: z.boolean(),
+})
+    .strip();
+export const WorkflowLogsResultSchema = z
+    .object({
+    ...CommandResultMetadata,
+    workflowId: z.string().min(1),
+    runAt: z.iso.datetime().nullable(),
+    logs: z.array(WorkflowLogDataSchema).max(500),
+    hasMore: z.boolean(),
+})
+    .strip();
+export const WorkflowLogResultSchema = z
+    .object({
+    ...CommandResultMetadata,
+    workflowId: z.string().min(1),
+    runAt: z.iso.datetime().nullable(),
+    log: WorkflowLogDataSchema.extend({ detailsTruncated: z.literal(false) }),
+})
+    .strip();
+export const DataListInputSchema = z
+    .object({
+    tableName: z.string().trim().min(1).optional().describe('Case-insensitive substring of the saved table name.'),
+    workflowId: z.string().trim().min(1).optional().describe('Exact ID of the Workflow that owns the table.'),
+    page: z.number().int().positive().default(1),
+    pageSize: z.number().int().min(1).max(100).default(20),
+})
+    .strict()
+    .refine(({ page, pageSize }) => Number.isSafeInteger((page - 1) * pageSize), {
+    message: 'Page offset is too large',
+});
+export const DataListResultSchema = z
+    .object({
+    ...CommandResultMetadata,
+    page: z.number().int().positive(),
+    pageSize: z.number().int().min(1).max(100),
+    hasMore: z.boolean(),
+    tables: z
+        .array(z
+        .object({
+        tableId: z.string().min(1),
+        tableName: z.string(),
+        columnNames: z.array(z.string()).describe('Column names in saved table order.'),
+        rowCount: z.number().int().nonnegative(),
+        workflowId: z.string().min(1).optional(),
+        createdAt: z.iso.datetime(),
+        updatedAt: z.iso.datetime(),
+    })
+        .strip())
+        .max(100),
+})
+    .strip();
 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']);
+const DataPreviewSampleSchema = z.enum(['oldest', 'latest']);
+export const DataPreviewInputSchema = DataInputSchema.extend({
+    sample: DataPreviewSampleSchema.default('oldest').describe('Select the oldest or latest inserted rows.'),
+});
+export const DEFAULT_DATA_PAGE_SIZE = 50;
+export const DataGetInputSchema = DataInputSchema.extend({
+    all: z.boolean().optional().describe('Return the entire table. Omit page and pageSize when true.'),
+    page: z.number().int().positive().optional().describe('Page number, starting at 1. Defaults to 1.'),
+    pageSize: z.number().int().min(1).max(500).optional().describe('Rows per page. Defaults to 50.'),
+}).refine(({ all, page, pageSize }) => all
+    ? page === undefined && pageSize === undefined
+    : Number.isSafeInteger(((page ?? 1) - 1) * (pageSize ?? DEFAULT_DATA_PAGE_SIZE)), { message: 'Use all without pagination, or provide a valid page and pageSize' });
+export const DataDeleteResultSchema = z
+    .object({ ...CommandResultMetadata, tableId: z.string().min(1), tableName: z.string() })
+    .strip();
+const DataRowsResultSchema = DataDeleteResultSchema.extend({
+    columnNames: z.array(z.string()).describe('Registered column names in table order.'),
+    rowCount: z.number().int().nonnegative().describe('Total row count recorded in table metadata.'),
+    rows: z.array(z.record(z.string(), z.unknown())),
+});
+export const DataPreviewResultSchema = DataRowsResultSchema.extend({
+    rows: DataRowsResultSchema.shape.rows.max(10),
+    sample: DataPreviewSampleSchema,
+    isTruncated: z.boolean().describe('True if the response size limit omitted one or more sample rows.'),
+});
+export const DataGetResultSchema = z.union([
+    // 全量结果忽略新增字段，但出现分页字段时必须按分页结果校验。
+    z
+        .looseObject({ page: z.never().optional(), pageSize: z.never().optional(), hasMore: z.never().optional() })
+        .pipe(DataRowsResultSchema),
+    DataRowsResultSchema.extend({
+        page: z.number().int().positive(),
+        pageSize: z.number().int().min(1).max(500),
+        hasMore: z.boolean(),
+    }),
+]);
+const DataExportFormatSchema = z.enum(['xlsx', 'xls', 'csv', 'json', 'xml', 'txt']);
+export const DataExportInputSchema = DataInputSchema.extend({
+    format: DataExportFormatSchema.default('csv'),
+});
+export const DataExportReceiptSchema = DataDeleteResultSchema.extend({
+    format: DataExportFormatSchema,
+    filename: z.string().min(1),
+    rowCount: z.number().int().nonnegative(),
+    byteSize: z.number().int().nonnegative(),
+});
+export const DataExportResultSchema = DataExportReceiptSchema.strict().extend({
+    fileSize: z.string().min(1),
+    downloadPath: z.string().regex(/^\/v1\/exports\/[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/),
+    expiresAt: z.iso.datetime(),
+});
+export const UserMeInputSchema = z.object({}).strict();
+export const UserMeResultSchema = z
+    .object({
+    ...CommandResultMetadata,
+    user: UserSummarySchema.describe('The current Tapicker account.'),
+})
+    .strip();
+export const ExtensionListResultSchema = z
+    .object({
+    extensions: z.array(z
+        .object({
+        ready: z.boolean(),
+        pairingRequired: z.boolean().optional(),
+        clientId: z.uuid().optional(),
+        clientName: z.string().optional(),
+        clientVersion: z.string().optional(),
+        user: UserSummarySchema.optional().describe('The Tapicker account snapshot for a ready Extension.'),
+        capabilities: z.array(z.string()),
+    })
+        .strict()),
+})
+    .strict();
+export const WorkflowControlResultSchema = WorkflowControlInputSchema.extend(CommandResultMetadata).strip();
+export const WorkflowProcessStatusSchema = z.enum(['running', 'paused', 'stopping', 'stopped']);
+export const WorkflowProcessReasonSchema = z.enum([
+    'failed',
+    'completed',
+    'interrupted',
+    'workflow_stopped',
+    'user_stopped',
+]);
 export const WorkflowStatusDataSchema = z
     .object({
     workflowId: z.string().min(1),
-    state: WorkflowLifecycleStateSchema,
+    status: WorkflowProcessStatusSchema,
+    reason: WorkflowProcessReasonSchema.optional(),
+    runAt: z.iso.datetime().optional(),
+    stopAt: z.iso.datetime().optional(),
     updatedAt: z.iso.datetime(),
 })
-    .strict();
+    .strip();
 export const WorkflowStatusEventSchema = z
     .object({
     clientId: z.uuid(),
     ...WorkflowStatusDataSchema.shape,
 })
     .strict();
-export const WorkflowWatchRequestSchema = z
+export const WorkflowStatusInputSchema = WorkflowControlInputSchema.extend({
+    runAt: z.iso.datetime().optional().describe('Require the runAt from a previous status snapshot to match.'),
+    includeDataSummary: z.boolean().optional().describe('Include the saved data changes when the run has stopped.'),
+});
+export const WorkflowStatusResultSchema = z
+    .object({
+    clientId: WorkflowStatusEventSchema.shape.clientId,
+    workflowId: WorkflowStatusDataSchema.shape.workflowId,
+    workflowName: z.string().min(1).optional(),
+    status: WorkflowStatusDataSchema.shape.status,
+    reason: WorkflowStatusDataSchema.shape.reason,
+    runAt: WorkflowStatusDataSchema.shape.runAt,
+    stopAt: WorkflowStatusDataSchema.shape.stopAt,
+    createdAt: z.iso.datetime(),
+    updatedAt: WorkflowStatusDataSchema.shape.updatedAt,
+    dataSummary: z
+        .array(z
+        .object({
+        tableId: z.string().min(1),
+        tableName: z.string(),
+        insertedCount: z.number().int().nonnegative(),
+        updatedCount: z.number().int().nonnegative(),
+        deletedCount: z.number().int().nonnegative(),
+    })
+        .strip())
+        .optional(),
+})
+    .strip();
+export const WorkflowStatusWatchResultSchema = WorkflowStatusEventSchema.extend({ isTimedOut: z.boolean() });
+export const WorkflowStatusWatchRequestSchema = z
     .object({
     clientId: z.uuid().optional(),
     input: WorkflowControlInputSchema,
@@ -109,9 +489,10 @@ export const WorkflowStartResultSchema = z
     clientId: z.uuid(),
     workflowId: z.string().min(1),
     workflowName: z.string().min(1),
-    state: z.enum(['accepted', 'starting', 'running']).optional(),
+    runAt: z.iso.datetime(),
+    state: z.literal('accepted'),
 })
-    .strict();
+    .strip();
 export function createEnvelope(type, data, options = {}) {
     const envelope = {
         id: options.id ?? randomUUID(),

package/dist/server.d.ts

@@ -20,6 +20,8 @@ export declare class BridgeServer {
     private readonly requestedPort?;
     private readonly portMax;
     private readonly token?;
+    private readonly exports;
+    private exportCleanupTimer?;
     private readonly corsOrigins;
     private readonly tls?;
     private readonly mcpHandler;
@@ -37,7 +39,7 @@ export declare class BridgeServer {
         port: number;
         httpUrl: string;
         wsUrl: string;
-        workflowWatchWsUrl: string;
+        workflowStatusWatchWsUrl: string;
         mcpUrl: string;
     }>;
     close(): Promise<void>;
@@ -46,15 +48,16 @@ export declare class BridgeServer {
         port: number;
         httpUrl: string;
         wsUrl: string;
-        workflowWatchWsUrl: string;
+        workflowStatusWatchWsUrl: string;
         mcpUrl: string;
     };
     private getPorts;
     private createRuntime;
+    private cleanExports;
     private handleRequest;
     private assertAuthorized;
-    private attachWorkflowWatcher;
-    private sendWorkflowWatchResult;
+    private attachWorkflowStatusWatcher;
+    private sendWorkflowStatusWatchResult;
     private publishWorkflowStatus;
     private getOrigin;
     private applyCors;