@codewithdan/zingit 0.17.4 → 0.17.5

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@codewithdan/zingit",
-  "version": "0.17.4",
+  "version": "0.17.5",
   "description": "AI-powered UI marker tool - point, mark, and let AI fix it",
   "type": "module",
   "engines": {
     "node": ">=22.0.0"
   },
+  "workspaces": [
+    "client",
+    "server"
+  ],
   "bin": {
     "zingit": "bin/cli.js"
   },
@@ -21,16 +25,16 @@
   "main": "client/dist/zingit-client.js",
   "scripts": {
     "build": "npm run build:client && npm run build:server",
-    "build:client": "cd client && npm run build",
-    "build:server": "cd server && npm run build",
-    "deploy": "cd client && npm run deploy",
+    "build:client": "npm run build -w client",
+    "build:server": "npm run build -w server",
+    "deploy": "npm run deploy -w client",
     "dev": "concurrently \"npm run dev:server\" \"npm run dev:client\"",
-    "dev:server": "cd server && npm run dev",
-    "dev:client": "cd client && npm run dev",
-    "test": "cd client && npm run test",
-    "test:watch": "cd client && npm run test:watch",
-    "test:ui": "cd client && npm run test:ui",
-    "release": "standard-version && npm run build && npm publish --access public"
+    "dev:server": "npm run dev -w server",
+    "dev:client": "npm run dev -w client",
+    "test": "npm run test -w client",
+    "test:watch": "npm run test:watch -w client",
+    "test:ui": "npm run test:ui -w client",
+    "release": "commit-and-tag-version && npm run build && npm publish --access public"
   },
   "keywords": [
     "ui",
@@ -56,22 +60,19 @@
   "homepage": "https://github.com/danwahlin/zingit#readme",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.17",
+    "@codewithdan/agent-sdk-core": "^0.2.0",
     "@github/copilot-sdk": "^0.1.16",
-    "@openai/codex-sdk": "^0.89.0",
+    "@openai/codex-sdk": ">=0.80.0",
     "diff": "^8.0.3",
     "uuid": "^11.1.0",
     "ws": "^8.19.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@types/diff": "^6.0.0",
-    "@types/node": "^25.0.10",
-    "@types/uuid": "^10.0.0",
-    "@types/ws": "^8.18.1",
-    "concurrently": "^9.1.2",
-    "gh-pages": "^6.3.0",
-    "standard-version": "^9.5.0",
-    "tsx": "^4.21.0",
-    "typescript": "^5.9.3"
+    "commit-and-tag-version": "^12.6.1",
+    "concurrently": "^9.1.2"
+  },
+  "overrides": {
+    "minimatch": "^10.2.1"
   }
 }

package/server/dist/agents/core-adapter.d.ts

@@ -0,0 +1,16 @@
+import type { AgentSession as ZingitSession, WebSocketRef } from '../types.js';
+import type { AgentProvider as CoreProvider } from '@codewithdan/agent-sdk-core';
+import { BaseAgent } from './base.js';
+/**
+ * Adapter that wraps a @codewithdan/agent-sdk-core provider to match zingit's Agent interface.
+ */
+export declare class CoreProviderAdapter extends BaseAgent {
+    name: string;
+    model: string;
+    private provider;
+    private started;
+    constructor(provider: CoreProvider);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    createSession(wsRef: WebSocketRef, projectDir: string, resumeSessionId?: string): Promise<ZingitSession>;
+}

package/server/dist/agents/core-adapter.js

