@fitchmultz/pi-subagents 0.45.0 → 0.46.0

package/src/pi-intercom/bridge-launch.ts

@@ -0,0 +1,317 @@
+import { createHash } from "node:crypto";
+import { statSync } from "node:fs";
+import { setTimeout as delay } from "node:timers/promises";
+import { loadNativeSession } from "../shared/native-session-loader.ts";
+import { isRecord, type UnknownRecord } from "../shared/unknown.ts";
+import type { SessionInfo } from "./types.ts";
+import type { Identity } from "./bridge-config.ts";
+import type { LaunchPolicy } from "./bridge-launch-policy.ts";
+import { Fault, cancelled, log, wait } from "./bridge-protocol.ts";
+import { RpcProcess } from "./bridge-rpc-process.ts";
+
+interface Launch {
+  readonly identity: Identity;
+  readonly name: string;
+  readonly controller: Readonly<AbortController>;
+  readonly expires: number;
+  admitted: boolean;
+  sessionId?: string;
+  peerId?: string;
+  sessionFile?: string;
+  process?: RpcProcess;
+  timer?: NodeJS.Timeout;
+}
+interface StartContext {
+  readonly identity: Identity;
+  readonly expires: number;
+  readonly signal: AbortSignal;
+  readonly peers: (
+    signal: AbortSignal,
+  ) => Promise<readonly Readonly<Pick<SessionInfo, "id" | "name" | "cwd">>[]>;
+}
+
+export function sameIdentity(left: Identity, right: Identity | undefined): boolean {
+  return (
+    left.name === right?.name &&
+    left.cwd === right.cwd &&
+    JSON.stringify(left.launch) === JSON.stringify(right.launch)
+  );
+}
+function view(entry: Readonly<Launch>): UnknownRecord {
+  return {
+    sessionId: entry.sessionId,
+    peerId: entry.peerId,
+    name: entry.name,
+    sessionFile: entry.sessionFile,
+    pid: entry.process?.pid,
+    status: entry.process?.status ?? "starting",
+    error: entry.process?.failure?.code,
+  };
+}
+
+export class Launcher {
+  private readonly launches = new Set<Launch>();
+  private stopping = false;
+
+  list(identity: Identity): UnknownRecord {
+    return {
+      sessions: [...this.launches]
+        .filter((entry) => entry.identity.fingerprint256 === identity.fingerprint256)
+        .map(view),
+    };
+  }
+  async stop(identity: Identity, sessionId: string): Promise<UnknownRecord> {
+    const entry = [...this.launches].find(
+      (candidate) =>
+        candidate.identity.fingerprint256 === identity.fingerprint256 &&
+        candidate.sessionId === sessionId,
+    );
+    if (!entry) {
+      throw new Fault(404, "unknown_session", "Session is not owned by this identity and helper.");
+    }
+    await this.retire(entry, new Fault(410, "session_stopped", "Session stopped by its owner."));
+    return { session: view(entry) };
+  }
+  async start(name: string, context: StartContext): Promise<UnknownRecord> {
+    cancelled(context.signal);
+    const policy = context.identity.launch;
+    if (!policy || this.stopping) {
+      throw new Fault(403, "launch_disabled", "Session launching is not enabled by local policy.");
+    }
+    const fullName = `remote:${context.identity.name}:${name}`;
+    const existing = [...this.launches].find(
+      (entry) =>
+        entry.identity.fingerprint256 === context.identity.fingerprint256 &&
+        entry.name === fullName &&
+        entry.process?.status !== "exited",
+    );
+    if (existing) {
+      return this.reuse(existing);
+    }
+    this.capacity(context.identity, policy);
+    const entry: Launch = {
+      identity: context.identity,
+      name: fullName,
+      controller: new AbortController(),
+      expires: context.expires,
+      admitted: false,
+    };
+    this.launches.add(entry);
+    try {
+      return await this.establish(entry, policy, context);
+    } catch (error) {
+      await this.retire(entry, new Fault(503, "launch_failed", "Pi startup failed.")).catch(() =>
+        log("launch_cleanup", { pid: entry.process?.pid, result: "failed" }),
+      );
+      if (!entry.process) {
+        this.launches.delete(entry);
+      }
+      throw error instanceof Fault
+        ? error
+        : new Fault(
+            503,
+            "launch_failed",
+            "Pi startup failed; inspect the pinned local policy and resources.",
+          );
+    }
+  }
+  private reuse(entry: Readonly<Launch>): UnknownRecord {
+    if (
+      entry.admitted &&
+      (entry.process?.status === "idle" || entry.process?.status === "running")
+    ) {
+      return { session: view(entry), reused: true };
+    }
+    throw new Fault(
+      409,
+      "launch_in_progress",
+      "This named session is starting or stopping; inspect sessions before retrying.",
+    );
+  }
+  private capacity(identity: Identity, policy: LaunchPolicy): void {
+    const active = [...this.launches].filter((entry) => entry.process?.status !== "exited");
+    if (
+      active.length >= 32 ||
+      active.filter((entry) => entry.identity.fingerprint256 === identity.fingerprint256).length >=
+        policy.maxSessions
+    ) {
+      throw new Fault(
+        429,
+        "session_limit",
+        "Local launched-session capacity reached; stop an owned session first.",
+      );
+    }
+    for (const entry of this.launches) {
+      if (this.launches.size >= 64 && entry.process?.status === "exited") {
+        this.launches.delete(entry);
+      }
+    }
+  }
+  private async journal(entry: Launch, policy: LaunchPolicy): Promise<void> {
+    const { SessionManager } = await wait(
+      loadNativeSession(policy.packageRoot),
+      entry.controller.signal,
+    );
+    cancelled(entry.controller.signal);
+    const storage = statSync(policy.sessionDir);
+    if (
+      !storage.isDirectory() ||
+      storage.uid !== process.getuid?.() ||
+      (storage.mode & 0o777) !== 0o700
+    ) {
+      throw new Fault(503, "storage_invalid", "Private launch storage is no longer valid.");
+    }
+    const previous = process.umask(0o077);
+    try {
+      const manager = SessionManager.create(entry.identity.cwd, policy.sessionDir);
+      manager.appendSessionInfo(entry.name);
+      manager.appendMessage({ role: "user", content: policy.context, timestamp: Date.now() });
+      entry.sessionId = manager.getSessionId();
+      entry.sessionFile = manager.getSessionFile();
+      entry.peerId = `pi-${createHash("sha256").update(entry.sessionId).digest("hex").slice(0, 32)}`;
+      if (entry.sessionFile === undefined || (statSync(entry.sessionFile).mode & 0o777) !== 0o600) {
+        throw new Fault(503, "journal_invalid", "Native journal was not privately persisted.");
+      }
+      const saved = SessionManager.open(entry.sessionFile, policy.sessionDir);
+      if (
+        saved.getSessionId() !== entry.sessionId ||
+        saved.getSessionName() !== entry.name ||
+        saved.getCwd() !== entry.identity.cwd
+      ) {
+        throw new Fault(503, "journal_invalid", "Native journal identity did not persist.");
+      }
+    } finally {
+      process.umask(previous);
+    }
+  }
+  private async establish(
+    entry: Launch,
+    policy: LaunchPolicy,
+    context: StartContext,
+  ): Promise<UnknownRecord> {
+    const signal = AbortSignal.any([context.signal, entry.controller.signal]);
+    const deadline = setTimeout(
+      () =>
+        entry.controller.abort(
+          new Fault(504, "launch_timeout", "Pi startup readiness deadline exceeded."),
+        ),
+      policy.startupTimeoutMs,
+    );
+    const abort = () =>
+      entry.controller.abort(
+        new Fault(499, "launch_cancelled", "Session startup cancelled or exceeded its deadline."),
+      );
+    signal.addEventListener("abort", abort, { once: true });
+    try {
+      await this.journal(entry, policy);
+      cancelled(signal);
+      if (entry.sessionFile === undefined) {
+        throw new Fault(503, "journal_invalid", "Native journal path unavailable.");
+      }
+      entry.process = new RpcProcess(policy, entry.identity.cwd, entry.sessionFile);
+      this.expiry(entry);
+      const state = await entry.process.state(signal);
+      this.validateState(entry, policy, state);
+      await this.peerReady(entry, context.peers, signal);
+      cancelled(signal);
+      entry.process.ready();
+      entry.admitted = true;
+      log("launch_ready", {
+        fingerprint: entry.identity.fingerprint256,
+        name: entry.name,
+        peer: entry.peerId,
+        pid: entry.process.pid,
+        result: "ready",
+      });
+      return { session: view(entry), reused: false };
+    } finally {
+      clearTimeout(deadline);
+      signal.removeEventListener("abort", abort);
+    }
+  }
+  private validateState(entry: Readonly<Launch>, policy: LaunchPolicy, state: UnknownRecord): void {
+    if (
+      state.sessionId !== entry.sessionId ||
+      state.sessionFile !== entry.sessionFile ||
+      state.sessionName !== entry.name ||
+      state.isStreaming !== false ||
+      state.pendingMessageCount !== 0 ||
+      !isRecord(state.model) ||
+      state.model.provider !== policy.provider ||
+      state.model.id !== policy.model
+    ) {
+      throw new Fault(
+        503,
+        "readiness_failed",
+        "Pi did not start idle with the exact saved session and configured model.",
+      );
+    }
+  }
+  private async peerReady(
+    entry: Readonly<Launch>,
+    peers: StartContext["peers"],
+    signal: AbortSignal,
+  ): Promise<void> {
+    while (!entry.process?.failure) {
+      cancelled(signal);
+      // Registration is asynchronous after native session_start; observe real broker publication.
+      // oxlint-disable-next-line no-await-in-loop
+      const rows = await peers(signal);
+      if (
+        rows.some(
+          (peer) =>
+            peer.id === entry.peerId && peer.name === entry.name && peer.cwd === entry.identity.cwd,
+        )
+      ) {
+        return;
+      }
+      // Bounded readiness polling is not an acknowledgement substitute; only the row above succeeds.
+      // oxlint-disable-next-line no-await-in-loop
+      await delay(100, undefined, { signal });
+    }
+    throw entry.process.failure;
+  }
+  private expiry(entry: Launch): void {
+    const expire = () => {
+      if (entry.expires <= Date.now()) {
+        this.retire(
+          entry,
+          new Fault(403, "certificate_expired", "Launch owner's certificate expired."),
+        ).catch(() => log("launch_cleanup", { result: "failed" }));
+      } else {
+        entry.timer = setTimeout(expire, Math.min(entry.expires - Date.now(), 0x7fffffff));
+      }
+    };
+    expire();
+    entry.process?.exited
+      .then(() => clearTimeout(entry.timer))
+      .catch(() => log("launch_cleanup", { result: "failed" }));
+  }
+  private async retire(entry: Launch, fault: Readonly<Fault>): Promise<void> {
+    entry.controller.abort(fault);
+    clearTimeout(entry.timer);
+    await entry.process?.stop();
+  }
+  async revoke(clients: Readonly<ReadonlyMap<string, Identity>>): Promise<void> {
+    await Promise.all(
+      [...this.launches]
+        .filter(
+          (entry) => !sameIdentity(entry.identity, clients.get(entry.identity.fingerprint256)),
+        )
+        .map((entry) =>
+          this.retire(
+            entry,
+            new Fault(403, "revoked", "Launch owner's identity or policy was revoked."),
+          ),
+        ),
+    );
+  }
+  async shutdown(): Promise<void> {
+    this.stopping = true;
+    await Promise.all(
+      [...this.launches].map((entry) =>
+        this.retire(entry, new Fault(503, "shutting_down", "Bridge is shutting down.")),
+      ),
+    );
+  }
+}

