tryharness 0.7.25 → 0.7.28

package/lib/goals.mjs

@@ -0,0 +1,199 @@
+// A thread's goal (owner, October 15: "very little plumbing on evaluating whether that goal has been reached… no
+// mechanism to update the goal by whoever is leading the swarm"). The thread's title is only its first line; the goal is
+// the whole aim in the person's terms, the checks that show it is reached, and where it stands. The lead drafts it from
+// the person's words, writes a new version when the person changes what they want, and marks each check reached with
+// the posts that show it. Every version stays, with the post that caused it. A version can say what the work is for, never
+// what it may spend or do: those stay the person's own limits.
+
+const KEY = (threadId) => `goal-record:${threadId}`;
+const MAX_CRITERIA = 12;
+const STATES = ["working", "ready_for_review", "met"];
+
+/** The record as stored, or null. */
+const readRecord = (store, threadId) => {
+  try {
+    const record = JSON.parse(store.meta(KEY(threadId)) || "null");
+    return record && typeof record.statement === "string" ? record : null;
+  } catch {
+    return null;
+  }
+};
+
+const listed = (criteria) =>
+  criteria.map((criterion, index) => `${index + 1}. ${criterion.text}`);
+
+export function createGoals({ store, notifyBoard = () => {} }) {
+  const save = (threadId, record) =>
+    store.meta(KEY(threadId), JSON.stringify(record));
+  // The lead's goal posts are the coordinator's, not Harness the agent's (coordinator.mjs speakerOf); the person's are theirs.
+  const post = (threadId, author, text) => {
+    const posted = store.roomPost({
+      goalId: threadId,
+      author,
+      kind: "goal_update",
+      text,
+    });
+    if (posted && author !== "user")
+      store.meta(`coordinator-post:${posted.id}`, "1");
+    return posted;
+  };
+
+  /** The goal as a coordinator round reads it, or null when the thread has none yet. */
+  const view = (threadId) => {
+    const record = readRecord(store, threadId);
+    return record
+      ? {
+          version: record.version,
+          statement: record.statement,
+          criteria: record.criteria.map(({ id, text, status, evidence }) => ({
+            id,
+            text,
+            status,
+            evidence,
+          })),
+          state: record.state,
+        }
+      : null;
+  };
+
+  /**
+   * A new version, from the lead's round or the person. A criterion kept word for word keeps what it reached; one left
+   * out is dropped, so the record still shows it. Posted in the thread with the post it follows.
+   */
+  const set = (threadId, { statement, criteria }, { by, seq = null }) => {
+    const text = String(statement || "")
+      .trim()
+      .slice(0, 4_000);
+    const wanted = [
+      ...new Set(
+        (Array.isArray(criteria) ? criteria : [])
+          .map((entry) =>
+            String(entry || "")
+              .trim()
+              .slice(0, 500)
+          )
+          .filter(Boolean)
+      ),
+    ];
+    if (!text || !wanted.length) return null;
+    const before = readRecord(store, threadId);
+    const kept = new Map(
+      (before?.criteria ?? []).map((criterion) => [criterion.text, criterion])
+    );
+    let next = before?.nextId ?? 1;
+    const current = wanted.map((wording) => {
+      const same = kept.get(wording);
+      if (same)
+        return same.status === "dropped" ? { ...same, status: "open" } : same;
+      return { id: `c${next++}`, text: wording, status: "open", evidence: [] };
+    });
+    const dropped = (before?.criteria ?? [])
+      .filter((criterion) => !wanted.includes(criterion.text))
+      .map((criterion) => ({ ...criterion, status: "dropped" }));
+    const version = (before?.version ?? 0) + 1;
+    const at = new Date().toISOString();
+    const record = {
+      version,
+      statement: text,
+      criteria: [...current, ...dropped].slice(0, MAX_CRITERIA),
+      state: "working",
+      nextId: next,
+      versions: [
+        ...(before?.versions ?? []),
+        { version, statement: text, criteria: wanted, by, seq, at },
+      ],
+    };
+    save(threadId, record);
+    const cause =
+      version === 1
+        ? ""
+        : seq === null
+          ? ` (version ${version})`
+          : ` (version ${version}, after post ${seq})`;
+    post(
+      threadId,
+      by,
+      [`Goal${cause}: ${text}`, "Done when:", ...listed(current)].join("\n")
+    );
+    notifyBoard(store.getTask(threadId));
+    return record;
+  };
+
+  /**
+   * What a round found: checks reached with the posts that show them, and where the goal stands. Says so in the thread
+   * when it becomes ready for the person's review; returns "met" when every check is reached, for the lead to close it.
+   */
+  const progress = (threadId, { met = [], goalState = null }, { by }) => {
+    const record = readRecord(store, threadId);
+    if (!record) return { became: null };
+    const reached = new Map(
+      (Array.isArray(met) ? met : []).map((entry) => [entry?.id, entry])
+    );
+    const criteria = record.criteria.map((criterion) => {
+      const entry = reached.get(criterion.id);
+      if (!entry || criterion.status !== "open") return criterion;
+      const evidence = (Array.isArray(entry.evidence) ? entry.evidence : [])
+        .map(Number)
+        .filter(Number.isInteger)
+        .slice(0, 10);
+      return { ...criterion, status: "met", evidence };
+    });
+    const allMet = criteria.every((criterion) => criterion.status !== "open");
+    // Met only when every check is reached: a round that says so early leaves it working.
+    const state = STATES.includes(goalState)
+      ? goalState === "met" && !allMet
+        ? "working"
+        : goalState
+      : record.state;
+    save(threadId, { ...record, criteria, state });
+    const became = state !== record.state ? state : null;
+    if (became === "ready_for_review") {
+      const done = criteria.filter((criterion) => criterion.status === "met");
+      post(
+        threadId,
+        by,
+        [
+          "Ready for your review.",
+          ...done.map(
+            (criterion) =>
+              `Reached: ${criterion.text}${criterion.evidence.length ? ` (post ${criterion.evidence.join(", ")})` : ""}`
+          ),
+        ].join("\n")
+      );
+    }
+    if (became) notifyBoard(store.getTask(threadId));
+    return { became };
+  };
+
+  /** The person wrote in a thread whose goal was met: it is being worked again. */
+  const reopen = (threadId) => {
+    const record = readRecord(store, threadId);
+    if (record && record.state !== "working")
+      save(threadId, { ...record, state: "working" });
+  };
+
+  /** The whole record, every version included, for the thread's read. */
+  const record = (threadId) => {
+    const stored = readRecord(store, threadId);
+    if (!stored) return null;
+    const { nextId, ...shown } = stored;
+    return shown;
+  };
+
+  /** What the thread's answer says when its goal is met: the goal and each check with the posts that show it. */
+  const summary = (threadId) => {
+    const stored = readRecord(store, threadId);
+    if (!stored) return "";
+    return [
+      `The goal is met: ${stored.statement}`,
+      ...stored.criteria
+        .filter((criterion) => criterion.status === "met")
+        .map(
+          (criterion) =>
+            `Reached: ${criterion.text}${criterion.evidence.length ? ` (post ${criterion.evidence.join(", ")})` : ""}`
+        ),
+    ].join("\n");
+  };
+
+  return { view, set, progress, reopen, record, summary };
+}

