amai 0.0.5 → 0.0.6

package/dist/lib/daemon-entry.cjs

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 'use strict';
 
-var WebSocket = require('ws');
-var events = require('events');
+var WebSocket2 = require('ws');
 var zod = require('zod');
 var promises = require('fs/promises');
 var path9 = require('path');
@@ -18,7 +17,7 @@ var cors = require('hono/cors');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var WebSocket__default = /*#__PURE__*/_interopDefault(WebSocket);
+var WebSocket2__default = /*#__PURE__*/_interopDefault(WebSocket2);
 var path9__default = /*#__PURE__*/_interopDefault(path9);
 var fs3__default = /*#__PURE__*/_interopDefault(fs3);
 var os2__default = /*#__PURE__*/_interopDefault(os2);
@@ -1421,15 +1420,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";
@@ -1440,7 +1430,6 @@ var startHttpServer = (connection) => {
           }
         }, 15e3);
         c.req.raw.signal.addEventListener("abort", () => {
-          statusEmitter.off("status", statusHandler);
           clearInterval(heartbeatInterval);
         });
       }
@@ -1664,6 +1653,20 @@ function getTokens() {
   const data = JSON.parse(raw);
   return data;
 }
+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")
 });
@@ -1752,8 +1755,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(pc2__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(pc2__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(pc2__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(pc2__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(pc2__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(pc2__default.default.red(`Failed to parse message: ${parseError}`));
+    }
+  });
+  ws.on("close", (code, reason) => {
+    console.log(pc2__default.default.yellow(`CLI disconnected from user-streams (code: ${code})`));
+    console.log(pc2__default.default.gray("Reconnecting in 5 seconds..."));
+    reconnectTimeout = setTimeout(() => {
+      connectToUserStreams(serverUrl).catch((err) => {
+        console.error(pc2__default.default.red(`Reconnection failed: ${err.message}`));
+      });
+    }, 5e3);
+  });
+  ws.on("error", (error) => {
+    console.error(pc2__default.default.red(`User streams WebSocket error: ${error.message}`));
+  });
+  return ws;
+};
+
 // src/server.ts
-var statusEmitter = new events.EventEmitter();
 var toolExecutors = {
   editFile: editFiles,
   deleteFile,
@@ -1765,7 +1961,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();
@@ -1773,14 +1969,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(pc2__default.default.green("Connected to server agent streams"));
-    statusEmitter.emit("status", { connected: true });
   });
   ws.on("message", async (data) => {
     const message = JSON.parse(data.toString());
@@ -1810,12 +2005,10 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
   });
   ws.on("close", () => {
     console.log(pc2__default.default.red("Disconnected from server. Reconnecting in 5s..."));
-    statusEmitter.emit("status", { connected: false });
     setTimeout(() => connectToServer2(serverUrl), 5e3);
   });
   ws.on("error", (error) => {
     console.error(pc2__default.default.red(`WebSocket error: ${error.message}`));
-    statusEmitter.emit("status", { connected: false });
   });
   return ws;
 }
@@ -1824,6 +2017,7 @@ async function main() {
   console.log(pc2__default.default.green("Starting local amai..."));
   console.log(pc2__default.default.gray(`Connecting to server at ${serverUrl}`));
   const connection = connectToServer2(serverUrl);
+  await connectToUserStreams(serverUrl);
   startHttpServer(connection);
 }
 var execAsync2 = util.promisify(child_process.exec);

package/dist/lib/daemon-entry.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
-import WebSocket from 'ws';
-import { EventEmitter } from 'events';
+import WebSocket2 from 'ws';
 import { z } from 'zod';
 import { readFile, writeFile, stat, access, readdir, glob, unlink, mkdir } from 'fs/promises';
 import path9 from 'path';
@@ -1411,15 +1410,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";
@@ -1430,7 +1420,6 @@ var startHttpServer = (connection) => {
           }
         }, 15e3);
         c.req.raw.signal.addEventListener("abort", () => {
-          statusEmitter.off("status", statusHandler);
           clearInterval(heartbeatInterval);
         });
       }