@@ -0,0 +1,152 @@
+// server/src/agents/core-adapter.ts
+// Adapts @codewithdan/agent-sdk-core providers to the zingit Agent/AgentSession interface.
+// This lets zingit use the shared provider implementations while keeping
+// its own WS transport model (agents send directly to per-connection WebSocket).
+import { BaseAgent } from './base.js';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { randomUUID } from 'crypto';
+/**
+ * Maps core AgentEvent types to zingit WSOutgoingMessage types.
+ * Zingit uses a simpler event model: delta, tool_start, tool_end, idle, error.
+ */
+function mapCoreEventToWS(event) {
+    switch (event.type) {
+        case 'output':
+        case 'thinking':
+        case 'command_output':
+        case 'test_result':
+            return { type: 'delta', content: event.content };
+        case 'command':
+        case 'file_read':
+        case 'file_write':
+        case 'file_edit':
+        case 'tool_call':
+            return { type: 'tool_start', tool: event.metadata?.command || event.content };
+        case 'complete':
+            return { type: 'idle' };
+        case 'error':
+            return { type: 'error', message: event.content };
+        default:
+            return null;
+    }
+}
+/**
+ * Convert zingit ImageContent[] to core AgentAttachment[].
+ */
+function imagesToAttachments(images) {
+    if (!images || images.length === 0)
+        return undefined;
+    return images.map(img => ({
+        type: 'base64_image',
+        data: img.base64,
+        mediaType: img.mediaType,
+        displayName: img.label,
+    }));
+}
+/**
+ * Adapter that wraps a @codewithdan/agent-sdk-core provider to match zingit's Agent interface.
+ */
+export class CoreProviderAdapter extends BaseAgent {
+    name;
+    model;
+    provider;
+    started = false;
+    constructor(provider) {
+        super();
+        this.name = provider.name;
+        this.model = provider.model;
+        this.provider = provider;
+    }
+    async start() {
+        if (!this.started) {
+            await this.provider.start();
+            this.started = true;
+        }
+    }
+    async stop() {
+        if (this.started) {
+            await this.provider.stop();
+            this.started = false;
+        }
+    }
+    async createSession(wsRef, projectDir, resumeSessionId) {
+        const send = (data) => {
+            const ws = wsRef.current;
+            if (ws && ws.readyState === ws.OPEN) {
+                ws.send(JSON.stringify(data));
+            }
+        };
+        const contextId = `zingit-${randomUUID()}`;
+        const sessionTempFiles = [];
+        // Build system prompt for the zingit context
+        const systemPrompt = `
+<context>
+You are a UI debugging assistant working in the project directory: ${projectDir}
+
+When given markers about UI elements:
+1. Search for the corresponding code using the selectors and HTML context provided
+2. Make the requested changes in the project at ${projectDir}
+3. Be thorough in finding the right files and making precise edits
+
+IMPORTANT: Format all responses using markdown.
+</context>
+`;
+        const coreSession = await this.provider.createSession({
+            contextId,
+            workingDirectory: projectDir,
+            systemPrompt,
+            resumeSessionId: resumeSessionId || undefined,
+            onEvent: (event) => {
+                const wsMsg = mapCoreEventToWS(event);
+                if (wsMsg)
+                    send(wsMsg);
+            },
+        });
+        return {
+            send: async (msg) => {
+                try {
+                    // For the first message we use execute(), for follow-ups we use send()
+                    // Since zingit always calls send(), we use execute() which handles both
+                    const attachments = imagesToAttachments(msg.images);
+                    // If we have attachments that need temp files (for providers that need file paths),
+                    // save them now
+                    if (msg.images && msg.images.length > 0) {
+                        for (const img of msg.images) {
+                            const ext = img.mediaType.split('/')[1] || 'png';
+                            const tempPath = path.join(os.tmpdir(), `zingit-screenshot-${randomUUID()}.${ext}`);
+                            try {
+                                const buffer = Buffer.from(img.base64, 'base64');
+                                await fs.writeFile(tempPath, buffer, { mode: 0o600 });
+                                sessionTempFiles.push(tempPath);
+                            }
+                            catch {
+                                // Skip failed images
+                            }
+                        }
+                    }
+                    await coreSession.execute(msg.prompt);
+                }
+                catch (err) {
+                    send({ type: 'error', message: err.message });
+                }
+            },
+            destroy: async () => {
+                try {
+                    await coreSession.destroy();
+                }
+                finally {
+                    for (const tempPath of sessionTempFiles) {
+                        try {
+                            await fs.unlink(tempPath);
+                        }
+                        catch { /* ignore */ }
+                    }
+                    sessionTempFiles.length = 0;
+                }
+            },
+            getSessionId: () => coreSession.sessionId,
+        };
+    }
+}

