heyatlas 1.2.2 → 1.3.3

package/dist/cli.js

@@ -5496,7 +5496,7 @@ var DEFAULT_HOST = "agent.heyatlas.app";
 class AtlasTunnel {
   client = null;
   options;
-  agentId = "heyatlas-cli";
+  agentId = "local";
   currentUserId = null;
   seenTaskIds = new Set;
   taskCallback = null;
@@ -52114,9 +52114,9 @@ _a153 = symbol153;
 // agents/acp-provider.ts
 var ACP_COMMANDS = {
   opencode: { command: "opencode", args: ["acp"] },
-  claude: { command: "claude-code-acp", args: [] },
+  "claude-code": { command: "claude-code-acp", args: [] },
   goose: { command: "goose", args: ["acp"] },
-  gemini: { command: "gemini", args: ["--experimental-acp"] },
+  "gemini-code": { command: "gemini", args: ["--experimental-acp"] },
   codex: { command: "npx", args: ["@zed-industries/codex-acp"] },
   kimi: { command: "kimi", args: ["--acp"] },
   vibe: { command: "vibe-acp", args: [] },
@@ -52199,17 +52199,259 @@ class ACPProviderAgent {
   }
 }
 
+// agents/config.ts
+function isHTTPAgent(agent) {
+  return agent === "agent-smith-py";
+}
+
+// agents/http-agent.ts
+import { spawn as spawn2 } from "child_process";
+var HTTP_AGENT_CONFIG = {
+  "agent-smith-py": {
+    command: "uv",
+    args: ["run", "python", "main.py"],
+    port: 3141,
+    healthPath: "/health",
+    taskPath: "/agents/agent-smith/text",
+    streamPath: "/agents/agent-smith/stream",
+    cwd: "desktop-sandbox/agent-smith-py"
+  }
+};
+
+class HTTPAgent {
+  agentType;
+  options;
+  process = null;
+  baseUrl;
+  config;
+  constructor(agentType, options = {}) {
+    this.agentType = agentType;
+    this.options = options;
+    this.config = HTTP_AGENT_CONFIG[agentType];
+    this.baseUrl = `http://localhost:${this.config.port}`;
+  }
+  get name() {
+    return this.agentType;
+  }
+  get port() {
+    return this.config.port;
+  }
+  async isAvailable() {
+    try {
+      const { promisify } = await import("node:util");
+      const exec = promisify((await import("node:child_process")).exec);
+      await exec("which uv || where uv");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async start() {
+    const env = {
+      ...process.env,
+      PYTHONUNBUFFERED: "1"
+    };
+    const cwd = this.config.cwd ? `${this.options.cwd || process.cwd()}/${this.config.cwd}` : this.options.cwd || process.cwd();
+    this.process = spawn2(this.config.command, [...this.config.args, "--port", String(this.config.port)], {
+      cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.process.stdout?.on("data", (data) => {
+      console.log(`[${this.agentType}] ${data.toString().trim()}`);
+    });
+    this.process.stderr?.on("data", (data) => {
+      console.error(`[${this.agentType}] ${data.toString().trim()}`);
+    });
+    await this.waitForReady();
+  }
+  async waitForReady(maxAttempts = 30) {
+    const delay2 = (ms) => new Promise((r) => setTimeout(r, ms));
+    for (let i = 0;i < maxAttempts; i++) {
+      try {
+        const response = await fetch(`${this.baseUrl}${this.config.healthPath}`);
+        if (response.ok) {
+          return;
+        }
+      } catch {}
+      await delay2(1000);
+    }
+    throw new Error(`Agent ${this.agentType} failed to start after ${maxAttempts}s`);
+  }
+  async executeTask(prompt, taskId) {
+    const response = await fetch(`${this.baseUrl}${this.config.taskPath}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ prompt, task_id: taskId })
+    });
+    if (!response.ok) {
+      throw new Error(`Task failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async* executeTaskStream(prompt, taskId) {
+    const response = await fetch(`${this.baseUrl}${this.config.streamPath}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ prompt, task_id: taskId })
+    });
+    if (!response.ok) {
+      throw new Error(`Stream failed: ${response.statusText}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder;
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          try {
+            const event = JSON.parse(line.slice(6));
+            yield event;
+          } catch {}
+        }
+      }
+    }
+  }
+  stop() {
+    if (this.process) {
+      this.process.kill("SIGTERM");
+      this.process = null;
+    }
+  }
+}
+
 // commands/connect.ts
 async function connect(agentType, options = {}) {
   const credentials = await login();
-  if (!isACPAgent(agentType)) {
-    console.error(`Error: Agent '${agentType}' is not ACP-compatible`);
-    console.error(`Supported agents: opencode, claude, goose, gemini, codex, etc.`);
+  if (isHTTPAgent(agentType)) {
+    return connectHTTPAgent(agentType, credentials, options);
+  }
+  if (isACPAgent(agentType)) {
+    return connectACPAgent(agentType, credentials, options);
+  }
+  console.error(`Error: Unknown agent type '${agentType}'`);
+  process.exit(1);
+}
+async function connectHTTPAgent(agentType, credentials, options) {
+  const agent = new HTTPAgent(agentType, { cwd: process.cwd() });
+  const available = await agent.isAvailable();
+  if (!available) {
+    console.error(`Error: Python not found. Install Python 3.11+ to use ${agentType}`);
+    process.exit(1);
+  }
+  console.log(`Agent: ${agentType} (HTTP mode)`);
+  try {
+    console.log("Starting agent server...");
+    await agent.start();
+    console.log(`Agent server running on port ${agent.port}`);
+  } catch (error87) {
+    console.error(`Failed to start agent: ${error87}`);
     process.exit(1);
   }
-  const agent = new ACPProviderAgent(agentType, {
-    cwd: process.cwd()
+  const tunnel = new AtlasTunnel({
+    host: process.env.ATLAS_AGENT_HOST || "agent.heyatlas.app",
+    token: credentials.accessToken,
+    interactive: true
   });
+  tunnel.onNewTask(async (task) => {
+    const prompt = task.description || "Hello";
+    console.log(`Task: ${prompt.slice(0, 50)}...`);
+    await tunnel.updateTask(task.id, { state: "in-progress" });
+    await tunnel.appendContext(task.id, [
+      {
+        type: "message",
+        timestamp: Date.now(),
+        data: { role: "user", content: prompt }
+      }
+    ]);
+    await tunnel.broadcastTaskEvent(task.id, {
+      type: "workforce_event",
+      timestamp: Date.now(),
+      data: { event_type: "task_started", task_content: prompt }
+    });
+    try {
+      let finalResult = "Task completed";
+      let finalStatus = "completed";
+      const parts = [];
+      for await (const event of agent.executeTaskStream(prompt, task.id)) {
+        await tunnel.broadcastTaskEvent(task.id, {
+          type: "workforce_event",
+          timestamp: Date.now(),
+          data: event
+        });
+        if (event.event_type === "result") {
+          finalResult = event.result || event.error || "Task completed";
+          finalStatus = event.status || "completed";
+        }
+        if (event.event_type === "task_assigned") {
+          console.log(`  → Assigned to: ${event.worker_name?.slice(0, 40)}...`);
+        } else if (event.event_type === "task_decomposed") {
+          console.log(`  → Decomposed into ${event.subtasks?.length || 0} subtasks`);
+        }
+      }
+      await tunnel.appendContext(task.id, [
+        {
+          type: "ui_message",
+          timestamp: Date.now(),
+          data: {
+            id: crypto.randomUUID(),
+            role: "assistant",
+            parts: [{ type: "text", text: finalResult }]
+          }
+        }
+      ]);
+      await tunnel.updateTask(task.id, {
+        state: finalStatus === "completed" ? "completed" : "failed",
+        result: finalResult
+      });
+      console.log(`Task ${finalStatus}`);
+    } catch (error87) {
+      console.error(`Task failed: ${error87}`);
+      await tunnel.updateTask(task.id, {
+        state: "failed",
+        result: String(error87)
+      });
+    }
+  });
+  await tunnel.connect(credentials.userId, agentType);
+  console.log("Tunnel established");
+  const voiceUrl = `${process.env.HEYATLAS_API || "https://heyatlas.app"}/chat`;
+  if (options.openBrowser !== false) {
+    try {
+      const { execSync } = await import("child_process");
+      const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? 'start ""' : "xdg-open";
+      execSync(`${cmd} "${voiceUrl}"`, { stdio: "ignore" });
+    } catch {}
+  }
+  console.log(`
+HeyAtlas connected to ${agentType}`);
+  console.log(`Continue here: ${voiceUrl}`);
+  console.log(`
+Press Ctrl+C to disconnect
+`);
+  process.on("SIGINT", async () => {
+    console.log(`
+Disconnecting...
+`);
+    agent.stop();
+    await tunnel.disconnect();
+    process.exit(0);
+  });
+  await new Promise(() => {});
+}
+async function connectACPAgent(agentType, credentials, options) {
+  const agent = new ACPProviderAgent(agentType, { cwd: process.cwd() });
   const available = await agent.isAvailable();
   if (!available) {
     const cmd = getACPCommand(agentType);
@@ -52220,7 +52462,7 @@ async function connect(agentType, options = {}) {
   console.log(`Agent: ${agentType} (via ACP AI Provider)`);
   try {
     await agent.init();
-    console.log(`ACP provider initialized`);
+    console.log("ACP provider initialized");
   } catch (error87) {
     console.error(`Failed to initialize agent: ${error87}`);
     process.exit(1);
@@ -52269,49 +52511,56 @@ async function connect(agentType, options = {}) {
               text: "",
               state: "streaming"
             };
-            activeReasoningParts.set(chunk.id, reasoningPart);
+            activeReasoningParts.set(chunk.id || "default", reasoningPart);
             parts.push(reasoningPart);
             break;
           }
-          case "reasoning-delta": {
-            const reasoningPart = activeReasoningParts.get(chunk.id);
-            if (reasoningPart && "text" in reasoningPart) {
-              reasoningPart.text += chunk.delta || "";
+          case "reasoning-delta":
+          case "reasoning": {
+            const id = chunk.id || "default";
+            let reasoningPart = activeReasoningParts.get(id);
+            if (!reasoningPart) {
+              reasoningPart = { type: "reasoning", text: "", state: "streaming" };
+              activeReasoningParts.set(id, reasoningPart);
+              parts.push(reasoningPart);
             }
+            reasoningPart.text += chunk.delta || chunk.text || "";
             break;
           }
           case "reasoning-end": {
-            const reasoningPart = activeReasoningParts.get(chunk.id);
+            const id = chunk.id || "default";
+            const reasoningPart = activeReasoningParts.get(id);
             if (reasoningPart) {
               reasoningPart.state = "done";
-              activeReasoningParts.delete(chunk.id);
+              activeReasoningParts.delete(id);
             }
             break;
           }
-          case "tool-input-available":
+          case "tool-input-available": {
+            const input = chunk.input;
+            const realToolName = input?.toolName || chunk.toolName;
+            const realArgs = input?.args || input || {};
             toolCalls.set(chunk.toolCallId, {
               type: "dynamic-tool",
               toolCallId: chunk.toolCallId,
-              toolName: chunk.toolName,
+              toolName: realToolName,
               state: "input-available",
-              input: chunk.input
+              input: realArgs
             });
             parts.push(toolCalls.get(chunk.toolCallId));
             break;
-          case "tool-output-available":
+          }
+          case "tool-output-available": {
             const existing = toolCalls.get(chunk.toolCallId);
             if (existing) {
-              const updated = {
-                ...existing,
-                state: "output-available",
-                output: chunk.output
-              };
+              const updated = { ...existing, state: "output-available", output: chunk.output };
               toolCalls.set(chunk.toolCallId, updated);
               const idx = parts.findIndex((p) => p.type === "dynamic-tool" && p.toolCallId === chunk.toolCallId);
               if (idx >= 0)
                 parts[idx] = updated;
             }
             break;
+          }
         }
       }
       if (parts.length > 0) {
@@ -52319,29 +52568,19 @@ async function connect(agentType, options = {}) {
           {
             type: "ui_message",
             timestamp: Date.now(),
-            data: {
-              id: crypto.randomUUID(),
-              role: "assistant",
-              parts
-            }
+            data: { id: crypto.randomUUID(), role: "assistant", parts }
           }
         ]);
       }
-      await tunnel.updateTask(task.id, {
-        state: "completed",
-        result: "end_turn"
-      });
-      console.log(`Task completed`);
+      await tunnel.updateTask(task.id, { state: "completed", result: "end_turn" });
+      console.log("Task completed");
     } catch (error87) {
       console.error(`Task failed: ${error87}`);
-      await tunnel.updateTask(task.id, {
-        state: "failed",
-        result: String(error87)
-      });
+      await tunnel.updateTask(task.id, { state: "failed", result: String(error87) });
     }
   });
   await tunnel.connect(credentials.userId, agentType);
-  console.log(`Tunnel established`);
+  console.log("Tunnel established");
   const voiceUrl = `${process.env.HEYATLAS_API || "https://heyatlas.app"}/chat`;
   if (options.openBrowser !== false) {
     try {
@@ -52386,10 +52625,7 @@ function buildPromptWithContext(task) {
     } else if (e.type === "message" && e.data) {
       const data = e.data;
       if (data.role && data.content) {
-        messages.push({
-          role: String(data.role),
-          content: String(data.content)
-        });
+        messages.push({ role: String(data.role), content: String(data.content) });
       }
     } else if (e.role && e.content) {
       messages.push({ role: String(e.role), content: String(e.content) });
@@ -52421,11 +52657,11 @@ Please continue based on the above context.`;
 }
 
 // index.ts
-var SUPPORTED_AGENTS = [
+var ACP_AGENTS = [
   "opencode",
-  "claude",
+  "claude-code",
   "goose",
-  "gemini",
+  "gemini-code",
   "codex",
   "kimi",
   "vibe",
@@ -52434,6 +52670,8 @@ var SUPPORTED_AGENTS = [
   "openhands",
   "cagent"
 ];
+var HTTP_AGENTS = ["agent-smith-py"];
+var SUPPORTED_AGENTS = [...ACP_AGENTS, ...HTTP_AGENTS];
 var { positionals, values } = parseArgs({
   args: process.argv.slice(2),
   options: {
@@ -52445,27 +52683,23 @@ var { positionals, values } = parseArgs({
 });
 function printHelp() {
   console.log(`
-heyatlas - Tunnel local AI agents to the cloud via ACP
+heyatlas - Tunnel local AI agents to the cloud
 
 Usage:
-  heyatlas connect <agent>    Connect agent to Atlas (via ACP protocol)
+  heyatlas connect <agent>    Connect agent to Atlas
 
-ACP-Compatible Agents:
-  ${SUPPORTED_AGENTS.join(", ")}
+Supported Agents:
+  ACP Agents:    ${ACP_AGENTS.join(", ")}
+  HTTP Agents:   ${HTTP_AGENTS.join(", ")}
 
 Options:
   -h, --help        Show this help message
   -v, --version     Show version
   --no-browser      Don't open browser automatically
 
-Prerequisites:
-  - The agent must be installed and support ACP mode
-  - Agent-specific setup (API keys, etc.)
-
 Examples:
-  heyatlas connect opencode   Connect OpenCode via ACP
-  heyatlas connect goose      Connect Goose via ACP
-  heyatlas connect claude     Connect Claude Code via ACP
+  heyatlas connect opencode         Connect OpenCode via ACP
+  heyatlas connect agent-smith-py   Connect Agent Smith (CAMEL-AI workforce)
 `);
 }
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heyatlas",
-  "version": "1.2.2",
+  "version": "1.3.3",
   "description": "Tunnel local AI agents to the cloud for voice-powered interactions",
   "author": "Bishwendu Kundu <bishwenduk029@gmail.com>",
   "license": "MIT",