vibeman 0.0.0 → 0.0.1

package/dist/runtime/api/api/routers/worktrees.js

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import { publicProcedure } from '../trpc.js';
+import { TaskIdSchema, WorktreePathSchema, withErrors } from '../router-helpers.js';
+import { log } from '../../lib/logger.js';
+export function buildWorktreeRoutes({ requireOrchestrator, requireOrchestratorSync }) {
+    return {
+        listWorktrees: publicProcedure.query(withErrors('list worktrees', 'router:listWorktrees', async () => {
+            const orchestrator = await requireOrchestrator();
+            return await orchestrator.listWorktrees();
+        })),
+        syncWorktreeState: publicProcedure.mutation(withErrors('sync worktree state', 'router:syncWorktreeState', async () => {
+            const orchestrator = await requireOrchestrator();
+            await orchestrator.syncWorktreeState();
+            return { success: true, message: 'Worktree state synchronized' };
+        })),
+        getWorktreeInfo: publicProcedure.input(TaskIdSchema).query(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            const worktree = orchestrator.getWorktreeInfo(input.taskId);
+            if (!worktree)
+                return null;
+            const { git, ...serializableWorktree } = worktree;
+            return serializableWorktree;
+        }),
+        createWorktree: publicProcedure.input(TaskIdSchema).mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            const worktree = await orchestrator.createWorktree(input.taskId);
+            const { git, ...serializableWorktree } = worktree;
+            return serializableWorktree;
+        }),
+        deleteWorktree: publicProcedure
+            .input(z.object({ taskId: z.string(), force: z.coerce.boolean().optional() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            await orchestrator.deleteWorktree(input.taskId, input.force || false);
+            if (orchestrator) {
+                await orchestrator.removeWorkflowsByTask(input.taskId);
+            }
+            return { success: true };
+        }),
+        openInEditor: publicProcedure.input(WorktreePathSchema).mutation(withErrors('open in editor', 'router:openInEditor', async ({ input }) => {
+            const orchestrator = requireOrchestratorSync();
+            await orchestrator.openInEditor(input.worktreePath);
+            // Ensure we return a clean, serializable object
+            return { success: true };
+        })),
+        openInTerminal: publicProcedure.input(WorktreePathSchema).mutation(withErrors('open in terminal', 'router:openInTerminal', async ({ input }) => {
+            const orchestrator = requireOrchestratorSync();
+            await orchestrator.openInTerminal(input.worktreePath);
+            // Ensure we return a clean, serializable object
+            return { success: true };
+        })),
+        // TODO: Deprecated alias; prefer createPullRequest
+        createWorktreePR: publicProcedure
+            .input(z.object({ taskId: z.string(), baseBranch: z.string().optional().default('main') }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            log.warn('Deprecated route used: createWorktreePR; prefer createPullRequest', { taskId: input.taskId }, 'router:createWorktreePR');
+            return await orchestrator.createPullRequest(input.taskId, input.baseBranch);
+        }),
+        createPullRequest: publicProcedure
+            .input(z.object({ taskId: z.string(), baseBranch: z.string().optional().default('main') }))
+            .mutation(withErrors('create pull request', 'router:createPullRequest', async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            return await orchestrator.createPullRequest(input.taskId, input.baseBranch);
+        })),
+        cleanupWorktree: publicProcedure
+            .input(z.object({
+            taskId: z.string().optional(),
+            worktreePath: z.string().optional(),
+            branchName: z.string().optional(),
+            isConnectedToTask: z.boolean(),
+            force: z.coerce.boolean().optional().default(false),
+        }))
+            .mutation(async ({ input }) => {
+            const orchestrator = await requireOrchestrator();
+            await orchestrator.cleanupWorktree(input);
+            return { success: true };
+        }),
+    };
+}

package/dist/runtime/api/api/trpc.d.ts