@@ -1654,6 +1643,20 @@ function getTokens() {
   const data = JSON.parse(raw);
   return data;
 }
+var getUserId = () => {
+  try {
+    if (!fs3.existsSync(CREDENTIALS_PATH)) {
+      return;
+    }
+    const raw = fs3.readFileSync(CREDENTIALS_PATH, "utf8");
+    const data = JSON.parse(raw);
+    return {
+      userId: data.user.id
+    };
+  } catch {
+    throw new Error("Error while getting userId");
+  }
+};
 var ExplanationSchema = z.object({
   explanation: z.string().describe("One sentence explanation as to why this tool is being used")
 });
@@ -1742,8 +1745,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(wsUrl, {
+    headers: {
+      Authorization: `Bearer ${tokens.access_token}`
+    }
+  });
+  ws.on("open", () => {
+    console.log(pc2.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(pc2.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(pc2.yellow(`Unknown RPC method: ${method}`));
+          return;
+        }
+        try {
+          const result = await handler(input || {});
+          ws.send(JSON.stringify({
+            _tag: "rpc_result",
+            requestId,
+            data: result
+          }));
+          console.log(pc2.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(pc2.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(pc2.red(`Failed to parse message: ${parseError}`));
+    }
+  });
+  ws.on("close", (code, reason) => {
+    console.log(pc2.yellow(`CLI disconnected from user-streams (code: ${code})`));
+    console.log(pc2.gray("Reconnecting in 5 seconds..."));
+    reconnectTimeout = setTimeout(() => {
+      connectToUserStreams(serverUrl).catch((err) => {
+        console.error(pc2.red(`Reconnection failed: ${err.message}`));
+      });
+    }, 5e3);
+  });
+  ws.on("error", (error) => {
+    console.error(pc2.red(`User streams WebSocket error: ${error.message}`));
+  });
+  return ws;
+};
+
 // src/server.ts
-var statusEmitter = new EventEmitter();
 var toolExecutors = {
   editFile: editFiles,
   deleteFile,
@@ -1755,7 +1951,7 @@ var toolExecutors = {
   runTerminalCommand
 };
 function getConnectionStatus(ws) {
-  return ws.readyState === WebSocket.CONNECTING ? "connecting" : ws.readyState === WebSocket.OPEN ? "open" : ws.readyState === WebSocket.CLOSING ? "closing" : "closed";
+  return ws.readyState === WebSocket2.CONNECTING ? "connecting" : ws.readyState === WebSocket2.OPEN ? "open" : ws.readyState === WebSocket2.CLOSING ? "closing" : "closed";
 }
 function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
   const tokens = getTokens();
@@ -1763,14 +1959,13 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
     throw new Error("No tokens found");
   }
   const wsUrl = `${serverUrl}/agent-streams`;
-  const ws = new WebSocket(wsUrl, {
+  const ws = new WebSocket2(wsUrl, {
     headers: {
       "Authorization": `Bearer ${tokens.access_token}`
     }
   });
   ws.on("open", () => {
     console.log(pc2.green("Connected to server agent streams"));
-    statusEmitter.emit("status", { connected: true });
   });
   ws.on("message", async (data) => {
     const message = JSON.parse(data.toString());
@@ -1800,12 +1995,10 @@ function connectToServer2(serverUrl = DEFAULT_SERVER_URL) {
   });
   ws.on("close", () => {
     console.log(pc2.red("Disconnected from server. Reconnecting in 5s..."));
-    statusEmitter.emit("status", { connected: false });
     setTimeout(() => connectToServer2(serverUrl), 5e3);
   });
   ws.on("error", (error) => {
     console.error(pc2.red(`WebSocket error: ${error.message}`));
-    statusEmitter.emit("status", { connected: false });
   });
   return ws;
 }
@@ -1814,6 +2007,7 @@ async function main() {
   console.log(pc2.green("Starting local amai..."));
   console.log(pc2.gray(`Connecting to server at ${serverUrl}`));
   const connection = connectToServer2(serverUrl);
+  await connectToUserStreams(serverUrl);
   startHttpServer(connection);
 }
 var execAsync2 = promisify(exec);