package/server/dist/handlers/messageHandlers.js

@@ -47,6 +47,7 @@ export async function handleSelectAgent(ws, state, msg, deps) {
         }
         finally {
             state.session = null;
+            state.sessionId = null; // Clear stale session ID to prevent resume with wrong agent
         }
     }
     // Initialize the agent

package/server/dist/index.js

@@ -1,26 +1,65 @@
 // server/src/index.ts
 import { WebSocketServer } from 'ws';
-import { CopilotAgent } from './agents/copilot.js';
-import { ClaudeCodeAgent } from './agents/claude.js';
-import { CodexAgent } from './agents/codex.js';
+import { CoreProviderAdapter } from './agents/core-adapter.js';
+import { CopilotProvider, ClaudeProvider, CodexProvider, } from '@codewithdan/agent-sdk-core';
+import { spawn } from 'node:child_process';
+import { userInfo } from 'node:os';
 import { detectAgents } from './utils/agent-detection.js';
 import { GitManager, GitManagerError } from './services/git-manager.js';
 import { sendMessage, handleGetAgents, handleSelectAgent, handleBatch, handleMessage, handleReset, handleStop, handleGetHistory, handleUndo, handleRevertTo, handleClearHistory } from './handlers/messageHandlers.js';
+import { resolve } from 'path';
 const PORT = parseInt(process.env.PORT || '3000', 10);
 // Legacy support: still allow AGENT env var for backwards compatibility
 const DEFAULT_AGENT = process.env.AGENT || null;
