@selesai/code 0.9.6 → 0.9.9

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);
+  }
+}

package/dist/extensions/pi-intercom/broker/runtime-claim.test.ts

@@ -1,34 +1,34 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import path from "node:path";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { assertNoLiveBroker } from "./runtime-claim.ts";
-
-test("broker startup refuses to replace a live broker PID", () => {
-  const directory = mkdtempSync(path.join(tmpdir(), "pi-intercom-runtime-"));
-  const pidPath = path.join(directory, "broker.pid");
-  try {
-    writeFileSync(pidPath, `${process.pid}\n`);
-    assert.throws(
-      () => assertNoLiveBroker(pidPath),
-      new RegExp(`Refusing to replace live intercom broker process ${process.pid}`),
-    );
-  } finally {
-    rmSync(directory, { recursive: true, force: true });
-  }
-});
-
-test("broker startup tolerates absent, invalid, and stale PID files", () => {
-  const directory = mkdtempSync(path.join(tmpdir(), "pi-intercom-runtime-"));
-  const pidPath = path.join(directory, "broker.pid");
-  try {
-    assert.doesNotThrow(() => assertNoLiveBroker(pidPath));
-    writeFileSync(pidPath, "invalid\n");
-    assert.doesNotThrow(() => assertNoLiveBroker(pidPath));
-    writeFileSync(pidPath, "2147483647\n");
-    assert.doesNotThrow(() => assertNoLiveBroker(pidPath));
-  } finally {
-    rmSync(directory, { recursive: true, force: true });
-  }
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import path from "node:path";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { assertNoLiveBroker } from "./runtime-claim.ts";
+
+test("broker startup refuses to replace a live broker PID", () => {
+  const directory = mkdtempSync(path.join(tmpdir(), "pi-intercom-runtime-"));
+  const pidPath = path.join(directory, "broker.pid");
+  try {
+    writeFileSync(pidPath, `${process.pid}\n`);
+    assert.throws(
+      () => assertNoLiveBroker(pidPath),
+      new RegExp(`Refusing to replace live intercom broker process ${process.pid}`),
+    );
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+test("broker startup tolerates absent, invalid, and stale PID files", () => {
+  const directory = mkdtempSync(path.join(tmpdir(), "pi-intercom-runtime-"));
+  const pidPath = path.join(directory, "broker.pid");
+  try {
+    assert.doesNotThrow(() => assertNoLiveBroker(pidPath));
+    writeFileSync(pidPath, "invalid\n");
+    assert.doesNotThrow(() => assertNoLiveBroker(pidPath));
+    writeFileSync(pidPath, "2147483647\n");
+    assert.doesNotThrow(() => assertNoLiveBroker(pidPath));
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});

package/dist/extensions/pi-intercom/broker/runtime-claim.ts

@@ -1,21 +1,21 @@
-import { existsSync, readFileSync } from "node:fs";
-
-export function assertNoLiveBroker(pidPath: string): void {
-  if (!existsSync(pidPath)) return;
-
-  let pid: number;
-  try {
-    pid = Number.parseInt(readFileSync(pidPath, "utf8").trim(), 10);
-  } catch {
-    return;
-  }
-  if (!Number.isSafeInteger(pid) || pid <= 0) return;
-
-  try {
-    process.kill(pid, 0);
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ESRCH") return;
-    throw error;
-  }
-  throw new Error(`Refusing to replace live intercom broker process ${pid}`);
-}
+import { existsSync, readFileSync } from "node:fs";
+
+export function assertNoLiveBroker(pidPath: string): void {
+  if (!existsSync(pidPath)) return;
+
+  let pid: number;
+  try {
+    pid = Number.parseInt(readFileSync(pidPath, "utf8").trim(), 10);
+  } catch {
+    return;
+  }
+  if (!Number.isSafeInteger(pid) || pid <= 0) return;
+
+  try {
+    process.kill(pid, 0);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ESRCH") return;
+    throw error;
+  }
+  throw new Error(`Refusing to replace live intercom broker process ${pid}`);
+}

package/dist/extensions/pi-intercom/cwd.test.ts

@@ -1,40 +1,40 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, symlinkSync, mkdirSync, realpathSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { normalizeCwd, sameCwd } from "./cwd.ts";
-
-test("sameCwd collapses a trailing slash", () => {
-  assert.equal(sameCwd("/usr/local", "/usr/local/"), true);
-});
-
-test("sameCwd collapses lexical '.' and '..' segments", () => {
-  assert.equal(sameCwd("/usr/local/../local/./bin", "/usr/local/bin"), true);
-});
-
-test("sameCwd treats genuinely different directories as different", () => {
-  assert.equal(sameCwd("/usr/local", "/usr/lib"), false);
-});
-
-test("sameCwd collapses a symlink to its real target", () => {
-  const base = mkdtempSync(join(tmpdir(), "cwd-symlink-"));
-  try {
-    const real = join(base, "real");
-    const link = join(base, "link");
-    mkdirSync(real);
-    symlinkSync(real, link);
-    // Reached via the symlink vs its canonical path — must compare equal.
-    assert.equal(sameCwd(link, real), true);
-    // And normalizeCwd resolves the link to the real path.
-    assert.equal(normalizeCwd(link), realpathSync(real));
-  } finally {
-    rmSync(base, { recursive: true, force: true });
-  }
-});
-
-test("normalizeCwd falls back to the resolved path for a nonexistent dir", () => {
-  // realpathSync throws for a missing dir; normalizeCwd must still collapse the
-  // lexical variants rather than throw.
-  assert.equal(normalizeCwd("/no/such/dir/../dir"), "/no/such/dir");
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, symlinkSync, mkdirSync, realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { normalizeCwd, sameCwd } from "./cwd.ts";
+
+test("sameCwd collapses a trailing slash", () => {
+  assert.equal(sameCwd("/usr/local", "/usr/local/"), true);
+});
+
+test("sameCwd collapses lexical '.' and '..' segments", () => {
+  assert.equal(sameCwd("/usr/local/../local/./bin", "/usr/local/bin"), true);
+});
+
+test("sameCwd treats genuinely different directories as different", () => {
+  assert.equal(sameCwd("/usr/local", "/usr/lib"), false);
+});
+
+test("sameCwd collapses a symlink to its real target", () => {
+  const base = mkdtempSync(join(tmpdir(), "cwd-symlink-"));
+  try {
+    const real = join(base, "real");
+    const link = join(base, "link");
+    mkdirSync(real);
+    symlinkSync(real, link);
+    // Reached via the symlink vs its canonical path — must compare equal.
+    assert.equal(sameCwd(link, real), true);
+    // And normalizeCwd resolves the link to the real path.
+    assert.equal(normalizeCwd(link), realpathSync(real));
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("normalizeCwd falls back to the resolved path for a nonexistent dir", () => {
+  // realpathSync throws for a missing dir; normalizeCwd must still collapse the
+  // lexical variants rather than throw.
+  assert.equal(normalizeCwd("/no/such/dir/../dir"), "/no/such/dir");
+});

package/dist/extensions/pi-intercom/cwd.ts

@@ -1,31 +1,31 @@
-import { resolve } from "node:path";
-import { realpathSync } from "node:fs";
-
-// Normalize a cwd for same-directory comparison. A raw string match ("a === b")
-// hides genuine same-directory peers when two cwd strings differ only by a
-// trailing slash, a "."/".." segment, or a symlink (e.g. macOS /tmp <->
-// /private/tmp). resolve() collapses the lexical variants; realpathSync()
-// collapses symlinks (best-effort: falls back to the resolved path if the
-// directory no longer exists). Memoized — the set of distinct cwd strings is
-// small and stable, so repeat comparisons are free after warmup.
-const normalizeCache = new Map<string, string>();
-
-export function normalizeCwd(cwd: string): string {
-  const cached = normalizeCache.get(cwd);
-  if (cached !== undefined) {
-    return cached;
-  }
-  const resolved = resolve(cwd);
-  let normalized: string;
-  try {
-    normalized = realpathSync(resolved);
-  } catch {
-    normalized = resolved;
-  }
-  normalizeCache.set(cwd, normalized);
-  return normalized;
-}
-
-export function sameCwd(a: string, b: string): boolean {
-  return normalizeCwd(a) === normalizeCwd(b);
-}
+import { resolve } from "node:path";
+import { realpathSync } from "node:fs";
+
+// Normalize a cwd for same-directory comparison. A raw string match ("a === b")
+// hides genuine same-directory peers when two cwd strings differ only by a
+// trailing slash, a "."/".." segment, or a symlink (e.g. macOS /tmp <->
+// /private/tmp). resolve() collapses the lexical variants; realpathSync()
+// collapses symlinks (best-effort: falls back to the resolved path if the
+// directory no longer exists). Memoized — the set of distinct cwd strings is
+// small and stable, so repeat comparisons are free after warmup.
+const normalizeCache = new Map<string, string>();
+
+export function normalizeCwd(cwd: string): string {
+  const cached = normalizeCache.get(cwd);
+  if (cached !== undefined) {
+    return cached;
+  }
+  const resolved = resolve(cwd);
+  let normalized: string;
+  try {
+    normalized = realpathSync(resolved);
+  } catch {
+    normalized = resolved;
+  }
+  normalizeCache.set(cwd, normalized);
+  return normalized;
+}
+
+export function sameCwd(a: string, b: string): boolean {
+  return normalizeCwd(a) === normalizeCwd(b);
+}

package/dist/extensions/pi-intercom/extension-api.ts

@@ -1,44 +1,44 @@
-import type { SessionInfo } from "./types.ts";
-
-export const INTERCOM_EXTENSION_REGISTER_EVENT = "intercom:extension-register";
-export const INTERCOM_EXTENSION_REGISTRY_READY_EVENT = "intercom:extension-registry-ready";
-
-export interface IntercomExtensionOwner {
-  sessionId: string;
-  epoch: string;
-}
-
-export interface IntercomExtensionState {
-  revision: number;
-  payload: unknown;
-}
-
-export type IntercomExtensionEvent =
-  | { type: "connection"; connected: boolean; supported: boolean }
-  | { type: "owner"; owner?: IntercomExtensionOwner }
-  | { type: "message"; fromSessionId: string; owner?: IntercomExtensionOwner; payload: unknown }
-  | { type: "state"; state: IntercomExtensionState }
-  | { type: "state_result"; committed: boolean; revision: number; reason?: string }
-  | { type: "session_joined"; session: SessionInfo }
-  | { type: "session_left"; sessionId: string }
-  | { type: "presence_update"; session: SessionInfo };
-
-export interface IntercomExtensionChannel {
-  readonly namespace: string;
-  snapshot(): {
-    connected: boolean;
-    supported: boolean;
-    owner?: IntercomExtensionOwner;
-    state?: IntercomExtensionState;
-  };
-  publish(payload: unknown, options?: { audience?: "owner" | "capable"; ownerOnly?: boolean }): void;
-  commitState(payload: unknown, expectedRevision?: number): void;
-  listSessions(): Promise<SessionInfo[]>;
-}
-
-export interface IntercomExtensionRegistration {
-  namespace: string;
-  ownerEligible: boolean;
-  onEvent(event: IntercomExtensionEvent): void;
-  onReady(channel: IntercomExtensionChannel): void;
-}
+import type { SessionInfo } from "./types.ts";
+
+export const INTERCOM_EXTENSION_REGISTER_EVENT = "intercom:extension-register";
+export const INTERCOM_EXTENSION_REGISTRY_READY_EVENT = "intercom:extension-registry-ready";
+
+export interface IntercomExtensionOwner {
+  sessionId: string;
+  epoch: string;
+}
+
+export interface IntercomExtensionState {
+  revision: number;
+  payload: unknown;
+}
+
+export type IntercomExtensionEvent =
+  | { type: "connection"; connected: boolean; supported: boolean }
+  | { type: "owner"; owner?: IntercomExtensionOwner }
+  | { type: "message"; fromSessionId: string; owner?: IntercomExtensionOwner; payload: unknown }
+  | { type: "state"; state: IntercomExtensionState }
+  | { type: "state_result"; committed: boolean; revision: number; reason?: string }
+  | { type: "session_joined"; session: SessionInfo }
+  | { type: "session_left"; sessionId: string }
+  | { type: "presence_update"; session: SessionInfo };
+
+export interface IntercomExtensionChannel {
+  readonly namespace: string;
+  snapshot(): {
+    connected: boolean;
+    supported: boolean;
+    owner?: IntercomExtensionOwner;
+    state?: IntercomExtensionState;
+  };
+  publish(payload: unknown, options?: { audience?: "owner" | "capable"; ownerOnly?: boolean }): void;
+  commitState(payload: unknown, expectedRevision?: number): void;
+  listSessions(): Promise<SessionInfo[]>;
+}
+
+export interface IntercomExtensionRegistration {
+  namespace: string;
+  ownerEligible: boolean;
+  onEvent(event: IntercomExtensionEvent): void;
+  onReady(channel: IntercomExtensionChannel): void;
+}