agent-companion 0.1.0

package/scripts/ui-claude-delegate.mjs

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, "..");
+
+const DEFAULT_RESUME_ID = "9f359518-cae4-4da8-9e55-0ac7e261e85a";
+const JOBS_DIR = path.resolve(projectRoot, ".agent", "ui-jobs");
+
+const argv = process.argv.slice(2);
+const args = parseArgs(argv);
+const prompt = resolvePrompt(args);
+const resumeId = trim(args.resume) || DEFAULT_RESUME_ID;
+const cwd = path.resolve(trim(args.cwd) || projectRoot);
+const wait = toBool(args.wait);
+const dryRun = toBool(args["dry-run"]);
+
+if (!prompt) {
+  printUsageAndExit(1, "prompt is required");
+}
+
+if (!isUuid(resumeId)) {
+  printUsageAndExit(1, `invalid resume id: ${resumeId}`);
+}
+
+if (!fs.existsSync(cwd) || !fs.statSync(cwd).isDirectory()) {
+  printUsageAndExit(1, `cwd must be an existing directory: ${cwd}`);
+}
+
+fs.mkdirSync(JOBS_DIR, { recursive: true });
+
+const jobId = buildJobId();
+const logPath = path.resolve(JOBS_DIR, `${jobId}.log`);
+const metaPath = path.resolve(JOBS_DIR, `${jobId}.json`);
+
+const commandArgs = [
+  "--resume",
+  resumeId,
+  "--dangerously-skip-permissions",
+  "--verbose",
+  "--output-format",
+  "stream-json",
+  "-p",
+  prompt
+];
+
+const commandPreview = `claude ${commandArgs.map(shellEscape).join(" ")}`;
+const metadata = {
+  id: jobId,
+  createdAt: Date.now(),
+  cwd,
+  resumeId,
+  prompt,
+  command: ["claude", ...commandArgs],
+  status: "STARTING",
+  pid: null,
+  logPath
+};
+
+fs.writeFileSync(metaPath, `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
+
+if (dryRun) {
+  metadata.status = "DRY_RUN";
+  fs.writeFileSync(metaPath, `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
+  console.log(`[ui-delegate] dry-run`);
+  console.log(`[ui-delegate] command: ${commandPreview}`);
+  console.log(`[ui-delegate] meta: ${metaPath}`);
+  process.exit(0);
+}
+
+if (wait) {
+  const outFd = fs.openSync(logPath, "a");
+  fs.writeSync(outFd, `# ${new Date().toISOString()} ${commandPreview}\n`);
+
+  const child = spawn("claude", commandArgs, {
+    cwd,
+    env: process.env,
+    stdio: ["ignore", outFd, outFd]
+  });
+
+  metadata.pid = child.pid || null;
+  metadata.status = "RUNNING";
+  fs.writeFileSync(metaPath, `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
+
+  child.on("close", (code, signal) => {
+    metadata.status = Number.isInteger(code) && code === 0 ? "COMPLETED" : "FAILED";
+    metadata.exitCode = Number.isInteger(code) ? code : null;
+    metadata.signal = signal || null;
+    metadata.endedAt = Date.now();
+    fs.writeFileSync(metaPath, `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
+    fs.closeSync(outFd);
+    process.exit(code ?? 1);
+  });
+
+  child.on("error", (error) => {
+    metadata.status = "FAILED";
+    metadata.error = String(error?.message || error);
+    metadata.endedAt = Date.now();
+    fs.writeFileSync(metaPath, `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
+    fs.closeSync(outFd);
+    process.exit(1);
+  });
+
+  console.log(`[ui-delegate] running (wait mode): ${jobId}`);
+  console.log(`[ui-delegate] log: ${logPath}`);
+  console.log(`[ui-delegate] meta: ${metaPath}`);
+  process.exit(0);
+}
+
+const outFd = fs.openSync(logPath, "a");
+fs.writeSync(outFd, `# ${new Date().toISOString()} ${commandPreview}\n`);
+
+const child = spawn("claude", commandArgs, {
+  cwd,
+  env: process.env,
+  detached: true,
+  stdio: ["ignore", outFd, outFd]
+});
+
+metadata.pid = child.pid || null;
+metadata.status = "RUNNING";
+fs.writeFileSync(metaPath, `${JSON.stringify(metadata, null, 2)}\n`, "utf8");
+
+child.unref();
+fs.closeSync(outFd);
+
+console.log(`[ui-delegate] started: ${jobId}`);
+console.log(`[ui-delegate] pid: ${metadata.pid ?? "unknown"}`);
+console.log(`[ui-delegate] log: ${logPath}`);
+console.log(`[ui-delegate] meta: ${metaPath}`);
+console.log(`[ui-delegate] tail: tail -f ${shellEscape(logPath)}`);
+
+function parseArgs(tokens) {
+  const out = { _: [] };
+  const valueFlags = new Set(["resume", "cwd", "prompt"]);
+  for (let i = 0; i < tokens.length; i += 1) {
+    const token = tokens[i];
+    if (!token.startsWith("--")) {
+      out._.push(token);
+      continue;
+    }
+    const key = token.slice(2);
+    if (!valueFlags.has(key)) {
+      out[key] = "true";
+      continue;
+    }
+    const next = tokens[i + 1];
+    if (!next || next.startsWith("--")) {
+      printUsageAndExit(1, `missing value for --${key}`);
+    }
+    out[key] = next;
+    i += 1;
+  }
+  return out;
+}
+
+function resolvePrompt(argsInput) {
+  const explicit = trim(argsInput.prompt);
+  if (explicit) return explicit;
+  const fromPositional = Array.isArray(argsInput._) ? argsInput._ : [];
+  return trim(fromPositional.join(" "));
+}
+
+function toBool(value) {
+  const normalized = trim(value).toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+
+function trim(value) {
+  return String(value || "").trim();
+}
+
+function isUuid(value) {
+  const candidate = trim(value).toLowerCase();
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(candidate);
+}
+
+function buildJobId() {
+  const now = new Date();
+  const parts = [
+    now.getUTCFullYear(),
+    String(now.getUTCMonth() + 1).padStart(2, "0"),
+    String(now.getUTCDate()).padStart(2, "0"),
+    String(now.getUTCHours()).padStart(2, "0"),
+    String(now.getUTCMinutes()).padStart(2, "0"),
+    String(now.getUTCSeconds()).padStart(2, "0")
+  ];
+  const rand = Math.floor(Math.random() * 10000)
+    .toString()
+    .padStart(4, "0");
+  return `ui_${parts.join("")}_${rand}`;
+}
+
+function shellEscape(value) {
+  const text = String(value || "");
+  if (/^[a-zA-Z0-9_./:@-]+$/.test(text)) return text;
+  return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+
+function printUsageAndExit(code, error = "") {
+  if (error) {
+    console.error(`[ui-delegate] ${error}`);
+  }
+  console.log(`Usage:
+  node scripts/ui-claude-delegate.mjs --prompt "<text>" [options]
+  node scripts/ui-claude-delegate.mjs "<text>" [options]
+
+Options:
+  --resume <uuid>    Claude resume thread id (default project UI thread)
+  --cwd <path>       Working directory for Claude (default: repo root)
+  --wait             Run in foreground and wait for completion
+  --dry-run          Print command and metadata without running Claude
+`);
+  process.exit(code);
+}

package/wake-proxy/server.mjs

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+import cors from "cors";
+import dgram from "node:dgram";
+import express from "express";
+
+const app = express();
+
+const WAKE_PROXY_PORT = clamp(toInt(process.env.PORT || process.env.WAKE_PROXY_PORT, 9898), 1, 65535);
+const WAKE_PROXY_TOKEN = safeText(process.env.WAKE_PROXY_TOKEN, 500);
+const WAKE_BROADCAST_ADDRESS = safeText(process.env.WAKE_BROADCAST_ADDRESS, 120) || "255.255.255.255";
+const WAKE_UDP_PORT = clamp(toInt(process.env.WAKE_UDP_PORT, 9), 1, 65535);
+const WAKE_PACKET_REPEAT = clamp(toInt(process.env.WAKE_PACKET_REPEAT, 3), 1, 12);
+const WAKE_PACKET_DELAY_MS = clamp(toInt(process.env.WAKE_PACKET_DELAY_MS, 120), 0, 5000);
+
+app.use(cors());
+app.use(express.json({ limit: "64kb" }));
+
+app.get("/health", (_req, res) => {
+  return res.json({
+    ok: true,
+    service: "wake-proxy",
+    udpPort: WAKE_UDP_PORT,
+    broadcastAddress: WAKE_BROADCAST_ADDRESS,
+    tokenRequired: Boolean(WAKE_PROXY_TOKEN)
+  });
+});
+
+app.post("/api/wake", async (req, res) => {
+  if (WAKE_PROXY_TOKEN) {
+    const authHeader = String(req.header("authorization") || "").trim();
+    const bearer = authHeader.toLowerCase().startsWith("bearer ") ? authHeader.slice(7).trim() : "";
+    const fromHeader = safeText(req.header("x-wake-proxy-token"), 500);
+    const token = bearer || fromHeader;
+    if (!token || token !== WAKE_PROXY_TOKEN) {
+      return res.status(401).json({
+        ok: false,
+        error: "wake proxy token missing or invalid"
+      });
+    }
+  }
+
+  const macAddress = normalizeMacAddress(
+    req.body?.macAddress || req.body?.wakeMac || req.body?.mac || req.body?.address
+  );
+  if (!macAddress) {
+    return res.status(400).json({
+      ok: false,
+      error: "macAddress is required"
+    });
+  }
+
+  try {
+    await sendWakePacket(macAddress, {
+      udpPort: WAKE_UDP_PORT,
+      broadcastAddress: WAKE_BROADCAST_ADDRESS,
+      repeat: WAKE_PACKET_REPEAT,
+      delayMs: WAKE_PACKET_DELAY_MS
+    });
+
+    return res.json({
+      ok: true,
+      macAddress,
+      sentAt: Date.now(),
+      repeats: WAKE_PACKET_REPEAT
+    });
+  } catch (error) {
+    return res.status(502).json({
+      ok: false,
+      error: String(error?.message || error)
+    });
+  }
+});
+
+app.listen(WAKE_PROXY_PORT, () => {
+  console.log(`[wake-proxy] listening on http://localhost:${WAKE_PROXY_PORT}`);
+  console.log(`[wake-proxy] udp target: ${WAKE_BROADCAST_ADDRESS}:${WAKE_UDP_PORT}`);
+  if (WAKE_PROXY_TOKEN) {
+    console.log("[wake-proxy] auth token: enabled");
+  }
+});
+
+async function sendWakePacket(macAddress, options) {
+  const macBytes = macAddress.split(":").map((part) => Number.parseInt(part, 16));
+  if (macBytes.length !== 6 || macBytes.some((item) => !Number.isFinite(item))) {
+    throw new Error("invalid MAC address");
+  }
+
+  const packet = Buffer.alloc(6 + 16 * 6, 0xff);
+  for (let i = 0; i < 16; i += 1) {
+    for (let j = 0; j < 6; j += 1) {
+      packet[6 + i * 6 + j] = macBytes[j];
+    }
+  }
+
+  const socket = dgram.createSocket("udp4");
+
+  try {
+    await new Promise((resolve, reject) => {
+      socket.once("error", reject);
+      socket.bind(0, () => {
+        try {
+          socket.setBroadcast(true);
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+
+    for (let attempt = 0; attempt < options.repeat; attempt += 1) {
+      await new Promise((resolve, reject) => {
+        socket.send(packet, 0, packet.length, options.udpPort, options.broadcastAddress, (error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        });
+      });
+
+      if (attempt < options.repeat - 1 && options.delayMs > 0) {
+        await sleep(options.delayMs);
+      }
+    }
+  } finally {
+    socket.close();
+  }
+}
+
+function normalizeMacAddress(value) {
+  const raw = String(value || "")
+    .trim()
+    .toUpperCase()
+    .replace(/[^0-9A-F]/g, "");
+  if (raw.length !== 12) return "";
+  if (raw === "000000000000" || raw === "FFFFFFFFFFFF") return "";
+  const chunks = raw.match(/.{1,2}/g);
+  return chunks ? chunks.join(":") : "";
+}
+
+function toInt(value, fallback = 0) {
+  const parsed = Number.parseInt(String(value), 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+function safeText(value, maxLength) {
+  if (typeof value !== "string") return "";
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  if (trimmed.length <= maxLength) return trimmed;
+  return trimmed.slice(0, maxLength);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}