autowonder 0.2.0 → 0.2.2

package/README.md

@@ -1,50 +1,44 @@
 # autowonder
 
-Local runtime daemon for executing AI agent dispatch packages.
+AutoWonder 本地 agent runtime。安装后启动 daemon，持续轮询本地 assignment 队列并执行任务包。
 
-## Quick Start
+## 连接 AutoWonder 服务
 
 ```bash
-# Connect to server (like harness)
-npx -y autowonder connect --server-url https://autowonder.example.com --token <your-token>
+# Qoder CLI
+npx -y autowonder@0.2.2 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider qoder
 
-# Or run locally
-npx -y autowonder start
-npx -y autowonder dispatch ./assignment.json
-```
+# Claude Code
+npx -y autowonder@0.2.2 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider claude
 
-## Commands
+# Codex CLI
+npx -y autowonder@0.2.2 connect --ws-url <wss-endpoint> --token <executor-token> --executor-id <executor-id> --provider codex
+```
 
-| 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 |
+`connect` 会安装当前 npm 包内置的 daemon，并使用页面生成的 WebSocket endpoint、Token 和执行器 ID 建立连接。目标机器必须提前安装并登录对应的 Qoder CLI、Claude Code 或 Codex CLI；runtime 会继承当前用户的 HOME、环境变量和 CLI 登录状态。
 
-## Options
+## 提交 assignment
 
-- `--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)
+daemon 默认轮询 `~/autowonder_workspaces/assignments/*.json`。队列里放 assignment JSON，不放 package zip；JSON 的 `taskPackageRef.downloadUrl` 应指向可下载的 OSS、HTTP 或本地 package 地址。
 
-## Requirements
+```bash
+queue="$HOME/autowonder_workspaces/assignments"
+mkdir -p "$queue"
+cp ./assignment.json "$queue/.assignment.tmp"
+mv "$queue/.assignment.tmp" "$queue/assignment.json"
+```
 
-- One of: Claude Code CLI, Codex CLI, or Qoder CLI
-- For building from source: Go 1.22+ and Git
+也可以直接提交到本地 API：
 
-## How It Works
+```bash
+npx -y autowonder@0.2.2 dispatch ./assignment.json
+```
 
-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
+## 管理 daemon
 
-## License
+```bash
+npx -y autowonder@0.2.2 status
+npx -y autowonder@0.2.2 stop
+```
 
-Apache-2.0
+默认 API 是 `http://127.0.0.1:34989`，日志位于 `~/.autowonder/daemon.log`。npm 包不包含任何 agent、MCP 或服务端凭证。

package/bin/cli.js

@@ -2,6 +2,7 @@
 "use strict";
 
 const { execFileSync, spawn, spawnSync } = require("child_process");
+const crypto = require("crypto");
 const path = require("path");
 const fs = require("fs");
 const os = require("os");
@@ -14,6 +15,7 @@ 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 STATE_PATH = path.join(AUTOWONDER_HOME, "daemon-state.json");
 const LOG_PATH = path.join(AUTOWONDER_HOME, "daemon.log");
 
 const BINARY_BASE_URL = process.env.AUTOWONDER_BINARY_URL || "";
@@ -40,17 +42,105 @@ 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 {}
+  try { execFileSync("which", ["qodercli"], { stdio: "ignore" }); providers.push("qoder"); } 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;
+  const pid = readPid();
+  return Boolean(pid && processRunning(pid) && ownsDaemonProcess(pid));
+}
+
+function processRunning(pid) {
   try { process.kill(pid, 0); return true; } catch { return false; }
 }
 