-if (!process.env.PROJECT_DIR) {
-    console.error('ERROR: PROJECT_DIR environment variable is required');
-    console.error('Example: PROJECT_DIR=/path/to/your/project npm run dev');
-    process.exit(1);
+// Resolve PROJECT_DIR: explicit env var > npm invocation directory > cwd
+const rawProjectDir = process.env.PROJECT_DIR;
+const initCwd = process.env.INIT_CWD || process.cwd();
+let PROJECT_DIR;
+if (rawProjectDir) {
+    PROJECT_DIR = resolve(initCwd, rawProjectDir);
 }
-const PROJECT_DIR = process.env.PROJECT_DIR;
-// Agent registry
-const agentClasses = {
-    copilot: CopilotAgent,
-    claude: ClaudeCodeAgent,
-    codex: CodexAgent,
-};
+else {
+    PROJECT_DIR = initCwd;
+    console.log(`ℹ PROJECT_DIR not set, defaulting to: ${PROJECT_DIR}`);
+}
+// Agent registry — wraps @codewithdan/agent-sdk-core providers with zingit adapter
+function createClaudeSpawner() {
+    if (userInfo().uid === 0) {
+        return {
+            permissionMode: 'bypassPermissions',
+            spawnClaudeCodeProcess: (options) => {
+                const { command, args, cwd, env, signal } = options;
+                const child = spawn('sudo', ['-u', 'ccrunner', '-E', command, ...args], {
+                    cwd,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                    signal,
+                    env: { ...env, HOME: '/home/ccrunner', USER: 'ccrunner' },
+                    windowsHide: true,
+                });
+                return {
+                    stdin: child.stdin,
+                    stdout: child.stdout,
+                    get killed() { return child.killed; },
+                    get exitCode() { return child.exitCode; },
+                    kill: (sig) => child.kill(sig),
+                    on: child.on.bind(child),
+                    once: child.once.bind(child),
+                    off: child.off.bind(child),
+                };
+            },
+        };
+    }
+    return { permissionMode: 'acceptEdits' };
+}
+function createAgentFactory() {
+    const claudeOpts = createClaudeSpawner();
+    return {
+        copilot: () => new CoreProviderAdapter(new CopilotProvider()),
+        claude: () => new CoreProviderAdapter(new ClaudeProvider(claudeOpts)),
+        codex: () => new CoreProviderAdapter(new CodexProvider()),
+    };
+}
+const agentFactories = createAgentFactory();
 // Cache for initialized agents (lazy initialization)
 const initializedAgents = new Map();
 /**
@@ -33,11 +72,11 @@ async function getAgent(agentName) {
         return cached;
     }
     // Initialize new agent
-    const AgentClass = agentClasses[agentName];
-    if (!AgentClass) {
+    const factory = agentFactories[agentName];
+    if (!factory) {
         throw new Error(`Unknown agent: ${agentName}`);
     }
-    const agent = new AgentClass();
+    const agent = factory();
     await agent.start();
     initializedAgents.set(agentName, agent);
     return agent;
@@ -135,52 +174,57 @@ async function main() {
             detectAgents,
             getAgent
         };
-        ws.on('message', async (data) => {
-            let msg;
-            try {
-                msg = JSON.parse(data.toString());
-            }
-            catch {
-                sendMessage(ws, { type: 'error', message: 'Invalid JSON' });
-                return;
-            }
-            try {
-                switch (msg.type) {
-                    case 'get_agents':
-                        await handleGetAgents(ws, deps);
-                        break;
-                    case 'select_agent':
-                        await handleSelectAgent(ws, state, msg, deps);
-                        break;
-                    case 'batch':
-                        await handleBatch(ws, state, msg, deps);
-                        break;
-                    case 'message':
-                        await handleMessage(ws, state, msg, deps);
-                        break;
-                    case 'reset':
-                        await handleReset(ws, state);
-                        break;
-                    case 'stop':
-                        await handleStop(ws, state);
-                        break;
-                    case 'get_history':
-                        await handleGetHistory(ws, state);
-                        break;
-                    case 'undo':
-                        await handleUndo(ws, state, GitManagerError);
-                        break;
-                    case 'revert_to':
-                        await handleRevertTo(ws, state, msg, GitManagerError);
-                        break;
-                    case 'clear_history':
-                        await handleClearHistory(ws, state);
-                        break;
+        // Serialize message processing to prevent race conditions
+        // (e.g., undo arriving while batch finalization is still in progress)
+        let messageQueue = Promise.resolve();
+        ws.on('message', (data) => {
+            messageQueue = messageQueue.then(async () => {
+                let msg;
+                try {
+                    msg = JSON.parse(data.toString());
                 }
-            }
-            catch (err) {
-                sendMessage(ws, { type: 'error', message: err.message });
-            }
+                catch {
+                    sendMessage(ws, { type: 'error', message: 'Invalid JSON' });
+                    return;
+                }
+                try {
+                    switch (msg.type) {
+                        case 'get_agents':
+                            await handleGetAgents(ws, deps);
+                            break;
+                        case 'select_agent':
+                            await handleSelectAgent(ws, state, msg, deps);
+                            break;
+                        case 'batch':
+                            await handleBatch(ws, state, msg, deps);
+                            break;
+                        case 'message':
+                            await handleMessage(ws, state, msg, deps);
+                            break;
+                        case 'reset':
+                            await handleReset(ws, state);
+                            break;
+                        case 'stop':
+                            await handleStop(ws, state);
+                            break;
+                        case 'get_history':
+                            await handleGetHistory(ws, state);
+                            break;
+                        case 'undo':
+                            await handleUndo(ws, state, GitManagerError);
+                            break;
+                        case 'revert_to':
+                            await handleRevertTo(ws, state, msg, GitManagerError);
+                            break;
+                        case 'clear_history':
+                            await handleClearHistory(ws, state);
+                            break;
+                    }
+                }
+                catch (err) {
+                    sendMessage(ws, { type: 'error', message: err.message });
+                }
+            });
         });
         ws.on('close', async () => {
             console.log('Client disconnected');