heyatlas 1.2.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;
@@ -5496,7 +5505,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 +52123,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 +52208,354 @@ class ACPProviderAgent {
   }
 }
 
+// agents/config.ts
+function isSmith(agent) {
+  return agent === "smith";
+}
+
+// agents/smith.ts
+import { spawn as spawn2 } from "child_process";
+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;
+  baseUrl;
+  process = null;
+  constructor(options = {}) {
+    this.options = options;
+    this.baseUrl = `http://localhost:${SMITH_CONFIG.port}`;
+  }
+  get name() {
+    return "smith";
+  }
+  get agentId() {
+    return SMITH_CONFIG.agentId;
+  }
+  get 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 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,
+      PORT: String(SMITH_CONFIG.port)
+    };
+    this.process = spawn2(command, args, {
+      cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: true
+    });
+    this.process.stdout?.on("data", (data) => {
+      console.log(`[smith] ${data.toString().trim()}`);
+    });
+    this.process.stderr?.on("data", (data) => {
+      console.error(`[smith] ${data.toString().trim()}`);
+    });
+    this.process.on("error", (err) => {
+      console.error(`[smith] Process error:`, err.message);
+    });
+    await this.waitForReady();
+  }
+  async waitForReady(maxAttempts = 60) {
+    const delay2 = (ms) => new Promise((r) => setTimeout(r, ms));
+    for (let i = 0;i < maxAttempts; i++) {
+      if (await this.isRunning()) {
+        return;
+      }
+      await delay2(1000);
+    }
+    throw new Error(`Smith failed to start after ${maxAttempts}s`);
+  }
+  stop() {
+    if (this.process) {
+      this.process.kill("SIGTERM");
+      this.process = null;
+    }
+  }
+  async* streamChat(prompt) {
+    const response = await fetch(`${this.baseUrl}${SMITH_CONFIG.chatPath}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        messages: [{ role: "user", content: prompt }]
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Chat request 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) {
+        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(jsonStr);
+            yield event;
+          } catch {}
+        }
+      }
+    }
+  }
+}
+
 // 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 (isSmith(agentType)) {
+    return connectSmith(credentials, options);
+  }
+  if (isACPAgent(agentType)) {
+    return connectACPAgent(agentType, credentials, options);
+  }
+  console.error(`Error: Unknown agent type '${agentType}'`);
+  process.exit(1);
+}
+async function connectSmith(credentials, options) {
+  const agent = new Smith({ cwd: process.cwd() });
+  const available = await agent.isAvailable();
+  if (!available) {
+    console.error("Error: npx not found. Install Node.js to use smith");
+    process.exit(1);
+  }
+  console.log("Agent: smith");
+  try {
+    console.log("Starting smith server...");
+    await agent.start();
+    console.log(`Smith 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, 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: latestUserMessage }
+      }
+    ]);
+    try {
+      const parts = [];
+      const toolCalls = new Map;
+      const activeReasoningParts = new Map;
+      for await (const chunk of agent.streamChat(prompt)) {
+        await tunnel.broadcastTaskEvent(task.id, {
+          type: "ui_stream_chunk",
+          timestamp: Date.now(),
+          data: chunk
+        });
+        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;
+          }
+        }
+      }
+      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: "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.connect(credentials.userId, "smith");
+  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 smith`);
+  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 +52566,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 +52615,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 +52672,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 +52729,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 +52761,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 +52774,8 @@ var SUPPORTED_AGENTS = [
   "openhands",
   "cagent"
 ];
+var SMITH_AGENTS = ["smith"];
+var SUPPORTED_AGENTS = [...ACP_AGENTS, ...SMITH_AGENTS];
 var { positionals, values } = parseArgs({
   args: process.argv.slice(2),
   options: {
@@ -52445,27 +52787,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(", ")}
+  Smith:         ${SMITH_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 smith       Connect Smith
 `);
 }
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heyatlas",
-  "version": "1.2.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",
@@ -50,4 +50,4 @@
   "engines": {
     "node": ">=18.0.0"
   }
-}
+}