@codewithdan/zingit 0.0.1

package/server/dist/types.d.ts

@@ -0,0 +1,74 @@
+import type { WebSocket } from 'ws';
+import type { CheckpointInfo } from './services/git-manager.js';
+export interface Agent {
+    name: string;
+    model: string;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    createSession(ws: WebSocket, projectDir: string): Promise<AgentSession>;
+    formatPrompt(data: BatchData, projectDir: string): string;
+    extractImages(data: BatchData): ImageContent[];
+}
+export interface ImageContent {
+    base64: string;
+    mediaType: string;
+    label?: string;
+}
+export interface AgentSession {
+    send(msg: {
+        prompt: string;
+        images?: ImageContent[];
+    }): Promise<void>;
+    destroy(): Promise<void>;
+}
+export interface Annotation {
+    id: string;
+    selector: string;
+    identifier: string;
+    html: string;
+    notes: string;
+    status?: 'pending' | 'processing' | 'completed';
+    selectedText?: string;
+    parentContext?: string;
+    textContent?: string;
+    siblingContext?: string;
+    parentHtml?: string;
+    screenshot?: string;
+}
+export interface BatchData {
+    pageUrl: string;
+    pageTitle: string;
+    annotations: Annotation[];
+    projectDir?: string;
+}
+export type WSIncomingType = 'batch' | 'message' | 'reset' | 'stop' | 'get_agents' | 'select_agent' | 'get_history' | 'undo' | 'revert_to' | 'clear_history';
+export interface WSIncomingMessage {
+    type: WSIncomingType;
+    data?: BatchData;
+    content?: string;
+    agent?: string;
+    checkpointId?: string;
+}
+export type WSOutgoingType = 'connected' | 'processing' | 'response' | 'delta' | 'tool_start' | 'tool_end' | 'idle' | 'error' | 'reset_complete' | 'agents' | 'agent_selected' | 'agent_error' | 'checkpoint_created' | 'history' | 'undo_complete' | 'revert_complete' | 'history_cleared';
+export interface AgentInfoMessage {
+    name: string;
+    displayName: string;
+    available: boolean;
+    version?: string;
+    reason?: string;
+    installCommand: string;
+}
+export interface WSOutgoingMessage {
+    type: WSOutgoingType;
+    content?: string;
+    message?: string;
+    tool?: string;
+    agent?: string;
+    model?: string;
+    projectDir?: string;
+    agents?: AgentInfoMessage[];
+    checkpoint?: CheckpointInfo;
+    checkpoints?: CheckpointInfo[];
+    checkpointId?: string;
+    filesReverted?: string[];
+}

package/server/dist/types.js

@@ -0,0 +1,2 @@
+// server/src/types.ts
+export {};

package/server/dist/utils/agent-detection.d.ts

@@ -0,0 +1,17 @@
+export interface AgentInfo {
+    name: string;
+    displayName: string;
+    available: boolean;
+    version?: string;
+    reason?: string;
+    installCommand: string;
+}
+/**
+ * Detect all available agents and their status
+ * Uses async operations to avoid blocking the event loop
+ */
+export declare function detectAgents(): Promise<AgentInfo[]>;
+/**
+ * Check if a specific agent is available
+ */
+export declare function isAgentAvailable(agentName: string): Promise<AgentInfo | undefined>;

package/server/dist/utils/agent-detection.js

@@ -0,0 +1,91 @@
+// server/src/utils/agent-detection.ts
+// Cross-platform agent CLI detection
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const execAsync = promisify(exec);
+/**
+ * Check if a CLI command is available (cross-platform)
+ * Uses async exec to avoid blocking the event loop
+ */
+async function checkCLI(command) {
+    try {
+        const { stdout } = await execAsync(`${command} --version`, {
+            encoding: 'utf-8',
+            timeout: 5000
+        });
+        return { installed: true, version: stdout.split('\n')[0].trim() };
+    }
+    catch {
+        return { installed: false };
+    }
+}
+/**
+ * Check if Codex auth file exists (cross-platform using os.homedir())
+ */
+function checkCodexAuth() {
+    const authPath = join(homedir(), '.codex', 'auth.json');
+    return existsSync(authPath);
+}
+/**
+ * Detect all available agents and their status
+ * Uses async operations to avoid blocking the event loop
+ */
+export async function detectAgents() {
+    // Run all CLI checks in parallel for better performance
+    const [claudeCheck, copilotCheck, codexCheck] = await Promise.all([
+        checkCLI('claude'),
+        checkCLI('copilot'),
+        checkCLI('codex')
+    ]);
+    const agents = [];
+    // Claude Code
+    agents.push({
+        name: 'claude',
+        displayName: 'Claude Code',
+        available: claudeCheck.installed,
+        version: claudeCheck.version,
+        reason: claudeCheck.installed ? undefined : 'Claude Code CLI not found',
+        installCommand: 'npm install -g @anthropic-ai/claude-code'
+    });
+    // GitHub Copilot
+    agents.push({
+        name: 'copilot',
+        displayName: 'GitHub Copilot CLI',
+        available: copilotCheck.installed,
+        version: copilotCheck.version,
+        reason: copilotCheck.installed ? undefined : 'Copilot CLI not found',
+        installCommand: 'npm install -g @github/copilot'
+    });
+    // OpenAI Codex
+    if (codexCheck.installed) {
+        const hasAuth = checkCodexAuth();
+        agents.push({
+            name: 'codex',
+            displayName: 'OpenAI Codex',
+            available: hasAuth,
+            version: codexCheck.version,
+            reason: hasAuth ? undefined : 'Codex CLI installed but not logged in. Run: codex',
+            installCommand: 'npm install -g @openai/codex'
+        });
+    }
+    else {
+        agents.push({
+            name: 'codex',
+            displayName: 'OpenAI Codex',
+            available: false,
+            reason: 'Codex CLI not found',
+            installCommand: 'npm install -g @openai/codex'
+        });
+    }
+    return agents;
+}
+/**
+ * Check if a specific agent is available
+ */
+export async function isAgentAvailable(agentName) {
+    const agents = await detectAgents();
+    return agents.find(a => a.name === agentName);
+}

