tabctl 0.2.1 → 0.3.1

package/dist/host/host.bundle.js

@@ -0,0 +1,667 @@
+#!/usr/bin/env node
+"use strict";
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// dist/shared/config.js
+var require_config = __commonJS({
+  "dist/shared/config.js"(exports2) {
+    "use strict";
+    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.resolveSocketPath = resolveSocketPath;
+    exports2.resetConfig = resetConfig;
+    exports2.expandEnvVars = expandEnvVars;
+    exports2.resolveConfig = resolveConfig;
+    var os_1 = __importDefault2(require("os"));
+    var path_1 = __importDefault2(require("path"));
+    var crypto_12 = __importDefault2(require("crypto"));
+    var fs_12 = __importDefault2(require("fs"));
+    function defaultConfigBase() {
+      if (process.platform === "win32") {
+        return process.env.APPDATA || path_1.default.join(os_1.default.homedir(), "AppData", "Roaming");
+      }
+      return path_1.default.join(os_1.default.homedir(), ".config");
+    }
+    function defaultStateBase() {
+      if (process.platform === "win32") {
+        return process.env.LOCALAPPDATA || path_1.default.join(os_1.default.homedir(), "AppData", "Local");
+      }
+      return path_1.default.join(os_1.default.homedir(), ".local", "state");
+    }
+    function resolveSocketPath(dataDir) {
+      if (process.platform === "win32") {
+        const hash = crypto_12.default.createHash("sha256").update(dataDir).digest("hex").slice(0, 12);
+        return `\\\\.\\pipe\\tabctl-${hash}`;
+      }
+      return path_1.default.join(dataDir, "tabctl.sock");
+    }
+    var cached;
+    function resetConfig() {
+      cached = void 0;
+    }
+    function expandEnvVars(value) {
+      return value.replace(/\$\{(\w+)\}|\$(\w+)/g, (match, braced, bare) => {
+        const varName = braced || bare;
+        return process.env[varName] ?? match;
+      });
+    }
+    function resolveConfig(profileName) {
+      if (!profileName && cached)
+        return cached;
+      const configDir = process.env.TABCTL_CONFIG_DIR || path_1.default.join(process.env.XDG_CONFIG_HOME || defaultConfigBase(), "tabctl");
+      let fileConfig = {};
+      try {
+        const raw = fs_12.default.readFileSync(path_1.default.join(configDir, "config.json"), "utf-8");
+        fileConfig = JSON.parse(raw);
+      } catch {
+      }
+      let dataDir;
+      if (typeof fileConfig.dataDir === "string" && fileConfig.dataDir) {
+        dataDir = expandEnvVars(fileConfig.dataDir);
+        if (!path_1.default.isAbsolute(dataDir)) {
+          throw new Error(`dataDir in config.json must be an absolute path (got: ${dataDir}). Use $HOME or full paths.`);
+        }
+      } else if (process.env.TABCTL_CONFIG_DIR) {
+        dataDir = path_1.default.join(configDir, "data");
+      } else {
+        dataDir = path_1.default.join(process.env.XDG_STATE_HOME || defaultStateBase(), "tabctl");
+      }
+      const baseDataDir = dataDir;
+      const explicitProfile = profileName;
+      const effectiveProfile = profileName || process.env.TABCTL_PROFILE;
+      let activeProfileName;
+      if (effectiveProfile) {
+        try {
+          const raw = fs_12.default.readFileSync(path_1.default.join(configDir, "profiles.json"), "utf-8");
+          const registry = JSON.parse(raw);
+          const profile = registry.profiles[effectiveProfile];
+          if (profile) {
+            dataDir = profile.dataDir;
+            activeProfileName = effectiveProfile;
+          } else if (explicitProfile) {
+            throw new Error(`Profile "${explicitProfile}" not found in profiles.json`);
+          }
+        } catch (err) {
+          if (err instanceof Error && err.message.includes("not found in profiles.json")) {
+            throw err;
+          }
+          if (explicitProfile) {
+            throw new Error(`Profile "${explicitProfile}" not found: no profiles.json`);
+          }
+        }
+      } else {
+        try {
+          const raw = fs_12.default.readFileSync(path_1.default.join(configDir, "profiles.json"), "utf-8");
+          const registry = JSON.parse(raw);
+          if (registry.default && registry.profiles[registry.default]) {
+            dataDir = registry.profiles[registry.default].dataDir;
+            activeProfileName = registry.default;
+          }
+        } catch {
+        }
+      }
+      const result = {
+        configDir,
+        dataDir,
+        baseDataDir,
+        socketPath: process.env.TABCTL_SOCKET || resolveSocketPath(dataDir),
+        undoLog: path_1.default.join(dataDir, "undo.jsonl"),
+        wrapperDir: dataDir,
+        policyPath: path_1.default.join(configDir, "policy.json"),
+        activeProfileName
+      };
+      if (!profileName) {
+        cached = result;
+      }
+      return result;
+    }
+  }
+});
+
+// dist/shared/version.js
+var require_version = __commonJS({
+  "dist/shared/version.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.DIRTY = exports2.GIT_SHA = exports2.VERSION = exports2.BASE_VERSION = void 0;
+    exports2.BASE_VERSION = "0.3.1";
+    exports2.VERSION = "0.3.1";
+    exports2.GIT_SHA = null;
+    exports2.DIRTY = false;
+  }
+});
+
+// dist/host/lib/undo.js
+var require_undo = __commonJS({
+  "dist/host/lib/undo.js"(exports2) {
+    "use strict";
+    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.appendUndoRecord = appendUndoRecord;
+    exports2.readUndoRecords = readUndoRecords;
+    exports2.filterByRetention = filterByRetention;
+    exports2.findUndoRecord = findUndoRecord;
+    exports2.findLatestUndoRecord = findLatestUndoRecord;
+    var fs_12 = __importDefault2(require("fs"));
+    var path_1 = __importDefault2(require("path"));
+    var DEFAULT_RETENTION_DAYS = 30;
+    function appendUndoRecord(filePath, record) {
+      const dir = path_1.default.dirname(filePath);
+      fs_12.default.mkdirSync(dir, { recursive: true, mode: 448 });
+      fs_12.default.appendFileSync(filePath, `${JSON.stringify(record)}
+`, "utf8");
+    }
+    function readUndoRecords(filePath) {
+      try {
+        const content = fs_12.default.readFileSync(filePath, "utf8");
+        const lines = content.split("\n").filter(Boolean);
+        const records = [];
+        for (const line of lines) {
+          try {
+            records.push(JSON.parse(line));
+          } catch {
+          }
+        }
+        return records;
+      } catch {
+        return [];
+      }
+    }
+    function filterByRetention(records, retentionDays = DEFAULT_RETENTION_DAYS, now = Date.now()) {
+      const cutoff = now - retentionDays * 24 * 60 * 60 * 1e3;
+      return records.filter((record) => {
+        const createdAt = record.createdAt;
+        return !createdAt || createdAt >= cutoff;
+      });
+    }
+    function findUndoRecord(filePath, txid, retentionDays = DEFAULT_RETENTION_DAYS, now = Date.now()) {
+      const records = filterByRetention(readUndoRecords(filePath), retentionDays, now);
+      for (let i = records.length - 1; i >= 0; i -= 1) {
+        if (records[i].txid === txid) {
+          return records[i];
+        }
+      }
+      return null;
+    }
+    function findLatestUndoRecord(filePath, retentionDays = DEFAULT_RETENTION_DAYS, now = Date.now()) {
+      const records = filterByRetention(readUndoRecords(filePath), retentionDays, now);
+      if (!records.length) {
+        return null;
+      }
+      return records[records.length - 1] || null;
+    }
+  }
+});
+
+// dist/host/lib/handlers.js
+var require_handlers = __commonJS({
+  "dist/host/lib/handlers.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.respond = respond;
+    exports2.refreshTimeout = refreshTimeout;
+    exports2.forwardToExtension = forwardToExtension;
+    exports2.handleNativeMessage = handleNativeMessage2;
+    exports2.handleCliRequest = handleCliRequest2;
+    var version_1 = require_version();
+    var undo_1 = require_undo();
+    var REQUEST_TIMEOUT_MS = 3e4;
+    var MAX_RESPONSE_BYTES = 20 * 1024 * 1024;
+    var HISTORY_LIMIT_DEFAULT = 20;
+    var RETENTION_DAYS = 30;
+    var UNDO_ACTIONS = /* @__PURE__ */ new Set([
+      "archive",
+      "close",
+      "group-update",
+      "group-ungroup",
+      "group-assign",
+      "move-tab",
+      "move-group",
+      "merge-window"
+    ]);
+    var LOCAL_ACTIONS = /* @__PURE__ */ new Set(["history", "undo", "version"]);
+    function respond(socket, payload) {
+      const serialized = JSON.stringify(payload);
+      if (Buffer.byteLength(serialized, "utf8") > MAX_RESPONSE_BYTES) {
+        socket.write(`${JSON.stringify({
+          ok: false,
+          action: payload.action,
+          requestId: payload.requestId,
+          component: "host",
+          version: version_1.VERSION,
+          error: { message: "Response too large", hint: "Reduce scope or use --out to write files." }
+        })}
+`);
+        return;
+      }
+      socket.write(`${serialized}
+`);
+    }
+    function refreshTimeout(deps2, pendingRequest, requestId) {
+      clearTimeout(pendingRequest.timeout);
+      pendingRequest.timeout = setTimeout(() => {
+        deps2.pending.delete(requestId);
+        respond(pendingRequest.socket, {
+          ok: false,
+          action: pendingRequest.action,
+          requestId,
+          component: "host",
+          version: version_1.VERSION,
+          error: { message: "Request timed out" }
+        });
+      }, REQUEST_TIMEOUT_MS);
+    }
+    function forwardToExtension(deps2, socket, request, overrides = {}) {
+      const requestId = request.id || deps2.createId("req");
+      const txid = overrides.txid || null;
+      const params = { ...request.params || {} };
+      if (txid) {
+        params.txid = txid;
+      }
+      if (!LOCAL_ACTIONS.has(request.action)) {
+        params.client = {
+          component: "host",
+          version: version_1.VERSION
+        };
+      }
+      deps2.pending.set(requestId, {
+        socket,
+        action: request.action,
+        txid,
+        timeout: setTimeout(() => {
+          deps2.pending.delete(requestId);
+          respond(socket, {
+            ok: false,
+            action: request.action,
+            requestId,
+            component: "host",
+            version: version_1.VERSION,
+            error: { message: "Request timed out" }
+          });
+        }, REQUEST_TIMEOUT_MS)
+      });
+      deps2.sendNative({ id: requestId, action: request.action, params });
+    }
+    function handleNativeMessage2(deps2, payload) {
+      let message;
+      try {
+        message = JSON.parse(payload);
+      } catch (error) {
+        const err = error;
+        deps2.log("Failed to parse native message", err.message);
+        return;
+      }
+      const messageId = message.id;
+      if (!messageId) {
+        return;
+      }
+      const pendingRequest = deps2.pending.get(messageId);
+      if (!pendingRequest) {
+        return;
+      }
+      if (message.progress) {
+        refreshTimeout(deps2, pendingRequest, messageId);
+        respond(pendingRequest.socket, {
+          ok: true,
+          action: pendingRequest.action,
+          requestId: messageId,
+          progress: true,
+          component: "host",
+          version: version_1.VERSION,
+          data: message.data || {}
+        });
+        return;
+      }
+      const messageData = message.data || {};
+      const extensionVersion = typeof messageData.version === "string" ? messageData.version : null;
+      const extensionComponent = typeof messageData.component === "string" ? messageData.component : null;
+      if (extensionVersion && extensionVersion !== version_1.VERSION) {
+        deps2.log(`Version mismatch: host ${version_1.VERSION}, extension ${extensionVersion}`);
+      }
+      clearTimeout(pendingRequest.timeout);
+      deps2.pending.delete(messageId);
+      if (!message.ok) {
+        respond(pendingRequest.socket, {
+          ok: false,
+          action: pendingRequest.action,
+          requestId: messageId,
+          component: "host",
+          version: version_1.VERSION,
+          error: message.error || { message: "Unknown error" }
+        });
+        return;
+      }
+      if (pendingRequest.action === "analyze") {
+        const analysisId = deps2.createId("analysis");
+        deps2.analyses.set(analysisId, {
+          createdAt: Date.now(),
+          data: messageData
+        });
+        respond(pendingRequest.socket, {
+          ok: true,
+          action: "analyze",
+          requestId: messageId,
+          component: "host",
+          version: version_1.VERSION,
+          data: {
+            ...messageData,
+            extensionVersion,
+            extensionComponent,
+            hostBaseVersion: version_1.BASE_VERSION,
+            hostGitSha: version_1.GIT_SHA,
+            hostDirty: version_1.DIRTY,
+            analysisId
+          }
+        });
+        return;
+      }
+      if (UNDO_ACTIONS.has(pendingRequest.action)) {
+        const record = {
+          txid: pendingRequest.txid,
+          createdAt: Date.now(),
+          action: pendingRequest.action,
+          summary: messageData.summary || {},
+          undo: messageData.undo || null
+        };
+        if (record.undo) {
+          (0, undo_1.appendUndoRecord)(deps2.undoLog, record);
+        }
+        respond(pendingRequest.socket, {
+          ok: true,
+          action: pendingRequest.action,
+          requestId: messageId,
+          component: "host",
+          version: version_1.VERSION,
+          data: {
+            ...messageData,
+            extensionVersion,
+            extensionComponent,
+            hostBaseVersion: version_1.BASE_VERSION,
+            hostGitSha: version_1.GIT_SHA,
+            hostDirty: version_1.DIRTY,
+            txid: pendingRequest.txid
+          }
+        });
+        return;
+      }
+      respond(pendingRequest.socket, {
+        ok: true,
+        action: pendingRequest.action,
+        requestId: messageId,
+        component: "host",
+        version: version_1.VERSION,
+        data: {
+          ...messageData,
+          extensionVersion,
+          extensionComponent,
+          hostBaseVersion: version_1.BASE_VERSION,
+          hostGitSha: version_1.GIT_SHA,
+          hostDirty: version_1.DIRTY
+        }
+      });
+    }
+    function handleCliRequest2(deps2, socket, request) {
+      if (!request || typeof request !== "object") {
+        respond(socket, { ok: false, error: { message: "Invalid request" } });
+        return;
+      }
+      const action = request.action;
+      if (!action) {
+        respond(socket, { ok: false, error: { message: "Missing action" } });
+        return;
+      }
+      if (action === "history") {
+        const limit = Number.isFinite(request.params?.limit) ? Number(request.params?.limit) : HISTORY_LIMIT_DEFAULT;
+        const records = (0, undo_1.readUndoRecords)(deps2.undoLog);
+        const filtered = (0, undo_1.filterByRetention)(records, RETENTION_DAYS);
+        respond(socket, {
+          ok: true,
+          action,
+          requestId: request.id || null,
+          component: "host",
+          version: version_1.VERSION,
+          data: filtered.slice(-limit)
+        });
+        return;
+      }
+      if (action === "version") {
+        respond(socket, {
+          ok: true,
+          action,
+          requestId: request.id || null,
+          component: "host",
+          version: version_1.VERSION,
+          data: {
+            version: version_1.VERSION,
+            baseVersion: version_1.BASE_VERSION,
+            gitSha: version_1.GIT_SHA,
+            dirty: version_1.DIRTY,
+            component: "host"
+          }
+        });
+        return;
+      }
+      if (action === "undo") {
+        const txid = request.params?.txid;
+        const latest = request.params?.latest === true;
+        if (!txid && !latest) {
+          respond(socket, {
+            ok: false,
+            action,
+            component: "host",
+            version: version_1.VERSION,
+            error: {
+              message: "Missing txid",
+              hint: "Use tabctl history --json to find a txid, or run tabctl undo --latest"
+            }
+          });
+          return;
+        }
+        const record = txid ? (0, undo_1.findUndoRecord)(deps2.undoLog, txid, RETENTION_DAYS) : (0, undo_1.findLatestUndoRecord)(deps2.undoLog, RETENTION_DAYS);
+        if (!record) {
+          respond(socket, { ok: false, action, component: "host", version: version_1.VERSION, error: { message: "Undo record not found" } });
+          return;
+        }
+        forwardToExtension(deps2, socket, {
+          id: request.id,
+          action: "undo",
+          params: { record }
+        });
+        return;
+      }
+      if (action === "close" && request.params?.mode === "apply") {
+        const analysisId = request.params.analysisId;
+        const analysis = analysisId ? deps2.analyses.get(analysisId) : void 0;
+        if (!analysis) {
+          respond(socket, { ok: false, action, component: "host", version: version_1.VERSION, error: { message: "Unknown analysisId" } });
+          return;
+        }
+        const candidates = analysis.data.candidates || [];
+        const tabIds = candidates.map((candidate) => candidate.tabId).filter(Boolean);
+        const expectedUrls = {};
+        for (const candidate of candidates) {
+          if (candidate.tabId) {
+            expectedUrls[String(candidate.tabId)] = candidate.url;
+          }
+        }
+        if (!tabIds.length) {
+          respond(socket, {
+            ok: true,
+            action,
+            requestId: request.id || null,
+            component: "host",
+            version: version_1.VERSION,
+            data: {
+              txid: null,
+              summary: { closedTabs: 0, skippedTabs: 0 },
+              skipped: []
+            }
+          });
+          return;
+        }
+        const txid = deps2.createId("tx");
+        forwardToExtension(deps2, socket, {
+          id: request.id,
+          action: "close",
+          params: {
+            mode: "apply",
+            tabIds,
+            expectedUrls
+          }
+        }, { txid });
+        return;
+      }
+      if (UNDO_ACTIONS.has(action)) {
+        const txid = deps2.createId("tx");
+        forwardToExtension(deps2, socket, request, { txid });
+        return;
+      }
+      forwardToExtension(deps2, socket, request);
+    }
+  }
+});
+
+// dist/host/host.js
+var __importDefault = exports && exports.__importDefault || function(mod) {
+  return mod && mod.__esModule ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fs_1 = __importDefault(require("fs"));
+var net_1 = __importDefault(require("net"));
+var crypto_1 = __importDefault(require("crypto"));
+var config_1 = require_config();
+var handlers_1 = require_handlers();
+var config;
+try {
+  config = (0, config_1.resolveConfig)();
+} catch (err) {
+  process.stderr.write(`[tabctl-host] Fatal: ${err.message}
+`);
+  process.exit(1);
+}
+var SOCKET_DIR = config.dataDir;
+var SOCKET_PATH = config.socketPath;
+var pending = /* @__PURE__ */ new Map();
+var analyses = /* @__PURE__ */ new Map();
+function log(...args) {
+  process.stderr.write(`[tabctl-host] ${args.join(" ")}
+`);
+}
+function ensureDir() {
+  fs_1.default.mkdirSync(SOCKET_DIR, { recursive: true, mode: 448 });
+}
+function createId(prefix) {
+  return `${prefix}-${Date.now()}-${crypto_1.default.randomBytes(4).toString("hex")}`;
+}
+function sendNative(message) {
+  const json = JSON.stringify(message);
+  const length = Buffer.byteLength(json);
+  const buffer = Buffer.alloc(4 + length);
+  buffer.writeUInt32LE(length, 0);
+  buffer.write(json, 4);
+  process.stdout.write(buffer);
+}
+var deps = {
+  pending,
+  analyses,
+  undoLog: config.undoLog,
+  createId,
+  sendNative,
+  log
+};
+function handleNativeMessage(payload) {
+  (0, handlers_1.handleNativeMessage)(deps, payload);
+}
+function handleCliRequest(socket, request) {
+  (0, handlers_1.handleCliRequest)(deps, socket, request);
+}
+var nativeBuffer = Buffer.alloc(0);
+process.stdin.on("data", (chunk) => {
+  nativeBuffer = Buffer.concat([nativeBuffer, chunk]);
+  while (nativeBuffer.length >= 4) {
+    const length = nativeBuffer.readUInt32LE(0);
+    if (nativeBuffer.length < 4 + length) {
+      return;
+    }
+    const payload = nativeBuffer.slice(4, 4 + length).toString("utf8");
+    nativeBuffer = nativeBuffer.slice(4 + length);
+    handleNativeMessage(payload);
+  }
+});
+process.stdin.on("end", () => {
+  log("Extension disconnected, exiting");
+  cleanupAndExit(0);
+});
+function startSocketServer() {
+  ensureDir();
+  if (process.platform !== "win32" && fs_1.default.existsSync(SOCKET_PATH)) {
+    fs_1.default.unlinkSync(SOCKET_PATH);
+  }
+  const server2 = net_1.default.createServer((socket) => {
+    socket.setEncoding("utf8");
+    let buffer = "";
+    socket.on("data", (data) => {
+      buffer += data;
+      let index;
+      while ((index = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, index).trim();
+        buffer = buffer.slice(index + 1);
+        if (!line) {
+          continue;
+        }
+        let request;
+        try {
+          request = JSON.parse(line);
+        } catch {
+          (0, handlers_1.respond)(socket, { ok: false, error: { message: "Invalid JSON" } });
+          continue;
+        }
+        handleCliRequest(socket, request);
+      }
+    });
+    socket.on("error", (error) => {
+      log("CLI socket error", error.message);
+    });
+  });
+  let retries = 0;
+  const maxRetries = process.platform === "win32" ? 5 : 0;
+  server2.on("error", (err) => {
+    if (err.code === "EADDRINUSE" && retries < maxRetries) {
+      retries++;
+      log(`Socket in use, retrying (${retries}/${maxRetries})\u2026`);
+      setTimeout(() => server2.listen(SOCKET_PATH), 500);
+    } else {
+      throw err;
+    }
+  });
+  server2.listen(SOCKET_PATH, () => {
+    if (process.platform !== "win32") {
+      try {
+        fs_1.default.chmodSync(SOCKET_PATH, 384);
+      } catch {
+      }
+    }
+    log(`Listening on ${SOCKET_PATH}`);
+  });
+  return server2;
+}
+function cleanupAndExit(code) {
+  try {
+    if (process.platform !== "win32" && fs_1.default.existsSync(SOCKET_PATH)) {
+      fs_1.default.unlinkSync(SOCKET_PATH);
+    }
+  } catch {
+  }
+  process.exit(code);
+}
+var server = startSocketServer();
+process.on("SIGINT", () => cleanupAndExit(0));
+process.on("SIGTERM", () => cleanupAndExit(0));
+server.on("close", () => cleanupAndExit(0));

package/dist/host/host.js

@@ -71,7 +71,8 @@ process.stdin.on("end", () => {
 });
 function startSocketServer() {
     ensureDir();
-    if (fs_1.default.existsSync(SOCKET_PATH)) {
+    // Named pipes on Windows don't use filesystem paths; skip cleanup
+    if (process.platform !== "win32" && fs_1.default.existsSync(SOCKET_PATH)) {
         fs_1.default.unlinkSync(SOCKET_PATH);
     }
     const server = net_1.default.createServer((socket) => {
@@ -101,15 +102,33 @@ function startSocketServer() {
             log("CLI socket error", error.message);
         });
     });
+    let retries = 0;
+    const maxRetries = process.platform === "win32" ? 5 : 0;
+    server.on("error", (err) => {
+        if (err.code === "EADDRINUSE" && retries < maxRetries) {
+            retries++;
+            log(`Socket in use, retrying (${retries}/${maxRetries})…`);
+            setTimeout(() => server.listen(SOCKET_PATH), 500);
+        }
+        else {
+            throw err;
+        }
+    });
     server.listen(SOCKET_PATH, () => {
-        fs_1.default.chmodSync(SOCKET_PATH, 0o600);
+        if (process.platform !== "win32") {
+            try {
+                fs_1.default.chmodSync(SOCKET_PATH, 0o600);
+            }
+            catch { /* ignore on platforms without chmod */ }
+        }
         log(`Listening on ${SOCKET_PATH}`);
     });
     return server;
 }
 function cleanupAndExit(code) {
     try {
-        if (fs_1.default.existsSync(SOCKET_PATH)) {
+        // Named pipes on Windows don't need filesystem cleanup
+        if (process.platform !== "win32" && fs_1.default.existsSync(SOCKET_PATH)) {
             fs_1.default.unlinkSync(SOCKET_PATH);
         }
     }