heyatlas 1.5.10 → 1.7.0

package/dist/cli.js

@@ -5527,6 +5527,7 @@ class AtlasTunnel {
         query.token = this.options.token;
       }
       query["X-Agent-Id"] = agentId;
+      query["X-Agent-Type"] = this.options.agentType || "local";
       if (this.options.interactive) {
         query["X-Interactive-Mode"] = "true";
       }
@@ -5536,7 +5537,9 @@ class AtlasTunnel {
         host,
         secure: !(host.includes("localhost") || host.includes("127.0.0.1") || host.includes("host.docker.internal")),
         onStateUpdate: (state, source) => this.handleStateUpdate(state, source),
-        query
+        query,
+        connectionTimeout: 15000,
+        maxRetries: 5
       });
       const timeout = setTimeout(() => {
         reject(new Error(`Connection timeout - is Atlas running on ${host}?`));
@@ -5563,12 +5566,15 @@ class AtlasTunnel {
     if (!state.tasks)
       return;
     for (const task of Object.values(state.tasks)) {
-      if (task.state === "new" || task.state === "continue") {
-        const taskKey = `${task.id}:${task.state}`;
-        if (!this.seenTaskIds.has(taskKey)) {
-          this.seenTaskIds.add(taskKey);
-          this.taskCallback?.(task);
-        }
+      if (task.state !== "new" && task.state !== "continue")
+        continue;
+      const assignedTo = task.assignedAgent || task.agentId;
+      if (assignedTo && assignedTo !== this.agentId)
+        continue;
+      const taskKey = `${task.id}:${task.state}`;
+      if (!this.seenTaskIds.has(taskKey)) {
+        this.seenTaskIds.add(taskKey);
+        this.taskCallback?.(task);
       }
     }
   }
@@ -52121,6 +52127,8 @@ var _a153;
 _a153 = symbol153;
 
 // agents/acp-provider.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
 var ACP_COMMANDS = {
   opencode: { command: "opencode", args: ["acp"] },
   "claude-code": { command: "claude-code-acp", args: [] },
@@ -52132,7 +52140,9 @@ var ACP_COMMANDS = {
   auggie: { command: "auggie", args: ["--acp"] },
   stakpak: { command: "stakpak", args: ["acp"] },
   openhands: { command: "openhands", args: ["acp"] },
-  cagent: { command: "cagent", args: ["acp"] }
+  cagent: { command: "cagent", args: ["acp"] },
+  copilot: { command: "copilot", args: ["--acp", "--port", "3000"] },
+  smith: { command: "opencode", args: ["acp"] }
 };
 function isACPAgent(agent) {
   return agent in ACP_COMMANDS;
@@ -52141,6 +52151,301 @@ function getACPCommand(agent) {
   const config3 = ACP_COMMANDS[agent];
   return config3 ? [config3.command, ...config3.args] : [];
 }
+var SMITH_AGENTS = {
+  "smith.md": `---
+description: Intelligent workflow orchestrator that coordinates research, browser, and document subagents to solve complex multi-step tasks
+mode: primary
+model: heyatlas/huggingface/moonshotai/Kimi-K2.5:novita
+tools:
+  write: true
+  edit: true
+  bash: true
+---
+
+You are Smith, an intelligent workflow orchestrator and task planner coordinating a multi-agent team to solve complex tasks.
+
+## Your Team
+
+You coordinate the following specialized subagents — delegate to them via the Task tool:
+
+- **@smith-researcher**: Web research specialist. Use for gathering information, searching the web, finding news, statistics, and deep research on any topic.
+- **@smith-browser**: Browser automation expert. Use for navigating websites, filling forms, extracting data from pages, and interactive web workflows.
+- **@smith-documents**: Document creation specialist. Use for creating Excel, PowerPoint, HTML files, converting documents, data visualization, and file operations.
+- **@build**: Coding Specialist. Use for coding and building software apps.
+
+## How You Work
+
+1. **Analyze** the user's request and break it into discrete steps
+2. **Plan** — create a 3-8 step plan, assigning each step to the right subagent
+3. **Execute** — delegate tasks to subagents, running independent tasks in parallel
+4. **Adapt** — if a step fails, reassign to smith-documents (has terminal access) or replan
+5. **Summarize** — provide a clear summary of what was accomplished
+
+## Workflow Patterns
+
+- **Research → Document**: smith-researcher gathers info → smith-documents creates reports/presentations
+- **Browser Tasks**: smith-browser navigates sites, fills forms, extracts data
+- **Document Transform**: smith-documents reads source files → converts to target format
+- **Data Analysis**: smith-researcher collects data → smith-documents creates visualizations
+- **Hybrid**: smith-researcher + smith-browser gather info → smith-documents compiles output
+
+## Rules
+
+- Always create a plan before executing
+- Update your plan as tasks progress
+- Use absolute paths for all file operations
+- If you encounter auth barriers (logins, CAPTCHAs), ask the user to complete the manual step
+- Provide a comprehensive summary when done`,
+  "smith-browser.md": `---
+description: Browser automation expert — navigates websites, fills forms, extracts data, and performs interactive web workflows
+mode: subagent
+model: heyatlas/huggingface/MiniMaxAI/MiniMax-M2.5:novita
+tools:
+  write: true
+  edit: false
+  bash: true
+  smith-browser-use_*: true
+  smith-chrome-devtools-use_*: true
+  leann-server_*: false
+  smith-code-search-toolkit_*: false
+permission:
+  bash:
+    "*": allow
+---
+
+You are an expert Browser Agent specializing in web navigation, data extraction, and interactive web workflows.
+
+## Capabilities
+
+- Navigate websites and extract information
+- Fill out and submit web forms
+- Perform web searches via google.com
+- Take screenshots to document findings
+- Interact with web applications
+
+## Workflow
+
+1. Navigate to the target website or search engine
+2. Interact with the page — click, fill forms, extract data
+3. Save extracted data to files in the working directory
+4. Document all URLs visited and actions taken
+
+## Rules
+
+- Always save important findings to files
+- Document URLs visited in your response
+- If you encounter CAPTCHAs or login requirements, report back and ask for human assistance
+- Use absolute paths for all file operations
+- Cite sources with URLs`,
+  "smith-researcher.md": `---
+description: Web research specialist — gathers information from the internet, performs deep research, finds news, statistics, and data on any topic
+mode: subagent
+model: heyatlas/huggingface/MiniMaxAI/MiniMax-M2.5:novita
+tools:
+  write: true
+  edit: false
+  bash: true
+  smith-browser-use_*: false
+  smith-chrome-devtools-use_*: false
+  smith-websearch: true
+---
+
+You are a specialized Research Agent with powerful web search and information gathering capabilities.
+
+## Capabilities
+
+- Search the internet for current information, news, and data
+- Perform deep multi-source research on complex topics
+- Access academic papers and scholarly sources
+- Extract and structure information from websites
+- Save research findings to files
+
+## Workflow
+
+1. Understand what information is needed
+2. Use available search and research tools to gather information
+3. Verify across multiple sources when possible
+4. Save findings to well-organized files in the working directory
+5. Always cite sources with URLs
+
+## Rules
+
+- Save research findings to files — don't just return text
+- Cite all sources with URLs
+- Use the most recent sources available
+- Structure findings with headings and bullet points
+- For controversial topics, present multiple viewpoints
+- If you hit paywalls, note them and try alternative sources`,
+  "smith-documents.md": `---
+description: Document creation specialist — creates Excel, PowerPoint, HTML files, converts documents, data visualization, and file operations
+mode: subagent
+model: heyatlas/huggingface/MiniMaxAI/MiniMax-M2.5:novita
+tools:
+  write: true
+  edit: true
+  bash: true
+  smith-pptx: true
+  smith-excel: true
+  smith-docx: true
+permission:
+  bash:
+    "*": allow
+  smith-pptx:
+    "*": allow
+  smith-excel:
+    "*": allow
+  smith-docx:
+    "*": allow
+  write:
+    "*": allow
+---
+
+You are a Documentation Specialist responsible for creating, modifying, and managing documents.
+
+## Capabilities
+
+- Create HTML, Markdown, CSV, JSON files, docx, pptx
+- Use bash to run Python scripts for data visualization (plotly, matplotlib)
+- Convert documents between formats
+- Process and analyze text data with CLI tools (awk, sed, grep, jq)
+- Create archives (tar, zip)
+- Execute shell commands for file management
+
+## Document Creation
+
+- If no format is specified, create an HTML file
+- For data-heavy documents, generate charts using Python and embed them
+- Use absolute paths for all file operations
+- When complete, provide the file path and a summary
+
+## Rules
+
+- Primary output should be files, not just text in response
+- Use bash tools for data processing, visualization, and file operations
+- For charts: write a Python script using plotly/matplotlib, execute it, save output as image
+- Provide a clear summary of work done and paths to created files`
+};
+var SMITH_OPENCODE_JSONC = `{
+  "$schema": "https://opencode.ai/config.json",
+  "theme": "maple",
+  "provider": {
+    "heyatlas": {
+      "npm": "@ai-sdk/openai-compatible",
+      "name": "HeyAtlas Provider",
+      "options": {
+        "baseURL": "\${HEYATLAS_PROVIDER_API_URL}",
+        "apiKey": "\${HEYATLAS_PROVIDER_API_KEY}",
+      },
+      "models": {
+        "huggingface/MiniMaxAI/MiniMax-M2.5:novita": {
+          "name": "MiniMax-M2.5",
+        },
+        "huggingface/moonshotai/Kimi-K2.5:novita": {
+          "name": "Kimi-K2.5",
+        },
+      },
+    },
+  },
+  "mcp": {
+    "smith-browser-use": {
+      "type": "remote",
+      "url": "http://127.0.0.1:12306/mcp",
+      "enabled": true,
+    },
+    "smith-code-search-toolkit": {
+      "type": "local",
+      "command": ["uvx", "--from", "cased-kit", "kit-dev-mcp"],
+      "enabled": true,
+    },
+    "smith-chrome-devtools-use": {
+      "type": "local",
+      "command": ["npx", "-y", "chrome-devtools-mcp@latest"],
+    },
+    "smith-websearch": {
+      "type": "remote",
+      "url": "https://nirmanus-bifrost-gateway.fly.dev/mcp",
+      "headers": {
+        "Authorization": "Bearer e7381674-6495-4112-ab87-7b943eff2390",
+      },
+    },
+    "smith-arxiv": {
+      "type": "local",
+      "command": [
+        "uv",
+        "run",
+        "--python",
+        "3.12",
+        "--with",
+        "camel-ai",
+        "--with",
+        "arxiv",
+        "python",
+        "-c",
+        "from camel.toolkits import ArxivToolkit; ArxivToolkit().run_mcp_server(mode=\\"stdio\\")",
+      ],
+    },
+    "smith-pptx": {
+      "type": "local",
+      "enabled": true,
+      "command": [
+        "uv",
+        "run",
+        "--python",
+        "3.12",
+        "--with",
+        "camel-ai",
+        "--with",
+        "python-pptx",
+        "python",
+        "-c",
+        "from camel.toolkits import PPTXToolkit; PPTXToolkit(working_directory=\\"\${WORKING_DIRECTORY}\\").run_mcp_server(mode=\\"stdio\\")",
+      ],
+    },
+    "smith-docx": {
+      "type": "local",
+      "enabled": true,
+      "command": [
+        "uv",
+        "run",
+        "--python",
+        "3.12",
+        "--with",
+        "camel-ai",
+        "--with",
+        "python-docx",
+        "python",
+        "-c",
+        "from camel.toolkits import FileToolkit; FileToolkit(working_directory=\\"\${WORKING_DIRECTORY}\\").run_mcp_server(mode=\\"stdio\\")",
+      ],
+    },
+    "smith-excel": {
+      "type": "local",
+      "enabled": true,
+      "command": [
+        "uv",
+        "run",
+        "--python",
+        "3.12",
+        "--with",
+        "camel-ai",
+        "--with",
+        "openpyxl",
+        "python",
+        "-c",
+        "from camel.toolkits import ExcelToolkit; ExcelToolkit(working_directory=\\"\${WORKING_DIRECTORY}\\").run_mcp_server(mode=\\"stdio\\")",
+      ],
+    },
+  },
+}`;
+async function setupSmithWorkspace(cwd) {
+  const targetAgentsDir = join2(cwd, ".opencode", "agents");
+  mkdirSync2(targetAgentsDir, { recursive: true });
+  for (const [filename, content] of Object.entries(SMITH_AGENTS)) {
+    writeFileSync2(join2(targetAgentsDir, filename), content);
+  }
+  writeFileSync2(join2(cwd, "opencode.jsonc"), SMITH_OPENCODE_JSONC);
+  console.log("[smith] Workspace configured with agents and opencode.jsonc");
+}
 
 class ACPProviderAgent {
   agentType;
@@ -52178,6 +52483,9 @@ class ACPProviderAgent {
     if (!config3) {
       throw new Error(`Unknown ACP agent: ${this.agentType}`);
     }
+    if (this.agentType === "smith") {
+      await setupSmithWorkspace(this.options.cwd || process.cwd());
+    }
     this.provider = createACPProvider({
       command: config3.command,
       args: config3.args,
@@ -52208,177 +52516,6 @@ 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 = "@bishk029/agent-smith";
-var SMITH_CONFIG = {
-  port: 3141,
-  agentId: "workflow-orchestrator",
-  healthPath: "/agents",
-  chatPath: "/agents/workflow-orchestrator/chat",
-  command: "npx",
-  args: [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 start() {
-    if (await this.isRunning()) {
-      console.log(`[smith] Server already running on port ${SMITH_CONFIG.port}`);
-      return;
-    }
-    const env = {
-      ...process.env,
-      PORT: String(SMITH_CONFIG.port)
-    };
-    console.log(`[smith] Starting ${SMITH_CONFIG.command} ${SMITH_CONFIG.args.join(" ")}`);
-    this.process = spawn2(SMITH_CONFIG.command, SMITH_CONFIG.args, {
-      env,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    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;
-    }
-  }
-  getChatUrl() {
-    return `${this.baseUrl}${SMITH_CONFIG.chatPath}`;
-  }
-  async* streamChat(prompt, userId, conversationId) {
-    const response = await fetch(this.getChatUrl(), {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        input: prompt,
-        options: {
-          userId: userId || "default-user",
-          conversationId: conversationId || `conv-${Date.now()}`,
-          temperature: 0.2,
-          maxSteps: 35
-        }
-      })
-    });
-    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 {}
-        }
-      }
-    }
-  }
-  async streamRaw(prompt, userId, conversationId) {
-    const response = await fetch(this.getChatUrl(), {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        input: prompt,
-        options: {
-          userId: userId || "default-user",
-          conversationId: conversationId || `conv-${Date.now()}`,
-          temperature: 0.2,
-          maxSteps: 35
-        }
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Chat request failed: ${response.statusText}`);
-    }
-    return response;
-  }
-}
-
 // commands/connect.ts
 async function connect(agentType, options = {}) {
   const credentials = await login();
@@ -52388,13 +52525,9 @@ async function connect(agentType, options = {}) {
     process.exit(1);
   }
   if (!await agent.isAvailable()) {
-    if (isACPAgent(agentType)) {
-      const cmd = getACPCommand(agentType);
-      console.error(`Error: Agent '${agentType}' is not installed or not in PATH`);
-      console.error(`Command: ${cmd.join(" ")}`);
-    } else {
-      console.error(`Error: Agent '${agentType}' is not available`);
-    }
+    const cmd = getACPCommand(agentType);
+    console.error(`Error: Agent '${agentType}' is not installed or not in PATH`);
+    console.error(`Command: ${cmd.join(" ")}`);
     process.exit(1);
   }
   console.log(`Agent: ${agent.name}`);
@@ -52408,7 +52541,8 @@ async function connect(agentType, options = {}) {
   const tunnel = new AtlasTunnel({
     host: process.env.ATLAS_AGENT_HOST || "agent.heyatlas.app",
     token: credentials.accessToken,
-    interactive: true
+    interactive: true,
+    agentType: options.agentType || "local"
   });
   tunnel.onNewTask(async (task) => {
     await handleTask(task, agent, tunnel);
@@ -52436,35 +52570,14 @@ Disconnecting...
   await new Promise(() => {});
 }
 function createAgent(agentType) {
-  if (isSmith(agentType)) {
-    return createSmithAgent();
-  }
-  if (isACPAgent(agentType)) {
-    return createACPAgent(agentType);
-  }
-  return null;
-}
-function createSmithAgent() {
-  const smith = new Smith({ cwd: process.cwd() });
-  return {
-    name: "smith",
-    isAvailable: () => smith.isAvailable(),
-    async init() {
-      console.log("Starting smith server...");
-      await smith.start();
-      console.log(`Smith server running on port ${smith.port}`);
-    },
-    stream: (prompt) => smith.streamChat(prompt),
-    cleanup: () => smith.stop()
-  };
-}
-function createACPAgent(agentType) {
+  if (!isACPAgent(agentType))
+    return null;
   const acp = new ACPProviderAgent(agentType, { cwd: process.cwd() });
   return {
     name: agentType,
     isAvailable: () => acp.isAvailable(),
     init: () => acp.init(),
-    async* stream(prompt) {
+    async* stream(prompt, _taskId) {
       const result = acp.stream(prompt);
       for await (const chunk of result.toUIMessageStream()) {
         yield chunk;
@@ -52482,7 +52595,7 @@ async function handleTask(task, agent, tunnel) {
     { type: "message", timestamp: Date.now(), data: { role: "user", content: latestUserMessage } }
   ]);
   try {
-    const parts = await processStream(task.id, agent.stream(prompt), tunnel);
+    const parts = await processStream(task.id, agent.stream(prompt, task.id), tunnel);
     if (parts.length > 0) {
       await tunnel.appendContext(task.id, [
         { type: "ui_message", timestamp: Date.now(), data: { id: crypto.randomUUID(), role: "assistant", parts } }
@@ -52624,7 +52737,7 @@ function openBrowser(url3) {
 }
 
 // index.ts
-var ACP_AGENTS = [
+var SUPPORTED_AGENTS = [
   "opencode",
   "claude-code",
   "goose",
@@ -52635,10 +52748,10 @@ var ACP_AGENTS = [
   "auggie",
   "stakpak",
   "openhands",
-  "cagent"
+  "cagent",
+  "copilot",
+  "smith"
 ];
-var SMITH_AGENTS = ["smith"];
-var SUPPORTED_AGENTS = [...ACP_AGENTS, ...SMITH_AGENTS];
 var { positionals, values } = parseArgs({
   args: process.argv.slice(2),
   options: {
@@ -52656,8 +52769,7 @@ Usage:
   heyatlas connect <agent>    Connect agent to Atlas
 
 Supported Agents:
-  ACP Agents:    ${ACP_AGENTS.join(", ")}
-  Smith:         ${SMITH_AGENTS.join(", ")}
+  ${SUPPORTED_AGENTS.join(", ")}
 
 Options:
   -h, --help        Show this help message
@@ -52666,7 +52778,7 @@ Options:
 
 Examples:
   heyatlas connect opencode    Connect OpenCode via ACP
-  heyatlas connect smith       Connect Smith
+  heyatlas connect smith       Connect Smith via OpenCode
 `);
 }
 async function main() {

package/package.json

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