@@ -0,0 +1,118 @@
+import { z } from 'zod';
+import superjson from 'superjson';
+import type { TaskService } from '../tasks/task-service.js';
+export interface Context {
+    taskService?: TaskService;
+}
+export declare const t: import("@trpc/server").TRPCRootObject<Context, object, {
+    transformer: typeof superjson;
+}, {
+    ctx: Context;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: true;
+}>;
+export declare const router: import("@trpc/server").TRPCRouterBuilder<{
+    ctx: Context;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: true;
+}>;
+export declare const publicProcedure: import("@trpc/server").TRPCProcedureBuilder<Context, object, object, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
+export declare const TaskCreateSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    type: z.ZodEnum<["feature", "bug", "chore", "refactor", "test", "doc"]>;
+    status: z.ZodDefault<z.ZodEnum<["backlog", "in-progress", "review", "done"]>>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    due_date: z.ZodOptional<z.ZodString>;
+    assignee: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
+    comments: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
+    status: "backlog" | "in-progress" | "review" | "done";
+    priority: "low" | "medium" | "high";
+    title: string;
+    tags: string[];
+    assignee: string[];
+    comments: string[];
+    content: string;
+    id?: string | undefined;
+    due_date?: string | undefined;
+}, {
+    type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
+    title: string;
+    content: string;
+    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
+    priority?: "low" | "medium" | "high" | undefined;
+    id?: string | undefined;
+    tags?: string[] | undefined;
+    due_date?: string | undefined;
+    assignee?: string[] | undefined;
+    comments?: string[] | undefined;
+}>;
+export declare const TaskUpdateSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<["feature", "bug", "chore", "refactor", "test", "doc"]>>;
+    status: z.ZodOptional<z.ZodDefault<z.ZodEnum<["backlog", "in-progress", "review", "done"]>>>;
+    tags: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
+    due_date: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    assignee: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
+    priority: z.ZodOptional<z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>>;
+    comments: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
+    content: z.ZodOptional<z.ZodString>;
+} & {
+    id: z.ZodString;
+    deleted_at: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
+    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
+    priority?: "low" | "medium" | "high" | undefined;
+    title?: string | undefined;
+    tags?: string[] | undefined;
+    due_date?: string | undefined;
+    assignee?: string[] | undefined;
+    comments?: string[] | undefined;
+    content?: string | undefined;
+    deleted_at?: string | undefined;
+}, {
+    id: string;
+    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
+    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
+    priority?: "low" | "medium" | "high" | undefined;
+    title?: string | undefined;
+    tags?: string[] | undefined;
+    due_date?: string | undefined;
+    assignee?: string[] | undefined;
+    comments?: string[] | undefined;
+    content?: string | undefined;
+    deleted_at?: string | undefined;
+}>;
+export declare const TaskFilterSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<["backlog", "in-progress", "review", "done"]>>;
+    type: z.ZodOptional<z.ZodEnum<["feature", "bug", "chore", "refactor", "test", "doc"]>>;
+    priority: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    search: z.ZodOptional<z.ZodString>;
+    includeDeleted: z.ZodOptional<z.ZodBoolean>;
+    onlyDeleted: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
+    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
+    priority?: "low" | "medium" | "high" | undefined;
+    search?: string | undefined;
+    tags?: string[] | undefined;
+    includeDeleted?: boolean | undefined;
+    onlyDeleted?: boolean | undefined;
+}, {
+    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
+    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
+    priority?: "low" | "medium" | "high" | undefined;
+    search?: string | undefined;
+    tags?: string[] | undefined;
+    includeDeleted?: boolean | undefined;
+    onlyDeleted?: boolean | undefined;
+}>;

package/dist/runtime/api/api/trpc.js

@@ -0,0 +1,34 @@
+import { initTRPC } from '@trpc/server';
+import { z } from 'zod';
+import superjson from 'superjson';
+export const t = initTRPC.context().create({
+    transformer: superjson,
+});
+export const router = t.router;
+export const publicProcedure = t.procedure;
+// Input validation schemas
+export const TaskCreateSchema = z.object({
+    id: z.string().optional(), // Made optional - will be auto-generated if not provided
+    title: z.string(),
+    type: z.enum(['feature', 'bug', 'chore', 'refactor', 'test', 'doc']),
+    status: z.enum(['backlog', 'in-progress', 'review', 'done']).default('backlog'),
+    tags: z.array(z.string()).default([]),
+    due_date: z.string().optional(),
+    assignee: z.array(z.string()).default([]),
+    priority: z.enum(['low', 'medium', 'high']).default('medium'),
+    comments: z.array(z.string()).default([]),
+    content: z.string(),
+});
+export const TaskUpdateSchema = TaskCreateSchema.partial().extend({
+    id: z.string(),
+    deleted_at: z.string().optional(),
+});
+export const TaskFilterSchema = z.object({
+    status: z.enum(['backlog', 'in-progress', 'review', 'done']).optional(),
+    type: z.enum(['feature', 'bug', 'chore', 'refactor', 'test', 'doc']).optional(),
+    priority: z.enum(['low', 'medium', 'high']).optional(),
+    tags: z.array(z.string()).optional(),
+    search: z.string().optional(),
+    includeDeleted: z.boolean().optional(),
+    onlyDeleted: z.boolean().optional(),
+});

