tryharness 0.7.7 → 0.7.9

package/lib/swarm.mjs

@@ -114,6 +114,9 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
 
   const sessionOpen = (agent, sessionId) => sessions().find((session) => session.agent === agent && session.sessionId === sessionId)?.open ?? false;
 
+  // The agent a request names in `to`: null for none, false for one no thread can have.
+  const recipient = (request) => (request.to == null || request.to === "" ? null : roomAgents.includes(String(request.to)) ? String(request.to) : false);
+
   const lastFolder = (agent) => store.recentSessions(100).find((session) => session.agent === agent && isDir(session.cwd))?.cwd ?? null;
 
   const read = (thread) => {
@@ -125,16 +128,17 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
     return { ok: true, thread: summary(thread), posts: store.roomPosts(thread.id, 0, 500), runs };
   };
 
-  const post = (thread, text) => {
+  // `to`: the one agent the person wrote to (the desktop's agent list), so their words go as written, with no @name.
+  const post = (thread, text, to = null) => {
     // A new name in the person's message joins the thread.
-    const joining = mentionsIn(text, roomAgents).filter((agent) => !thread.goal.team.includes(agent));
+    const joining = [...new Set([...mentionsIn(text, roomAgents), ...(to ? [to] : [])])].filter((agent) => !thread.goal.team.includes(agent));
     if (joining.length) store.setGoalTeam(thread.id, [...thread.goal.team, ...joining]);
     if (thread.status !== "open") {
       store.setGoalState(thread.id, { status: "open" });
       store.roomPost({ goalId: thread.id, author: "user", kind: "note", text: "Picked up again by you." });
     }
     const current = store.getTask(thread.id);
-    return goalCommand({ command: "board.room.post", id: thread.id, text, mentions: addressed(current, text) }, "user");
+    return goalCommand({ command: "board.room.post", id: thread.id, text, mentions: to ? [to] : addressed(current, text) }, "user");
   };
 
   return function swarmCommand(request, agent) {
@@ -198,7 +202,9 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
       const from = request.continueSession && typeof request.continueSession === "object" ? request.continueSession : null;
       let folder = request.folder ? String(request.folder) : null;
       if (folder && !isDir(folder)) return { ok: false, error: `${folder} is not an absolute path to a folder` };
-      const team = new Set(mentionsIn(text, roomAgents));
+      const to = recipient(request);
+      if (to === false) return { ok: false, error: `${request.to} can't be written to in a thread` };
+      const team = new Set([...mentionsIn(text, roomAgents), ...(to ? [to] : [])]);
       if (from) {
         const agentName = String(from.agent || ""), sessionId = String(from.sessionId || "");
         if (!PROCESS_NAMES[agentName]) return { ok: false, error: "only a coding agent's session continues in a thread" };
@@ -245,7 +251,9 @@ export function createSwarm({ store, roomAgents, mentionsIn, wakeFor, notifyBoar
     if (command === "board.swarm.post") {
       const text = String(request.text || "").trim().slice(0, 20_000);
       if (!text) return { ok: false, error: "a message needs text" };
-      const posted = post(thread, text);
+      const to = recipient(request);
+      if (to === false) return { ok: false, error: `${request.to} can't be written to in a thread` };
+      const posted = post(thread, text, to);
       return posted.ok ? { ...posted, thread: summary(store.getTask(thread.id)) } : posted;
     }
     if (command === "board.swarm.stop") {

package/lib/t3.mjs

@@ -0,0 +1,172 @@
+import http from "node:http";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { readJson, writeJsonAtomic } from "./files.mjs";
+import { paths } from "./paths.mjs";
+import { t3Home } from "./places.mjs";
+
+// T3 Code's door for agents it did not start (its /mcp; T3's docs/user/outside-agents.md). Harness signs in once and the
+// person approves it inside T3, choosing what it may do; T3 asks for a pairing code from its Settings → Connections, and
+// no T3 account. From then on a message the person sends a session running in T3 Code (from the desktop app or the
+// phone) goes into that session's T3 thread as T3 sends any message: started when the thread is idle, queued behind its
+// turn when it is busy. T3 shows it as sent by an agent through MCP. The key lives in ~/.harness/t3.json (0600), works
+// only on T3's /mcp on this computer's loopback, lasts 30 days, and is revoked in T3 under Settings → Connections.
+
+// T3's desktop app binds the first free port from 3773 up (T3 apps/server/src/auth/utils.ts).
+const FIRST_PORT = 3773;
+const PORTS = 20;
+// Its descriptor answered in at most 1.7 ms over 40 tries while T3 ran four busy sessions (October 12); a closed port
+// refuses in under 0.4 ms. The limit only keeps a port held by something else from stalling the search.
+const PROBE_MS = 1_000;
+const PROTOCOL = "2025-06-18";
+
+const b64u = (bytes) => Buffer.from(bytes).toString("base64url");
+const file = () => path.join(paths.home, "t3.json");
+
+class T3Error extends Error {
+  constructor(code, message) { super(message); this.code = code; }
+}
+
+/** This computer's T3 Code: its environment (from T3's own data folder) and the loopback address that answers as it. */
+export async function findT3(home = t3Home(), hint = null) {
+  let environmentId = "";
+  try { environmentId = fs.readFileSync(path.join(home, "environment-id"), "utf8").trim(); } catch { return null; }
+  const answers = async (origin) => {
+    try {
+      const response = await fetch(`${origin}/.well-known/t3/environment`, { signal: AbortSignal.timeout(PROBE_MS) });
+      return response.ok && (await response.json())?.environmentId === environmentId;
+    } catch { return false; }
+  };
+  if (hint && await answers(hint)) return { origin: hint, environmentId };
+  for (let port = FIRST_PORT; port < FIRST_PORT + PORTS; port++) {
+    const origin = `http://127.0.0.1:${port}`;
+    if (origin !== hint && await answers(origin)) return { origin, environmentId };
+  }
+  return null;
+}
+
+/** What Harness may do in T3 Code: "send", "read", "expired", or null before the person approves it. */
+export function t3Access() {
+  const saved = readJson(file(), null);
+  if (!saved?.token) return null;
+  if (!(Date.parse(saved.expiresAt) > Date.now())) return { state: "expired", at: saved.expiresAt };
+  return { state: String(saved.scope || "").split(" ").includes("orchestration:operate") ? "send" : "read", until: saved.expiresAt };
+}
+
+export function forgetT3() {
+  try { fs.rmSync(file()); } catch {}
+}
+
+const json = async (url, body) => {
+  const response = await fetch(url, body ? { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) } : {});
+  const value = await response.json().catch(() => null);
+  if (!response.ok || !value) throw new T3Error("t3", value?.error_description || `T3 Code answered ${response.status}`);
+  return value;
+};
+
+const page = (title, words) => `<!doctype html><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>${title}</title>`
+  + `<body style="font-family:-apple-system,system-ui,sans-serif;display:grid;place-items:center;min-height:90vh;margin:0"><main style="max-width:420px;padding:24px"><h1 style="font-size:20px">${title}</h1><p style="line-height:1.5">${words}</p></main>`;
+
+let pending = null;
+
+/**
+ * Starts the sign-in: registers Harness with this computer's T3 Code and returns the page where the person approves it.
+ * The approval comes back to a loopback address here, which keeps listening until it does or another sign-in starts.
+ */
+export async function startT3SignIn() {
+  const t3 = await findT3(t3Home(), readJson(file(), null)?.origin ?? null);
+  if (!t3) throw new T3Error("not_running", "T3 Code is not running on this computer. Open it, then try again.");
+  // T3 Code takes outside agents from its 0.0.46 builds on; an older one has no sign-in to offer.
+  const server = await json(`${t3.origin}/.well-known/oauth-authorization-server`).catch(() => {
+    throw new T3Error("too_old", "This T3 Code can't approve outside agents yet. Update it (0.0.46 or newer), then try again.");
+  });
+  pending?.close();
+  const listener = http.createServer();
+  pending = listener;
+  await new Promise((resolve, reject) => { listener.once("error", reject); listener.listen(0, "127.0.0.1", resolve); });
+  const redirect = `http://127.0.0.1:${listener.address().port}/t3/callback`;
+  const client = await json(server.registration_endpoint, { client_name: "Harness", redirect_uris: [redirect] });
+  const verifier = b64u(randomBytes(32));
+  const state = b64u(randomBytes(16));
+  const resource = `${t3.origin}/mcp`;
+  listener.on("request", async (request, response) => {
+    const url = new URL(request.url, redirect);
+    const answer = (status, title, words) => { response.writeHead(status, { "content-type": "text/html; charset=utf-8" }); response.end(page(title, words)); };
+    if (url.pathname !== "/t3/callback" || url.searchParams.get("state") !== state) return answer(400, "Not this sign-in", "This page is not the sign-in Harness started. Start it again from Harness.");
+    const done = () => { listener.close(); if (pending === listener) pending = null; };
+    if (url.searchParams.get("error")) { done(); return answer(200, "Harness was not approved", "Nothing changed. Harness keeps leaving your messages for T3 Code's sessions to pick up themselves."); }
+    if (url.searchParams.has("iss") && url.searchParams.get("iss") !== server.issuer) return answer(400, "Not this sign-in", "The approval came from another server.");
+    try {
+      const exchanged = await fetch(server.token_endpoint, { method: "POST", headers: { "content-type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({ grant_type: "authorization_code", code: url.searchParams.get("code") || "", redirect_uri: redirect, client_id: client.client_id, code_verifier: verifier, resource }) });
+      const token = await exchanged.json().catch(() => null);
+      if (!exchanged.ok || !token?.access_token) throw new Error(token?.error_description || `T3 Code answered ${exchanged.status}`);
+      writeJsonAtomic(file(), { origin: t3.origin, environmentId: t3.environmentId, clientId: client.client_id, token: token.access_token, scope: token.scope || "",
+        expiresAt: new Date(Date.now() + Number(token.expires_in || 0) * 1000).toISOString(), approvedAt: new Date().toISOString() });
+      done();
+      const send = t3Access()?.state === "send";
+      answer(200, send ? "Harness can send into T3 Code" : "Harness can read T3 Code", send
+        ? "Messages you send your T3 Code sessions from Harness, on this computer or your phone, now go straight into their threads. You can close this tab."
+        : "You approved read only, so messages still wait for your sessions to pick them up. To send into T3 Code's threads, approve Harness again with the access your threads run with.");
+    } catch (error) {
+      answer(502, "The sign-in did not finish", `${String(error.message).replace(/[<>&]/g, "")}. Start it again from Harness.`);
+    }
+  });
+  const url = `${server.authorization_endpoint}?${new URLSearchParams({ response_type: "code", client_id: client.client_id, redirect_uri: redirect,
+    code_challenge: b64u(createHash("sha256").update(verifier).digest()), code_challenge_method: "S256", state, resource })}`;
+  return { url };
+}
+
+/** One JSON-RPC message to T3's /mcp (Streamable HTTP): the answer comes as JSON or as a server-sent event. */
+async function rpc(origin, token, session, message) {
+  const response = await fetch(`${origin}/mcp`, { method: "POST", body: JSON.stringify({ jsonrpc: "2.0", ...message }), headers: {
+    authorization: `Bearer ${token}`, "content-type": "application/json", accept: "application/json, text/event-stream", "mcp-protocol-version": PROTOCOL,
+    ...(session ? { "mcp-session-id": session } : {}) } });
+  if (response.status === 401 || response.status === 403) throw new T3Error("expired", "T3 Code no longer accepts Harness's sign-in.");
+  if (!response.ok) throw new T3Error("t3", `T3 Code answered ${response.status}`);
+  const next = response.headers.get("mcp-session-id") || session;
+  if (message.id === undefined) return { session: next };
+  const text = await response.text();
+  const replies = (response.headers.get("content-type") || "").includes("text/event-stream")
+    ? text.split("\n").filter((line) => line.startsWith("data:")).map((line) => { try { return JSON.parse(line.slice(5)); } catch { return null; } })
+    : [JSON.parse(text)];
+  const reply = replies.find((entry) => entry?.id === message.id);
+  if (!reply) throw new T3Error("t3", "T3 Code sent no answer");
+  if (reply.error) throw new T3Error("t3", reply.error.message || "T3 Code refused");
+  return { session: next, result: reply.result };
+}
+
+async function callTool(origin, token, name, args) {
+  let { session } = await rpc(origin, token, null, { id: 1, method: "initialize", params: { protocolVersion: PROTOCOL, capabilities: {}, clientInfo: { name: "Harness", version: "1" } } });
+  try {
+    ({ session } = await rpc(origin, token, session, { method: "notifications/initialized" }));
+    const { result } = await rpc(origin, token, session, { id: 2, method: "tools/call", params: { name, arguments: args } });
+    const words = (result?.content || []).map((part) => part?.text || "").join("\n").trim();
+    if (result?.isError) throw new T3Error("refused", words || "T3 Code refused");
+    if (result?.structuredContent) return result.structuredContent;
+    try { return JSON.parse(words); } catch { return {}; }
+  } finally {
+    if (session) fetch(`${origin}/mcp`, { method: "DELETE", headers: { authorization: `Bearer ${token}`, "mcp-session-id": session } }).catch(() => {});
+  }
+}
+
+/** Sends the person's words into a T3 Code thread: "started" or "queued" behind its turn. */
+export async function sendToT3(threadId, text) {
+  const saved = readJson(file(), null);
+  const access = t3Access();
+  if (!access) throw new T3Error("not_connected", "Harness is not approved in T3 Code yet.");
+  if (access.state === "expired") throw new T3Error("expired", "Harness's approval in T3 Code ran out.");
+  if (access.state !== "send") throw new T3Error("read_only", "Harness was approved in T3 Code to read only.");
+  // T3 may come back on another port after a restart: the saved address first, else the search again.
+  const t3 = await findT3(t3Home(), saved.origin);
+  if (!t3 || t3.environmentId !== saved.environmentId) throw new T3Error("not_running", "T3 Code is not running on this computer.");
+  if (t3.origin !== saved.origin) writeJsonAtomic(file(), { ...saved, origin: t3.origin });
+  try {
+    const sent = await callTool(t3.origin, saved.token, "t3_thread_send", { threadId, message: text, mode: "queue", clientRequestId: randomUUID() });
+    return sent.delivery === "queued" ? "queued" : "started";
+  } catch (error) {
+    if (error.code === "expired") writeJsonAtomic(file(), { ...saved, expiresAt: new Date(0).toISOString() });
+    throw error;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tryharness",
-  "version": "0.7.7",
+  "version": "0.7.9",
   "description": "Harness Relay: the daemon that turns the agents on this machine into your personal swarm. Memory, history, and work handed between any of them.",
   "bin": {
     "tryharness": "cli.mjs"
@@ -36,8 +36,8 @@
     "onnxruntime-web": "1.26.0-dev.20260416-b7804b056c"
   },
   "optionalDependencies": {
-    "tryharness-desktop-darwin-arm64": "0.7.7",
-    "tryharness-desktop-darwin-x64": "0.7.7",
+    "tryharness-desktop-darwin-arm64": "0.7.9",
+    "tryharness-desktop-darwin-x64": "0.7.9",
     "tryharness-desktop-linux-x64": "0.7.4",
     "tryharness-desktop-win32-x64": "0.7.4"
   }