heyatlas 1.3.3 → 1.3.5

package/dist/cli.js

@@ -4815,6 +4815,15 @@ async function pollForToken(deviceCode, interval) {
   }
 }
 async function login() {
+  const envToken = process.env.HEYATLAS_ACCESS_TOKEN;
+  const envUserId = process.env.HEYATLAS_USER_ID;
+  if (envToken && envUserId) {
+    return {
+      accessToken: envToken,
+      userId: envUserId,
+      email: "sandbox@heyatlas.app"
+    };
+  }
   const existing = loadCredentials();
   if (existing) {
     return existing;
@@ -52200,104 +52209,148 @@ class ACPProviderAgent {
 }
 
 // agents/config.ts
-function isHTTPAgent(agent) {
-  return agent === "agent-smith-py";
+function isSmith(agent) {
+  return agent === "smith";
 }
 
-// agents/http-agent.ts
+// agents/smith.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;
+var SANDBOX_BUNDLE_PATH = "/home/user/agents/agent-smith.cjs";
+var SMITH_CONFIG = {
+  port: 3141,
+  agentId: "workflow-orchestrator",
+  healthPath: "/agents",
+  chatPath: "/agents/workflow-orchestrator/chat",
+  command: "npx",
+  args: ["tsx", "src/index.ts"],
+  cwd: "smith",
+  sandboxCommand: "node",
+  sandboxArgs: [SANDBOX_BUNDLE_PATH]
+};
+
+class Smith {
   options;
-  process = null;
   baseUrl;
-  config;
-  constructor(agentType, options = {}) {
-    this.agentType = agentType;
+  process = null;
+  constructor(options = {}) {
     this.options = options;
-    this.config = HTTP_AGENT_CONFIG[agentType];
-    this.baseUrl = `http://localhost:${this.config.port}`;
+    this.baseUrl = `http://localhost:${SMITH_CONFIG.port}`;
   }
   get name() {
-    return this.agentType;
+    return "smith";
+  }
+  get agentId() {
+    return SMITH_CONFIG.agentId;
   }
   get port() {
-    return this.config.port;
+    return SMITH_CONFIG.port;
+  }
+  async isRunning() {
+    try {
+      const response = await fetch(`${this.baseUrl}${SMITH_CONFIG.healthPath}`, {
+        method: "GET",
+        signal: AbortSignal.timeout(2000)
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
   }
   async isAvailable() {
     try {
       const { promisify } = await import("node:util");
       const exec = promisify((await import("node:child_process")).exec);
-      await exec("which uv || where uv");
+      await exec("which npx || where npx");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async isSandboxMode() {
+    try {
+      const fs = await import("node:fs/promises");
+      await fs.access(SANDBOX_BUNDLE_PATH);
       return true;
     } catch {
       return false;
     }
   }
   async start() {
+    if (await this.isRunning()) {
+      console.log(`[smith] Server already running on port ${SMITH_CONFIG.port}`);
+      return;
+    }
+    const isSandbox = await this.isSandboxMode();
+    let command;
+    let args;
+    let cwd;
+    if (isSandbox) {
+      command = SMITH_CONFIG.sandboxCommand;
+      args = SMITH_CONFIG.sandboxArgs;
+      cwd = "/home/user/agents";
+      console.log(`[smith] Running in sandbox mode with pre-built bundle`);
+    } else {
+      const baseCwd = this.options.cwd || process.cwd();
+      const path = await import("node:path");
+      const fs = await import("node:fs/promises");
+      let smithPath = path.join(baseCwd, SMITH_CONFIG.cwd);
+      try {
+        await fs.access(smithPath);
+      } catch {
+        smithPath = path.join(baseCwd, "..", SMITH_CONFIG.cwd);
+      }
+      command = SMITH_CONFIG.command;
+      args = SMITH_CONFIG.args;
+      cwd = smithPath;
+      console.log(`[smith] Running in development mode from: ${cwd}`);
+    }
     const env = {
       ...process.env,
-      PYTHONUNBUFFERED: "1"
+      PORT: String(SMITH_CONFIG.port)
     };
-    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)], {
+    this.process = spawn2(command, args, {
       cwd,
       env,
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: true
     });
     this.process.stdout?.on("data", (data) => {
-      console.log(`[${this.agentType}] ${data.toString().trim()}`);
+      console.log(`[smith] ${data.toString().trim()}`);
     });
     this.process.stderr?.on("data", (data) => {
-      console.error(`[${this.agentType}] ${data.toString().trim()}`);
+      console.error(`[smith] ${data.toString().trim()}`);
+    });
+    this.process.on("error", (err) => {
+      console.error(`[smith] Process error:`, err.message);
     });
     await this.waitForReady();
   }
-  async waitForReady(maxAttempts = 30) {
+  async waitForReady(maxAttempts = 60) {
     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 {}
+      if (await this.isRunning()) {
+        return;
+      }
       await delay2(1000);
     }
-    throw new Error(`Agent ${this.agentType} failed to start after ${maxAttempts}s`);
+    throw new Error(`Smith 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}`);
+  stop() {
+    if (this.process) {
+      this.process.kill("SIGTERM");
+      this.process = null;
     }
-    const data = await response.json();
-    return data;
   }
-  async* executeTaskStream(prompt, taskId) {
-    const response = await fetch(`${this.baseUrl}${this.config.streamPath}`, {
+  async* streamChat(prompt) {
+    const response = await fetch(`${this.baseUrl}${SMITH_CONFIG.chatPath}`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ prompt, task_id: taskId })
+      body: JSON.stringify({
+        messages: [{ role: "user", content: prompt }]
+      })
     });
     if (!response.ok) {
-      throw new Error(`Stream failed: ${response.statusText}`);
+      throw new Error(`Chat request failed: ${response.statusText}`);
     }
     const reader = response.body?.getReader();
     if (!reader) {
@@ -52314,28 +52367,32 @@ class HTTPAgent {
 `);
       buffer = lines.pop() || "";
       for (const line of lines) {
-        if (line.startsWith("data: ")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+          continue;
+        let jsonStr = null;
+        if (trimmed.startsWith("data: ")) {
+          jsonStr = trimmed.slice(6);
+        } else if (/^\d+:/.test(trimmed)) {
+          const colonIndex = trimmed.indexOf(":");
+          jsonStr = trimmed.slice(colonIndex + 1);
+        }
+        if (jsonStr && jsonStr !== "[DONE]") {
           try {
-            const event = JSON.parse(line.slice(6));
+            const event = JSON.parse(jsonStr);
             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 (isHTTPAgent(agentType)) {
-    return connectHTTPAgent(agentType, credentials, options);
+  if (isSmith(agentType)) {
+    return connectSmith(credentials, options);
   }
   if (isACPAgent(agentType)) {
     return connectACPAgent(agentType, credentials, options);
@@ -52343,18 +52400,18 @@ async function connect(agentType, 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() });
+async function connectSmith(credentials, options) {
+  const agent = new Smith({ cwd: process.cwd() });
   const available = await agent.isAvailable();
   if (!available) {
-    console.error(`Error: Python not found. Install Python 3.11+ to use ${agentType}`);
+    console.error("Error: npx not found. Install Node.js to use smith");
     process.exit(1);
   }
-  console.log(`Agent: ${agentType} (HTTP mode)`);
+  console.log("Agent: smith");
   try {
-    console.log("Starting agent server...");
+    console.log("Starting smith server...");
     await agent.start();
-    console.log(`Agent server running on port ${agent.port}`);
+    console.log(`Smith server running on port ${agent.port}`);
   } catch (error87) {
     console.error(`Failed to start agent: ${error87}`);
     process.exit(1);
@@ -52365,66 +52422,113 @@ async function connectHTTPAgent(agentType, credentials, options) {
     interactive: true
   });
   tunnel.onNewTask(async (task) => {
-    const prompt = task.description || "Hello";
-    console.log(`Task: ${prompt.slice(0, 50)}...`);
+    const { prompt, latestUserMessage } = buildPromptWithContext(task);
+    const isNewTask = task.state === "new";
+    console.log(`${isNewTask ? "New" : "Continue"}: ${latestUserMessage.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 }
+        data: { role: "user", content: latestUserMessage }
       }
     ]);
-    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)) {
+      const toolCalls = new Map;
+      const activeReasoningParts = new Map;
+      for await (const chunk of agent.streamChat(prompt)) {
         await tunnel.broadcastTaskEvent(task.id, {
-          type: "workforce_event",
+          type: "ui_stream_chunk",
           timestamp: Date.now(),
-          data: event
+          data: chunk
         });
-        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`);
+        switch (chunk.type) {
+          case "text-delta": {
+            const existingText = parts.find((p) => p.type === "text");
+            if (existingText && "text" in existingText) {
+              existingText.text += chunk.delta || "";
+            } else {
+              parts.push({ type: "text", text: chunk.delta || "" });
+            }
+            break;
+          }
+          case "reasoning-start": {
+            const reasoningPart = {
+              type: "reasoning",
+              text: "",
+              state: "streaming"
+            };
+            activeReasoningParts.set(chunk.id || "default", reasoningPart);
+            parts.push(reasoningPart);
+            break;
+          }
+          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 id = chunk.id || "default";
+            const reasoningPart = activeReasoningParts.get(id);
+            if (reasoningPart) {
+              reasoningPart.state = "done";
+              activeReasoningParts.delete(id);
+            }
+            break;
+          }
+          case "tool-input-available": {
+            const input = chunk.input;
+            const realToolName = input?.toolName || chunk.toolName || "tool";
+            const realArgs = input?.args || input || {};
+            toolCalls.set(chunk.toolCallId || "", {
+              type: "dynamic-tool",
+              toolCallId: chunk.toolCallId,
+              toolName: realToolName,
+              state: "input-available",
+              input: realArgs,
+              subAgentName: chunk.subAgentName
+            });
+            parts.push(toolCalls.get(chunk.toolCallId || ""));
+            break;
+          }
+          case "tool-output-available": {
+            const existing = toolCalls.get(chunk.toolCallId || "");
+            if (existing) {
+              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;
+          }
         }
       }
-      await tunnel.appendContext(task.id, [
-        {
-          type: "ui_message",
-          timestamp: Date.now(),
-          data: {
-            id: crypto.randomUUID(),
-            role: "assistant",
-            parts: [{ type: "text", text: finalResult }]
+      if (parts.length > 0) {
+        await tunnel.appendContext(task.id, [
+          {
+            type: "ui_message",
+            timestamp: Date.now(),
+            data: { id: crypto.randomUUID(), role: "assistant", parts }
           }
-        }
-      ]);
-      await tunnel.updateTask(task.id, {
-        state: finalStatus === "completed" ? "completed" : "failed",
-        result: finalResult
-      });
-      console.log(`Task ${finalStatus}`);
+        ]);
+      }
+      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);
+  await tunnel.connect(credentials.userId, "smith");
   console.log("Tunnel established");
   const voiceUrl = `${process.env.HEYATLAS_API || "https://heyatlas.app"}/chat`;
   if (options.openBrowser !== false) {
@@ -52435,7 +52539,7 @@ async function connectHTTPAgent(agentType, credentials, options) {
     } catch {}
   }
   console.log(`
-HeyAtlas connected to ${agentType}`);
+HeyAtlas connected to smith`);
   console.log(`Continue here: ${voiceUrl}`);
   console.log(`
 Press Ctrl+C to disconnect
@@ -52670,8 +52774,8 @@ var ACP_AGENTS = [
   "openhands",
   "cagent"
 ];
-var HTTP_AGENTS = ["agent-smith-py"];
-var SUPPORTED_AGENTS = [...ACP_AGENTS, ...HTTP_AGENTS];
+var SMITH_AGENTS = ["smith"];
+var SUPPORTED_AGENTS = [...ACP_AGENTS, ...SMITH_AGENTS];
 var { positionals, values } = parseArgs({
   args: process.argv.slice(2),
   options: {
@@ -52690,7 +52794,7 @@ Usage:
 
 Supported Agents:
   ACP Agents:    ${ACP_AGENTS.join(", ")}
-  HTTP Agents:   ${HTTP_AGENTS.join(", ")}
+  Smith:         ${SMITH_AGENTS.join(", ")}
 
 Options:
   -h, --help        Show this help message
@@ -52698,8 +52802,8 @@ Options:
   --no-browser      Don't open browser automatically
 
 Examples:
-  heyatlas connect opencode         Connect OpenCode via ACP
-  heyatlas connect agent-smith-py   Connect Agent Smith (CAMEL-AI workforce)
+  heyatlas connect opencode    Connect OpenCode via ACP
+  heyatlas connect smith       Connect Smith
 `);
 }
 async function main() {

package/package.json

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