vibeman 0.0.0 → 0.0.2

package/dist/runtime/api/index.js

@@ -0,0 +1,117 @@
+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 () => {
+            const port = getNumberEnv('PORT', 3000);
+            return port + 1;
+        };
+        (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>;

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

@@ -0,0 +1,125 @@
+import { Extension } from '@tiptap/core';
+import { Plugin, PluginKey } from '@tiptap/pm/state';
+import { handleImageUpload } from './tiptap-utils.js';
+export const ImagePasteDrop = Extension.create({
+    name: 'imagePasteDrop',
+    addOptions() {
+        return {
+            upload: handleImageUpload,
+            onError: undefined,
+            onSuccess: undefined,
+            maxSize: 5 * 1024 * 1024, // 5MB
+            allowedTypes: [
+                'image/jpeg',
+                'image/jpg',
+                'image/png',
+                'image/gif',
+                'image/webp',
+                'image/svg+xml',
+            ],
+        };
+    },
+    addProseMirrorPlugins() {
+        const uploadAndInsertImages = (files, view, position) => {
+            files.forEach(async (file) => {
+                try {
+                    // Validate file size
+                    if (this.options.maxSize && file.size > this.options.maxSize) {
+                        const error = new Error(`File size exceeds maximum allowed (${this.options.maxSize / (1024 * 1024)}MB)`);
+                        this.options.onError?.(error);
+                        return;
+                    }
+                    // Insert placeholder first
+                    const placeholderTransaction = view.state.tr.insert(position, view.state.schema.text('🔄 Uploading...'));
+                    view.dispatch(placeholderTransaction);
+                    // Upload the image
+                    const uploadFunction = this.options.upload || handleImageUpload;
+                    const imageUrl = await uploadFunction(file);
+                    // Replace placeholder with actual image
+                    const filename = file.name.replace(/\.[^/.]+$/, '') || 'image';
+                    const imageNode = view.state.schema.nodes.image.create({
+                        src: imageUrl,
+                        alt: filename,
+                        title: filename,
+                    });
+                    // Find the placeholder text and replace it
+                    const currentState = view.state;
+                    let found = false;
+                    currentState.doc.descendants((node, pos) => {
+                        if (!found && node.isText && node.text === '🔄 Uploading...') {
+                            const replaceTransaction = currentState.tr.replaceRangeWith(pos, pos + node.nodeSize, imageNode);
+                            view.dispatch(replaceTransaction);
+                            found = true;
+                            return false;
+                        }
+                        return true;
+                    });
+                    this.options.onSuccess?.(imageUrl);
+                }
+                catch (error) {
+                    // Remove placeholder on error
+                    const currentState = view.state;
+                    currentState.doc.descendants((node, pos) => {
+                        if (node.isText && node.text === '🔄 Uploading...') {
+                            const deleteTransaction = currentState.tr.delete(pos, pos + node.nodeSize);
+                            view.dispatch(deleteTransaction);
+                            return false;
+                        }
+                        return true;
+                    });
+                    const errorMessage = error instanceof Error ? error : new Error('Upload failed');
+                    this.options.onError?.(errorMessage);
+                }
+            });
+        };
+        return [
+            new Plugin({
+                key: new PluginKey('imagePasteDrop'),
+                props: {
+                    handleDOMEvents: {
+                        // Handle drag and drop
+                        drop: (view, event) => {
+                            event.preventDefault();
+                            const { files } = event.dataTransfer;
+                            const imageFiles = Array.from(files).filter((file) => this.options.allowedTypes?.includes(file.type));
+                            if (imageFiles.length === 0) {
+                                return false;
+                            }
+                            // Get drop position
+                            const pos = view.posAtCoords({
+                                left: event.clientX,
+                                top: event.clientY,
+                            });
+                            if (!pos)
+                                return false;
+                            uploadAndInsertImages(imageFiles, view, pos.pos);
+                            return true;
+                        },
+                        // Handle paste
+                        paste: (view, event) => {
+                            const { files } = event.clipboardData;
+                            const imageFiles = Array.from(files).filter((file) => this.options.allowedTypes?.includes(file.type));
+                            if (imageFiles.length === 0) {
+                                return false;
+                            }
+                            event.preventDefault();
+                            // Insert at current cursor position
+                            const { selection } = view.state;
+                            uploadAndInsertImages(imageFiles, view, selection.from);
+                            return true;
+                        },
+                        // Prevent default drag behaviors
+                        dragover: (view, event) => {
+                            event.preventDefault();
+                            return false;
+                        },
+                        dragenter: (view, event) => {
+                            event.preventDefault();
+                            return false;
+                        },
+                    },
+                },
+            }),
+        ];
+    },
+});