@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.3

package/src/collab/link-api.js

@@ -0,0 +1,229 @@
+import { isAbsolute } from "node:path";
+import { isAgentId, validateAgentSettings } from "../adapters/index.js";
+import { readJson, send } from "../http.js";
+import { logError } from "../log.js";
+import { CHECKPOINT_ID, CollabError, validatePathId } from "./model.js";
+import { ownerActor } from "./store.js";
+const BODY_LIMIT = 16 * 1024, START_BODY_LIMIT = 64 * 1024, BODY_TIMEOUT = { timeoutMs: 1e4 };
+const TRUSTS = ["safe", "standard", "trusted", "full"], START_FIELDS = ["repo", "pattern", "roles", "agentSettings", "roleSettings", "trust", "loop", "fromCheckpointId"], LOOP_FIELDS = ["check", "setup", "maxMinutes", "maxSteps"];
+const object = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+const absent = (v) => v === void 0 || v === null || v === "";
+const body = (req, limit = BODY_LIMIT) => readJson(req, limit, BODY_TIMEOUT);
+function assertKeys(value, allowed, what) {
+  const extra = Object.keys(value).find((key) => !allowed.includes(key));
+  if (extra !== void 0) throw new CollabError(`Unknown ${what} field ${JSON.stringify(extra.slice(0, 40))}; the allowed fields are ${allowed.join(", ")}`);
+}
+function repoPath(value, required) {
+  if (absent(value)) {
+    if (required) throw new CollabError("Send the absolute path of your clone as repo");
+    return void 0;
+  }
+  if (typeof value !== "string" || !isAbsolute(value) || value.length > 4096) throw new CollabError("Repository must be an absolute path");
+  return value;
+}
+function validateRoles(pattern, input, installed) {
+  if (!object(input)) throw new CollabError("Send roles as { <role>: [agent ids] }");
+  const known = pattern.roles.map((spec) => spec.id), extra = Object.keys(input).find((key) => !known.includes(key));
+  if (extra !== void 0) throw new CollabError(`The ${pattern.name} pattern has no role ${JSON.stringify(extra.slice(0, 40))}; its roles are ${known.join(", ")}`);
+  const roles = {};
+  for (const spec of pattern.roles) {
+    const raw = input[spec.id], list = raw === void 0 || raw === null ? [] : Array.isArray(raw) ? raw : [raw];
+    if (list.length > 6) throw new CollabError(`Pick at most 6 agents for "${spec.label}"`);
+    const agents = [];
+    for (const entry of list) {
+      if (!isAgentId(entry)) throw new CollabError(`Pick an installed agent for "${spec.label}" (claude, codex or agy)`);
+      if (!installed.includes(entry)) throw new CollabError(`${entry} is not installed or not on PATH on this computer`);
+      if (!agents.includes(entry)) agents.push(entry);
+    }
+    const chosen = spec.multiple ? agents : agents.slice(0, 1);
+    if (!chosen.length && !spec.optional) throw new CollabError(`Pick an agent for "${spec.label}"`);
+    roles[spec.id] = chosen;
+  }
+  return roles;
+}
+function settings(value, label) {
+  if (!object(value)) throw new CollabError(`Send ${label} as { <agent>: { model?, effort? } }`);
+  try {
+    return validateAgentSettings(value);
+  } catch (error) {
+    throw new CollabError(error instanceof Error ? error.message : String(error));
+  }
+}
+function roleSettings(value) {
+  if (!object(value)) throw new CollabError("Send roleSettings as { <role>: { <agent>: { model?, effort? } } }");
+  const out = {};
+  for (const [role, entry] of Object.entries(value)) {
+    if (!/^[\w-]{1,40}$/.test(role)) throw new CollabError(`Role settings name an unknown role ${JSON.stringify(role.slice(0, 40))}`);
+    const valid = settings(entry, `roleSettings.${role}`);
+    if (Object.keys(valid).length) out[role] = valid;
+  }
+  return out;
+}
+function loop(value) {
+  if (!object(value)) throw new CollabError("Send loop as { check?, setup?, maxMinutes?, maxSteps? }");
+  assertKeys(value, LOOP_FIELDS, "loop");
+  const out = {};
+  const command = (key) => {
+    if (absent(value[key])) return;
+    const line = value[key];
+    if (typeof line !== "string" || line.length > 1e3 || /[\r\n\x00]/.test(line)) throw new CollabError(`The ${key} command must be a single line of at most 1000 characters`);
+    if (line.trim()) out[key] = line.trim();
+  };
+  const number = (key, min, max) => {
+    if (absent(value[key])) return;
+    const n = Number(value[key]);
+    if (!Number.isFinite(n)) throw new CollabError(`Send ${key} as a number between ${min} and ${max}`);
+    out[key] = Math.min(max, Math.max(min, Math.round(n)));
+  };
+  command("check");
+  command("setup");
+  number("maxMinutes", 1, 720);
+  number("maxSteps", 1, 200);
+  return out;
+}
+function validateStartBody(raw, host) {
+  assertKeys(raw, START_FIELDS, "start");
+  const pattern = typeof raw.pattern === "string" && /^[a-z0-9-]{1,40}$/.test(raw.pattern) ? host.findPattern(raw.pattern) : void 0;
+  if (!pattern) throw new CollabError("Unknown pattern");
+  const input = { pattern, roles: validateRoles(pattern, raw.roles ?? {}, host.agents()) }, repo = repoPath(raw.repo, false);
+  if (repo) input.repo = repo;
+  if (!absent(raw.trust)) {
+    if (typeof raw.trust !== "string" || !TRUSTS.includes(raw.trust)) throw new CollabError("Choose agent permissions: safe, standard, trusted or full");
+    input.trust = raw.trust;
+  }
+  if (!absent(raw.agentSettings)) input.agentSettings = settings(raw.agentSettings, "agentSettings");
+  if (!absent(raw.roleSettings)) input.roleSettings = roleSettings(raw.roleSettings);
+  if (!absent(raw.loop)) input.loop = loop(raw.loop);
+  if (!absent(raw.fromCheckpointId)) {
+    if (typeof raw.fromCheckpointId !== "string" || !CHECKPOINT_ID.test(raw.fromCheckpointId)) throw new CollabError("Send the checkpoint id as 32 lowercase hexadecimal characters");
+    input.fromCheckpointId = raw.fromCheckpointId;
+  }
+  return input;
+}
+function validateDraftBody(raw, installed) {
+  assertKeys(raw, ["projectId", "repository", "idea", "agent", "repo", "baseRef", "agentSettings"], "draft");
+  const text = (key, max, required = true) => {
+    const value = raw[key];
+    if (!required && absent(value)) return void 0;
+    if (typeof value !== "string" || !value.trim() || value.length > max || value.includes("\0")) throw new CollabError(`Send ${key} as text of 1\u2013${max} characters`);
+    return value.trim();
+  };
+  if (!isAgentId(raw.agent) || !installed.includes(raw.agent)) throw new CollabError("Choose an installed drafting agent on this computer");
+  return {
+    projectId: text("projectId", 100),
+    repository: text("repository", 64),
+    idea: text("idea", 16384),
+    agent: raw.agent,
+    repo: repoPath(raw.repo, false),
+    baseRef: text("baseRef", 100, false),
+    ...!absent(raw.agentSettings) ? { agentSettings: settings(raw.agentSettings, "agentSettings") } : {}
+  };
+}
+async function linkInfo(host) {
+  const state = host.link.state(), info = { ...state };
+  if (!state.linked && host.hubName && !info.hubName) info.hubName = host.hubName;
+  if (state.linked) {
+    try {
+      const me = await host.runner.hub.me();
+      const runner = me.runners.find((entry) => entry.id === state.runnerId);
+      if (runner) info.runner = runner;
+      else info.error ??= "The team server no longer lists this computer's runner; reconnect in Settings \u2192 Team";
+    } catch (error) {
+      info.error ??= error instanceof Error ? error.message : String(error);
+    }
+  }
+  return info;
+}
+async function dispatch(req, res, _url, parts, host) {
+  const method = (req.method ?? "GET").toUpperCase(), [, , head, id, action] = parts;
+  if (head === void 0 && parts.length === 2) {
+    if (method === "GET") return send(res, 200, await linkInfo(host));
+    if (method === "DELETE") {
+      await host.link.disconnect();
+      const state = host.link.state();
+      await host.onLinkChanged?.(state);
+      return send(res, 200, { ...state });
+    }
+  }
+  if (head === "connect" && parts.length === 3 && method === "POST") {
+    const raw = await body(req);
+    assertKeys(raw, ["url", "username", "password", "name"], "connect");
+    if (host.link.linked) throw new CollabError(`This computer is already connected to ${host.link.state().url}; disconnect it first`, 409);
+    const local = await host.store.board(ownerActor(host.store.ownerName));
+    if (local.tasks.length) throw new CollabError(`This computer's own team board holds ${local.tasks.length} task${local.tasks.length === 1 ? "" : "s"}; delete them (or keep using this computer as the team server) before connecting it to another team server`, 409);
+    const state = await host.link.connect({ url: raw.url, username: raw.username, password: raw.password, name: raw.name });
+    await host.onLinkChanged?.(state);
+    host.runner.reconcile().catch((error) => logError("Local attempts could not be reconciled after connecting to the team server", error));
+    return send(res, 201, await linkInfo(host));
+  }
+  if (head === "draft" && parts.length === 3 && method === "POST") return send(res, 201, await host.runner.draftTask(validateDraftBody(await body(req, START_BODY_LIMIT), host.agents())));
+  if (head === "reconcile" && parts.length === 3 && method === "POST") return send(res, 200, await host.runner.reconcile());
+  if (head === "mappings" && parts.length === 3 && method === "PUT") {
+    const raw = await body(req);
+    assertKeys(raw, ["projectId", "repository", "path"], "mapping");
+    const mappings = await host.link.setMapping(raw.projectId, raw.repository, raw.path);
+    return send(res, 200, { mappings });
+  }
+  if (head === "attempts" && parts.length === 3 && method === "GET") {
+    const attempts = await host.runner.attempts();
+    return send(res, 200, attempts.map((record) => {
+      const run = record.runId ? host.manager.get(record.runId) : void 0;
+      return run ? { ...record, runStatus: run.status } : record;
+    }));
+  }
+  if (head === "tasks" && id !== void 0 && action !== void 0 && parts.length === 5 && method === "POST") {
+    const taskId = validatePathId(id, "task id"), runner = host.runner;
+    switch (action) {
+      case "start": {
+        const input = validateStartBody(await body(req, START_BODY_LIMIT), host);
+        return send(res, 201, await runner.startAttempt(taskId, input));
+      }
+      case "stop": {
+        const record = await runner.attemptForTask(taskId, ["claimed", "running"]);
+        if (!record) throw new CollabError("No attempt of this task is running on this computer", 409);
+        return send(res, 200, await runner.stopAttempt(record.attemptId));
+      }
+      case "resume": {
+        const record = await runner.attemptForTask(taskId, ["paused", "stopped", "unknown"]);
+        if (!record) throw new CollabError("No paused attempt of this task is on this computer; start a new attempt instead", 409);
+        return send(res, 200, await runner.resumeAttempt(record.attemptId));
+      }
+      case "handover": {
+        const raw = await body(req);
+        assertKeys(raw, ["to", "note", "includeUncommitted"], "hand-over");
+        if (typeof raw.to !== "string" || !raw.to) throw new CollabError("Choose the teammate to hand over to");
+        if (raw.includeUncommitted !== void 0 && typeof raw.includeUncommitted !== "boolean") throw new CollabError("Send includeUncommitted as true or false");
+        if (raw.note !== void 0 && raw.note !== null && typeof raw.note !== "string") throw new CollabError("Enter the note as text");
+        return send(res, 200, await runner.handOver(taskId, { to: raw.to, note: typeof raw.note === "string" ? raw.note : "", includeUncommitted: raw.includeUncommitted === true }));
+      }
+      case "accept": {
+        const raw = await body(req);
+        assertKeys(raw, ["handoffId", "repo"], "accept");
+        const handoffId = validatePathId(raw.handoffId, "hand-over id"), repo = repoPath(raw.repo, false);
+        return send(res, 200, await runner.acceptHandoff(taskId, handoffId, repo ? { repo } : {}));
+      }
+    }
+  }
+  if (head === "checkpoints" && id !== void 0 && action === "fetch" && parts.length === 5 && method === "POST") {
+    const raw = await body(req);
+    assertKeys(raw, ["repo"], "fetch");
+    const repo = repoPath(raw.repo, true);
+    return send(res, 200, await host.runner.fetchCheckpoint(validatePathId(id, "checkpoint id"), { repo }));
+  }
+  throw new CollabError("Unknown team link operation", 404);
+}
+async function handleTeamLinkApi(req, res, url, parts, host) {
+  try {
+    await dispatch(req, res, url, parts, host);
+  } catch (error) {
+    if (error instanceof CollabError) return send(res, error.status, { error: error.message });
+    throw error;
+  }
+}
+export {
+  handleTeamLinkApi,
+  linkInfo,
+  validateDraftBody,
+  validateRoles,
+  validateStartBody
+};