package/dist/runtime/api/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Starts a standalone HTTP server that serves tRPC over HTTP and WebSocket on the same port.
+ * HTTP endpoint:   /trpc
+ * WebSocket path:  /trpc
+ */
+export declare function startApiServer({ port, host }: {
+    port: number;
+    host: string;
+}): Promise<void>;

package/dist/runtime/api/index.js

@@ -0,0 +1,125 @@
+import { createServer } from 'http';
+import { nodeHTTPRequestHandler } from '@trpc/server/adapters/node-http';
+import { applyWSSHandler } from '@trpc/server/adapters/ws';
+import { WebSocketServer } from 'ws';
+import { appRouter } from './lib/trpc/server.js';
+import { getTaskService } from './lib/server/task-service-singleton.js';
+import { log } from './lib/logger.js';
+import { pathToFileURL } from 'url';
+function getNumberEnv(name, fallback) {
+    const raw = process.env[name];
+    const n = raw ? Number(raw) : NaN;
+    return Number.isFinite(n) ? n : fallback;
+}
+/**
+ * Starts a standalone HTTP server that serves tRPC over HTTP and WebSocket on the same port.
+ * HTTP endpoint:   /trpc
+ * WebSocket path:  /trpc
+ */
+export async function startApiServer({ port, host }) {
+    const httpServer = createServer((req, res) => {
+        // Basic CORS for local dev
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET,POST,PUT,DELETE,OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type,Authorization');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        if (req.url?.startsWith('/trpc')) {
+            const host = req.headers.host || 'localhost';
+            const url = new URL(req.url, `http://${host}`);
+            // Strip the /trpc prefix and any leading slash; omit query string
+            const rawPath = url.pathname.replace(/^\/trpc\/?/, '');
+            const trpcPath = rawPath.replace(/^\/+/, '');
+            return nodeHTTPRequestHandler({
+                router: appRouter,
+                createContext: () => ({ taskService: getTaskService() }),
+                req: req,
+                res: res,
+                path: trpcPath,
+            });
+        }
+        if (req.url === '/api/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'ok', timestamp: new Date().toISOString() }));
+            return;
+        }
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Not Found' }));
+    });
+    // Share same HTTP server for WS, listening on /trpc
+    const wss = new WebSocketServer({ noServer: true });
+    // Upgrade handler for WebSocket path filtering
+    httpServer.on('upgrade', (request, socket, head) => {
+        const { url } = request;
+        if (!url || !url.startsWith('/trpc')) {
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(request, socket, head, (ws) => {
+            wss.emit('connection', ws, request);
+        });
+    });
+    // Hook tRPC WS handler
+    applyWSSHandler({
+        wss,
+        router: appRouter,
+        createContext: () => ({ taskService: getTaskService() }),
+    });
+    await new Promise((resolve) => {
+        httpServer.listen(port, host, () => resolve());
+    });
+    const addr = httpServer.address();
+    const actualPort = typeof addr === 'object' && addr && 'port' in addr ? addr.port : port;
+    log.info('API server listening', { port: actualPort, host, path: '/trpc' }, 'api-server');
+    console.log(`📡 API ready at http://${host}:${actualPort}/trpc (HTTP & WS)`);
+    // Graceful shutdown
+    const shutdown = () => {
+        try {
+            wss.close();
+        }
+        catch (error) {
+            log.error('Failed to close WebSocket server', error, 'api-server');
+        }
+        try {
+            httpServer.close();
+        }
+        catch (error) {
+            log.error('Failed to close HTTP server', error, 'api-server');
+        }
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+// Self-executing entry when run directly under ESM (e.g., tsx src/index.ts or node dist/index.js)
+try {
+    const isMain = process.argv[1] ? pathToFileURL(process.argv[1]).href === import.meta.url : false;
+    if (isMain) {
+        const host = process.env.HOST || 'localhost';
+        const resolveApiPort = async () => {
+            // Highest precedence: explicit API port
+            const explicit = getNumberEnv('VIBEMAN_API_PORT', NaN);
+            if (Number.isFinite(explicit) && explicit > 0)
+                return explicit;
+            // If PORT (web) is set, use web+1
+            const webPort = getNumberEnv('PORT', 0);
+            if (webPort > 0)
+                return webPort + 1;
+            // Default dev behavior: assume web on 3000, so API on 3001
+            return 3001;
+        };
+        (async () => {
+            const port = await resolveApiPort();
+            startApiServer({ port, host }).catch((err) => {
+                console.error('Failed to start API server:', err);
+                process.exit(1);
+            });
+        })();
+    }
+}
+catch {
+    // ignore
+}

package/dist/runtime/api/lib/id-generator.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Unified ID generation utility for consistent ID creation across the application
+ */
+export type IdPrefix = 'workflow' | 'exec' | 'improve' | 'merge' | 'review' | 'claude' | 'task' | 'session';
+interface IdGeneratorOptions {
+    /**
+     * Use UUID v4 for guaranteed uniqueness (default: true)
+     */
+    useUuid?: boolean;
+    /**
+     * Include timestamp for sortability (default: false)
+     */
+    includeTimestamp?: boolean;
+    /**
+     * Custom separator between parts (default: '_')
+     */
+    separator?: string;
+}
+/**
+ * Generate a unique ID with consistent format
+ *
+ * @param prefix - The prefix to identify the ID type
+ * @param options - Configuration options for ID generation
+ * @returns A unique identifier string
+ *
+ * @example
+ * generateId('workflow') // 'workflow_550e8400-e29b-41d4-a716-446655440000'
+ * generateId('exec', { includeTimestamp: true }) // 'exec_1703123456789_550e8400-e29b-41d4'
+ */
+export declare function generateId(prefix: IdPrefix | string, options?: IdGeneratorOptions): string;
+/**
+ * Generate a short, human-readable ID (less secure, for display purposes)
+ *
+ * @param prefix - The prefix to identify the ID type
+ * @returns A shorter identifier string
+ *
+ * @example
+ * generateShortId('task') // 'task_a1b2c3d4'
+ */
+export declare function generateShortId(prefix: IdPrefix | string): string;
+/**
+ * Parse an ID to extract its components
+ *
+ * @param id - The ID to parse
+ * @param separator - The separator used in the ID
+ * @returns Parsed components of the ID
+ */
+export declare function parseId(id: string, separator?: string): {
+    prefix: string;
+    timestamp?: number;
+    uuid?: string;
+    full: string;
+};
+/**
+ * Validate if a string is a valid UUID v4
+ */
+export declare function isValidUuid(id: string): boolean;
+/**
+ * Extract the UUID portion from a prefixed ID
+ */
+export declare function extractUuid(id: string): string | null;
+/**
+ * Create a batch of IDs efficiently
+ */
+export declare function generateBatchIds(prefix: IdPrefix | string, count: number, options?: IdGeneratorOptions): string[];
+/**
+ * Generate a deterministic ID based on input (useful for idempotency)
+ */
+export declare function generateDeterministicId(prefix: IdPrefix | string, input: string): Promise<string>;
+export {};

package/dist/runtime/api/lib/id-generator.js

@@ -0,0 +1,123 @@
+import { v4 as uuidv4 } from 'uuid';
+/**
+ * Generate a unique ID with consistent format
+ *
+ * @param prefix - The prefix to identify the ID type
+ * @param options - Configuration options for ID generation
+ * @returns A unique identifier string
+ *
+ * @example
+ * generateId('workflow') // 'workflow_550e8400-e29b-41d4-a716-446655440000'
+ * generateId('exec', { includeTimestamp: true }) // 'exec_1703123456789_550e8400-e29b-41d4'
+ */
+export function generateId(prefix, options = {}) {
+    const { useUuid = true, includeTimestamp = false, separator = '_' } = options;
+    const parts = [prefix];
+    if (includeTimestamp) {
+        // Use high-resolution timestamp for better uniqueness
+        parts.push(Date.now().toString());
+    }
+    if (useUuid) {
+        parts.push(uuidv4());
+    }
+    else {
+        // Fallback to crypto.randomUUID if available (browser/Node 19+)
+        if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+            parts.push(crypto.randomUUID());
+        }
+        else {
+            // Legacy fallback with better entropy
+            const timestamp = Date.now();
+            const random1 = Math.random().toString(36).substring(2, 11);
+            const random2 = Math.random().toString(36).substring(2, 7);
+            const counter = getCounter();
+            parts.push(`${timestamp.toString(36)}${random1}${random2}${counter.toString(36)}`);
+        }
+    }
+    return parts.join(separator);
+}
+/**
+ * Generate a short, human-readable ID (less secure, for display purposes)
+ *
+ * @param prefix - The prefix to identify the ID type
+ * @returns A shorter identifier string
+ *
+ * @example
+ * generateShortId('task') // 'task_a1b2c3d4'
+ */
+export function generateShortId(prefix) {
+    const timestamp = Date.now().toString(36).slice(-4);
+    const random = Math.random().toString(36).substring(2, 6);
+    return `${prefix}_${timestamp}${random}`;
+}
+/**
+ * Parse an ID to extract its components
+ *
+ * @param id - The ID to parse
+ * @param separator - The separator used in the ID
+ * @returns Parsed components of the ID
+ */
+export function parseId(id, separator = '_') {
+    const parts = id.split(separator);
+    const result = {
+        prefix: parts[0] || '',
+        full: id,
+    };
+    // Check if second part is a timestamp (13+ digit number for millisecond timestamps)
+    // This avoids treating short numbers like "123" as timestamps
+    if (parts[1] && /^\d{13,}$/.test(parts[1])) {
+        result.timestamp = parseInt(parts[1], 10);
+        // When timestamp is present, UUID is the third part onward
+        result.uuid = parts.slice(2).join(separator);
+    }
+    else {
+        // No timestamp, so UUID is everything after the prefix
+        result.uuid = parts.slice(1).join(separator);
+    }
+    return result;
+}
+/**
+ * Validate if a string is a valid UUID v4
+ */
+export function isValidUuid(id) {
+    const uuidV4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    return uuidV4Regex.test(id);
+}
+/**
+ * Extract the UUID portion from a prefixed ID
+ */
+export function extractUuid(id) {
+    const parts = id.split('_');
+    const lastPart = parts[parts.length - 1];
+    return isValidUuid(lastPart) ? lastPart : null;
+}
+// Counter for additional entropy in fallback ID generation
+let counter = 0;
+function getCounter() {
+    counter = (counter + 1) % 10000;
+    return counter;
+}
+/**
+ * Create a batch of IDs efficiently
+ */
+export function generateBatchIds(prefix, count, options) {
+    return Array.from({ length: count }, () => generateId(prefix, options));
+}
+/**
+ * Generate a deterministic ID based on input (useful for idempotency)
+ */
+export async function generateDeterministicId(prefix, input) {
+    // Use Web Crypto API if available
+    if (typeof crypto !== 'undefined' && crypto.subtle) {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(input);
+        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        const hashHex = hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
+        return `${prefix}_${hashHex.substring(0, 32)}`;
+    }
+    // Fallback for Node.js
+    const cryptoModule = await import('crypto');
+    const hash = cryptoModule.createHash('sha256').update(input).digest('hex');
+    return `${prefix}_${hash.substring(0, 32)}`;
+}

package/dist/runtime/api/lib/image-paste-drop-extension.d.ts

@@ -0,0 +1,26 @@
+import { Extension } from '@tiptap/core';
+export interface ImagePasteDropOptions {
+    /**
+     * Function that handles the image upload process
+     */
+    upload?: (file: File, onProgress?: (event: {
+        progress: number;
+    }) => void, abortSignal?: AbortSignal) => Promise<string>;
+    /**
+     * Callback for upload errors
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Callback for successful uploads
+     */
+    onSuccess?: (url: string) => void;
+    /**
+     * Maximum file size in bytes
+     */
+    maxSize?: number;
+    /**
+     * Allowed MIME types
+     */
+    allowedTypes?: string[];
+}
+export declare const ImagePasteDrop: Extension<ImagePasteDropOptions, any>;