agent-companion 0.1.0

package/scripts/laptop-service.mjs

@@ -0,0 +1,282 @@
+#!/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";
+import { printAgentCompanionBanner } from "./banner.mjs";
+
+const argv = process.argv.slice(2);
+const args = parseArgs(argv);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, "..");
+
+const bridgePort = clampInt(args["bridge-port"], 8787, 1, 65535);
+const relayPort = clampInt(args["relay-port"], 9797, 1, 65535);
+const withLocalRelay = toBool(args["with-local-relay"]);
+const defaultPublicRelayUrl = "https://agent-companion-relay.onrender.com";
+const relayUrl = withLocalRelay
+  ? trim(args.relay) || trim(process.env.AGENT_RELAY_URL) || `http://localhost:${relayPort}`
+  : trim(args.relay) || trim(process.env.AGENT_RELAY_URL) || defaultPublicRelayUrl;
+const companionName = trim(args.name);
+const companionStateFile = trim(args["state-file"]);
+const bridgeToken = trim(args["bridge-token"]) || trim(process.env.AGENT_BRIDGE_TOKEN);
+const wakeMac = trim(args["wake-mac"]) || trim(args.wakeMac) || trim(process.env.AGENT_WAKE_MAC);
+const verbose = toBool(args.verbose) || toBool(process.env.AGENT_VERBOSE);
+const keepAwakeEnabled = !toBool(args["allow-sleep"]) && !toBool(process.env.AGENT_ALLOW_SLEEP);
+
+const bridgeBaseUrl = `http://localhost:${bridgePort}`;
+const childSpecs = [];
+
+printAgentCompanionBanner();
+
+childSpecs.push({
+  name: "bridge",
+  cmd: process.execPath,
+  args: ["bridge/server.mjs"],
+  env: {
+    ...process.env,
+    AGENT_BRIDGE_PORT: String(bridgePort),
+    ...(bridgeToken ? { AGENT_BRIDGE_TOKEN: bridgeToken } : {})
+  }
+});
+
+if (withLocalRelay) {
+  childSpecs.push({
+    name: "relay",
+    cmd: process.execPath,
+    args: ["relay/server.mjs"],
+    env: {
+      ...process.env,
+      RELAY_PORT: String(relayPort),
+      RELAY_PUBLIC_URL: trim(args["relay-public-url"]) || process.env.RELAY_PUBLIC_URL || `http://localhost:${relayPort}`
+    }
+  });
+}
+
+const children = [];
+let shuttingDown = false;
+
+if (keepAwakeEnabled) {
+  const keepAwake = startKeepAwakeProcess({ verbose });
+  if (keepAwake) {
+    children.push({ name: keepAwake.name, child: keepAwake.child });
+  }
+}
+
+process.on("SIGINT", () => shutdown("SIGINT"));
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+
+for (const spec of childSpecs) {
+  const child = spawn(spec.cmd, spec.args, {
+    cwd: projectRoot,
+    env: spec.env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  attachLogs(spec.name, child);
+  children.push({ name: spec.name, child });
+}
+
+await waitForHealth(`${bridgeBaseUrl}/health`, 15_000, "bridge");
+if (withLocalRelay) {
+  await waitForHealth(`${relayUrl}/health`, 15_000, "relay");
+}
+
+const companionArgs = [
+  "scripts/laptop-companion.mjs",
+  "--bridge",
+  bridgeBaseUrl,
+  "--relay",
+  relayUrl
+];
+
+if (companionName) {
+  companionArgs.push("--name", companionName);
+}
+if (companionStateFile) {
+  companionArgs.push("--state-file", companionStateFile);
+}
+if (bridgeToken) {
+  companionArgs.push("--bridgeToken", bridgeToken);
+}
+if (wakeMac) {
+  companionArgs.push("--wake-mac", wakeMac);
+}
+
+const companion = spawn(process.execPath, companionArgs, {
+  cwd: projectRoot,
+  env: {
+    ...process.env,
+    AGENT_COMPANION_QUIET: verbose ? "0" : "1"
+  },
+  stdio: ["ignore", "pipe", "pipe"]
+});
+companion.stdout.pipe(process.stdout);
+companion.stderr.pipe(process.stderr);
+children.push({ name: "companion", child: companion });
+
+companion.on("close", (code) => {
+  if (shuttingDown) return;
+  if (Number.isInteger(code) && code === 0) return;
+  console.error(`[companion-service] companion exited with code ${code ?? "unknown"}`);
+  shutdown("companion-exit");
+});
+
+function attachLogs(name, child) {
+  if (!verbose) {
+    child.on("close", (code) => {
+      if (shuttingDown) return;
+      if (Number.isInteger(code) && code === 0) return;
+      console.error(`[companion-service] ${name} exited with code ${code ?? "unknown"}`);
+    });
+    return;
+  }
+
+  child.stdout.on("data", (chunk) => {
+    process.stdout.write(`[${name}] ${chunk}`);
+  });
+  child.stderr.on("data", (chunk) => {
+    process.stderr.write(`[${name}] ${chunk}`);
+  });
+  child.on("close", (code) => {
+    if (shuttingDown) return;
+    if (Number.isInteger(code) && code === 0) return;
+    console.error(`[companion-service] ${name} exited with code ${code ?? "unknown"}`);
+  });
+}
+
+function startKeepAwakeProcess({ verbose }) {
+  if (process.platform === "darwin") {
+    const child = spawn("caffeinate", ["-dimsu"], {
+      cwd: projectRoot,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    child.on("error", (error) => {
+      process.stderr.write(`[companion-service] keep-awake unavailable: ${String(error?.message || error)}\n`);
+    });
+    if (verbose) {
+      attachLogs("keep-awake", child);
+    } else {
+      child.stderr.on("data", () => {
+        // suppress noisy caffeinate stderr in quiet mode
+      });
+    }
+    return { name: "keep-awake", child };
+  }
+
+  if (process.platform === "linux") {
+    const child = spawn(
+      "systemd-inhibit",
+      ["--what=sleep", "--why=agent-companion", "--mode=block", "sleep", "infinity"],
+      {
+        cwd: projectRoot,
+        env: process.env,
+        stdio: ["ignore", "pipe", "pipe"]
+      }
+    );
+    child.on("error", (error) => {
+      process.stderr.write(`[companion-service] keep-awake unavailable: ${String(error?.message || error)}\n`);
+    });
+    if (verbose) {
+      attachLogs("keep-awake", child);
+    }
+    return { name: "keep-awake", child };
+  }
+
+  return null;
+}
+
+function shutdown(reason) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  process.stderr.write(`\n[companion-service] shutting down (${reason})...\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);
+  }, 1500);
+}
+
+async function waitForHealth(url, timeoutMs, name) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const response = await fetch(url, { method: "GET" });
+      if (response.ok) return;
+    } catch {
+      // keep retrying
+    }
+    await sleep(250);
+  }
+  throw new Error(`${name} health check timed out at ${url}`);
+}
+
+function parseArgs(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 toBool(value) {
+  const normalized = trim(value).toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+
+function trim(value) {
+  return String(value || "").trim();
+}
+
+function clampInt(value, fallback, min, max) {
+  const parsed = Number.parseInt(String(value || ""), 10);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.max(min, Math.min(max, parsed));
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function printUsageAndExit(code, error = "") {
+  if (error) {
+    console.error(`[companion-service] ${error}`);
+  }
+  console.log(`Usage:
+  node scripts/laptop-service.mjs [--relay <url>] [options]
+  node scripts/laptop-service.mjs --with-local-relay [options]
+
+Options:
+  --relay <url>                 Public or private relay URL for companion
+  --with-local-relay            Also run relay in this process group
+  --relay-port <port>           Relay port when --with-local-relay (default: 9797)
+  --relay-public-url <url>      Public URL relay announces (default local URL)
+  --bridge-port <port>          Bridge port (default: 8787)
+  --bridge-token <token>        Optional bridge token
+  --wake-mac <mac>              Optional Wake-on-LAN MAC (AA:BB:CC:DD:EE:FF)
+  --allow-sleep                 Disable keep-awake mode
+  --name <label>                Computer display name for pairing
+  --state-file <path>           Companion state file path
+`);
+  process.exit(code);
+}

package/scripts/repair-codex-resume.mjs

@@ -0,0 +1,300 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const argv = process.argv.slice(2);
+const dryRun = argv.includes("--dry-run");
+const daysValue = readOption(argv, "--days");
+const daysBack = safeInt(daysValue, 30);
+const maxAgeMs = daysBack > 0 ? daysBack * 24 * 60 * 60 * 1000 : 0;
+
+const codexRoot = path.join(os.homedir(), ".codex");
+const sessionsRoot = path.join(codexRoot, "sessions");
+const globalStateFile = path.join(codexRoot, ".codex-global-state.json");
+
+let scanned = 0;
+let patched = 0;
+let titlesFromRollouts = 0;
+
+const discoveredTitles = new Map();
+
+for (const rolloutPath of listRolloutFiles(sessionsRoot)) {
+  let stat;
+  try {
+    stat = fs.statSync(rolloutPath);
+  } catch {
+    continue;
+  }
+
+  if (maxAgeMs > 0 && Date.now() - stat.mtimeMs > maxAgeMs) {
+    continue;
+  }
+
+  scanned += 1;
+  const result = repairRollout(rolloutPath, { dryRun });
+  if (result.patched) patched += 1;
+
+  if (result.threadId) {
+    const existing = discoveredTitles.get(result.threadId) || "";
+    if (!existing && result.title) {
+      discoveredTitles.set(result.threadId, result.title);
+      titlesFromRollouts += 1;
+    } else if (!existing) {
+      discoveredTitles.set(result.threadId, `Phone task ${result.threadId.slice(0, 8)}`);
+    }
+  }
+}
+
+const indexed = upsertThreadTitles(globalStateFile, discoveredTitles, { dryRun });
+
+console.log(
+  `[resume-repair] scanned=${scanned} patched=${patched} indexed=${indexed} titles_detected=${titlesFromRollouts} dry_run=${dryRun}`
+);
+
+function repairRollout(filePath, options) {
+  const out = { patched: false, threadId: "", title: "" };
+
+  let raw = "";
+  try {
+    raw = fs.readFileSync(filePath, "utf8");
+  } catch {
+    return out;
+  }
+  if (!raw.trim()) return out;
+
+  const newlineIndex = raw.indexOf("\n");
+  const firstLine = newlineIndex >= 0 ? raw.slice(0, newlineIndex) : raw;
+  const rest = newlineIndex >= 0 ? raw.slice(newlineIndex) : "";
+  if (!firstLine.trim()) return out;
+
+  let meta = null;
+  try {
+    meta = JSON.parse(firstLine);
+  } catch {
+    return out;
+  }
+  if (!meta || typeof meta !== "object") return out;
+
+  const topLevelThreadId = typeof meta.thread_id === "string" ? meta.thread_id : "";
+  const payloadThreadId =
+    meta.payload && typeof meta.payload === "object" && typeof meta.payload.id === "string"
+      ? meta.payload.id
+      : "";
+  const threadId = topLevelThreadId || payloadThreadId;
+  if (threadId) out.threadId = threadId;
+
+  const candidates = [meta];
+  if (meta.payload && typeof meta.payload === "object") {
+    candidates.push(meta.payload);
+  }
+
+  let changed = false;
+  for (const candidate of candidates) {
+    if (!candidate || typeof candidate !== "object") continue;
+    const source = typeof candidate.source === "string" ? candidate.source.trim().toLowerCase() : "";
+
+    if (
+      (source === "exec" || source === "cli") &&
+      (candidate.originator === "codex_exec" || candidate.originator === "Codex Desktop")
+    ) {
+      candidate.originator = "codex_cli_rs";
+      changed = true;
+    }
+
+    if (source === "exec") {
+      candidate.source = "cli";
+      changed = true;
+    }
+  }
+
+  out.title = extractPromptTitle(raw);
+
+  if (!changed) return out;
+  out.patched = true;
+
+  if (!options.dryRun) {
+    const nextRaw = `${JSON.stringify(meta)}${rest}`;
+    atomicWriteText(filePath, nextRaw);
+  }
+
+  return out;
+}
+
+function extractPromptTitle(raw) {
+  const lines = raw.split(/\r?\n/);
+  const maxLines = Math.min(lines.length, 180);
+
+  for (let index = 1; index < maxLines; index += 1) {
+    const line = lines[index].trim();
+    if (!line || line[0] !== "{") continue;
+
+    let parsed = null;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+
+    const eventMessage =
+      parsed?.type === "event_msg" && parsed?.payload?.type === "user_message"
+        ? parsed?.payload?.message
+        : "";
+    const responseMessage = extractTextFromResponseItem(parsed);
+    const candidate = cleanTitle(eventMessage || responseMessage);
+
+    if (!candidate) continue;
+    if (!isLikelyPrompt(candidate)) continue;
+    return candidate.slice(0, 120);
+  }
+
+  return "";
+}
+
+function extractTextFromResponseItem(parsed) {
+  if (parsed?.type !== "response_item") return "";
+  const payload = parsed?.payload;
+  if (!payload || payload.type !== "message" || payload.role !== "user") return "";
+
+  for (const entry of Array.isArray(payload.content) ? payload.content : []) {
+    if (!entry || typeof entry !== "object") continue;
+    if (typeof entry.input_text === "string" && entry.input_text.trim()) return entry.input_text.trim();
+    if (typeof entry.text === "string" && entry.text.trim()) return entry.text.trim();
+  }
+  return "";
+}
+
+function cleanTitle(value) {
+  if (typeof value !== "string") return "";
+  return value.replace(/\s+/g, " ").trim();
+}
+
+function isLikelyPrompt(text) {
+  const lower = text.toLowerCase();
+  if (!lower) return false;
+  if (lower.startsWith("# agents.md")) return false;
+  if (lower.includes("<permissions instructions>")) return false;
+  if (lower.includes("<environment_context>")) return false;
+  if (lower.includes("collaboration mode")) return false;
+  if (lower.includes("mcp tool discovery")) return false;
+  return true;
+}
+
+function upsertThreadTitles(filePath, titlesMap, options) {
+  if (titlesMap.size === 0) return 0;
+
+  let parsed = {};
+  if (fs.existsSync(filePath)) {
+    try {
+      parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    } catch {
+      parsed = {};
+    }
+  }
+
+  if (!parsed || typeof parsed !== "object") {
+    parsed = {};
+  }
+
+  const current = parsed["thread-titles"];
+  const titles =
+    current && typeof current === "object" && current.titles && typeof current.titles === "object"
+      ? { ...current.titles }
+      : {};
+  const order =
+    current && typeof current === "object" && Array.isArray(current.order)
+      ? current.order.filter((item) => typeof item === "string")
+      : [];
+
+  let updated = 0;
+  const prioritized = [];
+  for (const [threadId, title] of titlesMap.entries()) {
+    const safeTitle = cleanTitle(title) || `Phone task ${threadId.slice(0, 8)}`;
+    const previous = typeof titles[threadId] === "string" ? titles[threadId] : "";
+
+    if (!previous || previous.startsWith("Phone task")) {
+      if (previous !== safeTitle) {
+        titles[threadId] = safeTitle;
+        updated += 1;
+      }
+    }
+    prioritized.push(threadId);
+  }
+
+  const nextOrder = [...prioritized, ...order.filter((id) => !prioritized.includes(id))].slice(0, 1200);
+  parsed["thread-titles"] = {
+    ...(current && typeof current === "object" ? current : {}),
+    titles,
+    order: nextOrder
+  };
+
+  if (!options.dryRun) {
+    atomicWriteText(filePath, JSON.stringify(parsed));
+  }
+
+  return updated;
+}
+
+function listRolloutFiles(root) {
+  const files = [];
+  if (!fs.existsSync(root)) return files;
+
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (!entry.name.startsWith("rollout-")) continue;
+      if (!entry.name.endsWith(".jsonl")) continue;
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+function atomicWriteText(filePath, content) {
+  const dir = path.dirname(filePath);
+  const base = path.basename(filePath);
+  const tempPath = path.join(dir, `.${base}.tmp-${process.pid}-${Date.now()}`);
+  let mode = undefined;
+
+  try {
+    mode = fs.statSync(filePath).mode;
+  } catch {
+    mode = undefined;
+  }
+
+  if (typeof mode === "number") {
+    fs.writeFileSync(tempPath, content, { mode });
+  } else {
+    fs.writeFileSync(tempPath, content);
+  }
+
+  fs.renameSync(tempPath, filePath);
+}
+
+function safeInt(value, fallback) {
+  const parsed = Number.parseInt(String(value), 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function readOption(args, name) {
+  const index = args.indexOf(name);
+  if (index < 0) return "";
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) return "";
+  return value;
+}

package/scripts/reset-bridge.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import process from "node:process";
+
+const bridge = process.env.AGENT_BRIDGE_URL || "http://localhost:8787";
+
+const response = await fetch(`${bridge}/api/reset`, {
+  method: "POST",
+  headers: {
+    "Content-Type": "application/json"
+  },
+  body: JSON.stringify({})
+});
+
+if (!response.ok) {
+  console.error(await response.text());
+  process.exit(1);
+}
+
+console.log("Bridge state reset to defaults.");

package/scripts/start-task.mjs

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+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 = options.bridge || process.env.AGENT_BRIDGE_URL || "http://localhost:8787";
+const workspacePath = options.workspace || process.cwd();
+const agentType = options.agent === "CLAUDE" ? "CLAUDE" : "CODEX";
+const prompt = options.prompt || "";
+const title = options.title || "";
+const token = options.token || process.env.AGENT_BRIDGE_TOKEN || "";
+const fullWorkspaceAccess = parseBooleanOption(options["full-workspace-access"]);
+const skipPermissions = parseBooleanOption(options["skip-permissions"]);
+const planMode = parseBooleanOption(options["plan-mode"]);
+
+if (commandArgs.length === 0 && !prompt.trim()) {
+  printUsageAndExit(1);
+}
+
+const payload = {
+  agentType,
+  workspacePath,
+  title,
+  prompt
+};
+
+if (commandArgs.length > 0) {
+  payload.command = commandArgs;
+}
+if (fullWorkspaceAccess) {
+  payload.fullWorkspaceAccess = true;
+}
+if (skipPermissions) {
+  payload.skipPermissions = true;
+}
+if (planMode) {
+  payload.planMode = true;
+}
+
+const headers = {
+  "Content-Type": "application/json"
+};
+if (token) {
+  headers["x-bridge-token"] = token;
+}
+
+const response = await fetch(`${bridgeUrl}/api/launcher/start`, {
+  method: "POST",
+  headers,
+  body: JSON.stringify(payload)
+});
+
+const text = await response.text();
+let json;
+try {
+  json = text ? JSON.parse(text) : {};
+} catch {
+  json = { raw: text };
+}
+
+if (!response.ok) {
+  console.error(`[start-task] error ${response.status}:`, json);
+  process.exit(1);
+}
+
+console.log("[start-task] launched:");
+console.log(JSON.stringify(json, null, 2));
+
+function parseOptions(args) {
+  const out = {};
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg.startsWith("--")) continue;
+
+    const key = arg.slice(2);
+    const next = args[index + 1];
+
+    if (!next || next.startsWith("--")) {
+      out[key] = "true";
+      continue;
+    }
+
+    out[key] = next;
+    index += 1;
+  }
+
+  return out;
+}
+
+function printUsageAndExit(code) {
+  console.log(`Usage:\n  node scripts/start-task.mjs --agent CODEX|CLAUDE --workspace <path> --prompt "Task" [--title "Name"] [--bridge <url>] [--token <token>] [--full-workspace-access] [--skip-permissions] [--plan-mode]\n\n  # custom command\n  node scripts/start-task.mjs --agent CODEX --workspace <path> --plan-mode -- -- zsh -lc "echo hello"\n`);
+  process.exit(code);
+}
+
+function parseBooleanOption(value) {
+  if (value == null) return false;
+  const normalized = String(value).trim().toLowerCase();
+  if (!normalized) return false;
+  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}