agent-companion 0.1.0

package/scripts/background-service.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+import path from "node:path";
+import process from "node:process";
+
+const argv = process.argv.slice(2);
+const dividerIndex = argv.indexOf("--");
+const optionArgs = dividerIndex >= 0 ? argv.slice(0, dividerIndex) : argv;
+const commandArgs = dividerIndex >= 0 ? argv.slice(dividerIndex + 1).filter(Boolean) : [];
+while (commandArgs[0] === "--") {
+  commandArgs.shift();
+}
+
+const options = parseOptions(optionArgs);
+const bridgeUrl = trimTrailingSlash(
+  options.bridge || process.env.AGENT_COMPANION_BRIDGE_URL || process.env.AGENT_BRIDGE_URL || "http://localhost:8787"
+);
+const workspacePath = path.resolve(options.workspace || process.env.AGENT_WORKSPACE_PATH || process.cwd());
+const sessionId = trim(options.session || process.env.AGENT_SESSION_ID || "");
+const label = trim(options.label || "");
+const commandText = trim(options.command || "");
+const token = trim(options.token || process.env.AGENT_BRIDGE_TOKEN || "");
+
+const portRaw = Number.parseInt(String(options.port || "").trim(), 10);
+const port = Number.isFinite(portRaw) && portRaw > 0 && portRaw <= 65535 ? portRaw : null;
+
+const payload = {
+  workspacePath,
+};
+if (sessionId) payload.sessionId = sessionId;
+if (label) payload.label = label;
+if (port) payload.port = port;
+
+if (commandArgs.length > 0) {
+  payload.command = commandArgs;
+} else if (commandText) {
+  payload.command = commandText;
+} else {
+  printUsageAndExit(1, "missing command");
+}
+
+const headers = {
+  "Content-Type": "application/json",
+  Accept: "application/json",
+};
+if (token) {
+  headers["x-bridge-token"] = token;
+}
+
+const response = await fetch(`${bridgeUrl}/api/launcher/services/start`, {
+  method: "POST",
+  headers,
+  body: JSON.stringify(payload),
+});
+
+const text = await response.text();
+let body;
+try {
+  body = text ? JSON.parse(text) : {};
+} catch {
+  body = { raw: text };
+}
+
+if (!response.ok || !body?.ok || !body?.service) {
+  const errorText = typeof body?.error === "string" ? body.error : `request failed (${response.status})`;
+  console.error(`[background-service] ${errorText}`);
+  if (body && typeof body === "object") {
+    console.error(JSON.stringify(body, null, 2));
+  }
+  process.exit(1);
+}
+
+const service = body.service;
+console.log(`[background-service] started ${service.id}`);
+console.log(`[background-service] status=${service.status} pid=${service.pid ?? "pending"}`);
+if (service.localhostUrl) {
+  console.log(`[background-service] localhost=${service.localhostUrl}`);
+}
+console.log(JSON.stringify({ ok: true, service }, null, 2));
+
+function parseOptions(tokens) {
+  const out = {};
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (!token.startsWith("--")) continue;
+    const key = token.slice(2);
+    const next = tokens[index + 1];
+    if (!next || next.startsWith("--")) {
+      out[key] = "true";
+      continue;
+    }
+    out[key] = next;
+    index += 1;
+  }
+  return out;
+}
+
+function trim(value) {
+  return String(value || "").trim();
+}
+
+function trimTrailingSlash(value) {
+  return trim(value).replace(/\/+$/, "");
+}
+
+function printUsageAndExit(code, error = "") {
+  if (error) {
+    console.error(`[background-service] ${error}`);
+  }
+  console.log(`Usage:
+  node scripts/background-service.mjs [options] -- <command> [args...]
+  node scripts/background-service.mjs --command "<shell command>" [options]
+
+Options:
+  --bridge <url>        Bridge URL (default: http://localhost:8787)
+  --workspace <path>    Workspace path (default: current directory)
+  --session <id>        Optional session id for timeline events
+  --label <text>        Optional display label
+  --port <n>            Optional localhost port hint
+  --token <token>       Optional bridge token
+`);
+  process.exit(code);
+}

