cc-peer 1.3.5 → 1.4.1

package/dist/errors-Dl_lSq1N.cjs

@@ -0,0 +1,88 @@
+//#region src/schemas/define-schema.ts
+/**
+* Attach an `.is()` type guard to a Zod schema so schema, inferred type, and runtime guard derive from one definition (single source of truth). `Schema.parse()` at JSON boundaries; `Schema.is()` for narrowing.
+*/
+function defineSchema(schema) {
+	return Object.assign(schema, { is(value) {
+		return schema.safeParse(value).success;
+	} });
+}
+//#endregion
+//#region src/errors.ts
+/** Base error for every cc-peer failure; `code` is machine-readable. */
+var CcPeerError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "CcPeerError";
+	}
+};
+var NoLiveInboxError = class extends CcPeerError {
+	constructor(message) {
+		super("NO_LIVE_INBOX", message);
+		this.name = "NoLiveInboxError";
+	}
+};
+var UnknownPeerError = class extends CcPeerError {
+	constructor(message) {
+		super("UNKNOWN_PEER", message);
+		this.name = "UnknownPeerError";
+	}
+};
+var MessageTooLargeError = class extends CcPeerError {
+	constructor(message) {
+		super("MESSAGE_TOO_LARGE", message);
+		this.name = "MessageTooLargeError";
+	}
+};
+var NotStartedError = class extends CcPeerError {
+	constructor(message) {
+		super("NOT_STARTED", message);
+		this.name = "NotStartedError";
+	}
+};
+/** A reply-alias worker process exited (or failed to reach the "started" acknowledgement) before it finished registering as a discoverable peer. */
+var AliasStartError = class extends CcPeerError {
+	constructor(message) {
+		super("ALIAS_START_FAILED", message);
+		this.name = "AliasStartError";
+	}
+};
+//#endregion
+Object.defineProperty(exports, "AliasStartError", {
+	enumerable: true,
+	get: function() {
+		return AliasStartError;
+	}
+});
+Object.defineProperty(exports, "MessageTooLargeError", {
+	enumerable: true,
+	get: function() {
+		return MessageTooLargeError;
+	}
+});
+Object.defineProperty(exports, "NoLiveInboxError", {
+	enumerable: true,
+	get: function() {
+		return NoLiveInboxError;
+	}
+});
+Object.defineProperty(exports, "NotStartedError", {
+	enumerable: true,
+	get: function() {
+		return NotStartedError;
+	}
+});
+Object.defineProperty(exports, "UnknownPeerError", {
+	enumerable: true,
+	get: function() {
+		return UnknownPeerError;
+	}
+});
+Object.defineProperty(exports, "defineSchema", {
+	enumerable: true,
+	get: function() {
+		return defineSchema;
+	}
+});

package/dist/rolldown-runtime-VH7oDXx4.cjs

@@ -0,0 +1,28 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});

package/docs/PROTOCOL.md

@@ -76,6 +76,15 @@ The roster builder (`listLivePeerSessions`) reads all `~/.claude/sessions/<pid>.
 
 Verified chain: a Python peer registered this way appears in `ListAgents` within seconds and receives native `SendMessage` by bare name (`from-name` resolves from the sender's own registry entry).
 
+### Session enumeration and reply aliases (for a relay/front building on this SDK)
+
+Two capabilities a message relay ("front") needs from this protocol, gated on what it actually supports rather than assumed:
+
+- **Session enumeration** — listing every live local Claude Code session, not just ones the relay itself registered — is already fully native. The roster builder above reads every `~/.claude/sessions/<pid>.json` file on disk, regardless of who wrote it; `cc-peer`'s own `CcPeer.roster()` (and the REST facade's `GET /sessions`) is exactly this roster builder, so a relay gets full session discovery for free, with no separate mechanism needed.
+- **Reply aliases** — giving each correspondent that messages a relayed session its own natively-`SendMessage`-reachable name, so the session can reply to it directly by name — is **not** natively supported for more than one name per process. The registry is one file per real OS pid (`registryFilePath`: `<pid>.json`) and each entry carries a single optional `name` field; a process publishing a second name overwrites, rather than adds to, its own entry. This is directly observable in this SDK's own test suite: two `CcPeer` instances sharing one pid (unavoidable — both are the same OS process) leave only the last-registered name visible in the roster, because both wrote to the identical `<pid>.json` file. Native name resolution (`ListAgents`/`SendMessage(name=X)`) walks the registry directory exactly as it is on disk — it has no concept of "this one process answers to several names."
+
+The practical consequence: a relay that wants N correspondents to each get their own reply-able name needs N distinct, genuinely live OS processes — one real pid, one registry file, one name, per correspondent — not a lighter-weight in-process mapping. `cc-peer`'s own `AliasPool` (see the root README) implements exactly this: it lazily forks one lightweight child process per correspondent name, each running an ordinary `CcPeer` instance under that name, and relays whatever the relayed session replies with back to the parent process for translation into whatever channel the correspondent actually lives on.
+
 ## Receipts and status
 
 `peer_message_status` is pushed from receiver to sender over a fresh connection to the sender's socket, authenticated with the sender's own peerToken:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-peer",
-  "version": "1.3.5",
+  "version": "1.4.1",
   "description": "Communicate with local Claude Code instances over their native cross-session peer messaging: send and receive messages, register as a named discoverable peer, receipts, idle subscriptions, and a REST facade via `npx cc-peer`.",
   "type": "module",
   "license": "MIT",
@@ -32,6 +32,16 @@
         "default": "./dist/cc-peer.cjs"
       }
     },
+    "./alias-pool": {
+      "import": {
+        "types": "./dist/alias-pool.d.mts",
+        "default": "./dist/alias-pool.mjs"
+      },
+      "require": {
+        "types": "./dist/alias-pool.d.cts",
+        "default": "./dist/alias-pool.cjs"
+      }
+    },
     "./schemas/*.schema.json": "./schemas/*.schema.json",
     "./package.json": "./package.json"
   },
@@ -59,7 +69,7 @@
     "test:integration": "vitest run --project integration",
     "test:e2e": "vitest run --config vitest.e2e.config.ts",
     "test:mutation": "stryker run stryker.config.ts",
-    "prepublishOnly": "pnpm lint && pnpm typecheck && pnpm test:coverage && pnpm build && publint && attw --pack",
+    "prepublishOnly": "pnpm lint && pnpm typecheck && pnpm test:coverage && pnpm build && publint && attw --pack --profile node16",
     "prepare": "husky",
     "test:coverage": "vitest run --coverage"
   },