amai 0.0.4 → 0.0.6

package/dist/cli.cjs

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 'use strict';
 
-var pc4 = require('picocolors');
-var WebSocket = require('ws');
-var events = require('events');
+var pc5 = require('picocolors');
+var WebSocket2 = require('ws');
 var zod = require('zod');
 var promises = require('fs/promises');
 var path9 = require('path');
 var fs3 = require('fs');
 var os2 = require('os');
+var crypto = require('crypto');
 var child_process = require('child_process');
 var util = require('util');
 var hono = require('hono');
@@ -20,8 +20,8 @@ var readline = require('readline');
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var pc4__default = /*#__PURE__*/_interopDefault(pc4);
-var WebSocket__default = /*#__PURE__*/_interopDefault(WebSocket);
+var pc5__default = /*#__PURE__*/_interopDefault(pc5);
+var WebSocket2__default = /*#__PURE__*/_interopDefault(WebSocket2);
 var path9__default = /*#__PURE__*/_interopDefault(path9);
 var fs3__default = /*#__PURE__*/_interopDefault(fs3);
 var os2__default = /*#__PURE__*/_interopDefault(os2);
@@ -612,15 +612,133 @@ function calculateDiffStats(oldContent, newContent) {
   }
   return { linesAdded, linesRemoved };
 }
