Headless server mode

#!/usr/bin/env node
import { spawn } from "node:child_process";

const WORKSPACE = process.argv[2] ?? process.cwd();
const PROMPT = process.argv[3] ?? "List the files in this project and summarize it.";
const PROTOCOL_VERSION = "0.7.0"; // the version your client targets

// ---- spawn the headless server ----
const server = spawn("embedder", ["--server"], {
  cwd: WORKSPACE,
  env: process.env, // inherits stored credentials / EMBEDDER_AUTH_TOKEN
  stdio: ["pipe", "pipe", "pipe"],
});
server.stderr.on("data", (b) => process.stderr.write(`[server] ${b}`));

// ---- JSON-RPC framing ----
let buf = Buffer.alloc(0);
let nextId = 1;
const pending = new Map();

function send(msg) {
  const body = JSON.stringify(msg);
  server.stdin.write(`Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`);
}
function request(method, params) {
  const id = nextId++;
  return new Promise((resolve, reject) => {
    pending.set(id, { resolve, reject });
    send({ jsonrpc: "2.0", id, method, params });
  });
}

server.stdout.on("data", (chunk) => {
  buf = Buffer.concat([buf, chunk]);
  while (true) {
    const headerEnd = buf.indexOf("\r\n\r\n");
    if (headerEnd === -1) break;
    const m = /content-length:\s*(\d+)/i.exec(buf.subarray(0, headerEnd).toString("ascii"));
    if (!m) { buf = buf.subarray(headerEnd + 4); continue; }
    const start = headerEnd + 4, end = start + Number(m[1]);
    if (buf.length < end) break;
    const msg = JSON.parse(buf.subarray(start, end).toString("utf8"));
    buf = buf.subarray(end);
    dispatch(msg);
  }
});

function dispatch(msg) {
  if (msg.id !== undefined && (msg.result !== undefined || msg.error !== undefined)) {
    const p = pending.get(msg.id);
    pending.delete(msg.id);
    if (p) msg.error ? p.reject(new Error(JSON.stringify(msg.error))) : p.resolve(msg.result);
  } else if (msg.method) {
    onNotification(msg.method, msg.params ?? {});
  }
}

// ---- turn state + completion detection ----
let sawBusy = false, busy = false, done;
const turnComplete = new Promise((r) => (done = r));
let graceTimer = null;
function maybeComplete() {
  clearTimeout(graceTimer);
  if (sawBusy && !busy) graceTimer = setTimeout(done, 3000);
}

function onNotification(method, p) {
  switch (method) {
    case "chat/textDelta":
      process.stdout.write(p.delta ?? "");
      if (p.isFinal) maybeComplete();
      break;
    case "chat/toolCall":
      if (p.status === "executing") console.error(`\n[tool] ${p.toolName} ${JSON.stringify(p.args)}`);
      break;
    case "chat/toolResult":
      console.error(`[tool ${p.result?.success === false ? "✗" : "✓"}] ${p.result?.summary ?? ""}`);
      break;
    case "tool/confirmRequest": // belt-and-suspenders if auto-confirm is off
      request("tool/respond", { toolCallId: p.toolCallId, response: "always" });
      break;
    case "question/ask": {
      const answers = {};
      for (const q of p.questions ?? [])
        answers[q.header ?? q.question] = { answers: [q.options?.[0]?.label ?? "yes"], isCustom: false };
      request("question/respond", { questionId: p.questionId, answers });
      break;
    }
    case "state/update":
      if (p.chatBusy && !busy) { busy = true; sawBusy = true; }
      else if (!p.chatBusy && busy) { busy = false; maybeComplete(); }
      break;
  }
}

// ---- run ----
const init = await request("initialize", {
  protocolVersion: PROTOCOL_VERSION,
  workspacePath: WORKSPACE,
  clientName: "example-client",
  clientVersion: "1.0.0",
});
console.error(`initialized: ${init.serverName} v${init.serverVersion}, session ${init.sessionId}`);

// wait for auth + model (see "Wait for readiness")
const fatal = new Set(["unauthenticated", "error", "no_plan", "subscription_past_due", "evaluation_expired", "suspended"]);
for (let i = 0; i < 90; i++) {
  const st = await request("session/status", {});
  if (fatal.has(st.sessionStatus)) throw new Error(`not usable: ${st.sessionStatus}`);
  if (st.currentModel || st.sessionStatus === "ready") break;
  await new Promise((r) => setTimeout(r, 700));
}

// select a team + project (required — the model proxy needs the project context)
const { teams } = await request("team/list", {});
if (teams?.[0]) { await request("team/select", { teamId: teams[0].id }); console.error(`team: ${teams[0].name}`); }
const { projects } = await request("project/list", {});
if (projects?.[0]) { await request("project/select", { projectId: projects[0].id }); console.error(`project: ${projects[0].name}`); }

await request("autoConfirm/set", { enabled: true });
const res = await request("chat/send", { content: PROMPT, mode: "act" });
console.error(`\nchat/send accepted: ${res.messageId}\n`);

await turnComplete;
console.error("\n\n[turn complete]");
server.stdin.end(); // server exits on stdin EOF