package/src/pi-intercom/bridge-routes.ts

@@ -5,6 +5,9 @@ import { body } from "./bridge-http.ts";
 
 export type Operation =
   | { readonly route: "GET /v1/list" | "GET /v1/inbox" | "POST /v1/register" }
+  | { readonly route: "GET /v1/sessions" }
+  | { readonly route: "POST /v1/start"; readonly name: string }
+  | { readonly route: "POST /v1/stop"; readonly sessionId: string }
   | { readonly route: "POST /v1/ack"; readonly ids: readonly string[] }
   | { readonly route: "POST /v1/send"; readonly to: string; readonly message: string }
   | {
@@ -14,6 +17,10 @@ export type Operation =
       readonly timeoutMs: number;
     }
   | { readonly route: "POST /v1/reply"; readonly replyTo: string; readonly message: string };
+export type MessagingOperation = Exclude<
+  Operation,
+  { readonly route: "POST /v1/start" | "POST /v1/stop" | "GET /v1/sessions" }
+>;
 type Route = Operation["route"];
 
 const fields = {
@@ -24,6 +31,9 @@ const fields = {
   "POST /v1/send": ["to", "message"],
   "POST /v1/ask": ["to", "message", "timeoutMs"],
   "POST /v1/reply": ["replyTo", "message"],
+  "POST /v1/start": ["name"],
+  "GET /v1/sessions": [],
+  "POST /v1/stop": ["sessionId"],
 };
 
 function isRoute(route: string): route is Route {
@@ -68,7 +78,12 @@ export async function operationFor(
     case "GET /v1/list":
     case "GET /v1/inbox":
     case "POST /v1/register":
+    case "GET /v1/sessions":
       return { route };
+    case "POST /v1/start":
+      return { route, name: label(input.name, "session name", 64).trim() };
+    case "POST /v1/stop":
+      return { route, sessionId: label(input.sessionId, "session ID", 128) };
     case "POST /v1/ack": {
       if (!isUnknownArray(input.ids) || input.ids.length > INBOX_COUNT) {
         throw new Fault(400, "invalid_input", "ids must be an array of at most 256 message IDs.");

package/src/pi-intercom/bridge-rpc-process.ts

@@ -0,0 +1,293 @@
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+import type { RpcCommand, RpcExtensionUIResponse } from "@earendil-works/pi-coding-agent";
+import { trySignalChildTree } from "../shared/post-exit-stdio-guard.ts";
+import { isRecord, type UnknownRecord } from "../shared/unknown.ts";
+import { Fault, log, wait } from "./bridge-protocol.ts";
+import type { LaunchPolicy } from "./bridge-launch-policy.ts";
+
+const FRAME_LIMIT = 4 * 1024 * 1024;
+function launchEnvironment(packageRoot: string): NodeJS.ProcessEnv {
+  const environment = Object.fromEntries(
+    Object.entries(process.env).filter(([key]) => !key.startsWith("PI_SUBAGENT_")),
+  );
+  return { ...environment, PI_PACKAGE_DIR: packageRoot };
+}
+
+// Native RpcClient lacks public EOF/exit/UI control and retains/reprints unbounded stderr.
+// This owner implements only get_state and dialog cancellation, never a remote RPC proxy.
+export class RpcProcess {
+  private readonly child: ChildProcessWithoutNullStreams;
+  readonly exited: Promise<void>;
+  status: "starting" | "idle" | "running" | "stopping" | "exited" = "starting";
+  failure?: Fault;
+  private readonly decoder = new StringDecoder("utf8");
+  private buffer = "";
+  private discarding = false;
+  private sequence = 0;
+  private pending?: {
+    readonly id: string;
+    readonly resolve: (data: UnknownRecord) => void;
+    readonly reject: (error: Readonly<Error>) => void;
+  };
+  private stopping?: Promise<void>;
+  private stderrBytes = 0;
+  private exitObserved = false;
+
+  constructor(policy: LaunchPolicy, cwd: string, sessionFile: string) {
+    this.child = spawn(process.execPath, this.arguments(policy, sessionFile), {
+      cwd,
+      detached: true,
+      env: launchEnvironment(policy.packageRoot),
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    this.exited = new Promise((resolveExit) => {
+      this.child.once("close", (code, signal) => {
+        this.exitObserved = true;
+        this.buffer = "";
+        this.discarding = false;
+        this.status = "exited";
+        this.fail(new Fault(503, "session_exited", "Launched Pi process exited."));
+        log("launch_exit", { pid: this.child.pid, code, signal, stderrBytes: this.stderrBytes });
+        resolveExit();
+      });
+    });
+    this.child.once("error", () =>
+      this.fail(new Fault(503, "launch_failed", "Pi process could not start.")),
+    );
+    this.child.stdin.on("error", () => {
+      this.fail(new Fault(503, "rpc_closed", "Pi RPC input closed."));
+      this.cleanup();
+    });
+    this.child.stdout.once("end", () => {
+      this.fail(new Fault(503, "rpc_closed", "Pi RPC output closed."));
+      this.cleanup();
+    });
+    for (const stream of [this.child.stdout, this.child.stderr]) {
+      stream.on("error", () => {
+        this.fail(new Fault(503, "rpc_closed", "Pi RPC output failed."));
+        this.cleanup();
+      });
+    }
+    this.child.stdout.on("data", (chunk: Buffer) => this.read(this.decoder.write(chunk)));
+    this.child.stderr.on("data", (chunk: Buffer) => {
+      // Drain without retaining or exposing diagnostics, including credential-bearing extension errors.
+      this.stderrBytes = Math.min(Number.MAX_SAFE_INTEGER, this.stderrBytes + chunk.length);
+    });
+  }
+  get pid(): number | undefined {
+    return this.child.pid;
+  }
+  private arguments(policy: LaunchPolicy, sessionFile: string): string[] {
+    const args = [
+      policy.cli,
+      "--mode",
+      "rpc",
+      "--session",
+      sessionFile,
+      "--provider",
+      policy.provider,
+      "--model",
+      policy.model,
+      policy.trustProject ? "--approve" : "--no-approve",
+    ];
+    if (!policy.discoverResources) {
+      args.push(
+        "--no-extensions",
+        "--no-skills",
+        "--no-prompt-templates",
+        "--no-themes",
+        "--no-context-files",
+      );
+    }
+    if (policy.offline) {
+      args.push("--offline");
+    }
+    for (const extension of policy.extensions) {
+      args.push("--extension", extension);
+    }
+    return args;
+  }
+  private fail(error: Readonly<Fault>): void {
+    this.failure ??= error;
+    this.pending?.reject(this.failure);
+    this.pending = undefined;
+  }
+  private retainedChunk(chunk: string): string {
+    if (!this.discarding) {
+      return chunk;
+    }
+    const end = chunk.indexOf("\n");
+    if (end < 0) {
+      return "";
+    }
+    this.discarding = false;
+    return chunk.slice(end + 1);
+  }
+  private read(chunk: string): void {
+    this.buffer += this.retainedChunk(chunk);
+    let newline = this.buffer.indexOf("\n");
+    while (newline >= 0) {
+      const line = this.buffer.slice(0, newline);
+      this.buffer = this.buffer.slice(newline + 1);
+      if (Buffer.byteLength(line) > FRAME_LIMIT) {
+        this.oversize(line);
+      } else {
+        this.record(line);
+      }
+      newline = this.buffer.indexOf("\n");
+    }
+    if (Buffer.byteLength(this.buffer) > FRAME_LIMIT) {
+      this.discarding = this.oversize(this.buffer);
+      this.buffer = "";
+    }
+  }
+  private oversize(prefix: string): boolean {
+    // Native event serializers put the discriminant first; responses may put their request ID first.
+    // ponytail: drain large native data events through LF; use token streaming if producer headers change.
+    const header = /^\{"type":"([a-z_]+)"[,}]/.exec(prefix.slice(0, 256));
+    const event = header?.[1];
+    if (
+      event !== undefined &&
+      !["response", "extension_ui_request", "agent_start", "agent_settled"].includes(event)
+    ) {
+      log("rpc_event_discarded", { pid: this.pid, result: "oversized" });
+      return true;
+    }
+    this.protocolFailure();
+    return false;
+  }
+  private protocolFailure(): void {
+    this.fail(new Fault(503, "rpc_invalid", "Pi RPC output violated its bounded JSONL contract."));
+    this.cleanup();
+  }
+  private record(line: string): void {
+    let data: unknown;
+    try {
+      data = JSON.parse(line);
+    } catch {
+      this.protocolFailure();
+      return;
+    }
+    if (!isRecord(data)) {
+      this.protocolFailure();
+      return;
+    }
+    if (data.type === "response" && data.id === this.pending?.id) {
+      this.response(data);
+    } else if (data.type === "extension_ui_request") {
+      this.dialog(data);
+    } else if (!this.failure) {
+      this.event(data.type);
+    }
+  }
+  private event(type: unknown): void {
+    if (type === "agent_start") {
+      this.status = "running";
+    } else if (type === "agent_settled") {
+      this.status = "idle";
+    }
+  }
+  private response(data: UnknownRecord): void {
+    const pending = this.pending;
+    this.pending = undefined;
+    if (data.success === true && data.command === "get_state" && isRecord(data.data)) {
+      pending?.resolve(data.data);
+    } else {
+      pending?.reject(new Fault(503, "rpc_failed", "Pi RPC state request failed."));
+    }
+  }
+  private dialog(data: UnknownRecord): void {
+    if (
+      typeof data.method !== "string" ||
+      !["confirm", "select", "input", "editor"].includes(data.method)
+    ) {
+      return;
+    }
+    if (typeof data.id === "string") {
+      this.write({ type: "extension_ui_response", id: data.id, cancelled: true });
+    }
+    this.fail(
+      new Fault(
+        409,
+        "interaction_required",
+        "Pi requested unsupported interactive input; dialog cancelled and session stopped.",
+      ),
+    );
+    this.cleanup();
+  }
+  private write(
+    command: Readonly<
+      | Extract<RpcCommand, { type: "get_state" }>
+      | Extract<RpcExtensionUIResponse, { cancelled: true }>
+    >,
+  ): void {
+    // Only one bounded state request can be in flight; no arbitrary input or growing write queue.
+    if (!this.child.stdin.write(`${JSON.stringify(command)}\n`)) {
+      this.fail(new Fault(503, "rpc_backpressure", "Pi RPC input is not being consumed."));
+      this.cleanup();
+    }
+  }
+  async state(signal: AbortSignal): Promise<UnknownRecord> {
+    if (this.failure) {
+      throw this.failure;
+    }
+    const id = `state-${++this.sequence}`;
+    const result = new Promise<UnknownRecord>((resolve, reject) => {
+      this.pending = { id, resolve, reject };
+      this.write({ type: "get_state", id });
+    });
+    try {
+      return await wait(result, signal);
+    } finally {
+      this.pending = undefined;
+    }
+  }
+  ready(): void {
+    if (this.failure || this.exitObserved) {
+      throw this.failure ?? new Fault(503, "session_exited", "Pi exited during startup.");
+    }
+    if (this.status === "starting") {
+      this.status = "idle";
+    }
+  }
+  private cleanup(): void {
+    this.stop().catch(() => log("launch_cleanup", { pid: this.child.pid, result: "failed" }));
+  }
+  stop(): Promise<void> {
+    if (this.exitObserved) {
+      return this.exited;
+    }
+    this.stopping ??= this.shutdown().finally(() => {
+      this.stopping = undefined;
+    });
+    return this.stopping;
+  }
+  private async shutdown(): Promise<void> {
+    if (this.exitObserved) {
+      return;
+    }
+    this.status = "stopping";
+    this.fail(new Fault(410, "session_stopped", "Launched session is stopping."));
+    this.child.stdin.end();
+    const terminate = setTimeout(() => {
+      trySignalChildTree(this.child, "SIGTERM");
+    }, 1000);
+    const kill = setTimeout(() => {
+      trySignalChildTree(this.child, "SIGKILL");
+    }, 3000);
+    const deadline = AbortSignal.timeout(8000);
+    try {
+      await wait(this.exited, deadline);
+    } catch {
+      throw new Fault(
+        503,
+        "stop_timeout",
+        "Launched Pi did not close within the cleanup deadline; inspect sessions before retrying.",
+      );
+    } finally {
+      clearTimeout(terminate);
+      clearTimeout(kill);
+    }
+  }
+}

package/src/pi-intercom/bridge-session.ts

@@ -9,7 +9,7 @@ import type { Message, SendResult, SessionInfo } from "./types.ts";
 import type { Identity } from "./bridge-config.ts";
 import { Fault, INBOX_BYTES, INBOX_COUNT, cancelled, log, wait } from "./bridge-protocol.ts";
 import type { UnknownRecord } from "../shared/unknown.ts";
-import type { Operation } from "./bridge-routes.ts";
+import type { MessagingOperation as Operation } from "./bridge-routes.ts";
 
 import { WaitingAsk, type Envelope } from "./bridge-ask.ts";
 const MAX_REQUESTS = 8;
@@ -307,6 +307,10 @@ export class Session {
     this.guard(signal);
     return peers;
   }
+  async connectedPeers(signal: AbortSignal): Promise<SessionInfo[]> {
+    await this.connect(signal);
+    return this.peers(signal);
+  }
   private async target(to: string, signal: AbortSignal): Promise<SessionInfo> {
     const resolution = resolveSessionTarget(await this.peers(signal), to);
     if (resolution.status === "none") {