package/server/dist/validation/payload.d.ts

@@ -0,0 +1,12 @@
+import type { BatchData } from '../types.js';
+export declare const MAX_ANNOTATIONS = 50;
+export declare const MAX_HTML_LENGTH = 50000;
+export declare const MAX_NOTES_LENGTH = 5000;
+export declare const MAX_SELECTOR_LENGTH = 1000;
+export declare const MAX_SCREENSHOT_SIZE = 5000000;
+export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+    sanitizedData?: BatchData;
+}
+export declare function validateBatchData(data: BatchData): ValidationResult;

package/server/dist/validation/payload.js

@@ -0,0 +1,64 @@
+// server/src/validation/payload.ts
+// ============================================
+// Payload Validation
+// ============================================
+export const MAX_ANNOTATIONS = 50;
+export const MAX_HTML_LENGTH = 50000;
+export const MAX_NOTES_LENGTH = 5000;
+export const MAX_SELECTOR_LENGTH = 1000;
+export const MAX_SCREENSHOT_SIZE = 5000000; // ~5MB base64 (matches Claude API limit)
+const VALID_STATUSES = ['pending', 'processing', 'completed'];
+function validateAnnotation(annotation, index) {
+    if (!annotation.id || typeof annotation.id !== 'string') {
+        return { valid: false, error: `Annotation ${index}: missing or invalid id` };
+    }
+    if (!annotation.identifier || typeof annotation.identifier !== 'string') {
+        return { valid: false, error: `Annotation ${index}: missing or invalid identifier` };
+    }
+    if (annotation.status && !VALID_STATUSES.includes(annotation.status)) {
+        return { valid: false, error: `Annotation ${index}: invalid status '${annotation.status}'` };
+    }
+    if (annotation.selector && annotation.selector.length > MAX_SELECTOR_LENGTH) {
+        return { valid: false, error: `Annotation ${index}: selector too long (max ${MAX_SELECTOR_LENGTH})` };
+    }
+    if (annotation.html && annotation.html.length > MAX_HTML_LENGTH) {
+        return { valid: false, error: `Annotation ${index}: html too long (max ${MAX_HTML_LENGTH})` };
+    }
+    if (annotation.notes && annotation.notes.length > MAX_NOTES_LENGTH) {
+        return { valid: false, error: `Annotation ${index}: notes too long (max ${MAX_NOTES_LENGTH})` };
+    }
+    if (annotation.screenshot && annotation.screenshot.length > MAX_SCREENSHOT_SIZE) {
+        return { valid: false, error: `Annotation ${index}: screenshot too large (max ${MAX_SCREENSHOT_SIZE / 1000}KB)` };
+    }
+    return { valid: true };
+}
+export function validateBatchData(data) {
+    if (!data) {
+        return { valid: false, error: 'Missing batch data' };
+    }
+    if (!data.annotations || !Array.isArray(data.annotations)) {
+        return { valid: false, error: 'Missing or invalid annotations array' };
+    }
+    if (data.annotations.length === 0) {
+        return { valid: false, error: 'No annotations provided' };
+    }
+    if (data.annotations.length > MAX_ANNOTATIONS) {
+        return { valid: false, error: `Too many annotations (max ${MAX_ANNOTATIONS})` };
+    }
+    // Validate each annotation
+    for (let i = 0; i < data.annotations.length; i++) {
+        const result = validateAnnotation(data.annotations[i], i);
+        if (!result.valid) {
+            return { valid: false, error: result.error };
+        }
+    }
+    // Sanitize and return
+    return {
+        valid: true,
+        sanitizedData: {
+            ...data,
+            pageUrl: data.pageUrl ? data.pageUrl.slice(0, 2000) : data.pageUrl,
+            pageTitle: data.pageTitle ? data.pageTitle.slice(0, 500) : data.pageTitle,
+        }
+    };
+}