pi-onlyne 2.1.0 → 2.3.0

package/src/session-scope.test.mjs

@@ -0,0 +1,61 @@
+// The rule that keeps a pi subagent from settling its parent's task, and the
+// sentence a foreign caller reads. The live defect these pin: a `task` subagent
+// runs a sidechain in the same pi process with the same inherited environment,
+// so it saw the parent's `ONLYNE_SESSION_ID` and its `onlyne_complete` settled
+// the parent's task (librarian cfa73386, 2026-08-11).
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  foreignSessionRefusal,
+  mountsSession,
+  ownsSession,
+  sessionIdOf,
+} from "./session-scope.mjs";
+
+const PARENT = "a379b47d-65b7-49c3-ad4b-b978cdf5a5d3";
+const SIDECHAIN = "4f1cb760-c254-4ea1-9d55-6f2a1c8bb0e1";
+
+test("the session id is read off the manager, and an unreadable one reads as unknown", () => {
+  assert.equal(sessionIdOf({ getSessionId: () => PARENT }), PARENT);
+  assert.equal(sessionIdOf({}), null, "no accessor, no id");
+  assert.equal(sessionIdOf(undefined), null);
+  assert.equal(sessionIdOf({ getSessionId: () => "" }), null, "an empty id names nothing");
+  assert.equal(sessionIdOf({ getSessionId: () => 7 }), null, "a non-string id is not one");
+  assert.equal(
+    sessionIdOf({
+      getSessionId: () => {
+        throw new Error("stale context");
+      },
+    }),
+    null,
+    "a context that throws is one this plugin cannot read",
+  );
+});
+
+test("only the session the client named mounts, and an unknown id does not stop the mount", () => {
+  assert.equal(mountsSession(PARENT, PARENT), true, "the spawned session is the one");
+  assert.equal(mountsSession(PARENT, SIDECHAIN), false, "a subagent sidechain is not");
+  assert.equal(
+    mountsSession(PARENT, null),
+    true,
+    "an older pi that cannot say which session this is keeps the env-bound mount",
+  );
+});
+
+test("a call is the bound session's unless pi names another session", () => {
+  assert.equal(ownsSession(PARENT, PARENT), true);
+  assert.equal(ownsSession(PARENT, SIDECHAIN), false, "the sidechain must not settle the parent");
+  assert.equal(ownsSession(PARENT, null), true, "a caller this pi cannot identify is allowed");
+  assert.equal(
+    ownsSession(null, SIDECHAIN),
+    false,
+    "a runner with no bound session has no session whose calls are its own",
+  );
+});
+
+test("the refusal names both sessions and why the call is refused", () => {
+  const sentence = foreignSessionRefusal(PARENT, SIDECHAIN);
+  assert.ok(sentence.includes(SIDECHAIN), sentence);
+  assert.ok(sentence.includes(PARENT), sentence);
+  assert.ok(sentence.includes("subagent"), sentence);
+});

package/src/socket.mjs

@@ -210,12 +210,57 @@ export function listClientRegistrations(env, options = {}) {
       path: join(dir, name),
       root: canonicalRoot(parsed.root, options),
       kind: parsed.kind,
+      role: typeof parsed.role === "string" && parsed.role !== "" ? parsed.role : null,
       runtime: typeof parsed.runtime === "string" && parsed.runtime !== "" ? parsed.runtime : null,
     });
   }
   return found;
 }
 
+/**
+ * Resolve the socket path for a resident or pre-started pi session.
+ *
+ * Unlike [`resolveSocketPath`], when `onlyne-client` has not been started yet
+ * (so `<runtime_dir>/<digest>.json` does not exist), this falls back to the
+ * deterministic `<runtime_dir>/<workspaceDigest(workspaceRoot)>.sock` path so
+ * the agent can enter its background reconnect loop and handshake automatically
+ * the moment `onlyne-client` binds the socket. When a client registration for
+ * `role` appears in `<runtime_dir>`, it prefers that registration's socket.
+ *
+ * @param {Record<string, string | undefined>} env
+ * @param {string} workspaceRoot
+ * @param {string} role
+ * @param {{ readFile?: (path: string) => string, readDir?: (path: string) => string[], realpath?: (path: string) => string, uid?: number | null, runtime?: string }} [options]
+ * @returns {string}
+ */
+export function resolveResidentSocketPath(env, workspaceRoot, role, options = {}) {
+  const injected = typeof env[SOCKET_ENV] === "string" ? env[SOCKET_ENV].trim() : "";
+  if (injected) return injected;
+
+  const dir = runtimeDir(env, options);
+  const here = canonicalRoot(workspaceRoot, options);
+  const candidates = listClientRegistrations(env, options);
+
+  const coveringRole = candidates.filter((entry) => covers(entry.root, here) && (!role || !entry.role || entry.role === role));
+  if (coveringRole.length > 0) {
+    const nearest = coveringRole.reduce((best, entry) => (entry.root.length > best.root.length ? entry : best));
+    return join(dir, `${workspaceDigest(nearest.root, options)}${SOCKET_SUFFIX}`);
+  }
+
+  if (role) {
+    const byRole = candidates.filter((entry) => entry.role === role);
+    if (byRole.length === 1) {
+      return join(dir, `${workspaceDigest(byRole[0].root, options)}${SOCKET_SUFFIX}`);
+    }
+  }
+
+  try {
+    return resolveSocketPath(env, workspaceRoot, options);
+  } catch {
+    return socketPath(workspaceRoot, env, options);
+  }
+}
+
 /**
  * The socket path to dial for the pi working directory `cwd`.
  *

package/src/socket.test.mjs

@@ -17,6 +17,7 @@ import {
   canonicalRoot,
   listClientRegistrations,
   registrationPath,
+  resolveResidentSocketPath,
   resolveSocketPath,
   runtimeDir,
   socketPath,
@@ -235,3 +236,29 @@ test("a registration read through the injected filesystem names the same socket"
   // The env is what names the socket a client injected, and it is still first.
   assert.equal(resolveSocketPath({ ONLYNE_RUNTIME_DIR: dir, [SOCKET_ENV]: "/tmp/served" }, workspace, options), "/tmp/served");
 });
+
+test("resolveResidentSocketPath falls back to deterministic socket before client starts, then adopts registered role socket", () => {
+  const clusterRoot = scratch("pi-onlyne-cluster-");
+  const roleWs = join(clusterRoot, "supervisor");
+  mkdirSync(roleWs, { recursive: true });
+  const emptyDir = runtime([]);
+
+  // Before onlyne-client starts, no registration exists; returns deterministic socket path.
+  assert.equal(
+    resolveResidentSocketPath(envFor(emptyDir), roleWs, "supervisor"),
+    socketPath(roleWs, envFor(emptyDir)),
+  );
+
+  // Once onlyne-client starts and registers the role in the runtime directory, even if
+  // omp was started in the parent clusterRoot, it resolves the registered role's socket.
+  const liveDir = runtime([
+    {
+      name: registrationName(roleWs),
+      body: { kind: "client", role: "supervisor", root: canonicalRoot(roleWs), pid: 9001, version: "2.3.0", runtime: "pi" },
+    },
+  ]);
+  assert.equal(
+    resolveResidentSocketPath(envFor(liveDir), clusterRoot, "supervisor"),
+    socketPath(roleWs, envFor(liveDir)),
+  );
+});