@selesai/code 0.10.2 → 0.12.0

package/dist/extensions/pi-intercom/broker/client.test.ts

@@ -1,83 +1,83 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { IntercomClient } from "./client.ts";
-
-test("validated session lifecycle messages reach broker-message subscribers", () => {
-  const client = new IntercomClient();
-  (client as any)._sessionId = "session-1";
-  const received: unknown[] = [];
-  client.onBrokerMessage((message) => received.push(message));
-  const session = {
-    id: "session-2",
-    cwd: "/test",
-    model: "test",
-    pid: 2,
-    startedAt: 1,
-    lastActivity: 1,
-  };
-
-  (client as any).handleBrokerMessage({ type: "session_joined", session });
-  (client as any).handleBrokerMessage({ type: "presence_update", session });
-  (client as any).handleBrokerMessage({ type: "session_left", sessionId: "session-2" });
-
-  assert.deepEqual(received, [
-    { type: "session_joined", session },
-    { type: "presence_update", session },
-    { type: "session_left", sessionId: "session-2" },
-  ]);
-});
-
-test("registered feature negotiation rejects non-string feature entries", () => {
-  const client = new IntercomClient();
-  assert.throws(
-    () => (client as any).handleBrokerMessage({ type: "registered", sessionId: "session-1", features: ["valid", 123] }),
-    /Invalid registered features/,
-  );
-});
-
-test("malformed extension broker messages are rejected", () => {
-  const client = new IntercomClient();
-  (client as any)._sessionId = "session-1";
-
-  assert.throws(
-    () => (client as any).handleBrokerMessage({ type: "extension_owner", namespace: "test/v1", ownerId: "owner" }),
-    /Invalid extension_owner/,
-  );
-  assert.throws(
-    () => (client as any).handleBrokerMessage({ type: "extension_owner", namespace: "test/v1", ownerEpoch: "epoch" }),
-    /Invalid extension_owner/,
-  );
-  assert.throws(
-    () => (client as any).handleBrokerMessage({ type: "extension_message", namespace: "test/v1" }),
-    /Invalid extension_message/,
-  );
-  assert.throws(
-    () => (client as any).handleBrokerMessage({ type: "extension_state", namespace: "test/v1", revision: -1 }),
-    /Invalid extension_state/,
-  );
-  assert.throws(
-    () => (client as any).handleBrokerMessage({ type: "extension_state_result", namespace: "test/v1", committed: "yes", revision: 1 }),
-    /Invalid extension_state_result/,
-  );
-  assert.doesNotThrow(() => (client as any).handleBrokerMessage({
-    type: "extension_message",
-    namespace: "test/v1",
-    fromSessionId: "session-2",
-    payload: { peerOnly: true },
-  }));
-});
-
-test("cancelAsk ignores synchronous socket write failures", () => {
-  const client = new IntercomClient();
-  (client as any)._sessionId = "session-1";
-  (client as any).socket = {
-    destroyed: false,
-    writableEnded: false,
-    writable: true,
-    write() {
-      throw new Error("write failed");
-    },
-  };
-
-  assert.doesNotThrow(() => client.cancelAsk("ask-1"));
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { IntercomClient } from "./client.ts";
+
+test("validated session lifecycle messages reach broker-message subscribers", () => {
+  const client = new IntercomClient();
+  (client as any)._sessionId = "session-1";
+  const received: unknown[] = [];
+  client.onBrokerMessage((message) => received.push(message));
+  const session = {
+    id: "session-2",
+    cwd: "/test",
+    model: "test",
+    pid: 2,
+    startedAt: 1,
+    lastActivity: 1,
+  };
+
+  (client as any).handleBrokerMessage({ type: "session_joined", session });
+  (client as any).handleBrokerMessage({ type: "presence_update", session });
+  (client as any).handleBrokerMessage({ type: "session_left", sessionId: "session-2" });
+
+  assert.deepEqual(received, [
+    { type: "session_joined", session },
+    { type: "presence_update", session },
+    { type: "session_left", sessionId: "session-2" },
+  ]);
+});
+
+test("registered feature negotiation rejects non-string feature entries", () => {
+  const client = new IntercomClient();
+  assert.throws(
+    () => (client as any).handleBrokerMessage({ type: "registered", sessionId: "session-1", features: ["valid", 123] }),
+    /Invalid registered features/,
+  );
+});
+
+test("malformed extension broker messages are rejected", () => {
+  const client = new IntercomClient();
+  (client as any)._sessionId = "session-1";
+
+  assert.throws(
+    () => (client as any).handleBrokerMessage({ type: "extension_owner", namespace: "test/v1", ownerId: "owner" }),
+    /Invalid extension_owner/,
+  );
+  assert.throws(
+    () => (client as any).handleBrokerMessage({ type: "extension_owner", namespace: "test/v1", ownerEpoch: "epoch" }),
+    /Invalid extension_owner/,
+  );
+  assert.throws(
+    () => (client as any).handleBrokerMessage({ type: "extension_message", namespace: "test/v1" }),
+    /Invalid extension_message/,
+  );
+  assert.throws(
+    () => (client as any).handleBrokerMessage({ type: "extension_state", namespace: "test/v1", revision: -1 }),
+    /Invalid extension_state/,
+  );
+  assert.throws(
+    () => (client as any).handleBrokerMessage({ type: "extension_state_result", namespace: "test/v1", committed: "yes", revision: 1 }),
+    /Invalid extension_state_result/,
+  );
+  assert.doesNotThrow(() => (client as any).handleBrokerMessage({
+    type: "extension_message",
+    namespace: "test/v1",
+    fromSessionId: "session-2",
+    payload: { peerOnly: true },
+  }));
+});
+
+test("cancelAsk ignores synchronous socket write failures", () => {
+  const client = new IntercomClient();
+  (client as any)._sessionId = "session-1";
+  (client as any).socket = {
+    destroyed: false,
+    writableEnded: false,
+    writable: true,
+    write() {
+      throw new Error("write failed");
+    },
+  };
+
+  assert.doesNotThrow(() => client.cancelAsk("ask-1"));
+});

package/dist/extensions/pi-intercom/broker/framing.test.ts

@@ -1,114 +1,114 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createMessageReader, writeMessage } from "./framing.ts";
-
-function framePayload(payload: Buffer): Buffer {
-  const header = Buffer.alloc(4);
-  header.writeUInt32BE(payload.length, 0);
-  return Buffer.concat([header, payload]);
-}
-
-test("createMessageReader handles normal fragmented frames", () => {
-  const messages: unknown[] = [];
-  const errors: Error[] = [];
-  const reader = createMessageReader(
-    (message) => messages.push(message),
-    (error) => errors.push(error),
-    64,
-  );
-  const frameA = framePayload(Buffer.from(JSON.stringify({ type: "one" }), "utf-8"));
-  const frameB = framePayload(Buffer.from(JSON.stringify({ type: "two" }), "utf-8"));
-  const combined = Buffer.concat([frameA, frameB]);
-
-  reader(combined.subarray(0, 2));
-  reader(combined.subarray(2, 7));
-  reader(combined.subarray(7));
-
-  assert.deepEqual(messages, [{ type: "one" }, { type: "two" }]);
-  assert.deepEqual(errors, []);
-});
-
-test("createMessageReader reassembles a fragmented frame after a header-boundary fast-path frame", () => {
-  const messages: unknown[] = [];
-  const errors: Error[] = [];
-  const reader = createMessageReader(
-    (message) => messages.push(message),
-    (error) => errors.push(error),
-    64,
-  );
-  const frameA = framePayload(Buffer.from(JSON.stringify({ a: 1 }), "utf-8"));
-  const frameB = framePayload(Buffer.from(JSON.stringify({ bb: "1234567890" }), "utf-8"));
-
-  reader(frameA.subarray(0, 4)); // chunk ends exactly at the end of frame A's header
-  reader(frameA.subarray(4)); // frame A's payload arrives whole (zero-copy fast path)
-  reader(frameB.subarray(0, 6)); // frame B header + partial payload (buffered path)
-  reader(frameB.subarray(6));
-
-  assert.deepEqual(messages, [{ a: 1 }, { bb: "1234567890" }]);
-  assert.deepEqual(errors, []);
-});
-
-test("createMessageReader rejects an oversized declared frame", () => {
-  const messages: unknown[] = [];
-  const errors: Error[] = [];
-  const reader = createMessageReader(
-    (message) => messages.push(message),
-    (error) => errors.push(error),
-    8,
-  );
-  const oversizedFrame = framePayload(Buffer.from(JSON.stringify({ text: "too large" }), "utf-8"));
-
-  reader(oversizedFrame);
-
-  assert.deepEqual(messages, []);
-  assert.equal(errors.length, 1);
-  assert.match(errors[0].message, /Intercom frame length \d+ exceeds maximum 8 bytes/);
-});
-
-test("createMessageReader rejects an oversized frame before retaining same-chunk payload bytes", () => {
-  const messages: unknown[] = [];
-  const errors: Error[] = [];
-  const reader = createMessageReader(
-    (message) => messages.push(message),
-    (error) => errors.push(error),
-    8,
-  );
-  const header = Buffer.alloc(4);
-  header.writeUInt32BE(9, 0);
-
-  reader(Buffer.concat([header, Buffer.alloc(1024 * 1024)]));
-
-  assert.deepEqual(messages, []);
-  assert.equal(errors.length, 1);
-  assert.equal(errors[0].message, "Intercom frame length 9 exceeds maximum 8 bytes");
-});
-
-test("createMessageReader rejects a partial oversized frame before buffering the payload", () => {
-  const messages: unknown[] = [];
-  const errors: Error[] = [];
-  const reader = createMessageReader(
-    (message) => messages.push(message),
-    (error) => errors.push(error),
-    8,
-  );
-  const header = Buffer.alloc(4);
-  header.writeUInt32BE(9, 0);
-
-  reader(header);
-
-  assert.deepEqual(messages, []);
-  assert.equal(errors.length, 1);
-  assert.equal(errors[0].message, "Intercom frame length 9 exceeds maximum 8 bytes");
-});
-
-test("writeMessage emits frames accepted by createMessageReader", () => {
-  const chunks: Buffer[] = [];
-  const socket = { write: (chunk: Buffer) => chunks.push(chunk) };
-  const messages: unknown[] = [];
-  const reader = createMessageReader((message) => messages.push(message), assert.fail, 64);
-
-  writeMessage(socket as never, { ok: true });
-  reader(Buffer.concat(chunks));
-
-  assert.deepEqual(messages, [{ ok: true }]);
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createMessageReader, writeMessage } from "./framing.ts";
+
+function framePayload(payload: Buffer): Buffer {
+  const header = Buffer.alloc(4);
+  header.writeUInt32BE(payload.length, 0);
+  return Buffer.concat([header, payload]);
+}
+
+test("createMessageReader handles normal fragmented frames", () => {
+  const messages: unknown[] = [];
+  const errors: Error[] = [];
+  const reader = createMessageReader(
+    (message) => messages.push(message),
+    (error) => errors.push(error),
+    64,
+  );
+  const frameA = framePayload(Buffer.from(JSON.stringify({ type: "one" }), "utf-8"));
+  const frameB = framePayload(Buffer.from(JSON.stringify({ type: "two" }), "utf-8"));
+  const combined = Buffer.concat([frameA, frameB]);
+
+  reader(combined.subarray(0, 2));
+  reader(combined.subarray(2, 7));
+  reader(combined.subarray(7));
+
+  assert.deepEqual(messages, [{ type: "one" }, { type: "two" }]);
+  assert.deepEqual(errors, []);
+});
+
+test("createMessageReader reassembles a fragmented frame after a header-boundary fast-path frame", () => {
+  const messages: unknown[] = [];
+  const errors: Error[] = [];
+  const reader = createMessageReader(
+    (message) => messages.push(message),
+    (error) => errors.push(error),
+    64,
+  );
+  const frameA = framePayload(Buffer.from(JSON.stringify({ a: 1 }), "utf-8"));
+  const frameB = framePayload(Buffer.from(JSON.stringify({ bb: "1234567890" }), "utf-8"));
+
+  reader(frameA.subarray(0, 4)); // chunk ends exactly at the end of frame A's header
+  reader(frameA.subarray(4)); // frame A's payload arrives whole (zero-copy fast path)
+  reader(frameB.subarray(0, 6)); // frame B header + partial payload (buffered path)
+  reader(frameB.subarray(6));
+
+  assert.deepEqual(messages, [{ a: 1 }, { bb: "1234567890" }]);
+  assert.deepEqual(errors, []);
+});
+
+test("createMessageReader rejects an oversized declared frame", () => {
+  const messages: unknown[] = [];
+  const errors: Error[] = [];
+  const reader = createMessageReader(
+    (message) => messages.push(message),
+    (error) => errors.push(error),
+    8,
+  );
+  const oversizedFrame = framePayload(Buffer.from(JSON.stringify({ text: "too large" }), "utf-8"));
+
+  reader(oversizedFrame);
+
+  assert.deepEqual(messages, []);
+  assert.equal(errors.length, 1);
+  assert.match(errors[0].message, /Intercom frame length \d+ exceeds maximum 8 bytes/);
+});
+
+test("createMessageReader rejects an oversized frame before retaining same-chunk payload bytes", () => {
+  const messages: unknown[] = [];
+  const errors: Error[] = [];
+  const reader = createMessageReader(
+    (message) => messages.push(message),
+    (error) => errors.push(error),
+    8,
+  );
+  const header = Buffer.alloc(4);
+  header.writeUInt32BE(9, 0);
+
+  reader(Buffer.concat([header, Buffer.alloc(1024 * 1024)]));
+
+  assert.deepEqual(messages, []);
+  assert.equal(errors.length, 1);
+  assert.equal(errors[0].message, "Intercom frame length 9 exceeds maximum 8 bytes");
+});
+
+test("createMessageReader rejects a partial oversized frame before buffering the payload", () => {
+  const messages: unknown[] = [];
+  const errors: Error[] = [];
+  const reader = createMessageReader(
+    (message) => messages.push(message),
+    (error) => errors.push(error),
+    8,
+  );
+  const header = Buffer.alloc(4);
+  header.writeUInt32BE(9, 0);
+
+  reader(header);
+
+  assert.deepEqual(messages, []);
+  assert.equal(errors.length, 1);
+  assert.equal(errors[0].message, "Intercom frame length 9 exceeds maximum 8 bytes");
+});
+
+test("writeMessage emits frames accepted by createMessageReader", () => {
+  const chunks: Buffer[] = [];
+  const socket = { write: (chunk: Buffer) => chunks.push(chunk) };
+  const messages: unknown[] = [];
+  const reader = createMessageReader((message) => messages.push(message), assert.fail, 64);
+
+  writeMessage(socket as never, { ok: true });
+  reader(Buffer.concat(chunks));
+
+  assert.deepEqual(messages, [{ ok: true }]);
+});

package/dist/extensions/pi-intercom/broker/paths.ts

@@ -1,134 +1,134 @@
-import { chmodSync, mkdirSync, readFileSync } from "fs";
-import { isAbsolute, join, resolve } from "path";
-import { getAgentDir } from "@selesai/code";
-
-export const INTERCOM_DIR_MODE = 0o700;
-export const INTERCOM_RUNTIME_FILE_MODE = 0o600;
-export const INTERCOM_TCP_HOST = "127.0.0.1";
-export const INTERCOM_PROTOCOL_NAME = "pi-intercom";
-export const INTERCOM_PROTOCOL_VERSION = 1;
-
-export interface BrokerTcpEndpoint {
-  transport: "tcp";
-  host: string;
-  port: number;
-  stateId?: string;
-}
-
-export type BrokerConnectTarget = string | BrokerTcpEndpoint;
-
-function sanitizePipeSegment(value: string): string {
-  return value
-    .replace(/[^a-zA-Z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .toLowerCase() || "default";
-}
-
-export function getAgentDirPath(
-  env: NodeJS.ProcessEnv = process.env,
-  cwd: string = process.cwd(),
-): string {
-  const configured = env.SELESAI_CODING_AGENT_DIR?.trim();
-  if (!configured) {
-    return getAgentDir();
-  }
-
-  return isAbsolute(configured) ? configured : resolve(cwd, configured);
-}
-
-export function getIntercomDirPath(agentDir: string = getAgentDirPath()): string {
-  return join(agentDir, "intercom");
-}
-
-export function shouldUseWindowsTcpTransport(
-  platform: NodeJS.Platform = process.platform,
-  env: NodeJS.ProcessEnv = process.env,
-): boolean {
-  if (platform !== "win32") {
-    return false;
-  }
-
-  const transport = env.PI_INTERCOM_TRANSPORT?.trim().toLowerCase();
-  if (transport === "tcp") {
-    return true;
-  }
-
-  const legacyOptIn = env.PI_INTERCOM_TCP?.trim().toLowerCase();
-  return legacyOptIn === "1" || legacyOptIn === "true";
-}
-
-export function getBrokerPortFilePath(intercomDir: string = getIntercomDirPath()): string {
-  return join(intercomDir, "broker.port.json");
-}
-
-export function getBrokerSocketPath(
-  platform: NodeJS.Platform = process.platform,
-  agentDir: string = getAgentDirPath(),
-): string {
-  if (platform === "win32") {
-    return `\\\\.\\pipe\\pi-intercom-${sanitizePipeSegment(agentDir)}`;
-  }
-
-  return join(getIntercomDirPath(agentDir), "broker.sock");
-}
-
-export function getBrokerConnectTarget(
-  platform: NodeJS.Platform = process.platform,
-  env: NodeJS.ProcessEnv = process.env,
-  intercomDir: string = getIntercomDirPath(getAgentDirPath(env)),
-): BrokerConnectTarget {
-  if (shouldUseWindowsTcpTransport(platform, env)) {
-    const endpointFile = getBrokerPortFilePath(intercomDir);
-    const raw = readFileSync(endpointFile, "utf-8");
-    const parsed: unknown = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      throw new Error(`Invalid intercom TCP endpoint at ${endpointFile}: expected a JSON object`);
-    }
-    const endpoint = parsed as Record<string, unknown>;
-    if (
-      endpoint.transport !== "tcp"
-      || endpoint.host !== INTERCOM_TCP_HOST
-      || typeof endpoint.port !== "number"
-      || !Number.isSafeInteger(endpoint.port)
-      || endpoint.port <= 0
-      || endpoint.port > 65535
-      || typeof endpoint.stateId !== "string"
-      || endpoint.stateId.length === 0
-    ) {
-      throw new Error(`Invalid intercom TCP endpoint at ${endpointFile}`);
-    }
-    return { transport: "tcp", host: endpoint.host, port: endpoint.port, stateId: endpoint.stateId };
-  }
-
-  return getBrokerSocketPath(platform, getAgentDirPath(env));
-}
-
-export function getBrokerListenTarget(
-  platform: NodeJS.Platform = process.platform,
-  env: NodeJS.ProcessEnv = process.env,
-): BrokerConnectTarget {
-  if (shouldUseWindowsTcpTransport(platform, env)) {
-    return { transport: "tcp", host: INTERCOM_TCP_HOST, port: 0 };
-  }
-
-  return getBrokerSocketPath(platform, getAgentDirPath(env));
-}
-
-export function ensureIntercomRuntimeDir(
-  intercomDir: string = getIntercomDirPath(),
-  platform: NodeJS.Platform = process.platform,
-): void {
-  mkdirSync(intercomDir, { recursive: true, mode: INTERCOM_DIR_MODE });
-  if (platform !== "win32") {
-    chmodSync(intercomDir, INTERCOM_DIR_MODE);
-  }
-}
-
-export function restrictIntercomRuntimeFile(
-  filePath: string,
-  platform: NodeJS.Platform = process.platform,
-): void {
-  if (platform !== "win32") {
-    chmodSync(filePath, INTERCOM_RUNTIME_FILE_MODE);
-  }
-}
+import { chmodSync, mkdirSync, readFileSync } from "fs";
+import { isAbsolute, join, resolve } from "path";
+import { getAgentDir } from "@selesai/code";
+
+export const INTERCOM_DIR_MODE = 0o700;
+export const INTERCOM_RUNTIME_FILE_MODE = 0o600;
+export const INTERCOM_TCP_HOST = "127.0.0.1";
+export const INTERCOM_PROTOCOL_NAME = "pi-intercom";
+export const INTERCOM_PROTOCOL_VERSION = 1;
+
+export interface BrokerTcpEndpoint {
+  transport: "tcp";
+  host: string;
+  port: number;
+  stateId?: string;
+}
+
+export type BrokerConnectTarget = string | BrokerTcpEndpoint;
+
+function sanitizePipeSegment(value: string): string {
+  return value
+    .replace(/[^a-zA-Z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .toLowerCase() || "default";
+}
+
+export function getAgentDirPath(
+  env: NodeJS.ProcessEnv = process.env,
+  cwd: string = process.cwd(),
+): string {
+  const configured = env.SELESAI_CODING_AGENT_DIR?.trim();
+  if (!configured) {
+    return getAgentDir();
+  }
+
+  return isAbsolute(configured) ? configured : resolve(cwd, configured);
+}
+
+export function getIntercomDirPath(agentDir: string = getAgentDirPath()): string {
+  return join(agentDir, "intercom");
+}
+
+export function shouldUseWindowsTcpTransport(
+  platform: NodeJS.Platform = process.platform,
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  if (platform !== "win32") {
+    return false;
+  }
+
+  const transport = env.PI_INTERCOM_TRANSPORT?.trim().toLowerCase();
+  if (transport === "tcp") {
+    return true;
+  }
+
+  const legacyOptIn = env.PI_INTERCOM_TCP?.trim().toLowerCase();
+  return legacyOptIn === "1" || legacyOptIn === "true";
+}
+
+export function getBrokerPortFilePath(intercomDir: string = getIntercomDirPath()): string {
+  return join(intercomDir, "broker.port.json");
+}
+
+export function getBrokerSocketPath(
+  platform: NodeJS.Platform = process.platform,
+  agentDir: string = getAgentDirPath(),
+): string {
+  if (platform === "win32") {
+    return `\\\\.\\pipe\\pi-intercom-${sanitizePipeSegment(agentDir)}`;
+  }
+
+  return join(getIntercomDirPath(agentDir), "broker.sock");
+}
+
+export function getBrokerConnectTarget(
+  platform: NodeJS.Platform = process.platform,
+  env: NodeJS.ProcessEnv = process.env,
+  intercomDir: string = getIntercomDirPath(getAgentDirPath(env)),
+): BrokerConnectTarget {
+  if (shouldUseWindowsTcpTransport(platform, env)) {
+    const endpointFile = getBrokerPortFilePath(intercomDir);
+    const raw = readFileSync(endpointFile, "utf-8");
+    const parsed: unknown = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      throw new Error(`Invalid intercom TCP endpoint at ${endpointFile}: expected a JSON object`);
+    }
+    const endpoint = parsed as Record<string, unknown>;
+    if (
+      endpoint.transport !== "tcp"
+      || endpoint.host !== INTERCOM_TCP_HOST
+      || typeof endpoint.port !== "number"
+      || !Number.isSafeInteger(endpoint.port)
+      || endpoint.port <= 0
+      || endpoint.port > 65535
+      || typeof endpoint.stateId !== "string"
+      || endpoint.stateId.length === 0
+    ) {
+      throw new Error(`Invalid intercom TCP endpoint at ${endpointFile}`);
+    }
+    return { transport: "tcp", host: endpoint.host, port: endpoint.port, stateId: endpoint.stateId };
+  }
+
+  return getBrokerSocketPath(platform, getAgentDirPath(env));
+}
+
+export function getBrokerListenTarget(
+  platform: NodeJS.Platform = process.platform,
+  env: NodeJS.ProcessEnv = process.env,
+): BrokerConnectTarget {
+  if (shouldUseWindowsTcpTransport(platform, env)) {
+    return { transport: "tcp", host: INTERCOM_TCP_HOST, port: 0 };
+  }
+
+  return getBrokerSocketPath(platform, getAgentDirPath(env));
+}
+
+export function ensureIntercomRuntimeDir(
+  intercomDir: string = getIntercomDirPath(),
+  platform: NodeJS.Platform = process.platform,
+): void {
+  mkdirSync(intercomDir, { recursive: true, mode: INTERCOM_DIR_MODE });
+  if (platform !== "win32") {
+    chmodSync(intercomDir, INTERCOM_DIR_MODE);
+  }
+}
+
+export function restrictIntercomRuntimeFile(
+  filePath: string,
+  platform: NodeJS.Platform = process.platform,
+): void {
+  if (platform !== "win32") {
+    chmodSync(filePath, INTERCOM_RUNTIME_FILE_MODE);
+  }
+}