opencara 0.25.1 → 0.100.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenCara
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OF OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bin.js

@@ -0,0 +1,600 @@
+#!/usr/bin/env node
+
+// src/commands/register.ts
+import { createHash, randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
+
+// ../shared/dist/events.js
+import { z } from "zod";
+var PlatformSchema = z.enum(["github"]);
+var PlatformEventSchema = z.object({
+  id: z.string(),
+  platform: PlatformSchema,
+  type: z.string(),
+  receivedAt: z.string().datetime(),
+  payload: z.unknown()
+});
+
+// ../shared/dist/agent.js
+import { z as z2 } from "zod";
+var AgentRunStatusSchema = z2.enum([
+  "queued",
+  "assigned",
+  "running",
+  "succeeded",
+  "failed",
+  "cancelled"
+]);
+var AgentSpecSchema = z2.object({
+  kind: z2.string(),
+  command: z2.string(),
+  args: z2.array(z2.string()).default([]),
+  env: z2.record(z2.string()).default({}),
+  cwd: z2.string().optional()
+});
+var AgentRunSchema = z2.object({
+  id: z2.string(),
+  spec: AgentSpecSchema,
+  triggerEventId: z2.string().optional(),
+  status: AgentRunStatusSchema,
+  hostId: z2.string().nullable(),
+  createdAt: z2.string().datetime(),
+  startedAt: z2.string().datetime().nullable(),
+  finishedAt: z2.string().datetime().nullable(),
+  exitCode: z2.number().int().nullable()
+});
+
+// ../shared/dist/host-protocol.js
+import { z as z3 } from "zod";
+var PairingCreateRequestSchema = z3.object({
+  device_secret_hash: z3.string()
+});
+var PairingCreateResponseSchema = z3.object({
+  code: z3.string(),
+  expires_at: z3.string().datetime()
+});
+var PairingStatusResponseSchema = z3.union([
+  z3.object({ status: z3.literal("pending") }),
+  z3.object({
+    status: z3.literal("confirmed"),
+    token: z3.string(),
+    agent_host_id: z3.string(),
+    device_name: z3.string()
+  }),
+  z3.object({ status: z3.literal("expired") })
+]);
+var PairingConfirmRequestSchema = z3.object({
+  device_name: z3.string().min(1)
+});
+var SystemInfoSchema = z3.object({
+  os: z3.string(),
+  // os.platform()
+  release: z3.string(),
+  // os.release()
+  arch: z3.string(),
+  // os.arch()
+  hostname: z3.string(),
+  cpu: z3.object({
+    model: z3.string(),
+    cores: z3.number().int().nonnegative(),
+    speedMhz: z3.number().int().nonnegative()
+  }),
+  memory: z3.object({
+    totalBytes: z3.number().nonnegative(),
+    freeBytes: z3.number().nonnegative()
+  }),
+  disk: z3.object({
+    path: z3.string(),
+    totalBytes: z3.number().nonnegative(),
+    freeBytes: z3.number().nonnegative()
+  }).optional(),
+  ipAddrs: z3.array(z3.string()).default([]),
+  uptimeSec: z3.number().nonnegative()
+});
+var HelloMessageSchema = z3.object({
+  type: z3.literal("hello"),
+  platform: z3.string(),
+  version: z3.string(),
+  capabilities: z3.array(z3.string()).default([]),
+  systemInfo: SystemInfoSchema.optional()
+});
+var JobAssignmentSchema = z3.object({
+  type: z3.literal("job"),
+  run: AgentRunSchema,
+  spec: AgentSpecSchema,
+  stdinJson: z3.unknown().optional()
+});
+var LogFrameSchema = z3.object({
+  type: z3.literal("log"),
+  runId: z3.string(),
+  seq: z3.number().int().min(0),
+  stream: z3.enum(["stdout", "stderr"]),
+  chunk: z3.string()
+});
+var RunDoneSchema = z3.object({
+  type: z3.literal("done"),
+  runId: z3.string(),
+  status: z3.enum(["succeeded", "failed", "cancelled"]),
+  exitCode: z3.number().int().nullable().optional(),
+  errorMessage: z3.string().optional()
+});
+var HelloAckSchema = z3.object({
+  type: z3.literal("hello-ack"),
+  agentHostId: z3.string(),
+  deviceName: z3.string()
+});
+var PingSchema = z3.object({ type: z3.literal("ping") });
+var PongSchema = z3.object({ type: z3.literal("pong") });
+var ServerToDeviceMessageSchema = z3.discriminatedUnion("type", [
+  JobAssignmentSchema,
+  HelloAckSchema,
+  PingSchema
+]);
+var DeviceToServerMessageSchema = z3.discriminatedUnion("type", [
+  HelloMessageSchema,
+  LogFrameSchema,
+  RunDoneSchema,
+  PongSchema
+]);
+var HostRegisterRequestSchema = z3.object({
+  hostId: z3.string(),
+  hostName: z3.string(),
+  capabilities: z3.array(z3.string()).default([]),
+  token: z3.string()
+});
+var HostRegisterResponseSchema = z3.object({
+  ok: z3.literal(true),
+  pollIntervalMs: z3.number().int().positive()
+});
+
+// src/config/store.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync } from "node:fs";
+import { z as z4 } from "zod";
+
+// src/config/paths.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+var CONFIG_DIR = join(homedir(), ".opencara");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var DEFAULT_ORCHESTRATOR_URL = "https://opencara.com";
+
+// src/config/store.ts
+var ConfigSchema = z4.object({
+  orchestratorUrl: z4.string().url(),
+  token: z4.string(),
+  agentHostId: z4.string(),
+  deviceName: z4.string()
+});
+function readConfig() {
+  if (!existsSync(CONFIG_FILE)) return null;
+  try {
+    return ConfigSchema.parse(JSON.parse(readFileSync(CONFIG_FILE, "utf8")));
+  } catch {
+    return null;
+  }
+}
+function writeConfig(cfg) {
+  if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2), { mode: 384 });
+}
+function clearConfig() {
+  if (existsSync(CONFIG_FILE)) unlinkSync(CONFIG_FILE);
+}
+function defaultOrchestratorUrl() {
+  return process.env["OPENCARA_URL"] ?? DEFAULT_ORCHESTRATOR_URL;
+}
+
+// src/commands/register.ts
+var POLL_INTERVAL_MS = 2e3;
+async function register(opts = {}) {
+  const orchestratorUrl = opts.url ?? defaultOrchestratorUrl();
+  if (!opts.force && readConfig()) {
+    console.log("Already paired. Use --force to re-pair.");
+    return;
+  }
+  const deviceSecret = randomBytes(32).toString("base64url");
+  const deviceSecretHash = createHash("sha256").update(deviceSecret).digest("hex");
+  const createRes = await fetch(`${orchestratorUrl}/api/devices/pairings`, {
+    method: "POST",
+    headers: { "content-type": "application/json", "x-requested-with": "fetch" },
+    body: JSON.stringify({ device_secret_hash: deviceSecretHash })
+  });
+  if (!createRes.ok) {
+    throw new Error(`pairing create failed: ${createRes.status} ${await createRes.text()}`);
+  }
+  const { code, expires_at } = PairingCreateResponseSchema.parse(await createRes.json());
+  const pairUrl = `${orchestratorUrl}/devices/pair?code=${encodeURIComponent(code)}`;
+  console.log(`
+  Pairing code: ${code}`);
+  console.log(`  Open ${pairUrl} in your browser to confirm.`);
+  console.log(`  Expires at ${expires_at}.
+`);
+  openBrowser(pairUrl);
+  const expiry = new Date(expires_at).getTime();
+  while (Date.now() < expiry) {
+    await sleep(POLL_INTERVAL_MS);
+    const statusRes = await fetch(
+      `${orchestratorUrl}/api/devices/pairings/${encodeURIComponent(code)}/status?secret=${deviceSecret}`
+    );
+    if (!statusRes.ok) {
+      console.error(`  status check failed: ${statusRes.status}`);
+      continue;
+    }
+    const result = PairingStatusResponseSchema.parse(await statusRes.json());
+    if (result.status === "pending") {
+      process.stdout.write(".");
+      continue;
+    }
+    if (result.status === "expired") {
+      throw new Error("pairing expired before confirmation");
+    }
+    writeConfig({
+      orchestratorUrl,
+      token: result.token,
+      agentHostId: result.agent_host_id,
+      deviceName: result.device_name
+    });
+    console.log(`
+
+  \u2713 Paired as "${result.device_name}".`);
+    console.log(`  Run 'opencara run' to start accepting jobs.`);
+    return;
+  }
+  throw new Error("pairing timed out");
+}
+function openBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    const child = spawn(cmd, [url], { detached: true, stdio: "ignore" });
+    child.on("error", () => void 0);
+    child.unref();
+  } catch {
+  }
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/commands/run.ts
+import {
+  arch,
+  cpus,
+  freemem,
+  hostname,
+  networkInterfaces,
+  platform,
+  release,
+  totalmem,
+  uptime
+} from "node:os";
+import { readFileSync as readFileSync2, statfsSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/transport/ws-client.ts
+import WebSocket from "ws";
+var HEARTBEAT_MS = 3e4;
+var WsClient = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.backoff = opts.initialBackoffMs ?? 1e3;
+  }
+  opts;
+  ws = null;
+  backoff;
+  heartbeat = null;
+  stopped = false;
+  start() {
+    this.connect();
+  }
+  stop() {
+    this.stopped = true;
+    if (this.heartbeat) clearInterval(this.heartbeat);
+    this.ws?.close();
+  }
+  send(msg) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    const parsed = DeviceToServerMessageSchema.parse(msg);
+    this.ws.send(JSON.stringify(parsed));
+  }
+  connect() {
+    if (this.stopped) return;
+    const ws = new WebSocket(this.opts.url, {
+      headers: { Authorization: `Bearer ${this.opts.token}` }
+    });
+    this.ws = ws;
+    ws.on("open", () => {
+      this.backoff = this.opts.initialBackoffMs ?? 1e3;
+      if (this.heartbeat) clearInterval(this.heartbeat);
+      this.heartbeat = setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) ws.ping();
+      }, HEARTBEAT_MS);
+      this.opts.onOpen?.();
+    });
+    ws.on("message", (raw) => {
+      let parsed;
+      try {
+        parsed = ServerToDeviceMessageSchema.parse(JSON.parse(raw.toString()));
+      } catch (err) {
+        console.error("[ws] invalid frame", err);
+        return;
+      }
+      this.opts.onMessage(parsed);
+    });
+    ws.on("close", (code, reasonBuf) => {
+      const reason = reasonBuf.toString();
+      if (this.heartbeat) clearInterval(this.heartbeat);
+      this.opts.onClose?.(code, reason);
+      if (!this.stopped) this.scheduleReconnect();
+    });
+    ws.on("error", (err) => {
+      console.error("[ws] error", err.message);
+    });
+  }
+  scheduleReconnect() {
+    const max = this.opts.maxBackoffMs ?? 3e4;
+    const jittered = Math.floor(this.backoff * (0.5 + Math.random()));
+    setTimeout(() => this.connect(), jittered);
+    this.backoff = Math.min(this.backoff * 2, max);
+  }
+};
+
+// src/runner/spawn.ts
+import { spawn as spawn2 } from "node:child_process";
+function runJob(spec, stdinJson, handlers) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2(spec.command, spec.args ?? [], {
+      env: { ...process.env, ...spec.env ?? {} },
+      cwd: spec.cwd,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (c) => handlers.onLog("stdout", c));
+    child.stderr.on("data", (c) => handlers.onLog("stderr", c));
+    child.on("error", reject);
+    child.on("close", (code) => resolve({ exitCode: code ?? -1 }));
+    if (stdinJson !== void 0) {
+      try {
+        child.stdin.end(JSON.stringify(stdinJson));
+      } catch (err) {
+        child.kill();
+        reject(err);
+        return;
+      }
+    } else {
+      child.stdin.end();
+    }
+  });
+}
+
+// src/commands/run.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var PKG_VERSION = readPkgVersion();
+var LOG_FLUSH_MS = 800;
+var MAX_CHUNK_SIZE = 4 * 1024;
+async function run() {
+  const cfg = readConfig();
+  if (!cfg) {
+    throw new Error("Not paired. Run 'opencara register' first.");
+  }
+  const wsUrl = cfg.orchestratorUrl.replace(/^http/, "ws") + "/api/devices/ws";
+  const client = new WsClient({
+    url: wsUrl,
+    token: cfg.token,
+    onOpen: () => {
+      console.log(`[opencara] connected to ${cfg.orchestratorUrl}`);
+      client.send({
+        type: "hello",
+        platform: platform(),
+        version: PKG_VERSION,
+        capabilities: [],
+        systemInfo: collectSystemInfo()
+      });
+    },
+    onMessage: (msg) => handleServerMessage(msg, client, cfg),
+    onClose: (code, reason) => {
+      console.log(`[opencara] disconnected (code=${code} reason="${reason}")`);
+    }
+  });
+  console.log(`[opencara] starting as ${cfg.deviceName} (${hostname()})`);
+  client.start();
+}
+function handleServerMessage(msg, client, _cfg) {
+  if (msg.type === "hello-ack") {
+    console.log(`[opencara] acked as ${msg.deviceName} (${msg.agentHostId})`);
+    return;
+  }
+  if (msg.type === "ping") return;
+  if (msg.type === "job") {
+    void executeJob(msg, client);
+  }
+}
+async function executeJob(job, client) {
+  const runId = job.run.id;
+  console.log(`[opencara] job ${runId.slice(-8)}: ${job.spec.command}`);
+  let seq = 0;
+  let pending = { stdout: "", stderr: "" };
+  let flushTimer = null;
+  const flush = () => {
+    for (const stream of ["stdout", "stderr"]) {
+      const chunk = pending[stream];
+      if (!chunk) continue;
+      let remaining = chunk;
+      while (remaining.length > 0) {
+        const take = remaining.slice(0, MAX_CHUNK_SIZE);
+        client.send({ type: "log", runId, seq: seq++, stream, chunk: take });
+        remaining = remaining.slice(MAX_CHUNK_SIZE);
+      }
+      pending[stream] = "";
+    }
+    flushTimer = null;
+  };
+  const scheduleFlush = () => {
+    if (flushTimer) return;
+    flushTimer = setTimeout(flush, LOG_FLUSH_MS);
+  };
+  try {
+    const result = await runJob(job.spec, job.stdinJson, {
+      onLog: (stream, chunk) => {
+        pending[stream] += chunk;
+        scheduleFlush();
+      }
+    });
+    flush();
+    client.send({
+      type: "done",
+      runId,
+      status: result.exitCode === 0 ? "succeeded" : "failed",
+      exitCode: result.exitCode
+    });
+    console.log(`[opencara] job ${runId.slice(-8)} \u2192 exit ${result.exitCode}`);
+  } catch (err) {
+    flush();
+    const message = err instanceof Error ? err.message : String(err);
+    client.send({ type: "done", runId, status: "failed", errorMessage: message });
+    console.error(`[opencara] job ${runId.slice(-8)} failed`, message);
+  }
+}
+function readPkgVersion() {
+  try {
+    const raw = readFileSync2(join2(__dirname, "..", "..", "package.json"), "utf8");
+    return JSON.parse(raw).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function collectSystemInfo() {
+  try {
+    const cpuList = cpus();
+    const head = cpuList[0];
+    const ipAddrs = [];
+    const ifaces = networkInterfaces();
+    for (const list of Object.values(ifaces)) {
+      if (!list) continue;
+      for (const iface of list) {
+        if (!iface.internal && iface.family === "IPv4") ipAddrs.push(iface.address);
+      }
+    }
+    let disk;
+    try {
+      const stats = statfsSync("/");
+      disk = {
+        path: "/",
+        totalBytes: Number(stats.blocks) * Number(stats.bsize),
+        freeBytes: Number(stats.bavail) * Number(stats.bsize)
+      };
+    } catch {
+      disk = void 0;
+    }
+    return {
+      os: platform(),
+      release: release(),
+      arch: arch(),
+      hostname: hostname(),
+      cpu: {
+        model: head?.model.trim() ?? "unknown",
+        cores: cpuList.length,
+        speedMhz: head?.speed ?? 0
+      },
+      memory: { totalBytes: totalmem(), freeBytes: freemem() },
+      disk,
+      ipAddrs,
+      uptimeSec: Math.floor(uptime())
+    };
+  } catch (err) {
+    console.warn("[opencara] system info collection failed", err);
+    return void 0;
+  }
+}
+
+// src/commands/status.ts
+async function status() {
+  const cfg = readConfig();
+  if (!cfg) {
+    console.log("Not paired. Run 'opencara register' to pair.");
+    return;
+  }
+  console.log(`Paired:`);
+  console.log(`  Device: ${cfg.deviceName}`);
+  console.log(`  Host ID: ${cfg.agentHostId}`);
+  console.log(`  Server: ${cfg.orchestratorUrl}`);
+}
+
+// src/commands/logout.ts
+async function logout() {
+  const cfg = readConfig();
+  if (!cfg) {
+    console.log("Not paired.");
+    return;
+  }
+  try {
+    const res = await fetch(
+      `${cfg.orchestratorUrl}/api/devices/${cfg.agentHostId}/revoke`,
+      {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${cfg.token}`,
+          "x-requested-with": "fetch"
+        }
+      }
+    );
+    if (!res.ok) {
+      console.warn(`server revoke responded ${res.status}; clearing local config anyway`);
+    }
+  } catch (err) {
+    console.warn(`server revoke failed: ${err.message}; clearing local config anyway`);
+  }
+  clearConfig();
+  console.log("Removed local credentials.");
+}
+
+// src/bin.ts
+async function main() {
+  const [, , cmd, ...rest] = process.argv;
+  switch (cmd) {
+    case "register":
+      await register({
+        force: rest.includes("--force"),
+        url: pickFlag(rest, "--url")
+      });
+      return;
+    case "run":
+      await run();
+      return;
+    case "status":
+      await status();
+      return;
+    case "logout":
+      await logout();
+      return;
+    case "--help":
+    case "-h":
+    case void 0:
+      printHelp();
+      return;
+    default:
+      console.error(`unknown command: ${cmd}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+function pickFlag(argv, name) {
+  const i = argv.indexOf(name);
+  if (i === -1) return void 0;
+  return argv[i + 1];
+}
+function printHelp() {
+  console.log(`opencara \u2014 agent host CLI
+
+Usage:
+  opencara register [--url URL] [--force]
+  opencara run
+  opencara status
+  opencara logout
+`);
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+});

package/package.json

@@ -1,58 +1,37 @@
 {
   "name": "opencara",
-  "version": "0.25.1",
-  "description": "Distributed AI code review agent — poll, review, and submit PR reviews using your own AI tools",
-  "type": "module",
+  "version": "0.100.0",
+  "description": "OpenCara agent-host CLI: register a machine as an agent host and run dispatched agents.",
   "license": "MIT",
-  "author": "OpenCara <https://github.com/OpenCara>",
-  "homepage": "https://github.com/OpenCara/OpenCara#readme",
   "repository": {
     "type": "git",
     "url": "https://github.com/OpenCara/OpenCara.git",
     "directory": "packages/cli"
   },
-  "bugs": {
-    "url": "https://github.com/OpenCara/OpenCara/issues"
-  },
-  "keywords": [
-    "ai",
-    "code-review",
-    "github",
-    "pull-request",
-    "cli",
-    "agent",
-    "review",
-    "openai",
-    "claude",
-    "gemini"
-  ],
-  "engines": {
-    "node": ">=20"
-  },
+  "homepage": "https://opencara.com",
+  "type": "module",
   "bin": {
-    "opencara": "dist/index.js"
+    "opencara": "./dist/bin.js"
   },
+  "main": "./dist/bin.js",
   "files": [
-    "dist",
-    "README.md"
+    "dist/bin.js"
   ],
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsx src/index.ts",
-    "clean": "rm -rf dist *.tsbuildinfo"
-  },
   "dependencies": {
-    "commander": "^13.0.0",
-    "picocolors": "^1.1.1",
-    "smol-toml": "^1.6.1"
+    "ws": "^8.18.0",
+    "zod": "^3.24.1"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20250214.0",
-    "@opencara/server": "workspace:*",
-    "@opencara/shared": "workspace:*",
-    "@types/node": "^22.0.0",
-    "hono": "^4.7.0",
-    "tsup": "^8.5.1",
-    "tsx": "^4.0.0"
+    "@types/ws": "^8.5.13",
+    "esbuild": "^0.27.3",
+    "tsx": "^4.19.2",
+    "@opencara/shared": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsc -b && node build.mjs",
+    "dev": "tsx watch src/bin.ts",
+    "start": "node dist/bin.js",
+    "typecheck": "tsc -b",
+    "clean": "rm -rf dist *.tsbuildinfo"
   }
-}
+}