package/lib/lane.mjs

@@ -0,0 +1,187 @@
+import fs from "node:fs";
+import path from "node:path";
+import { readJson, writeJsonAtomic } from "./files.mjs";
+import { paths } from "./paths.mjs";
+
+// The person's own model lane, kept on this computer once they let Harness Relay use it (owner, October 15): the API key
+// or model endpoint their Harness window runs on, so Harness can answer in their swarm's threads while that window is
+// closed. Only their linked Harness window gives it (sealed, phones.mjs), only they can take it back, and it leaves this
+// computer only with a task given to Harness, the way the window sends it with each of its own turns: Harness's server
+// uses it for that task and keeps nothing (src/server/swarm/harnessTask.ts). An endpoint only this computer reaches
+// (localhost or the person's network) is called from here for Harness's server (`fetch`), and only that endpoint.
+
+const PROVIDERS = new Set(["venice", "bankr", "openai", "dot"]);
+export const laneFile = () => path.join(paths.home, "harness-lane.json");
+
+// The shape Harness's server takes (src/schemas/credentials.ts), checked here so a malformed lane is refused when given.
+function credentialOf(value) {
+  if (!value || typeof value !== "object") return null;
+  if (value.type === "byok" && PROVIDERS.has(value.provider)) {
+    const keys = Object.fromEntries(
+      Object.entries(value.keys ?? {}).filter(
+        ([provider, key]) =>
+          PROVIDERS.has(provider) && typeof key === "string" && key.trim()
+      )
+    );
+    return keys[value.provider]
+      ? { type: "byok", provider: value.provider, keys }
+      : null;
+  }
+  const endpoint = value.endpoint;
+  if (
+    value.type === "custom" &&
+    typeof value.selectedModelId === "string" &&
+    endpoint &&
+    typeof endpoint === "object" &&
+    typeof endpoint.baseUrl === "string" &&
+    /^https?:\/\//.test(endpoint.baseUrl) &&
+    ["server", "relay"].includes(endpoint.transport)
+  )
+    return {
+      type: "custom",
+      endpoint,
+      selectedModelId: value.selectedModelId,
+    };
+  return null;
+}
+
+// What may be said of the lane anywhere: never a key.
+function described(lane) {
+  if (!lane) return { shared: false };
+  const credential = lane.credentialSource;
+  return {
+    shared: true,
+    modelId: lane.modelId,
+    sharedAt: lane.sharedAt,
+    ...(credential.type === "byok"
+      ? { kind: "key", provider: credential.provider }
+      : {
+          kind: "endpoint",
+          label: String(credential.endpoint.label || ""),
+          onThisComputer: credential.endpoint.transport === "relay",
+        }),
+  };
+}
+
+// `changed`: the lane was given or taken back, so the tasks for Harness that wait can be offered again.
+export function createHarnessLane({
+  file = laneFile(),
+  log = () => {},
+  changed = () => {},
+  fetchImpl = fetch,
+} = {}) {
+  const held = () => {
+    const saved = readJson(file, null);
+    const credentialSource = credentialOf(saved?.credentialSource);
+    return credentialSource && typeof saved.modelId === "string"
+      ? { ...saved, credentialSource }
+      : null;
+  };
+
+  /** The person's window gives its lane: the model it runs and the key or endpoint that serves it. */
+  const share = ({ modelId, credentialSource }) => {
+    const credential = credentialOf(credentialSource);
+    if (!credential || typeof modelId !== "string" || !modelId.trim())
+      return {
+        ok: false,
+        error: "only your own API key or model endpoint can be given",
+      };
+    if (credential.type === "custom" && credential.selectedModelId !== modelId)
+      return { ok: false, error: "the model is not the endpoint's" };
+    writeJsonAtomic(file, {
+      modelId: modelId.slice(0, 200),
+      credentialSource: credential,
+      sharedAt: new Date().toISOString(),
+    });
+    log(`harness lane: kept the person's ${described(held()).kind}`);
+    changed();
+    return { ok: true, lane: described(held()) };
+  };
+
+  /** The person takes it back: nothing of it stays here. */
+  const forget = () => {
+    try {
+      fs.unlinkSync(file);
+    } catch {}
+    changed();
+    return { ok: true, lane: described(null) };
+  };
+
+  /**
+   * One call Harness's server makes to an endpoint only this computer reaches, for a task given to Harness: the
+   * endpoint's own address only. Its answer goes back as it comes (`say`): the status and headers, the body in parts,
+   * then the end. A refusal is a 403 and an endpoint that cannot be reached a 502, each with an OpenAI-style error the
+   * server's model call reports. No deadline of its own: the server's stream guards bound each part.
+   */
+  const call = async (
+    { url, method = "POST", headers = {}, body = null },
+    say
+  ) => {
+    const failed = (status, message) => {
+      say({
+        type: "lane_head",
+        status,
+        headers: { "content-type": "application/json" },
+      });
+      say({ type: "lane_chunk", data: JSON.stringify({ error: { message } }) });
+      say({ type: "lane_end" });
+    };
+    const credential = held()?.credentialSource;
+    const base =
+      credential?.type === "custom" && credential.endpoint.transport === "relay"
+        ? credential.endpoint.baseUrl.replace(/\/+$/, "")
+        : null;
+    const target = String(url || "");
+    if (!base || (target !== base && !target.startsWith(`${base}/`)))
+      return failed(
+        403,
+        "that address is not the model endpoint the person let Harness Relay use"
+      );
+    if (!["GET", "POST"].includes(method))
+      return failed(403, `${method} is not a model call`);
+    let response;
+    try {
+      response = await fetchImpl(target, {
+        method,
+        headers: Object.fromEntries(
+          Object.entries(headers).map(([name, value]) => [name, String(value)])
+        ),
+        ...(body != null && method === "POST" ? { body: String(body) } : {}),
+      });
+    } catch (error) {
+      return failed(
+        502,
+        `the person's model endpoint did not answer: ${error.message}`
+      );
+    }
+    say({
+      type: "lane_head",
+      status: response.status,
+      headers: { "content-type": response.headers.get("content-type") ?? "" },
+    });
+    const decoder = new TextDecoder();
+    try {
+      for await (const bytes of response.body ?? [])
+        say({
+          type: "lane_chunk",
+          data: decoder.decode(bytes, { stream: true }),
+        });
+      const rest = decoder.decode();
+      if (rest) say({ type: "lane_chunk", data: rest });
+      say({ type: "lane_end" });
+    } catch (error) {
+      say({
+        type: "lane_end",
+        error: `the person's model endpoint broke off: ${error.message}`,
+      });
+    }
+  };
+
+  return {
+    share,
+    forget,
+    status: () => ({ ok: true, lane: described(held()) }),
+    held,
+    call,
+  };
+}