-
-// src/tools/apply-patch.ts
+var CheckpointStore = class {
+  checkpoints = /* @__PURE__ */ new Map();
+  fileCheckpoints = /* @__PURE__ */ new Map();
+  // filePath -> checkpointIds
+  /**
+   * Compute SHA-256 hash of content
+   */
+  computeHash(content) {
+    return crypto.createHash("sha256").update(content, "utf8").digest("hex");
+  }
+  /**
+   * Create a new checkpoint before an edit operation
+   */
+  createCheckpoint(id, filePath, beforeContent, afterContent) {
+    const checkpoint = {
+      id,
+      filePath,
+      beforeContent,
+      afterContent,
+      beforeHash: this.computeHash(beforeContent),
+      afterHash: this.computeHash(afterContent),
+      timestamp: Date.now()
+    };
+    this.checkpoints.set(id, checkpoint);
+    const fileCheckpointIds = this.fileCheckpoints.get(filePath) || [];
+    fileCheckpointIds.push(id);
+    this.fileCheckpoints.set(filePath, fileCheckpointIds);
+    return checkpoint;
+  }
+  /**
+   * Get a checkpoint by ID
+   */
+  getCheckpoint(id) {
+    return this.checkpoints.get(id);
+  }
+  /**
+   * Get all checkpoints for a file (ordered by timestamp)
+   */
+  getCheckpointsForFile(filePath) {
+    const ids = this.fileCheckpoints.get(filePath) || [];
+    return ids.map((id) => this.checkpoints.get(id)).filter((cp) => cp !== void 0).sort((a, b) => a.timestamp - b.timestamp);
+  }
+  /**
+   * Verify if current file content matches expected state
+   * Returns true if safe to revert
+   */
+  verifyFileState(checkpointId, currentContent) {
+    const checkpoint = this.checkpoints.get(checkpointId);
+    if (!checkpoint) {
+      return {
+        safe: false,
+        reason: "Checkpoint not found"
+      };
+    }
+    const currentHash = this.computeHash(currentContent);
+    if (currentHash === checkpoint.afterHash) {
+      return {
+        safe: true,
+        checkpoint,
+        currentHash
+      };
+    }
+    if (currentHash === checkpoint.beforeHash) {
+      return {
+        safe: false,
+        reason: "File appears to already be reverted",
+        checkpoint,
+        currentHash
+      };
+    }
+    return {
+      safe: false,
+      reason: "File was modified after this edit. Current content does not match expected state.",
+      checkpoint,
+      currentHash
+    };
+  }
+  /**
+   * Remove a checkpoint after successful revert or accept
+   */
+  removeCheckpoint(id) {
+    const checkpoint = this.checkpoints.get(id);
+    if (!checkpoint) return false;
+    this.checkpoints.delete(id);
+    const fileCheckpointIds = this.fileCheckpoints.get(checkpoint.filePath);
+    if (fileCheckpointIds) {
+      const filtered = fileCheckpointIds.filter((cpId) => cpId !== id);
+      if (filtered.length === 0) {
+        this.fileCheckpoints.delete(checkpoint.filePath);
+      } else {
+        this.fileCheckpoints.set(checkpoint.filePath, filtered);
+      }
+    }
+    return true;
+  }
+  /**
+   * Get all checkpoints (for debugging/listing)
+   */
+  getAllCheckpoints() {
+    return Array.from(this.checkpoints.values()).sort((a, b) => b.timestamp - a.timestamp);
+  }
+  /**
+   * Clear all checkpoints (for cleanup)
+   */
+  clear() {
+    this.checkpoints.clear();
+    this.fileCheckpoints.clear();
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return {
+      totalCheckpoints: this.checkpoints.size,
+      filesTracked: this.fileCheckpoints.size
+    };
+  }
+};
+var checkpointStore = new CheckpointStore();
 zod.z.object({
   file_path: zod.z.string().describe("The path to the file you want to search and replace in. You can use either a relative path in the workspace or an absolute path. If an absolute path is provided, it will be preserved as is"),
   new_string: zod.z.string().describe("The edited text to replace the old_string (must be different from the old_string)"),
-  old_string: zod.z.string().describe("The text to replace (must be unique within the file, and must match the file contents exactly, including all whitespace and indentation)")
+  old_string: zod.z.string().describe("The text to replace (must be unique within the file, and must match the file contents exactly, including all whitespace and indentation)"),
+  toolCallId: zod.z.string().optional().describe("Optional tool call ID for checkpoint tracking")
 });
 var apply_patch = async function(input, projectCwd) {
-  const { file_path, new_string, old_string } = input;
+  const { file_path, new_string, old_string, toolCallId } = input;
   try {
     if (!file_path) {
       return {
@@ -695,6 +813,13 @@ var apply_patch = async function(input, projectCwd) {
       };
     }
     const newContent = fileContent.replace(old_string, new_string);
+    const checkpointId = toolCallId || crypto.randomUUID();
+    const checkpoint = checkpointStore.createCheckpoint(
+      checkpointId,
+      absolute_file_path,
+      fileContent,
+      newContent
+    );
     try {
       await promises.writeFile(absolute_file_path, newContent, "utf-8");
       const diffStats = calculateDiffStats(fileContent, newContent);
@@ -704,9 +829,14 @@ var apply_patch = async function(input, projectCwd) {
         new_string,
         linesAdded: diffStats.linesAdded,
         linesRemoved: diffStats.linesRemoved,
-        message: `Successfully replaced string in file: ${file_path}`
+        message: `Successfully replaced string in file: ${file_path}`,
+        // Include checkpoint info for frontend
+        checkpointId: checkpoint.id,
+        beforeHash: checkpoint.beforeHash,
+        afterHash: checkpoint.afterHash
       };
     } catch (error) {
+      checkpointStore.removeCheckpoint(checkpointId);
       return {
         success: false,
         message: `Failed to write to file: ${file_path}`,
@@ -724,10 +854,11 @@ var apply_patch = async function(input, projectCwd) {
 zod.z.object({
   target_file: zod.z.string().describe("The relative path to the file to modify. The tool will create any directories in the path that don't exist"),
   content: zod.z.string().describe("The content to write to the file"),
-  providedNewFile: zod.z.boolean().describe("The new file content to write to the file").optional()
+  providedNewFile: zod.z.boolean().describe("The new file content to write to the file").optional(),
+  toolCallId: zod.z.string().optional().describe("Optional tool call ID for checkpoint tracking")
 });
 var editFiles = async function(input, projectCwd) {
-  const { target_file, content, providedNewFile } = input;
+  const { target_file, content, providedNewFile, toolCallId } = input;
   try {
     if (projectCwd) {
       const validation = validatePath(target_file, projectCwd);
@@ -759,7 +890,19 @@ var editFiles = async function(input, projectCwd) {
         isNewFile = true;
       }
     }
-    await fs3__default.default.promises.writeFile(filePath, content);
+    const checkpointId = toolCallId || crypto.randomUUID();
+    const checkpoint = checkpointStore.createCheckpoint(
+      checkpointId,
+      filePath,
+      existingContent,
+      content
+    );
+    try {
+      await fs3__default.default.promises.writeFile(filePath, content);
+    } catch (writeError) {
+      checkpointStore.removeCheckpoint(checkpointId);
+      throw writeError;
+    }
     const diffStats = calculateDiffStats(existingContent, content);
     if (isNewFile) {
       return {
@@ -769,7 +912,11 @@ var editFiles = async function(input, projectCwd) {
         new_string: content,
         message: `Created new file: ${target_file}`,
         linesAdded: diffStats.linesAdded,
-        linesRemoved: diffStats.linesRemoved
+        linesRemoved: diffStats.linesRemoved,
+        // Include checkpoint info for frontend
+        checkpointId: checkpoint.id,
+        beforeHash: checkpoint.beforeHash,
+        afterHash: checkpoint.afterHash
       };
     } else {
       return {
@@ -779,7 +926,11 @@ var editFiles = async function(input, projectCwd) {
         new_string: content,
         message: `Modified file: ${target_file}`,
         linesAdded: diffStats.linesAdded,
-        linesRemoved: diffStats.linesRemoved
+        linesRemoved: diffStats.linesRemoved,
+        // Include checkpoint info for frontend
+        checkpointId: checkpoint.id,
+        beforeHash: checkpoint.beforeHash,
+        afterHash: checkpoint.afterHash
       };
     }
   } catch (error) {
@@ -1274,15 +1425,6 @@ var startHttpServer = (connection) => {
         controller.enqueue(encoder.encode(`data: ${JSON.stringify({ connected: initialStatus === "open" })}
 
 `));
-        const statusHandler = (data) => {
-          try {
-            controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
-
-`));
-          } catch {
-          }
-        };
-        statusEmitter.on("status", statusHandler);
         const heartbeatInterval = setInterval(() => {
           try {
             const currentStatus = wsConnection ? getConnectionStatus(wsConnection) : "closed";
@@ -1293,7 +1435,6 @@ var startHttpServer = (connection) => {
           }
         }, 15e3);
         c.req.raw.signal.addEventListener("abort", () => {
-          statusEmitter.off("status", statusHandler);
           clearInterval(heartbeatInterval);
         });
       }
@@ -1335,7 +1476,15 @@ var startHttpServer = (connection) => {
   });
   app.post("/revert", async (c) => {
     try {
-      const { filePath, oldString, newString, projectCwd } = await c.req.json();
+      const {
+        filePath,
+        oldString,
+        newString,
+        projectCwd,
+        checkpointId,
+        expectedAfterHash,
+        force = false
+      } = await c.req.json();
       if (!filePath || oldString === void 0) {
         return c.json({ error: "filePath and oldString required" }, 400);
       }
@@ -1359,25 +1508,127 @@ var startHttpServer = (connection) => {
         }
         return c.json({ error: `Failed to read file: ${error.message}` }, 500);
       }
+      if (checkpointId) {
+        const verification = checkpointStore.verifyFileState(checkpointId, currentContent);
+        if (!verification.safe && !force) {
+          return c.json({
+            success: false,
+            conflict: true,
+            error: verification.reason,
+            currentHash: verification.currentHash,
+            expectedHash: verification.checkpoint?.afterHash,
+            checkpointId
+          }, 409);
+        }
+        if (verification.checkpoint) {
+          try {
+            await promises.writeFile(resolved, verification.checkpoint.beforeContent, "utf-8");
+            checkpointStore.removeCheckpoint(checkpointId);
+            return c.json({ success: true, usedCheckpoint: true });
+          } catch (writeError) {
+            return c.json({ error: `Failed to write file: ${writeError.message}` }, 500);
+          }
+        }
+      }
+      if (expectedAfterHash && !force) {
+        const currentHash = checkpointStore.computeHash(currentContent);
+        if (currentHash !== expectedAfterHash) {
+          return c.json({
+            success: false,
+            conflict: true,
+            error: "File was modified after this edit. Current content does not match expected state.",
+            currentHash,
+            expectedHash: expectedAfterHash
+          }, 409);
+        }
+      }
       let finalContent;
       if (newString && newString !== oldString) {
         if (!currentContent.includes(newString)) {
-          return c.json({ error: "Cannot revert: the new content is not found in the current file. The file may have been modified." }, 400);
+          return c.json({
+            success: false,
+            conflict: true,
+            error: "Cannot revert: the new content is not found in the current file. The file may have been modified."
+          }, 409);
         }
         const occurrences = currentContent.split(newString).length - 1;
         if (occurrences > 1) {
-          return c.json({ error: "Cannot revert: the new content appears multiple times in the file" }, 400);
+          return c.json({
+            success: false,
+            conflict: true,
+            error: "Cannot revert: the new content appears multiple times in the file"
+          }, 409);
         }
         finalContent = currentContent.replace(newString, oldString);
       } else {
         finalContent = oldString;
       }
       await promises.writeFile(resolved, finalContent, "utf-8");
+      if (checkpointId) {
+        checkpointStore.removeCheckpoint(checkpointId);
+      }
       return c.json({ success: true });
     } catch (error) {
       return c.json({ error: error.message }, 500);
     }
   });
+  app.post("/revert/force", async (c) => {
+    try {
+      const { filePath, checkpointId, projectCwd } = await c.req.json();
+      if (!checkpointId) {
+        return c.json({ error: "checkpointId is required for force revert" }, 400);
+      }
+      const checkpoint = checkpointStore.getCheckpoint(checkpointId);
+      if (!checkpoint) {
+        return c.json({ error: "Checkpoint not found" }, 404);
+      }
+      let resolved;
+      if (projectCwd) {
+        resolved = path9__default.default.isAbsolute(filePath || checkpoint.filePath) ? filePath || checkpoint.filePath : path9__default.default.resolve(projectCwd, filePath || checkpoint.filePath);
+        const normalizedResolved = path9__default.default.normalize(resolved);
+        const normalizedCwd = path9__default.default.normalize(projectCwd);
+        if (!normalizedResolved.startsWith(normalizedCwd)) {
+          return c.json({ error: "Path is outside project directory" }, 403);
+        }
+      } else {
+        resolved = checkpoint.filePath;
+      }
+      try {
+        await promises.writeFile(resolved, checkpoint.beforeContent, "utf-8");
+        checkpointStore.removeCheckpoint(checkpointId);
+        return c.json({ success: true, forced: true });
+      } catch (writeError) {
+        return c.json({ error: `Failed to write file: ${writeError.message}` }, 500);
+      }
+    } catch (error) {
+      return c.json({ error: error.message }, 500);
+    }
+  });
+  app.get("/checkpoints/:checkpointId", (c) => {
+    const checkpointId = c.req.param("checkpointId");
+    const checkpoint = checkpointStore.getCheckpoint(checkpointId);
+    if (!checkpoint) {
+      return c.json({ error: "Checkpoint not found" }, 404);
+    }
+    return c.json({
+      id: checkpoint.id,
+      filePath: checkpoint.filePath,
+      beforeHash: checkpoint.beforeHash,
+      afterHash: checkpoint.afterHash,
+      timestamp: checkpoint.timestamp
+    });
+  });
+  app.get("/checkpoints", (c) => {
+    const stats = checkpointStore.getStats();
+    const checkpoints = checkpointStore.getAllCheckpoints().map((cp) => ({
+      id: cp.id,
+      filePath: cp.filePath,
+      beforeHash: cp.beforeHash,
+      afterHash: cp.afterHash,
+      timestamp: cp.timestamp
+    }));
+    return c.json({ stats, checkpoints });
+  });
   app.get("/projects", (c) => {
     const projects = projectRegistry.list();
     return c.json({ projects });
@@ -1423,7 +1674,7 @@ function saveTokens(tokens) {
       "utf8"
     );
   } catch (error) {
-    console.error(pc4__default.default.red("Failed to save credentials"), error);
+    console.error(pc5__default.default.red("Failed to save credentials"), error);
   }
 }
 function logout() {
@@ -1432,7 +1683,7 @@ function logout() {
       fs3__default.default.unlinkSync(CREDENTIALS_PATH);
     }
   } catch (error) {
-    console.error(pc4__default.default.red("Failed to logout"), error);
+    console.error(pc5__default.default.red("Failed to logout"), error);
   }
 }
 function getTokens() {
@@ -1507,27 +1758,27 @@ async function pollForTokens({
 async function login() {
   try {
     const device = await authorizeDevice();
-    console.log(pc4__default.default.bold("To sign in, follow these steps:"));
+    console.log(pc5__default.default.bold("To sign in, follow these steps:"));
     if (device.verification_uri_complete) {
       console.log(
-        `  1. Open this URL in your browser: ${pc4__default.default.cyan(
+        `  1. Open this URL in your browser: ${pc5__default.default.cyan(
           device.verification_uri_complete
         )}`
       );
     } else {
       console.log(
-        `  1. Open this URL in your browser: ${pc4__default.default.cyan(
+        `  1. Open this URL in your browser: ${pc5__default.default.cyan(
           device.verification_uri
         )}`
       );
       console.log(
-        `  2. Enter this code when prompted: ${pc4__default.default.bold(device.user_code)}`
+        `  2. Enter this code when prompted: ${pc5__default.default.bold(device.user_code)}`
       );
     }
     console.log("  3. Come back here; we will detect when you finish logging in.");
     console.log();
     console.log(
-      pc4__default.default.gray(
+      pc5__default.default.gray(
         `Waiting for authorization (expires in ~${Math.round(
           device.expires_in / 60
         )} minutes)...`
@@ -1539,14 +1790,28 @@ async function login() {
       expiresIn: device.expires_in,
       interval: device.interval
     });
-    console.log(pc4__default.default.green("Successfully authenticated!"));
+    console.log(pc5__default.default.green("Successfully authenticated!"));
     saveTokens(tokens);
     return tokens;
   } catch (error) {
-    console.error(pc4__default.default.red(error.message || "Login failed"));
+    console.error(pc5__default.default.red(error.message || "Login failed"));
     throw error;
   }
 }
+var getUserId = () => {
+  try {
+    if (!fs3__default.default.existsSync(CREDENTIALS_PATH)) {
+      return;
+    }
+    const raw = fs3__default.default.readFileSync(CREDENTIALS_PATH, "utf8");
+    const data = JSON.parse(raw);
+    return {
+      userId: data.user.id
+    };
+  } catch {
+    throw new Error("Error while getting userId");
+  }
+};
 var ExplanationSchema = zod.z.object({
   explanation: zod.z.string().describe("One sentence explanation as to why this tool is being used")
 });
@@ -1635,8 +1900,201 @@ var runTerminalCommand = async (input, projectCwd) => {
   }
 };
 
+// src/lib/rpc-handlers.ts
+var rpcHandlers = {
+  "daemon:get_workspace_folders": async () => {
+    const projects = projectRegistry.list();
+    return {
+      folders: projects.map((p) => ({
+        id: p.id,
+        cwd: p.cwd,
+        name: p.name,
+        active: p.active
+      }))
+    };
+  },
+  "daemon:get_environment": async ({ gitRepositoryUrl }) => {
+    const projects = projectRegistry.list();
+    if (projects.length === 0) {
+      const error = {
+        _tag: "ProjectUnlinkedError",
+        message: `Getting a local project by git repository URL "${gitRepositoryUrl}" returned an unlinked project. Please link it by running \`amai link <project name> <path to project directory>\``
+      };
+      throw error;
+    }
+    return {
+      project: projects[0],
+      env: {
+        platform: process.platform,
+        arch: process.arch,
+        nodeVersion: process.version
+      }
+    };
+  },
+  "daemon:get_context": async ({ cwd }) => {
+    try {
+      const files = getContext(cwd);
+      return { files, cwd };
+    } catch (error) {
+      const rpcError = {
+        _tag: "ContextError",
+        message: error.message || "Failed to get context"
+      };
+      throw rpcError;
+    }
+  },
+  "daemon:get_ide_projects": async () => {
+    const projects = await scanIdeProjects();
+    return { projects };
+  },
+  "daemon:register_project": async ({ projectId, cwd, name }) => {
+    if (!projectId || !cwd) {
+      const error = {
+        _tag: "ValidationError",
+        message: "projectId and cwd are required"
+      };
+      throw error;
+    }
+    projectRegistry.register(projectId, cwd, name);
+    return { success: true, projectId, cwd };
+  },
+  "daemon:unregister_project": async ({ projectId }) => {
+    if (!projectId) {
+      const error = {
+        _tag: "ValidationError",
+        message: "projectId is required"
+      };
+      throw error;
+    }
+    projectRegistry.unregister(projectId);
+    return { success: true, projectId };
+  },
+  "daemon:get_project": async ({ projectId }) => {
+    const project = projectRegistry.getProject(projectId);
+    if (!project) {
+      const error = {
+        _tag: "ProjectNotFoundError",
+        message: `Project not found: ${projectId}`
+      };
+      throw error;
+    }
+    return { project };
+  },
+  "daemon:list_projects": async () => {
+    const projects = projectRegistry.list();
+    return { projects };
+  },
+  "daemon:status": async () => {
+    return {
+      connected: true,
+      timestamp: Date.now(),
+      platform: process.platform,
+      arch: process.arch
+    };
+  }
+};
+var reconnectTimeout = null;
+var connectToUserStreams = async (serverUrl) => {
+  const userId = getUserId();
+  if (!userId?.userId) {
+    throw new Error("User ID not found");
+  }
+  const params = new URLSearchParams({
+    userId: userId.userId,
+    type: "cli"
+  });
+  const tokens = getTokens();
+  if (!tokens) {
+    throw new Error("No tokens found");
+  }
+  const wsUrl = `${serverUrl}/api/v1/user-streams?${params.toString()}`;
+  const ws = new WebSocket2__default.default(wsUrl, {
+    headers: {
+      Authorization: `Bearer ${tokens.access_token}`
+    }
+  });
+  ws.on("open", () => {
+    console.log(pc5__default.default.green("CLI connected to user-streams"));
+    if (reconnectTimeout) {
+      clearTimeout(reconnectTimeout);
+      reconnectTimeout = null;
+    }
+  });
+  ws.on("message", async (event) => {
+    try {
+      const message = JSON.parse(event.toString());
+      if (message._tag === "rpc_call") {
+        const { requestId, method, input } = message;
+        console.log(pc5__default.default.gray(`RPC call: ${method}`));
+        const handler = rpcHandlers[method];
+        if (!handler) {
+          ws.send(JSON.stringify({
+            _tag: "rpc_result",
+            requestId,
+            data: {
+              _tag: "UnknownMethodError",
+              message: `Unknown RPC method: ${method}`
+            }
+          }));
+          console.log(pc5__default.default.yellow(`Unknown RPC method: ${method}`));
+          return;
+        }
+        try {
+          const result = await handler(input || {});
+          ws.send(JSON.stringify({
+            _tag: "rpc_result",
+            requestId,
+            data: result
+          }));
+          console.log(pc5__default.default.green(`RPC completed: ${method}`));
+        } catch (error) {
+          const rpcError = error._tag ? error : {
+            _tag: "RpcError",
+            message: error.message || String(error)
+          };
+          ws.send(JSON.stringify({
+            _tag: "rpc_result",
+            requestId,
+            data: rpcError
+          }));
+          console.log(pc5__default.default.red(`RPC failed: ${method} - ${rpcError.message}`));
+        }
+        return;
+      }
+      if (message.type === "presence_request") {
+        if (message.status === "connected") {
+          ws.send(JSON.stringify({
+            type: "presence_request",
+            status: "connected"
+          }));
+        }
+        if (message.status === "disconnected") {
+          ws.send(JSON.stringify({
+            type: "presence_request",
+            status: "disconnected"
+          }));
+        }
+      }
+    } catch (parseError) {
+      console.error(pc5__default.default.red(`Failed to parse message: ${parseError}`));
+    }
+  });
+  ws.on("close", (code, reason) => {
+    console.log(pc5__default.default.yellow(`CLI disconnected from user-streams (code: ${code})`));
+    console.log(pc5__default.default.gray("Reconnecting in 5 seconds..."));
+    reconnectTimeout = setTimeout(() => {
+      connectToUserStreams(serverUrl).catch((err) => {
+        console.error(pc5__default.default.red(`Reconnection failed: ${err.message}`));
+      });
+    }, 5e3);
+  });
+  ws.on("error", (error) => {
+    console.error(pc5__default.default.red(`User streams WebSocket error: ${error.message}`));
+  });
+  return ws;
+};
+
 // src/server.ts
-var statusEmitter = new events.EventEmitter();
 var toolExecutors = {
   editFile: editFiles,
   deleteFile,
@@ -1648,7 +2106,7 @@ var toolExecutors = {
   runTerminalCommand
 };
 function getConnectionStatus(ws) {
-  return ws.readyState === WebSocket__default.default.CONNECTING ? "connecting" : ws.readyState === WebSocket__default.default.OPEN ? "open" : ws.readyState === WebSocket__default.default.CLOSING ? "closing" : "closed";
+  return ws.readyState === WebSocket2__default.default.CONNECTING ? "connecting" : ws.readyState === WebSocket2__default.default.OPEN ? "open" : ws.readyState === WebSocket2__default.default.CLOSING ? "closing" : "closed";
 }
 function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
   const tokens = getTokens();
@@ -1656,14 +2114,13 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
     throw new Error("No tokens found");
   }
   const wsUrl = `${serverUrl}/agent-streams`;
-  const ws = new WebSocket__default.default(wsUrl, {
+  const ws = new WebSocket2__default.default(wsUrl, {
     headers: {
       "Authorization": `Bearer ${tokens.access_token}`
     }
   });
   ws.on("open", () => {
-    console.log(pc4__default.default.green("Connected to server agent streams"));
-    statusEmitter.emit("status", { connected: true });
+    console.log(pc5__default.default.green("Connected to server agent streams"));
   });
   ws.on("message", async (data) => {
     const message = JSON.parse(data.toString());
@@ -1680,33 +2137,32 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
           id: message.id,
           result
         }));
-        console.log(pc4__default.default.green(`Tool completed: ${message.tool}`));
+        console.log(pc5__default.default.green(`Tool completed: ${message.tool}`));
       } catch (error) {
         ws.send(JSON.stringify({
           type: "tool_result",
           id: message.id,
           error: error.message
         }));
-        console.error(pc4__default.default.red(`Tool failed: ${message.tool} ${error.message}`));
+        console.error(pc5__default.default.red(`Tool failed: ${message.tool} ${error.message}`));
       }
     }
   });
   ws.on("close", () => {
-    console.log(pc4__default.default.red("Disconnected from server. Reconnecting in 5s..."));
-    statusEmitter.emit("status", { connected: false });
+    console.log(pc5__default.default.red("Disconnected from server. Reconnecting in 5s..."));
     setTimeout(() => connectToServer2(serverUrl), 5e3);
   });
   ws.on("error", (error) => {
-    console.error(pc4__default.default.red(`WebSocket error: ${error.message}`));
-    statusEmitter.emit("status", { connected: false });
+    console.error(pc5__default.default.red(`WebSocket error: ${error.message}`));
   });
   return ws;
 }
 async function main() {
   const serverUrl = DEFAULT_SERVER_URL;
-  console.log(pc4__default.default.green("Starting local amai..."));
-  console.log(pc4__default.default.gray(`Connecting to server at ${serverUrl}`));
+  console.log(pc5__default.default.green("Starting local amai..."));
+  console.log(pc5__default.default.gray(`Connecting to server at ${serverUrl}`));
   const connection = connectToServer2(serverUrl);
+  await connectToUserStreams(serverUrl);
   startHttpServer(connection);
 }
 var execAsync2 = util.promisify(child_process.exec);
@@ -1758,22 +2214,22 @@ async function installCodeServer() {
   if (!fs3__default.default.existsSync(STORAGE_DIR)) {
     fs3__default.default.mkdirSync(STORAGE_DIR, { recursive: true });
   }
-  console.log(pc4__default.default.cyan(`Downloading code-server v${CODE_SERVER_VERSION}...`));
-  console.log(pc4__default.default.gray(downloadUrl));
+  console.log(pc5__default.default.cyan(`Downloading code-server v${CODE_SERVER_VERSION}...`));
+  console.log(pc5__default.default.gray(downloadUrl));
   const response = await fetch(downloadUrl);
   if (!response.ok) {
     throw new Error(`Failed to download code-server: ${response.statusText}`);
   }
   const buffer = await response.arrayBuffer();
   await fs3__default.default.promises.writeFile(tarballPath, Buffer.from(buffer));
-  console.log(pc4__default.default.cyan("Extracting code-server..."));
+  console.log(pc5__default.default.cyan("Extracting code-server..."));
   await execAsync2(`tar -xzf ${tarballPath} -C ${CODE_DIR}`);
   await fs3__default.default.promises.unlink(tarballPath);
   const binPath = getCodeServerBin();
   if (fs3__default.default.existsSync(binPath)) {
     await fs3__default.default.promises.chmod(binPath, 493);
   }
-  console.log(pc4__default.default.green("\u2713 code-server installed successfully"));
+  console.log(pc5__default.default.green("\u2713 code-server installed successfully"));
 }
 async function killExistingCodeServer() {
   try {
@@ -1812,7 +2268,7 @@ async function startCodeServer(cwd) {
     }
   } catch {
   }
-  console.log(pc4__default.default.cyan(`Starting code-server in ${workDir}...`));
+  console.log(pc5__default.default.cyan(`Starting code-server in ${workDir}...`));
   const codeServer = child_process.spawn(
     binPath,
     [
@@ -1831,7 +2287,7 @@ async function startCodeServer(cwd) {
       stdio: ["ignore", "pipe", "pipe"]
     }
   );
-  console.log(pc4__default.default.green(`\u2713 code-server running at http://localhost:8081/?folder=${encodeURIComponent(workDir)}`));
+  console.log(pc5__default.default.green(`\u2713 code-server running at http://localhost:8081/?folder=${encodeURIComponent(workDir)}`));
   return codeServer;
 }
 var __filename$1 = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href)));
@@ -1895,7 +2351,7 @@ function getDaemonPid() {
     return null;
   }
 }
-var VERSION = "0.0.4";
+var VERSION = "0.0.6";
 var PROJECT_DIR = process.cwd();
 function promptUser(question) {
   const rl = readline__default.default.createInterface({
@@ -1911,19 +2367,19 @@ function promptUser(question) {
 }
 async function startWithCodeServer() {
   if (!isCodeServerInstalled()) {
-    console.log(pc4__default.default.cyan("First run detected. Setting up code-server..."));
+    console.log(pc5__default.default.cyan("First run detected. Setting up code-server..."));
     try {
       await installCodeServer();
     } catch (error) {
-      console.error(pc4__default.default.red(`Failed to install code-server: ${error.message}`));
-      console.log(pc4__default.default.yellow("Continuing without code-server..."));
+      console.error(pc5__default.default.red(`Failed to install code-server: ${error.message}`));
+      console.log(pc5__default.default.yellow("Continuing without code-server..."));
     }
   }
   if (isCodeServerInstalled()) {
     try {
       await startCodeServer(PROJECT_DIR);
     } catch (error) {
-      console.error(pc4__default.default.red(`Failed to start code-server: ${error.message}`));
+      console.error(pc5__default.default.red(`Failed to start code-server: ${error.message}`));
     }
   }
   main();
@@ -1931,7 +2387,7 @@ async function startWithCodeServer() {
 var args = process.argv.slice(2);
 if (args[0] === "--help" || args[0] === "-h") {
   console.log(`
-${pc4__default.default.bold("amai cli")} ${pc4__default.default.gray(VERSION)}
+${pc5__default.default.bold("amai cli")} ${pc5__default.default.gray(VERSION)}
 
 Usage: amai [command] [options]
 
@@ -1959,32 +2415,32 @@ Example:
 }
 if (args[0] === "start") {
   if (isDaemonRunning()) {
-    console.log(pc4__default.default.yellow("Daemon is already running"));
+    console.log(pc5__default.default.yellow("Daemon is already running"));
     process.exit(0);
   }
   if (!isAuthenticated()) {
-    console.log(pc4__default.default.yellow("Not authenticated. Please log in first."));
+    console.log(pc5__default.default.yellow("Not authenticated. Please log in first."));
     login().then(() => {
-      console.log(pc4__default.default.green("Starting daemon..."));
+      console.log(pc5__default.default.green("Starting daemon..."));
       startDaemon();
-      console.log(pc4__default.default.green("Daemon started successfully"));
+      console.log(pc5__default.default.green("Daemon started successfully"));
       process.exit(0);
     }).catch(() => {
-      console.error(pc4__default.default.red("Login failed. Cannot start daemon."));
+      console.error(pc5__default.default.red("Login failed. Cannot start daemon."));
       process.exit(1);
     });
   } else {
     startDaemon();
-    console.log(pc4__default.default.green(pc4__default.default.bold("amai started in background mode")));
-    console.log(pc4__default.default.gray(`Tip: You can check status any time with ${pc4__default.default.bold("amai status")}`));
+    console.log(pc5__default.default.green(pc5__default.default.bold("amai started in background mode")));
+    console.log(pc5__default.default.gray(`Tip: You can check status any time with ${pc5__default.default.bold("amai status")}`));
     process.exit(0);
   }
 }
 if (args[0] === "stop") {
   if (stopDaemon()) {
-    console.log(pc4__default.default.green("Daemon stopped successfully"));
+    console.log(pc5__default.default.green("Daemon stopped successfully"));
   } else {
-    console.log(pc4__default.default.yellow("Daemon was not running"));
+    console.log(pc5__default.default.yellow("Daemon was not running"));
   }
   process.exit(0);
 }
@@ -1992,9 +2448,9 @@ if (args[0] === "status") {
   const running = isDaemonRunning();
   const pid = getDaemonPid();
   if (running && pid) {
-    console.log(pc4__default.default.green(`Daemon is running (PID: ${pid})`));
+    console.log(pc5__default.default.green(`Daemon is running (PID: ${pid})`));
   } else {
-    console.log(pc4__default.default.yellow("Daemon is not running"));
+    console.log(pc5__default.default.yellow("Daemon is not running"));
   }
   process.exit(0);
 }
@@ -2002,36 +2458,36 @@ if (args[0] === "project") {
   if (args[1] === "add") {
     const projectPath = args[2];
     if (!projectPath) {
-      console.error(pc4__default.default.red("Please provide a project path"));
+      console.error(pc5__default.default.red("Please provide a project path"));
       console.log("Usage: amai project add <path>");
       process.exit(1);
     }
     const resolvedPath = path9__default.default.resolve(projectPath);
     if (!fs3__default.default.existsSync(resolvedPath)) {
-      console.error(pc4__default.default.red(`Path does not exist: ${resolvedPath}`));
+      console.error(pc5__default.default.red(`Path does not exist: ${resolvedPath}`));
       process.exit(1);
     }
     if (!fs3__default.default.statSync(resolvedPath).isDirectory()) {
-      console.error(pc4__default.default.red(`Path is not a directory: ${resolvedPath}`));
+      console.error(pc5__default.default.red(`Path is not a directory: ${resolvedPath}`));
       process.exit(1);
     }
     const projectId = path9__default.default.basename(resolvedPath);
     projectRegistry.register(projectId, resolvedPath);
-    console.log(pc4__default.default.green(`Project registered: ${projectId} -> ${resolvedPath}`));
+    console.log(pc5__default.default.green(`Project registered: ${projectId} -> ${resolvedPath}`));
     process.exit(0);
   } else if (args[1] === "list") {
     const projects = projectRegistry.list();
     if (projects.length === 0) {
-      console.log(pc4__default.default.yellow("No projects registered"));
+      console.log(pc5__default.default.yellow("No projects registered"));
     } else {
-      console.log(pc4__default.default.bold("Registered projects:"));
+      console.log(pc5__default.default.bold("Registered projects:"));
       projects.forEach((project) => {
-        console.log(`  ${pc4__default.default.cyan(project.id)}: ${project.cwd} ${project.active ? pc4__default.default.green("(active)") : ""}`);
+        console.log(`  ${pc5__default.default.cyan(project.id)}: ${project.cwd} ${project.active ? pc5__default.default.green("(active)") : ""}`);
       });
     }
     process.exit(0);
   } else {
-    console.error(pc4__default.default.red(`Unknown project command: ${args[1]}`));
+    console.error(pc5__default.default.red(`Unknown project command: ${args[1]}`));
     console.log('Use "amai project add <path>" or "amai project list"');
     process.exit(1);
   }
@@ -2040,39 +2496,39 @@ if (args[0] === "login" || args[0] === "--login") {
   login().then(() => process.exit(0)).catch(() => process.exit(1));
 } else if (args[0] === "logout" || args[0] === "--logout") {
   logout();
-  console.log(pc4__default.default.green("Logged out successfully"));
+  console.log(pc5__default.default.green("Logged out successfully"));
   process.exit(0);
 } else {
   (async () => {
     if (!isAuthenticated()) {
-      console.log(pc4__default.default.yellow("Not authenticated. Please log in first."));
+      console.log(pc5__default.default.yellow("Not authenticated. Please log in first."));
       try {
         await login();
       } catch {
-        console.error(pc4__default.default.red("Login failed. Cannot start server."));
+        console.error(pc5__default.default.red("Login failed. Cannot start server."));
         process.exit(1);
       }
     }
     if (isDaemonRunning()) {
-      console.log(pc4__default.default.yellow('Daemon is already running. Use "amai status" to check its status.'));
+      console.log(pc5__default.default.yellow('Daemon is already running. Use "amai status" to check its status.'));
       process.exit(0);
     }
     console.log("");
-    console.log(pc4__default.default.bold("How would you like to run amai?"));
-    console.log(pc4__default.default.gray("Background mode is highly recommended for better performance and stability."));
+    console.log(pc5__default.default.bold("How would you like to run amai?"));
+    console.log(pc5__default.default.gray("Background mode is highly recommended for better performance and stability."));
     const answer = await promptUser(
-      pc4__default.default.cyan("Run in background? (Y/n): ")
+      pc5__default.default.cyan("Run in background? (Y/n): ")
     );
     const runInBackground = answer === "" || answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
     if (runInBackground) {
-      console.log(pc4__default.default.green("Starting daemon in background..."));
+      console.log(pc5__default.default.green("Starting daemon in background..."));
       startDaemon();
-      console.log(pc4__default.default.green("Daemon started successfully!"));
-      console.log(pc4__default.default.gray('Use "amai status" to check daemon status.'));
-      console.log(pc4__default.default.gray('Use "amai stop" to stop the daemon.'));
+      console.log(pc5__default.default.green("Daemon started successfully!"));
+      console.log(pc5__default.default.gray('Use "amai status" to check daemon status.'));
+      console.log(pc5__default.default.gray('Use "amai stop" to stop the daemon.'));
       process.exit(0);
     } else {
-      console.log(pc4__default.default.yellow("Starting in foreground mode..."));
+      console.log(pc5__default.default.yellow("Starting in foreground mode..."));
       startWithCodeServer();
     }
   })();