cc-peer 1.1.8 → 1.2.0

package/README.md

@@ -61,5 +61,6 @@ The REST facade (`npx cc-peer`) serves `GET /sessions`, `POST /messages`, `POST
 
 - **Same-process constraint**: receipts and idle notices only reach the process that owns the peer's listening socket (the protocol verifies return addresses via kernel peer-pids). Do not split `CcPeer` listening and sending across processes or differently-owned workers.
 - **Single machine**: the local protocol is Unix-socket only. Writing to cloud sessions directly is blocked by design (device-attestation-signed events); bridged sessions reachable locally still work via their local mirror.
+- **Windows uses a named pipe, not a Unix socket**: Node's `net` module has no real AF_UNIX support on Windows (its local domain there is a named pipe, under `\\.\pipe\`, not an arbitrary filesystem path — [nodejs/node#55979](https://github.com/nodejs/node/issues/55979)), and Claude Code's own docs confirm it uses exactly that on native Windows. `cc-peer` branches to a named pipe there automatically; nothing to configure. Windows also requires a valid, matching auth line on every inbound connection (macOS and Linux tolerate an absent or foreign one). The exact `procStart` string format `cc-peer` computes on Windows is its own convention (PowerShell's process start time, ISO-8601) rather than a confirmed match for a real native-Windows Claude Code session's own registry entries, which is not publicly documented.
 - **File transfers to Claude sessions** wait on an upstream feature flag (`tengu_send_file`) before Claude-side materialisation activates; peer-to-peer transfers work today.
 - Verified against Claude Code 2.1.269; treat every Claude Code upgrade as a potential protocol change.

package/dist/bin/cc-peer.cjs

@@ -21,7 +21,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-const require_cc_peer = require("../cc-peer-IGtoK_0q.cjs");
+const require_cc_peer = require("../cc-peer-CXzxAUE4.cjs");
 let node_crypto = require("node:crypto");
 let zod = require("zod");
 let node_process = require("node:process");

package/dist/bin/cc-peer.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as defineSchema, i as RegistryEntrySchema, n as CcPeer, r as PrioritySchema } from "../cc-peer-CWGY6H7F.mjs";
+import { a as defineSchema, i as RegistryEntrySchema, n as CcPeer, r as PrioritySchema } from "../cc-peer-CJqStHIL.mjs";
 import { randomBytes } from "node:crypto";
 import { z } from "zod";
 import process from "node:process";

package/dist/{cc-peer-CWGY6H7F.mjs → cc-peer-CJqStHIL.mjs}

@@ -157,10 +157,17 @@ const PeerKeyFileSchema = defineSchema(z.object({
 }));
 //#endregion
 //#region src/adapters/node/paths.ts
+/** Named-pipe prefix Windows requires; a listen()/connect() path must live under it. */
+const WINDOWS_PIPE_PREFIX = "\\\\.\\pipe\\";
+function isWindows() {
+	return process.platform === "win32";
+}
 /**
 * Candidate socket directories, in the order the reference client accepts
 * them. The tuple return type guarantees at least one candidate exists, so
-* callers can index [0] without a fallback branch.
+* callers can index [0] without a fallback branch. Meaningless on Windows,
+* where a named pipe has no filesystem directory of its own — callers there
+* use socketPathForPid directly instead of building a path from a directory.
 */
 function socketDirCandidates(config = {}) {
 	if (config.socketDir !== void 0) return [config.socketDir];
@@ -174,7 +181,23 @@ function socketDirCandidates(config = {}) {
 function sessionsDir(config = {}) {
 	return join(config.homeDir ?? homedir(), ".claude", "sessions");
 }
+/** Long enough that two distinct socketDir values collide only by the same astronomically small chance any truncated hash does; short enough to keep the pipe name readable. */
+const PIPE_NAMESPACE_HEX_LENGTH = 8;
+/**
+* Short, path-safe token distinguishing one caller-supplied socketDir from another in a Windows pipe name. A named pipe has no filesystem directory of its own to carry that distinction the way a POSIX socket path does, so the directory is folded into the name instead.
+*/
+function pipeNamespace(socketDir) {
+	return createHash("sha256").update(socketDir).digest("hex").slice(0, PIPE_NAMESPACE_HEX_LENGTH);
+}
+/**
+* On native Windows, Claude Code's own inbox is a named pipe rather than a Unix domain socket — Node's net module has no filesystem-path AF_UNIX support there at all (see docs/PROTOCOL.md), so unlike every other config override in this module, an explicit socketDir can never become a literal filesystem path on Windows: net.Server.listen() would reject it with EACCES regardless of what directory it names. Node still dispatches to the right OS primitive from the path's own shape, so UdsTransport needs no change; only path construction does. A caller-supplied socketDir keeps its usual purpose — separating one caller's sockets from another's, e.g. across concurrent test runs — by namespacing the pipe name instead of pointing at a real directory. The exact pipe name only needs to be unique per pid (and per socketDir) on this machine, not to match any specific value a real Windows Claude Code session uses.
+*/
 function socketPathForPid(pid, config = {}) {
+	if (isWindows()) {
+		const namespace = config.socketDir === void 0 ? "" : `-${pipeNamespace(config.socketDir)}`;
+		return `${WINDOWS_PIPE_PREFIX}cc-peer${namespace}-${pid.toString()}`;
+	}
+	if (config.socketDir !== void 0) return `${config.socketDir}/${pid.toString()}.sock`;
 	return `${socketDirCandidates(config)[0]}/${pid.toString()}.sock`;
 }
 function registryFilePath(pid, config = {}) {
@@ -186,6 +209,11 @@ function keyFilePath(socketPath, config = {}) {
 	return join(sessionsDir(config), `${pidFromSocketPath(socketPath).toString()}.${hash}.key`);
 }
 function pidFromSocketPath(socketPath) {
+	if (socketPath.startsWith(WINDOWS_PIPE_PREFIX)) {
+		const name = socketPath.slice(9);
+		const pid = Number.parseInt(name.slice(name.lastIndexOf("-") + 1), 10);
+		return Number.isNaN(pid) ? 0 : pid;
+	}
 	const base = socketPath.substring(socketPath.lastIndexOf("/") + 1);
 	const pid = Number.parseInt(base.replace(/\.sock$/, ""), 10);
 	return Number.isNaN(pid) ? 0 : pid;
@@ -343,7 +371,7 @@ var FsRegistryStore = class {
 	}
 };
 //#endregion
-//#region src/adapters/node/ps-proc-info.ts
+//#region src/adapters/node/cached-command.ts
 /**
 * The errno code of an unknown throwable: Node's process.kill throws a SystemError carrying a string code, but a defensive caller may hand us anything, so the narrowing is explicit rather than assumed. Exported for direct unit coverage of every narrowing side.
 */
@@ -351,38 +379,29 @@ function errnoOf(error) {
 	if (error instanceof Error && "code" in error && typeof error.code === "string") return error.code;
 	return "";
 }
-var PsProcInfo = class PsProcInfo {
-	async alive(pid) {
-		return new Promise((resolve) => {
-			try {
-				process.kill(pid, 0);
-				resolve(true);
-			} catch (error) {
-				resolve(errnoOf(error) === "EPERM");
-			}
-		});
-	}
-	/**
-	* `ps -o lstart=` under forced C locale and UTC, returning the trimmed output byte-exact. The registry's liveness check string-compares this value, so the forced environment is load-bearing: bare `ps` follows the user's locale (day-before-month order under en_GB) and local time.
-	*/
-	async lstart(pid) {
-		return (await this.runPs(pid))?.trim();
-	}
-	psCache = /* @__PURE__ */ new Map();
+/** Shared existence probe for PsProcInfo and WinProcInfo: no throw means the pid is live; EPERM means it exists but belongs to another user (still live, and Node emulates this check on Windows too); ESRCH (or any other code) means it is gone. */
+async function signalZeroAlive(pid) {
+	return new Promise((resolve) => {
+		try {
+			process.kill(pid, 0);
+			resolve(true);
+		} catch (error) {
+			resolve(errnoOf(error) === "EPERM");
+		}
+	});
+}
+/** Shared per-pid cache and in-flight dedup for a proc-info command runner, used by both PsProcInfo and WinProcInfo. */
+var CachedPidCommand = class CachedPidCommand {
+	cache = /* @__PURE__ */ new Map();
 	static CACHE_MS = 6e4;
 	inFlight = /* @__PURE__ */ new Map();
-	async runPs(pid) {
-		const cached = this.psCache.get(pid);
-		if (cached !== void 0 && Date.now() - cached.at < PsProcInfo.CACHE_MS) return Promise.resolve(cached.value);
+	async run(pid, command, args) {
+		const cached = this.cache.get(pid);
+		if (cached !== void 0 && Date.now() - cached.at < CachedPidCommand.CACHE_MS) return Promise.resolve(cached.value);
 		const existing = this.inFlight.get(pid);
 		if (existing !== void 0) return existing;
 		const promise = new Promise((resolve) => {
-			const child = spawn("ps", [
-				"-o",
-				"lstart=",
-				"-p",
-				String(pid)
-			], {
+			const child = spawn(command, args, {
 				env: {
 					...process.env,
 					LC_ALL: "C",
@@ -402,11 +421,12 @@ var PsProcInfo = class PsProcInfo {
 				resolve(void 0);
 			});
 			child.on("close", (code) => {
-				this.psCache.set(pid, {
+				const value = code === 0 && out.trim().length > 0 ? out : void 0;
+				this.cache.set(pid, {
 					at: Date.now(),
-					value: out
+					value
 				});
-				resolve(code === 0 && out.trim().length > 0 ? out : void 0);
+				resolve(value);
 			});
 		}).finally(() => {
 			this.inFlight.delete(pid);
@@ -416,6 +436,45 @@ var PsProcInfo = class PsProcInfo {
 	}
 };
 //#endregion
+//#region src/adapters/node/ps-proc-info.ts
+var PsProcInfo = class {
+	command = new CachedPidCommand();
+	async alive(pid) {
+		return signalZeroAlive(pid);
+	}
+	/**
+	* `ps -o lstart=` under forced C locale and UTC, returning the trimmed output byte-exact. The registry's liveness check string-compares this value, so the forced environment is load-bearing: bare `ps` follows the user's locale (day-before-month order under en_GB) and local time.
+	*/
+	async lstart(pid) {
+		return (await this.command.run(pid, "ps", [
+			"-o",
+			"lstart=",
+			"-p",
+			pid.toString()
+		]))?.trim();
+	}
+};
+//#endregion
+//#region src/adapters/node/win-proc-info.ts
+/**
+* Native Windows has no `ps`, so process-start-time verification uses PowerShell's own Process object instead. The exact string format is a cc-peer convention (round-trip ISO-8601, UTC), not a reproduction of whatever format a real native-Windows Claude Code session emits for its own registry entries — that value is not publicly documented and this implementation has not been verified against a live Windows Claude Code session. It is self-consistent for cc-peer's own entries (written and re-read with the same formatting), which is what roster admission actually needs for a peer this SDK itself created.
+*/
+var WinProcInfo = class {
+	command = new CachedPidCommand();
+	async alive(pid) {
+		return signalZeroAlive(pid);
+	}
+	async lstart(pid) {
+		const script = `(Get-Process -Id ${pid.toString()} -ErrorAction Stop).StartTime.ToUniversalTime().ToString('o')`;
+		return (await this.command.run(pid, "powershell.exe", [
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			script
+		]))?.trim();
+	}
+};
+//#endregion
 //#region src/schemas/envelope.ts
 /**
 * Grammar of the <cross-session-message> envelope attributes, mirroring the receiver's own parser. The serialized attribute ORDER is canonical (from, from-session, hop-chain, from-name, from-mode): the receiver's regex matches that sequence only, so any other order parses as nothing.
@@ -748,7 +807,7 @@ var CcPeer = class CcPeer extends EventEmitter {
 			transport: new UdsTransport(),
 			registry: new FsRegistryStore(options),
 			keys: new FsKeyStore(options),
-			procInfo: new PsProcInfo(),
+			procInfo: isWindows() ? new WinProcInfo() : new PsProcInfo(),
 			clock: new SystemClock()
 		});
 		await peer.start();
@@ -762,11 +821,11 @@ var CcPeer = class CcPeer extends EventEmitter {
 		this.ownKey = {
 			peerToken: randomBytes(PEER_TOKEN_BYTES).toString("hex"),
 			procStart: await this.deps.procInfo.lstart(process.pid) ?? "",
-			pidDomain: "darwin"
+			pidDomain: process.platform
 		};
 		if (this.ownKey.procStart === "") throw new NotStartedError("could not read own procStart via ps");
 		await this.deps.keys.writeForSocket(socketPath, this.ownKey);
-		await mkdir(dirname(socketPath), {
+		if (!isWindows()) await mkdir(dirname(socketPath), {
 			recursive: true,
 			mode: 448
 		});
@@ -796,7 +855,7 @@ var CcPeer = class CcPeer extends EventEmitter {
 			peerFeatures: ["notify_idle", "reply_across_default_dirs"],
 			kind: "interactive",
 			entrypoint: "cli",
-			pidDomain: "darwin",
+			pidDomain: process.platform,
 			messagingSocketPath: socketPathForPid(process.pid, this.options),
 			...this.options.name !== void 0 ? {
 				name: this.options.name,
@@ -892,7 +951,14 @@ var CcPeer = class CcPeer extends EventEmitter {
 		const first = await lines[Symbol.asyncIterator]().next();
 		if (first.done === true) return;
 		const parsed = JSON.parse(first.value);
-		if (AuthLineSchema.is(parsed) && parsed.token !== ownToken) this.log("inbound auth token mismatch (foreign token tolerated)");
+		const authenticated = AuthLineSchema.is(parsed) && parsed.token === ownToken;
+		if (isWindows()) {
+			if (!authenticated) {
+				this.log("inbound auth line missing or mismatched (connection closed)");
+				conn.close();
+				return;
+			}
+		} else if (!authenticated) this.log("inbound auth token mismatch (foreign token tolerated)");
 		for await (const line of lines) {
 			let frame;
 			try {

package/dist/{cc-peer-IGtoK_0q.cjs → cc-peer-CXzxAUE4.cjs}

@@ -157,10 +157,17 @@ const PeerKeyFileSchema = defineSchema(zod.z.object({
 }));
 //#endregion
 //#region src/adapters/node/paths.ts
+/** Named-pipe prefix Windows requires; a listen()/connect() path must live under it. */
+const WINDOWS_PIPE_PREFIX = "\\\\.\\pipe\\";
+function isWindows() {
+	return process.platform === "win32";
+}
 /**
 * Candidate socket directories, in the order the reference client accepts
 * them. The tuple return type guarantees at least one candidate exists, so
-* callers can index [0] without a fallback branch.
+* callers can index [0] without a fallback branch. Meaningless on Windows,
+* where a named pipe has no filesystem directory of its own — callers there
+* use socketPathForPid directly instead of building a path from a directory.
 */
 function socketDirCandidates(config = {}) {
 	if (config.socketDir !== void 0) return [config.socketDir];
@@ -174,7 +181,23 @@ function socketDirCandidates(config = {}) {
 function sessionsDir(config = {}) {
 	return (0, node_path.join)(config.homeDir ?? (0, node_os.homedir)(), ".claude", "sessions");
 }
+/** Long enough that two distinct socketDir values collide only by the same astronomically small chance any truncated hash does; short enough to keep the pipe name readable. */
+const PIPE_NAMESPACE_HEX_LENGTH = 8;
+/**
+* Short, path-safe token distinguishing one caller-supplied socketDir from another in a Windows pipe name. A named pipe has no filesystem directory of its own to carry that distinction the way a POSIX socket path does, so the directory is folded into the name instead.
+*/
+function pipeNamespace(socketDir) {
+	return (0, node_crypto.createHash)("sha256").update(socketDir).digest("hex").slice(0, PIPE_NAMESPACE_HEX_LENGTH);
+}
+/**
+* On native Windows, Claude Code's own inbox is a named pipe rather than a Unix domain socket — Node's net module has no filesystem-path AF_UNIX support there at all (see docs/PROTOCOL.md), so unlike every other config override in this module, an explicit socketDir can never become a literal filesystem path on Windows: net.Server.listen() would reject it with EACCES regardless of what directory it names. Node still dispatches to the right OS primitive from the path's own shape, so UdsTransport needs no change; only path construction does. A caller-supplied socketDir keeps its usual purpose — separating one caller's sockets from another's, e.g. across concurrent test runs — by namespacing the pipe name instead of pointing at a real directory. The exact pipe name only needs to be unique per pid (and per socketDir) on this machine, not to match any specific value a real Windows Claude Code session uses.
+*/
 function socketPathForPid(pid, config = {}) {
+	if (isWindows()) {
+		const namespace = config.socketDir === void 0 ? "" : `-${pipeNamespace(config.socketDir)}`;
+		return `${WINDOWS_PIPE_PREFIX}cc-peer${namespace}-${pid.toString()}`;
+	}
+	if (config.socketDir !== void 0) return `${config.socketDir}/${pid.toString()}.sock`;
 	return `${socketDirCandidates(config)[0]}/${pid.toString()}.sock`;
 }
 function registryFilePath(pid, config = {}) {
@@ -186,6 +209,11 @@ function keyFilePath(socketPath, config = {}) {
 	return (0, node_path.join)(sessionsDir(config), `${pidFromSocketPath(socketPath).toString()}.${hash}.key`);
 }
 function pidFromSocketPath(socketPath) {
+	if (socketPath.startsWith(WINDOWS_PIPE_PREFIX)) {
+		const name = socketPath.slice(9);
+		const pid = Number.parseInt(name.slice(name.lastIndexOf("-") + 1), 10);
+		return Number.isNaN(pid) ? 0 : pid;
+	}
 	const base = socketPath.substring(socketPath.lastIndexOf("/") + 1);
 	const pid = Number.parseInt(base.replace(/\.sock$/, ""), 10);
 	return Number.isNaN(pid) ? 0 : pid;
@@ -343,7 +371,7 @@ var FsRegistryStore = class {
 	}
 };
 //#endregion
-//#region src/adapters/node/ps-proc-info.ts
+//#region src/adapters/node/cached-command.ts
 /**
 * The errno code of an unknown throwable: Node's process.kill throws a SystemError carrying a string code, but a defensive caller may hand us anything, so the narrowing is explicit rather than assumed. Exported for direct unit coverage of every narrowing side.
 */
@@ -351,38 +379,29 @@ function errnoOf(error) {
 	if (error instanceof Error && "code" in error && typeof error.code === "string") return error.code;
 	return "";
 }
-var PsProcInfo = class PsProcInfo {
-	async alive(pid) {
-		return new Promise((resolve) => {
-			try {
-				process.kill(pid, 0);
-				resolve(true);
-			} catch (error) {
-				resolve(errnoOf(error) === "EPERM");
-			}
-		});
-	}
-	/**
-	* `ps -o lstart=` under forced C locale and UTC, returning the trimmed output byte-exact. The registry's liveness check string-compares this value, so the forced environment is load-bearing: bare `ps` follows the user's locale (day-before-month order under en_GB) and local time.
-	*/
-	async lstart(pid) {
-		return (await this.runPs(pid))?.trim();
-	}
-	psCache = /* @__PURE__ */ new Map();
+/** Shared existence probe for PsProcInfo and WinProcInfo: no throw means the pid is live; EPERM means it exists but belongs to another user (still live, and Node emulates this check on Windows too); ESRCH (or any other code) means it is gone. */
+async function signalZeroAlive(pid) {
+	return new Promise((resolve) => {
+		try {
+			process.kill(pid, 0);
+			resolve(true);
+		} catch (error) {
+			resolve(errnoOf(error) === "EPERM");
+		}
+	});
+}
+/** Shared per-pid cache and in-flight dedup for a proc-info command runner, used by both PsProcInfo and WinProcInfo. */
+var CachedPidCommand = class CachedPidCommand {
+	cache = /* @__PURE__ */ new Map();
 	static CACHE_MS = 6e4;
 	inFlight = /* @__PURE__ */ new Map();
-	async runPs(pid) {
-		const cached = this.psCache.get(pid);
-		if (cached !== void 0 && Date.now() - cached.at < PsProcInfo.CACHE_MS) return Promise.resolve(cached.value);
+	async run(pid, command, args) {
+		const cached = this.cache.get(pid);
+		if (cached !== void 0 && Date.now() - cached.at < CachedPidCommand.CACHE_MS) return Promise.resolve(cached.value);
 		const existing = this.inFlight.get(pid);
 		if (existing !== void 0) return existing;
 		const promise = new Promise((resolve) => {
-			const child = (0, node_child_process.spawn)("ps", [
-				"-o",
-				"lstart=",
-				"-p",
-				String(pid)
-			], {
+			const child = (0, node_child_process.spawn)(command, args, {
 				env: {
 					...process.env,
 					LC_ALL: "C",
@@ -402,11 +421,12 @@ var PsProcInfo = class PsProcInfo {
 				resolve(void 0);
 			});
 			child.on("close", (code) => {
-				this.psCache.set(pid, {
+				const value = code === 0 && out.trim().length > 0 ? out : void 0;
+				this.cache.set(pid, {
 					at: Date.now(),
-					value: out
+					value
 				});
-				resolve(code === 0 && out.trim().length > 0 ? out : void 0);
+				resolve(value);
 			});
 		}).finally(() => {
 			this.inFlight.delete(pid);
@@ -416,6 +436,45 @@ var PsProcInfo = class PsProcInfo {
 	}
 };
 //#endregion
+//#region src/adapters/node/ps-proc-info.ts
+var PsProcInfo = class {
+	command = new CachedPidCommand();
+	async alive(pid) {
+		return signalZeroAlive(pid);
+	}
+	/**
+	* `ps -o lstart=` under forced C locale and UTC, returning the trimmed output byte-exact. The registry's liveness check string-compares this value, so the forced environment is load-bearing: bare `ps` follows the user's locale (day-before-month order under en_GB) and local time.
+	*/
+	async lstart(pid) {
+		return (await this.command.run(pid, "ps", [
+			"-o",
+			"lstart=",
+			"-p",
+			pid.toString()
+		]))?.trim();
+	}
+};
+//#endregion
+//#region src/adapters/node/win-proc-info.ts
+/**
+* Native Windows has no `ps`, so process-start-time verification uses PowerShell's own Process object instead. The exact string format is a cc-peer convention (round-trip ISO-8601, UTC), not a reproduction of whatever format a real native-Windows Claude Code session emits for its own registry entries — that value is not publicly documented and this implementation has not been verified against a live Windows Claude Code session. It is self-consistent for cc-peer's own entries (written and re-read with the same formatting), which is what roster admission actually needs for a peer this SDK itself created.
+*/
+var WinProcInfo = class {
+	command = new CachedPidCommand();
+	async alive(pid) {
+		return signalZeroAlive(pid);
+	}
+	async lstart(pid) {
+		const script = `(Get-Process -Id ${pid.toString()} -ErrorAction Stop).StartTime.ToUniversalTime().ToString('o')`;
+		return (await this.command.run(pid, "powershell.exe", [
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			script
+		]))?.trim();
+	}
+};
+//#endregion
 //#region src/schemas/envelope.ts
 /**
 * Grammar of the <cross-session-message> envelope attributes, mirroring the receiver's own parser. The serialized attribute ORDER is canonical (from, from-session, hop-chain, from-name, from-mode): the receiver's regex matches that sequence only, so any other order parses as nothing.
@@ -748,7 +807,7 @@ var CcPeer = class CcPeer extends node_events.EventEmitter {
 			transport: new UdsTransport(),
 			registry: new FsRegistryStore(options),
 			keys: new FsKeyStore(options),
-			procInfo: new PsProcInfo(),
+			procInfo: isWindows() ? new WinProcInfo() : new PsProcInfo(),
 			clock: new SystemClock()
 		});
 		await peer.start();
@@ -762,11 +821,11 @@ var CcPeer = class CcPeer extends node_events.EventEmitter {
 		this.ownKey = {
 			peerToken: (0, node_crypto.randomBytes)(PEER_TOKEN_BYTES).toString("hex"),
 			procStart: await this.deps.procInfo.lstart(process.pid) ?? "",
-			pidDomain: "darwin"
+			pidDomain: process.platform
 		};
 		if (this.ownKey.procStart === "") throw new NotStartedError("could not read own procStart via ps");
 		await this.deps.keys.writeForSocket(socketPath, this.ownKey);
-		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(socketPath), {
+		if (!isWindows()) await (0, node_fs_promises.mkdir)((0, node_path.dirname)(socketPath), {
 			recursive: true,
 			mode: 448
 		});
@@ -796,7 +855,7 @@ var CcPeer = class CcPeer extends node_events.EventEmitter {
 			peerFeatures: ["notify_idle", "reply_across_default_dirs"],
 			kind: "interactive",
 			entrypoint: "cli",
-			pidDomain: "darwin",
+			pidDomain: process.platform,
 			messagingSocketPath: socketPathForPid(process.pid, this.options),
 			...this.options.name !== void 0 ? {
 				name: this.options.name,
@@ -892,7 +951,14 @@ var CcPeer = class CcPeer extends node_events.EventEmitter {
 		const first = await lines[Symbol.asyncIterator]().next();
 		if (first.done === true) return;
 		const parsed = JSON.parse(first.value);
-		if (AuthLineSchema.is(parsed) && parsed.token !== ownToken) this.log("inbound auth token mismatch (foreign token tolerated)");
+		const authenticated = AuthLineSchema.is(parsed) && parsed.token === ownToken;
+		if (isWindows()) {
+			if (!authenticated) {
+				this.log("inbound auth line missing or mismatched (connection closed)");
+				conn.close();
+				return;
+			}
+		} else if (!authenticated) this.log("inbound auth token mismatch (foreign token tolerated)");
 		for await (const line of lines) {
 			let frame;
 			try {

package/dist/cc-peer.cjs

@@ -1,4 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_cc_peer = require("./cc-peer-IGtoK_0q.cjs");
+const require_cc_peer = require("./cc-peer-CXzxAUE4.cjs");
 exports.CC_PEER_VERSION = require_cc_peer.CC_PEER_VERSION;
 exports.CcPeer = require_cc_peer.CcPeer;

package/dist/cc-peer.mjs

@@ -1,2 +1,2 @@
-import { n as CcPeer, t as CC_PEER_VERSION } from "./cc-peer-CWGY6H7F.mjs";
+import { n as CcPeer, t as CC_PEER_VERSION } from "./cc-peer-CJqStHIL.mjs";
 export { CC_PEER_VERSION, CcPeer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-peer",
-  "version": "1.1.8",
+  "version": "1.2.0",
   "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",
@@ -50,7 +50,7 @@
     "build": "turbo run _build",
     "_build": "tsdown && tsx scripts/generate-json-schema.ts",
     "lint": "turbo run _lint",
-    "_lint": "eslint . --cache",
+    "_lint": "eslint . --cache --fix",
     "typecheck": "turbo run _typecheck",
     "_typecheck": "tsc --noEmit",
     "test": "vitest run",