+function processFingerprint(pid) {
+  const result = spawnSync("ps", ["-p", String(pid), "-o", "lstart=", "-o", "command="], {
+    encoding: "utf8",
+    timeout: 2000,
+  });
+  return result.status === 0 ? (result.stdout || "").trim() : "";
+}
+
+function legacyDaemonProcess(pid) {
+  const result = spawnSync("ps", ["-p", String(pid), "-o", "command="], {
+    encoding: "utf8",
+    timeout: 2000,
+  });
+  if (result.status !== 0) return false;
+  const command = (result.stdout || "").trim();
+  return command === DAEMON_BIN || command.startsWith(`${DAEMON_BIN} `);
+}
+
+function readDaemonState() {
+  if (!fs.existsSync(STATE_PATH)) return null;
+  try { return JSON.parse(fs.readFileSync(STATE_PATH, "utf8")); } catch { return null; }
+}
+
+function ownsDaemonProcess(pid) {
+  const state = readDaemonState();
+  if (state && state.pid === pid) {
+    const fingerprint = processFingerprint(pid);
+    return Boolean(fingerprint && fingerprint === state.fingerprint);
+  }
+  return legacyDaemonProcess(pid);
+}
+
+function clearDaemonState() {
+  try { fs.unlinkSync(PID_PATH); } catch {}
+  try { fs.unlinkSync(STATE_PATH); } catch {}
+}
+
+function saveDaemonState(pid, instanceId) {
+  const fingerprint = processFingerprint(pid);
+  if (!fingerprint) return false;
+  fs.writeFileSync(PID_PATH, String(pid) + "\n");
+  fs.writeFileSync(STATE_PATH, JSON.stringify({ pid, fingerprint, instanceId }) + "\n", { mode: 0o600 });
+  return true;
+}
+
+async function waitForProcessExit(pid, timeoutMs = 5000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!processRunning(pid)) return true;
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  return !processRunning(pid);
+}
+
+function checkDaemonHealth(addr, instanceId) {
+  return new Promise((resolve) => {
+    const request = http.get(`http://${addr}/health`, { timeout: 500 }, (response) => {
+      let body = "";
+      response.setEncoding("utf8");
+      response.on("data", (chunk) => { body += chunk; });
+      response.on("end", () => {
+        try {
+          const health = JSON.parse(body);
+          resolve(response.statusCode === 200 && health.status === "ok" && health.instanceId === instanceId);
+        } catch {
+          resolve(false);
+        }
+      });
+    });
+    request.on("timeout", () => request.destroy());
+    request.on("error", () => resolve(false));
+  });
+}
+
+async function waitForDaemonHealth(addr, pid, instanceId, timeoutMs = 5000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!processRunning(pid)) return false;
+    if (await checkDaemonHealth(addr, instanceId)) return true;
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  return false;
+}
+
 function readPid() {
   if (!fs.existsSync(PID_PATH)) return null;
   const pid = parseInt(fs.readFileSync(PID_PATH, "utf8").trim(), 10);
@@ -125,7 +215,12 @@ function tryDownload(url, dest) {
     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" } };
+      const options = {
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port || undefined,
+        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);
@@ -177,28 +272,32 @@ function buildFromSource() {
 // ─── Commands ────────────────────────────────────────────────────────
 
 async function cmdConnect(args) {
-  const flags = parseFlags(args, ["token", "server-url", "provider", "name", "max-tasks"]);
+  const flags = parseFlags(args, ["ws-url", "token", "executor-id", "provider", "name", "max-tasks"]);
 
-  if (!flags.token && !flags["server-url"]) {
-    error("Usage: autowonder connect --server-url <url> --token <token> [--provider claude] [--name my-machine]");
+  if (!flags["ws-url"] || !flags.token || !flags["executor-id"]) {
+    error("Usage: autowonder connect --ws-url <url> --token <token> --executor-id <id> [--provider qoder]");
     process.exit(1);
   }
 
-  const installed = await installBinary();
+  // A version-pinned npx command must always run the binary bundled with that package.
+  const installed = await installBinary({ force: true });
   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`);
+  const provider = flags.provider || providers[0];
+  if (!provider) {
+    error(`No agent CLI detected. Install one of: claude, codex, qodercli`);
     process.exit(1);
   }
 
+  const executorId = flags["executor-id"];
+
   const config = {
-    serverUrl: flags["server-url"] || "",
-    token: flags.token || "",
+    serverUrl: flags["ws-url"],
+    token: flags.token,
+    executorId,
     provider,
-    name: flags.name || os.hostname(),
+    name: flags.name || `daemon_${provider}_${executorId}`,
     maxTasks: parseInt(flags["max-tasks"] || "2", 10),
   };
   saveConfig(config);
@@ -215,9 +314,13 @@ async function cmdConnect(args) {
     AUTOWONDER_PROVIDER: config.provider,
     AUTOWONDER_MAX_CONCURRENT_DISPATCHES: String(config.maxTasks),
     AUTOWONDER_DAEMON_ID: config.name,
+    AUTOWONDER_RUNTIME_ID: `rt_${provider}_${executorId}`,
+    AUTOWONDER_WORKSPACE_ROOT: path.join(os.homedir(), `autowonder_workspaces_${provider}_${executorId}`),
+    AUTOWONDER_LOCAL_API_ADDR: "127.0.0.1:0",
+    AUTOWONDER_SERVER_WS_URL: config.serverUrl,
+    AUTOWONDER_EXECUTOR_TOKEN: config.token,
+    AUTOWONDER_EXECUTOR_ID: executorId,
   };
-  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));
@@ -230,7 +333,7 @@ async function cmdStart(args) {
 
   if (daemonRunning()) {
     log("Daemon is already running.");
-    return;
+    return true;
   }
 
   const installed = await installBinary();
@@ -245,6 +348,7 @@ async function cmdStart(args) {
 
   ensureDir(AUTOWONDER_HOME);
   const logFd = fs.openSync(LOG_PATH, "a");
+  const instanceId = crypto.randomUUID();
   const child = spawn(DAEMON_BIN, [], {
     detached: true,
     stdio: ["ignore", logFd, logFd],
@@ -253,28 +357,52 @@ async function cmdStart(args) {
       AUTOWONDER_PROVIDER: provider,
       AUTOWONDER_LOCAL_API_ADDR: addr,
       AUTOWONDER_MAX_CONCURRENT_DISPATCHES: maxTasks,
+      AUTOWONDER_DAEMON_INSTANCE_ID: instanceId,
     },
   });
+  fs.closeSync(logFd);
   fs.writeFileSync(PID_PATH, String(child.pid) + "\n");
+
+  if (!await waitForDaemonHealth(addr, child.pid, instanceId) || !saveDaemonState(child.pid, instanceId)) {
+    if (processRunning(child.pid)) {
+      try { child.kill("SIGTERM"); } catch {}
+      await waitForProcessExit(child.pid, 2000);
+    }
+    clearDaemonState();
+    error(`Daemon failed to become healthy at http://${addr}/health.`);
+    process.exitCode = 1;
+    return false;
+  }
+
   child.unref();
-  fs.closeSync(logFd);
 
   log(`Daemon started (pid=${child.pid})`);
   log(`  API: http://${addr}`);
   log(`  Log: ${LOG_PATH}`);
   log(`  PID: ${PID_PATH}`);
+  return true;
 }
 
-function cmdStop() {
+async function cmdStop(options = {}) {
   const pid = readPid();
-  if (!pid || !daemonRunning()) {
-    log("Daemon is not running.");
-    try { fs.unlinkSync(PID_PATH); } catch {}
-    return;
+  if (!pid || !processRunning(pid)) {
+    if (!options.quiet) log("Daemon is not running.");
+    clearDaemonState();
+    return true;
+  }
+  if (!ownsDaemonProcess(pid)) {
+    if (!options.quiet) log(`Ignoring stale daemon PID ${pid}; it belongs to another process.`);
+    clearDaemonState();
+    return true;
   }
   process.kill(pid, "SIGTERM");
-  log(`Stopped daemon (pid=${pid})`);
-  try { fs.unlinkSync(PID_PATH); } catch {}
+  if (!await waitForProcessExit(pid)) {
+    error(`Daemon did not stop within 5 seconds (pid=${pid}).`);
+    return false;
+  }
+  if (!options.quiet) log(`Stopped daemon (pid=${pid})`);
+  clearDaemonState();
+  return true;
 }
 
 async function cmdStatus() {
@@ -340,7 +468,7 @@ async function cmdDispatch(args) {
     "-X", "POST",
     "-H", "Content-Type: application/json",
     "-d", body,
-    `http://${DEFAULT_API_ADDR}/dispatches`,
+    `http://${DEFAULT_API_ADDR}/dispatches/local`,
   ], { encoding: "utf8", timeout: 10000 });
 
   const lines = (res.stdout || "").trim().split("\n");
@@ -358,9 +486,14 @@ async function cmdDispatch(args) {
 }
 
 async function cmdInstall(args) {
-  const flags = parseFlags(args, ["force"]);
-  const installed = await installBinary({ force: flags.force === "true" || args.includes("--force") });
+  const flags = parseFlags(args, ["force", "provider", "max-tasks", "addr"]);
+  const force = flags.force === "true" || args.includes("--force");
+  if (force && daemonRunning() && !await cmdStop({ quiet: true })) {
+    process.exit(1);
+  }
+  const installed = await installBinary({ force });
   if (!installed) process.exit(1);
+  if (!await cmdStart(args)) process.exit(1);
 }
 
 function cmdHelp() {
@@ -368,25 +501,26 @@ function cmdHelp() {
   autowonder — local runtime for AI agent dispatch execution
 
   Usage:
-    autowonder connect --server-url <url> --token <token>   Connect to server and run
+    autowonder connect --ws-url <url> --token <token> --executor-id <id>  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
+    autowonder install [--force]                             Install/update and start daemon
 
   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)
+    --ws-url <url>        Executor WebSocket endpoint
+    --token <token>       Executor authentication token
+    --executor-id <id>    Executor ID
+    --name <name>         Runtime name (default: provider + executor ID)
     -h, --help            Show this help
 
   Examples:
     # Quick start — connect to server
-    npx -y autowonder connect --server-url https://autowonder.example.com --token xxx
+    npx -y autowonder connect --ws-url wss://autowonder.example.com/ws/executor --token xxx --executor-id 10000 --provider qoder
 
     # Local mode — start daemon, submit tasks manually
     npx -y autowonder start

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autowonder",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "AutoWonder local runtime — execute AI agent dispatch packages on your machine",
   "bin": {
     "autowonder": "bin/cli.js"
@@ -28,5 +28,9 @@
   },
   "engines": {
     "node": ">=16"
+  },
+  "scripts": {
+    "build": "./scripts/build-and-publish.sh --build",
+    "test": "node --test test/*.test.js"
   }
 }

package/scripts/build-and-publish.sh

@@ -18,6 +18,18 @@ PKG_DIR="$(dirname "$SCRIPT_DIR")"
 VENDOR_DIR="$PKG_DIR/vendor"
 SOURCE_DIR="${AUTOWONDER_SOURCE_DIR:-}"
 SOURCE_REPO="${AUTOWONDER_SOURCE_REPO:-}"
+TEMP_SOURCE_DIR=""
+NPM_CONFIG_FILE=""
+
+cleanup() {
+  if [[ -n "$TEMP_SOURCE_DIR" ]]; then
+    rm -rf "$TEMP_SOURCE_DIR"
+  fi
+  if [[ -n "$NPM_CONFIG_FILE" ]]; then
+    rm -f "$NPM_CONFIG_FILE"
+  fi
+}
+trap cleanup EXIT
 
 BUILD_ONLY=false
 if [[ "${1:-}" == "--build" ]]; then
@@ -27,11 +39,19 @@ fi
 echo "━━━ autowonder npm build ━━━"
 
 # Get source code
+if [[ -z "$SOURCE_DIR" && -f "$PKG_DIR/../go.mod" ]]; then
+  SOURCE_DIR="$(cd "$PKG_DIR/.." && pwd)"
+fi
+
 if [[ -n "$SOURCE_DIR" && -d "$SOURCE_DIR" ]]; then
   echo "Using local source: $SOURCE_DIR"
 else
-  SOURCE_DIR=$(mktemp -d)
-  trap "rm -rf $SOURCE_DIR" EXIT
+  if [[ -z "$SOURCE_REPO" ]]; then
+    echo "Error: set AUTOWONDER_SOURCE_DIR or AUTOWONDER_SOURCE_REPO"
+    exit 1
+  fi
+  TEMP_SOURCE_DIR="$(mktemp -d)"
+  SOURCE_DIR="$TEMP_SOURCE_DIR"
   echo "Cloning from $SOURCE_REPO..."
   git clone --depth 1 "$SOURCE_REPO" "$SOURCE_DIR"
 fi
@@ -51,7 +71,7 @@ for i in "${!platforms[@]}"; do
   output="$VENDOR_DIR/autowonder-daemon-${goos}-${goarch}"
 
   echo "Building $platform..."
-  (cd "$SOURCE_DIR" && GOOS="$goos" GOARCH="$goarch" go build -o "$output" -ldflags="-s -w" ./cmd/autowonder-daemon)
+  (cd "$SOURCE_DIR" && CGO_ENABLED=0 GOOS="$goos" GOARCH="$goarch" go build -o "$output" -ldflags="-s -w" ./cmd/autowonder-daemon)
   chmod +x "$output"
   echo "  -> $output ($(du -h "$output" | cut -f1))"
 done
@@ -76,10 +96,10 @@ if [[ -z "${NPM_TOKEN:-}" ]]; then
   exit 1
 fi
 
-echo "//registry.npmjs.org/:_authToken=$NPM_TOKEN" > .npmrc
-npm version patch --no-git-tag-version
-npm publish --access public
-rm -f .npmrc
+umask 077
+NPM_CONFIG_FILE="$(mktemp)"
+printf '//registry.npmjs.org/:_authToken=%s\n' "$NPM_TOKEN" > "$NPM_CONFIG_FILE"
+npm publish --access public --userconfig "$NPM_CONFIG_FILE"
 
 echo ""
 echo "Published $(node -p "require('./package.json').name + '@' + require('./package.json').version")"