package/scripts/banner.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+export function printAgentCompanionBanner() {
+  const useColor = shouldUseColor();
+  const reset = useColor ? "\x1b[0m" : "";
+  const brand = colorRgb(209, 145, 99, useColor, true);
+  const dot = colorRgb(34, 182, 155, useColor, true);
+  const text = colorRgb(181, 187, 200, useColor, true);
+  const hint = colorRgb(121, 123, 130, useColor);
+
+  console.log("");
+  console.log(`  ${brand}agent${reset}${text}.${reset}${text}companion${reset} ${dot}•${reset}`);
+  console.log(`  ${hint}computer service${reset}`);
+  console.log("");
+}
+
+export function printInfoLine(label, value) {
+  const useColor = shouldUseColor();
+  const labelColor = colorRgb(121, 123, 130, useColor);
+  const valueColor = colorRgb(236, 236, 239, useColor, true);
+  const reset = useColor ? "\x1b[0m" : "";
+
+  console.log(`  ${labelColor}${label.padEnd(10)}${reset}${valueColor}${value}${reset}`);
+}
+
+function shouldUseColor() {
+  if (process.env.NO_COLOR) return false;
+  if (process.env.FORCE_COLOR === "0") return false;
+  return process.stdout.isTTY;
+}
+
+function colorRgb(r, g, b, enabled, bold = false) {
+  if (!enabled) return "";
+  const boldPart = bold ? "1;" : "";
+  return `\x1b[${boldPart}38;2;${r};${g};${b}m`;
+}

package/scripts/cli.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import path from "node:path";
+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 computerServiceScript = path.resolve(projectRoot, "scripts", "laptop-service.mjs");
+
+const argv = process.argv.slice(2);
+const command = String(argv[0] || "").trim().toLowerCase();
+const rest = argv.slice(1);
+
+if (command === "help" || command === "--help" || command === "-h") {
+  printHelp(0);
+}
+
+if (!command || command.startsWith("--")) {
+  runNodeScript(computerServiceScript, argv);
+} else if (command === "laptop" || command === "computer" || command === "desktop") {
+  runNodeScript(computerServiceScript, rest);
+} else if (command === "relay") {
+  runNodeScript(path.resolve(projectRoot, "relay", "server.mjs"), rest);
+} else if (command === "bridge") {
+  runNodeScript(path.resolve(projectRoot, "bridge", "server.mjs"), rest);
+} else if (command === "background" || command === "bg") {
+  runNodeScript(path.resolve(projectRoot, "scripts", "background-service.mjs"), rest);
+} else if (command === "wake-proxy") {
+  runNodeScript(path.resolve(projectRoot, "wake-proxy", "server.mjs"), rest);
+} else {
+  console.error(`[agent-companion] unknown command "${command}"`);
+  printHelp(1);
+}
+
+function runNodeScript(scriptPath, args) {
+  const child = spawn(process.execPath, [scriptPath, ...args], {
+    cwd: projectRoot,
+    env: process.env,
+    stdio: "inherit"
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(Number.isInteger(code) ? code : 1);
+  });
+}
+
+function printHelp(exitCode) {
+  console.log(`Usage:
+  agent-companion
+  agent-companion --relay <url>
+  agent-companion --with-local-relay
+  agent-companion computer
+  agent-companion computer --relay <url>
+  agent-companion computer --with-local-relay
+  agent-companion relay
+  agent-companion bridge
+  agent-companion background --workspace <path> -- <command>
+  agent-companion wake-proxy
+
+Examples:
+  agent-companion
+  agent-companion --relay https://agent-companion-relay.onrender.com
+  agent-companion --with-local-relay
+  agent-companion computer
+  agent-companion computer --relay https://agent-companion-relay.onrender.com
+  agent-companion computer --with-local-relay
+  agent-companion background --workspace ~/Desktop/test --port 5173 -- npm run dev
+  agent-companion wake-proxy
+`);
+  process.exit(exitCode);
+}

package/scripts/dev-stack.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+
+const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+
+const runners = [
+  {
+    name: "bridge",
+    cmd: npmCmd,
+    args: ["run", "bridge"]
+  },
+  {
+    name: "web",
+    cmd: npmCmd,
+    args: ["run", "dev", "--", "--host", "0.0.0.0", "--port", "5173"]
+  }
+];
+
+const children = runners.map((runner) => {
+  const child = spawn(runner.cmd, runner.args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: false,
+    env: process.env
+  });
+
+  child.stdout.on("data", (chunk) => {
+    process.stdout.write(`[${runner.name}] ${chunk}`);
+  });
+
+  child.stderr.on("data", (chunk) => {
+    process.stderr.write(`[${runner.name}] ${chunk}`);
+  });
+
+  child.on("close", (code) => {
+    if (code === 0) return;
+    process.stderr.write(`[${runner.name}] exited with code ${code}\n`);
+  });
+
+  return child;
+});
+
+let shuttingDown = false;
+
+function shutdown(signal) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  process.stderr.write(`\n[stack] received ${signal}, shutting down...\n`);
+
+  for (const child of children) {
+    if (!child.killed) {
+      child.kill("SIGTERM");
+    }
+  }
+
+  setTimeout(() => {
+    for (const child of children) {
+      if (!child.killed) child.kill("SIGKILL");
+    }
+    process.exit(0);
+  }, 1200);
+}
+
+process.on("SIGINT", () => shutdown("SIGINT"));
+process.on("SIGTERM", () => shutdown("SIGTERM"));