autowonder 0.1.0

package/README.md

@@ -0,0 +1,50 @@
+# autowonder
+
+Local runtime daemon for executing AI agent dispatch packages.
+
+## Quick Start
+
+```bash
+# Connect to server (like harness)
+npx -y autowonder connect --server-url https://autowonder.example.com --token <your-token>
+
+# Or run locally
+npx -y autowonder start
+npx -y autowonder dispatch ./assignment.json
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `autowonder connect` | Connect to server and run in foreground |
+| `autowonder start` | Start daemon in background |
+| `autowonder stop` | Stop background daemon |
+| `autowonder status` | Show daemon status and runtime info |
+| `autowonder dispatch <file>` | Submit a dispatch assignment |
+| `autowonder install` | Install/update daemon binary |
+
+## Options
+
+- `--provider <name>` — Agent CLI: claude, codex, qoder (auto-detected)
+- `--max-tasks <n>` — Max concurrent dispatches (default: 2)
+- `--server-url <url>` — Server URL for remote task polling
+- `--token <token>` — Authentication token for server
+- `--name <name>` — Runtime instance name (default: hostname)
+
+## Requirements
+
+- One of: Claude Code CLI, Codex CLI, or Qoder CLI
+- For building from source: Go 1.22+ and Git
+
+## How It Works
+
+1. Downloads or builds the `autowonder-daemon` binary
+2. Starts a local HTTP API on `127.0.0.1:34989`
+3. Accepts dispatch assignments via file queue, API, or server polling
+4. Executes packages using the configured agent provider
+5. Produces structured artifacts, results, and observability
+
+## License
+
+Apache-2.0

package/bin/cli.js

@@ -0,0 +1,426 @@
+#!/usr/bin/env node
+"use strict";
+
+const { execFileSync, spawn, spawnSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+const https = require("https");
+const http = require("http");
+
+const VERSION = require("../package.json").version;
+const AUTOWONDER_HOME = path.join(os.homedir(), ".autowonder");
+const BIN_DIR = path.join(AUTOWONDER_HOME, "bin");
+const DAEMON_BIN = path.join(BIN_DIR, "autowonder-daemon");
+const CONFIG_PATH = path.join(AUTOWONDER_HOME, "config.json");
+const PID_PATH = path.join(AUTOWONDER_HOME, "daemon.pid");
+const LOG_PATH = path.join(AUTOWONDER_HOME, "daemon.log");
+
+const BINARY_BASE_URL = process.env.AUTOWONDER_BINARY_URL || "https://github.com/ZichaoJin/auto-wonder-client-runtime/releases/download";
+const SOURCE_REPO = "https://github.com/ZichaoJin/auto-wonder-client-runtime.git";
+
+const DEFAULT_API_ADDR = "127.0.0.1:34989";
+
+// ─── Helpers ─────────────────────────────────────────────────────────
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function log(msg) {
+  console.log(`\x1b[36m[autowonder]\x1b[0m ${msg}`);
+}
+
+function error(msg) {
+  console.error(`\x1b[31m[autowonder]\x1b[0m ${msg}`);
+}
+
+function detectProvider() {
+  const providers = [];
+  try { execFileSync("which", ["claude"], { stdio: "ignore" }); providers.push("claude"); } catch {}
+  try { execFileSync("which", ["codex"], { stdio: "ignore" }); providers.push("codex"); } catch {}
+  try { execFileSync("which", ["qoder"], { stdio: "ignore" }); providers.push("qoder"); } catch {}
+  return providers;
+}
+
+function daemonRunning() {
+  if (!fs.existsSync(PID_PATH)) return false;
+  const pid = parseInt(fs.readFileSync(PID_PATH, "utf8").trim(), 10);
+  if (!pid) return false;
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+function readPid() {
+  if (!fs.existsSync(PID_PATH)) return null;
+  const pid = parseInt(fs.readFileSync(PID_PATH, "utf8").trim(), 10);
+  return pid || null;
+}
+
+function loadConfig() {
+  if (!fs.existsSync(CONFIG_PATH)) return {};
+  try { return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8")); } catch { return {}; }
+}
+
+function saveConfig(config) {
+  ensureDir(AUTOWONDER_HOME);
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf8");
+}
+
+function binaryPlatformKey() {
+  const platform = process.platform;
+  const arch = process.arch === "arm64" ? "arm64" : "amd64";
+  return `${platform}-${arch}`;
+}
+
+function binaryExists() {
+  try {
+    fs.accessSync(DAEMON_BIN, fs.constants.X_OK);
+    return true;
+  } catch { return false; }
+}
+
+// ─── Binary Installation ─────────────────────────────────────────────
+
+async function installBinary(options = {}) {
+  if (binaryExists() && !options.force) {
+    log("Daemon binary already installed.");
+    return true;
+  }
+
+  const platform = binaryPlatformKey();
+  log(`Installing autowonder-daemon for ${platform}...`);
+
+  // Try download pre-built binary
+  const url = `${BINARY_BASE_URL}/v${VERSION}/autowonder-daemon-${platform}`;
+  const downloaded = await tryDownload(url, DAEMON_BIN);
+  if (downloaded) {
+    fs.chmodSync(DAEMON_BIN, 0o755);
+    log(`Installed daemon binary: ${DAEMON_BIN}`);
+    return true;
+  }
+
+  // Fallback: build from source
+  log("Pre-built binary not available. Building from source...");
+  return buildFromSource();
+}
+
+function tryDownload(url, dest) {
+  return new Promise((resolve) => {
+    ensureDir(path.dirname(dest));
+    const client = url.startsWith("https") ? https : http;
+
+    function doRequest(requestUrl, redirects) {
+      if (redirects > 5) { resolve(false); return; }
+      const parsedUrl = new URL(requestUrl);
+      const options = { hostname: parsedUrl.hostname, path: parsedUrl.pathname + parsedUrl.search, headers: { "User-Agent": "autowonder-npm" } };
+      client.get(options, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          doRequest(res.headers.location, redirects + 1);
+          return;
+        }
+        if (res.statusCode !== 200) { res.resume(); resolve(false); return; }
+        const file = fs.createWriteStream(dest);
+        res.pipe(file);
+        file.on("finish", () => { file.close(); resolve(true); });
+        file.on("error", () => { try { fs.unlinkSync(dest); } catch {} resolve(false); });
+      }).on("error", () => resolve(false));
+    }
+    doRequest(url, 0);
+  });
+}
+
+function buildFromSource() {
+  try { execFileSync("which", ["go"], { stdio: "ignore" }); } catch {
+    error("Go is not installed. Install Go 1.22+ or provide a pre-built binary.");
+    error("  macOS: brew install go");
+    error("  Linux: https://go.dev/dl/");
+    return false;
+  }
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "autowonder-build-"));
+  try {
+    log("Cloning source repository...");
+    execFileSync("git", ["clone", "--depth", "1", SOURCE_REPO, tmpDir], { stdio: "inherit" });
+    log("Building daemon...");
+    ensureDir(BIN_DIR);
+    execFileSync("go", ["build", "-o", DAEMON_BIN, "./cmd/autowonder-daemon"], { cwd: tmpDir, stdio: "inherit" });
+    fs.chmodSync(DAEMON_BIN, 0o755);
+    log(`Built daemon binary: ${DAEMON_BIN}`);
+    return true;
+  } catch (e) {
+    error(`Build failed: ${e.message}`);
+    return false;
+  } finally {
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  }
+}
+
+// ─── Commands ────────────────────────────────────────────────────────
+
+async function cmdConnect(args) {
+  const flags = parseFlags(args, ["token", "server-url", "provider", "name", "max-tasks"]);
+
+  if (!flags.token && !flags["server-url"]) {
+    error("Usage: autowonder connect --server-url <url> --token <token> [--provider claude] [--name my-machine]");
+    process.exit(1);
+  }
+
+  const installed = await installBinary();
+  if (!installed) process.exit(1);
+
+  const providers = detectProvider();
+  const provider = flags.provider || providers[0] || "claude";
+  if (providers.length === 0) {
+    error(`No agent CLI detected. Install one of: claude, codex, qoder`);
+    process.exit(1);
+  }
+
+  const config = {
+    serverUrl: flags["server-url"] || "",
+    token: flags.token || "",
+    provider,
+    name: flags.name || os.hostname(),
+    maxTasks: parseInt(flags["max-tasks"] || "2", 10),
+  };
+  saveConfig(config);
+
+  log(`Connecting to ${config.serverUrl || "local mode"}...`);
+  log(`Provider: ${provider}`);
+  log(`Name: ${config.name}`);
+  log(`Max concurrent: ${config.maxTasks}`);
+  log("");
+
+  // Start daemon in foreground (like harness connect)
+  const env = {
+    ...process.env,
+    AUTOWONDER_PROVIDER: config.provider,
+    AUTOWONDER_MAX_CONCURRENT_DISPATCHES: String(config.maxTasks),
+    AUTOWONDER_DAEMON_ID: config.name,
+  };
+  if (config.serverUrl) env.AUTOWONDER_SERVER_URL = config.serverUrl;
+  if (config.token) env.AUTOWONDER_SERVER_TOKEN = config.token;
+
+  const child = spawn(DAEMON_BIN, [], { env, stdio: "inherit" });
+  child.on("exit", (code) => process.exit(code || 0));
+  process.on("SIGINT", () => { child.kill("SIGINT"); });
+  process.on("SIGTERM", () => { child.kill("SIGTERM"); });
+}
+
+async function cmdStart(args) {
+  const flags = parseFlags(args, ["provider", "max-tasks", "addr"]);
+
+  if (daemonRunning()) {
+    log("Daemon is already running.");
+    return;
+  }
+
+  const installed = await installBinary();
+  if (!installed) process.exit(1);
+
+  const providers = detectProvider();
+  const provider = flags.provider || providers[0] || "claude";
+  const addr = flags.addr || DEFAULT_API_ADDR;
+  const maxTasks = flags["max-tasks"] || "2";
+
+  log(`Starting daemon (provider=${provider}, addr=${addr})...`);
+
+  ensureDir(AUTOWONDER_HOME);
+  const logFd = fs.openSync(LOG_PATH, "a");
+  const child = spawn(DAEMON_BIN, [], {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: {
+      ...process.env,
+      AUTOWONDER_PROVIDER: provider,
+      AUTOWONDER_LOCAL_API_ADDR: addr,
+      AUTOWONDER_MAX_CONCURRENT_DISPATCHES: maxTasks,
+    },
+  });
+  fs.writeFileSync(PID_PATH, String(child.pid) + "\n");
+  child.unref();
+  fs.closeSync(logFd);
+
+  log(`Daemon started (pid=${child.pid})`);
+  log(`  API: http://${addr}`);
+  log(`  Log: ${LOG_PATH}`);
+  log(`  PID: ${PID_PATH}`);
+}
+
+function cmdStop() {
+  const pid = readPid();
+  if (!pid || !daemonRunning()) {
+    log("Daemon is not running.");
+    try { fs.unlinkSync(PID_PATH); } catch {}
+    return;
+  }
+  process.kill(pid, "SIGTERM");
+  log(`Stopped daemon (pid=${pid})`);
+  try { fs.unlinkSync(PID_PATH); } catch {}
+}
+
+async function cmdStatus() {
+  const running = daemonRunning();
+  const pid = readPid();
+  const config = loadConfig();
+
+  console.log("");
+  console.log(`  Status:    ${running ? "\x1b[32mrunning\x1b[0m" : "\x1b[31mstopped\x1b[0m"}`);
+  if (pid && running) console.log(`  PID:       ${pid}`);
+  console.log(`  Provider:  ${config.provider || "not configured"}`);
+  console.log(`  Server:    ${config.serverUrl || "local only"}`);
+  console.log(`  Binary:    ${binaryExists() ? DAEMON_BIN : "not installed"}`);
+  console.log(`  Home:      ${AUTOWONDER_HOME}`);
+  console.log("");
+
+  if (running) {
+    try {
+      const res = spawnSync("curl", ["-s", `http://${DEFAULT_API_ADDR}/health`], { encoding: "utf8", timeout: 3000 });
+      if (res.stdout) {
+        const health = JSON.parse(res.stdout);
+        console.log(`  API:       http://${DEFAULT_API_ADDR} (${health.status})`);
+      }
+    } catch {}
+
+    try {
+      const res = spawnSync("curl", ["-s", `http://${DEFAULT_API_ADDR}/runtimes`], { encoding: "utf8", timeout: 3000 });
+      if (res.stdout) {
+        const runtimes = JSON.parse(res.stdout);
+        for (const rt of (runtimes.runtimes || runtimes)) {
+          console.log(`  Runtime:   ${rt.id} (${rt.provider}) ${rt.available ? "available" : "unavailable"}${rt.version ? " v" + rt.version : ""}`);
+        }
+      }
+    } catch {}
+    console.log("");
+  }
+}
+
+async function cmdDispatch(args) {
+  if (args.length === 0) {
+    error("Usage: autowonder dispatch <assignment.json | package-url>");
+    process.exit(1);
+  }
+
+  if (!daemonRunning()) {
+    error("Daemon is not running. Start it first: autowonder start");
+    process.exit(1);
+  }
+
+  const input = args[0];
+  let body;
+
+  if (fs.existsSync(input)) {
+    body = fs.readFileSync(input, "utf8");
+  } else {
+    error(`File not found: ${input}`);
+    process.exit(1);
+  }
+
+  log(`Submitting dispatch to http://${DEFAULT_API_ADDR}...`);
+  const res = spawnSync("curl", [
+    "-s", "-w", "\n%{http_code}",
+    "-X", "POST",
+    "-H", "Content-Type: application/json",
+    "-d", body,
+    `http://${DEFAULT_API_ADDR}/dispatches`,
+  ], { encoding: "utf8", timeout: 10000 });
+
+  const lines = (res.stdout || "").trim().split("\n");
+  const statusCode = lines.pop();
+  const responseBody = lines.join("\n");
+
+  if (statusCode === "200" || statusCode === "202") {
+    log("Dispatch submitted successfully.");
+    if (responseBody) console.log(responseBody);
+  } else {
+    error(`Dispatch failed (HTTP ${statusCode})`);
+    if (responseBody) console.error(responseBody);
+    process.exit(1);
+  }
+}
+
+async function cmdInstall(args) {
+  const flags = parseFlags(args, ["force"]);
+  const installed = await installBinary({ force: flags.force === "true" || args.includes("--force") });
+  if (!installed) process.exit(1);
+}
+
+function cmdHelp() {
+  console.log(`
+  autowonder — local runtime for AI agent dispatch execution
+
+  Usage:
+    autowonder connect --server-url <url> --token <token>   Connect to server and run
+    autowonder start [--provider claude]                     Start daemon in background
+    autowonder stop                                          Stop background daemon
+    autowonder status                                        Show daemon status
+    autowonder dispatch <assignment.json>                    Submit a dispatch
+    autowonder install [--force]                             Install/update daemon binary
+
+  Options:
+    --provider <name>     Agent provider: claude, codex, qoder (default: auto-detect)
+    --max-tasks <n>       Max concurrent dispatches (default: 2)
+    --addr <host:port>    Local API address (default: 127.0.0.1:34989)
+    --server-url <url>    Server URL for remote dispatch
+    --token <token>       Authentication token
+    --name <name>         Runtime name (default: hostname)
+    -h, --help            Show this help
+
+  Examples:
+    # Quick start — connect to server
+    npx -y autowonder connect --server-url https://autowonder.example.com --token xxx
+
+    # Local mode — start daemon, submit tasks manually
+    npx -y autowonder start
+    npx -y autowonder dispatch ./assignment.json
+
+    # Check what's happening
+    npx -y autowonder status
+  `);
+}
+
+// ─── Flag Parser ─────────────────────────────────────────────────────
+
+function parseFlags(args, knownFlags) {
+  const flags = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      if (knownFlags.includes(key) && i + 1 < args.length && !args[i + 1].startsWith("--")) {
+        flags[key] = args[++i];
+      } else {
+        flags[key] = "true";
+      }
+    }
+  }
+  return flags;
+}
+
+// ─── Main ────────────────────────────────────────────────────────────
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0] || "help";
+  const commandArgs = args.slice(1);
+
+  switch (command) {
+    case "connect":  return cmdConnect(commandArgs);
+    case "start":    return cmdStart(commandArgs);
+    case "stop":     return cmdStop();
+    case "status":   return cmdStatus();
+    case "dispatch": return cmdDispatch(commandArgs);
+    case "install":  return cmdInstall(commandArgs);
+    case "help":
+    case "--help":
+    case "-h":       return cmdHelp();
+    default:
+      error(`Unknown command: ${command}`);
+      cmdHelp();
+      process.exit(1);
+  }
+}
+
+main().catch((e) => {
+  error(e.message || String(e));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "autowonder",
+  "version": "0.1.0",
+  "description": "AutoWonder local runtime — execute AI agent dispatch packages on your machine",
+  "bin": {
+    "autowonder": "bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "scripts/"
+  ],
+  "keywords": [
+    "autowonder",
+    "runtime",
+    "ai-agent",
+    "daemon",
+    "dispatch",
+    "claude",
+    "codex",
+    "qoder"
+  ],
+  "author": "Alibaba Cloud",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ZichaoJin/auto-wonder-client-runtime.git"
+  },
+  "engines": {
+    "node": ">=16"
+  }
+}