codetrellis 0.0.0-stage → 0.2.0

package/src/backend/lifecycle.js

@@ -0,0 +1,102 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lifecycle_exports = {};
+__export(lifecycle_exports, {
+  gracefulShutdown: () => gracefulShutdown,
+  installProcessHandlers: () => installProcessHandlers
+});
+module.exports = __toCommonJS(lifecycle_exports);
+var import_server = require("./server");
+var import_file_watcher = require("./services/file-watcher");
+var import_server2 = require("./mcp/server");
+var import_terminal_service = require("./services/terminal-service");
+var import_persistence = require("./services/persistence");
+var import_database = require("./services/database");
+var import_persistence2 = require("./services/persistence");
+var import_claude_code_watcher = require("./agent/claude-code-watcher");
+var import_peer_connection_service = require("./services/peer-connection-service");
+function installProcessHandlers() {
+  process.on("uncaughtException", (err) => {
+    console.error("[Backend] Uncaught exception (kept alive):", err);
+  });
+  process.on("unhandledRejection", (reason) => {
+    console.error("[Backend] Unhandled rejection (kept alive):", reason);
+  });
+  process.on("SIGTERM", () => {
+    void gracefulShutdown("SIGTERM");
+  });
+  process.on("SIGINT", () => {
+    void gracefulShutdown("SIGINT");
+  });
+}
+let shuttingDown = false;
+async function gracefulShutdown(signal) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  console.log(`[Backend] ${signal} received \u2014 shutting down gracefully\u2026`);
+  const deadline = setTimeout(() => {
+    console.error("[Backend] Shutdown deadline exceeded \u2014 forcing exit");
+    process.exit(1);
+  }, 4e3);
+  deadline.unref();
+  try {
+    try {
+      (0, import_persistence2.stopAutoSave)();
+      (0, import_persistence.saveNow)(() => (0, import_database.exportDatabase)());
+      console.log("[Backend] Database flushed");
+    } catch (err) {
+      console.error("[Backend] Database flush failed:", err);
+    }
+    try {
+      (0, import_terminal_service.killAllTerminals)();
+      console.log("[Backend] Terminals killed");
+    } catch (err) {
+      console.error("[Backend] Terminal cleanup failed:", err);
+    }
+    try {
+      (0, import_claude_code_watcher.stopClaudeCodeWatcher)();
+      await (0, import_file_watcher.stopWatching)();
+      console.log("[Backend] File watchers stopped");
+    } catch (err) {
+      console.error("[Backend] File watcher cleanup failed:", err);
+    }
+    try {
+      await (0, import_peer_connection_service.stopPeerManager)();
+      console.log("[Backend] Peer manager stopped");
+    } catch (err) {
+      console.error("[Backend] Peer manager cleanup failed:", err);
+    }
+    try {
+      await (0, import_server2.stopMcpServer)();
+      console.log("[Backend] MCP server stopped");
+    } catch (err) {
+      console.error("[Backend] MCP cleanup failed:", err);
+    }
+    import_server.server.close();
+    console.log("[Backend] HTTP server closed");
+  } catch (err) {
+    console.error("[Backend] Shutdown error:", err);
+  }
+  clearTimeout(deadline);
+  process.exit(0);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  gracefulShutdown,
+  installProcessHandlers
+});

package/src/backend/mcp/binding-headers.js

@@ -0,0 +1,54 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var binding_headers_exports = {};
+__export(binding_headers_exports, {
+  CWD_HEADER: () => CWD_HEADER,
+  HOST_TERMINAL_HEADER: () => HOST_TERMINAL_HEADER,
+  bindingHeaders: () => bindingHeaders,
+  readBindingHeaders: () => readBindingHeaders
+});
+module.exports = __toCommonJS(binding_headers_exports);
+const CWD_HEADER = "x-codetrellis-cwd";
+const HOST_TERMINAL_HEADER = "x-codetrellis-host-terminal";
+function bindingHeaders(hint) {
+  const out = {};
+  if (hint.cwd) out[CWD_HEADER] = encodeURIComponent(hint.cwd);
+  if (hint.hostTerminal) out[HOST_TERMINAL_HEADER] = encodeURIComponent(hint.hostTerminal);
+  return out;
+}
+function readBindingHeaders(headers) {
+  const one = (name) => {
+    const raw = headers[name];
+    const value = Array.isArray(raw) ? raw[0] : raw;
+    if (!value) return null;
+    try {
+      const decoded = decodeURIComponent(value);
+      return decoded.includes("\0") ? null : decoded;
+    } catch {
+      return null;
+    }
+  };
+  return { cwd: one(CWD_HEADER), hostTerminal: one(HOST_TERMINAL_HEADER) };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CWD_HEADER,
+  HOST_TERMINAL_HEADER,
+  bindingHeaders,
+  readBindingHeaders
+});

package/src/backend/mcp/client-identity.js

@@ -0,0 +1,44 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var client_identity_exports = {};
+__export(client_identity_exports, {
+  agentTypeFromClientInfo: () => agentTypeFromClientInfo
+});
+module.exports = __toCommonJS(client_identity_exports);
+const KNOWN_CLIENTS = {
+  "claude-code": "claude-code",
+  "claude-ai": "claude-desktop",
+  "claude-desktop": "claude-desktop",
+  "cursor-vscode": "cursor",
+  cursor: "cursor",
+  codex: "codex",
+  "codex-mcp-client": "codex",
+  windsurf: "windsurf",
+  aider: "aider"
+};
+const RESERVED = /* @__PURE__ */ new Set(["mcp-client", "mcp-agent", "human", "user"]);
+function agentTypeFromClientInfo(name) {
+  if (typeof name !== "string") return null;
+  const slug = name.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+  if (!slug || RESERVED.has(slug)) return null;
+  return KNOWN_CLIENTS[slug] ?? slug;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  agentTypeFromClientInfo
+});

package/src/backend/mcp/connector/command.js

@@ -0,0 +1,110 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var command_exports = {};
+__export(command_exports, {
+  APPIMAGE_BOOTSTRAP: () => APPIMAGE_BOOTSTRAP,
+  CONNECTOR_SCRIPT: () => CONNECTOR_SCRIPT,
+  PORTABLE_CAVEAT: () => PORTABLE_CAVEAT,
+  claudeCodeConnectorCommand: () => claudeCodeConnectorCommand,
+  connectorConfig: () => connectorConfig,
+  isPackagedElectron: () => isPackagedElectron,
+  resolveConnectorCommand: () => resolveConnectorCommand,
+  shellQuote: () => shellQuote
+});
+module.exports = __toCommonJS(command_exports);
+var import_node_path = __toESM(require("node:path"));
+const CONNECTOR_SCRIPT = "mcp-connector.cjs";
+function isPackagedElectron(input) {
+  return !!input.electronVersion && !/[\\/]node_modules[\\/]electron[\\/]/.test(input.execPath);
+}
+function resolveConnectorCommand(input) {
+  const packaged = isPackagedElectron(input);
+  const script = packaged ? input.resourcesPath ? import_node_path.default.join(input.resourcesPath, "connector", CONNECTOR_SCRIPT) : null : import_node_path.default.join(input.cwd, "out", "connector", CONNECTOR_SCRIPT);
+  if (!script || !input.exists(script)) return null;
+  if (packaged) {
+    const appImage = runningAppImage(input);
+    if (appImage) return appImageCommand(appImage, input.dataDir);
+  }
+  const cmd = {
+    command: input.execPath,
+    args: [script, "--data-dir", input.dataDir],
+    env: input.electronVersion ? { ELECTRON_RUN_AS_NODE: "1" } : {}
+  };
+  if (packaged && input.env?.PORTABLE_EXECUTABLE_FILE) cmd.caveat = PORTABLE_CAVEAT;
+  return cmd;
+}
+const APPIMAGE_BOOTSTRAP = `require(require('path').join(process.resourcesPath, 'connector', '${CONNECTOR_SCRIPT}'))`;
+const PORTABLE_CAVEAT = "This is the portable build: the connector starts only while CodeTrellis is open, and this config must be copied again after updating. The Windows installer gives a config that always works.";
+function runningAppImage(input) {
+  const { APPIMAGE, APPDIR } = input.env ?? {};
+  if (!APPIMAGE || !APPDIR || !import_node_path.default.isAbsolute(APPIMAGE) || !import_node_path.default.isAbsolute(APPDIR)) return null;
+  if (import_node_path.default.dirname(input.execPath) !== import_node_path.default.resolve(APPDIR)) return null;
+  return input.exists(APPIMAGE) ? APPIMAGE : null;
+}
+function appImageCommand(appImage, dataDir) {
+  return {
+    command: appImage,
+    args: ["-e", APPIMAGE_BOOTSTRAP, "--", "--data-dir", dataDir, "--no-sandbox"],
+    env: { ELECTRON_RUN_AS_NODE: "1" }
+  };
+}
+function shellQuote(arg, platform = process.platform) {
+  if (/^[\w@%+=:,./\\-]+$/.test(arg)) return arg;
+  if (platform === "win32") return `"${arg.replace(/"/g, '\\"')}"`;
+  return `'${arg.replace(/'/g, `'\\''`)}'`;
+}
+function claudeCodeConnectorCommand(cmd, platform = process.platform) {
+  const env = Object.entries(cmd.env).map(([k, v]) => `-e ${k}=${v}`);
+  return [
+    "claude mcp add codetrellis --scope user",
+    ...env,
+    "--",
+    shellQuote(cmd.command, platform),
+    ...cmd.args.map((a) => shellQuote(a, platform))
+  ].join(" ");
+}
+function connectorConfig(cmd) {
+  return {
+    codetrellis: {
+      command: cmd.command,
+      args: cmd.args,
+      ...Object.keys(cmd.env).length > 0 ? { env: cmd.env } : {}
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APPIMAGE_BOOTSTRAP,
+  CONNECTOR_SCRIPT,
+  PORTABLE_CAVEAT,
+  claudeCodeConnectorCommand,
+  connectorConfig,
+  isPackagedElectron,
+  resolveConnectorCommand,
+  shellQuote
+});

package/src/backend/mcp/connector/core.js

@@ -0,0 +1,278 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var core_exports = {};
+__export(core_exports, {
+  ConnectorCore: () => ConnectorCore,
+  LOST_MESSAGE: () => LOST_MESSAGE,
+  NOT_RUNNING_MESSAGE: () => NOT_RUNNING_MESSAGE
+});
+module.exports = __toCommonJS(core_exports);
+const NOT_RUNNING_MESSAGE = "CodeTrellis is not running, so its tools are unavailable. Open the CodeTrellis app \u2014 this connection picks it up automatically, with no change to your MCP settings.";
+const LOST_MESSAGE = "CodeTrellis stopped (or restarted) while this request was in flight. It reconnects automatically; try the request again in a moment.";
+const REPLAY_ID_PREFIX = "ct-connector-reinit-";
+const DEFAULT_PROTOCOL_VERSION = "2025-06-18";
+const idKey = (id) => JSON.stringify(id);
+const isRequest = (m) => typeof m.method === "string" && m.id !== void 0 && m.id !== null;
+const isResponse = (m) => m.method === void 0 && m.id !== void 0 && m.id !== null;
+class ConnectorCore {
+  opts;
+  upstream = null;
+  /** The upstream has completed an `initialize` handshake of its own. */
+  ready = false;
+  /** The client's `initialize`, kept so it can be replayed to a new server. */
+  initRequest = null;
+  /** The id of the client's own `initialize`, while its reply is outstanding. */
+  clientInitInFlight = null;
+  /** We completed the client's handshake ourselves, because no app was there. */
+  answeredLocally = false;
+  /** The client's `initialize` is waiting to learn whether a server exists. */
+  deciding = false;
+  /** Client requests forwarded upstream and not yet answered. */
+  pending = /* @__PURE__ */ new Set();
+  replayWaiters = /* @__PURE__ */ new Map();
+  replaySeq = 0;
+  firstAttempt = Promise.resolve();
+  retryMs;
+  retryTimer = null;
+  stopped = false;
+  /** Log "waiting for CodeTrellis" once per outage, not once per retry. */
+  announcedDown = false;
+  constructor(options) {
+    this.opts = {
+      initialWaitMs: 3e3,
+      retryMinMs: 500,
+      retryMaxMs: 5e3,
+      replayTimeoutMs: 1e4,
+      log: () => {
+      },
+      ...options
+    };
+    this.retryMs = this.opts.retryMinMs;
+  }
+  start() {
+    this.firstAttempt = this.connectOnce();
+  }
+  stop() {
+    this.stopped = true;
+    if (this.retryTimer) clearTimeout(this.retryTimer);
+    this.retryTimer = null;
+    const up = this.upstream;
+    this.upstream = null;
+    up?.close();
+  }
+  /** True while there is a connected, initialised server behind us. */
+  get connected() {
+    return this.upstream !== null && this.ready;
+  }
+  // ── From the client ───────────────────────────────────────────────
+  async handleClientMessage(msg) {
+    if (isRequest(msg) && msg.method === "initialize") {
+      await this.handleInitialize(msg);
+      return;
+    }
+    if (msg.method === "notifications/initialized" && !isRequest(msg)) {
+      if (this.upstream && this.ready && this.clientInitInFlight === null && !this.answeredLocally) {
+        await this.forward(msg);
+      }
+      return;
+    }
+    if (isRequest(msg)) {
+      if (this.connected) {
+        this.pending.add(idKey(msg.id));
+        await this.forward(msg);
+      } else {
+        this.answerLocally(msg);
+      }
+      return;
+    }
+    if (this.upstream && (this.ready || isResponse(msg))) await this.forward(msg);
+  }
+  async handleInitialize(msg) {
+    this.initRequest = msg;
+    if (!this.upstream) {
+      this.deciding = true;
+      let timer;
+      await Promise.race([
+        this.firstAttempt,
+        new Promise((r) => {
+          timer = setTimeout(r, this.opts.initialWaitMs);
+        })
+      ]);
+      clearTimeout(timer);
+      this.deciding = false;
+    }
+    if (this.upstream) {
+      this.clientInitInFlight = idKey(msg.id);
+      this.pending.add(this.clientInitInFlight);
+      this.answeredLocally = false;
+      await this.forward(msg);
+      return;
+    }
+    this.answeredLocally = true;
+    const params = msg.params ?? {};
+    this.opts.send({
+      jsonrpc: "2.0",
+      id: msg.id,
+      result: {
+        protocolVersion: params.protocolVersion ?? DEFAULT_PROTOCOL_VERSION,
+        capabilities: { tools: { listChanged: true }, resources: { listChanged: true } },
+        serverInfo: { name: "codetrellis", version: this.opts.version },
+        instructions: NOT_RUNNING_MESSAGE
+      }
+    });
+  }
+  /** What a request gets when there is no server to ask. */
+  answerLocally(msg) {
+    const reply = (result) => this.opts.send({ jsonrpc: "2.0", id: msg.id, result });
+    switch (msg.method) {
+      case "ping":
+        return reply({});
+      case "tools/list":
+        return reply({ tools: [] });
+      case "resources/list":
+        return reply({ resources: [] });
+      case "resources/templates/list":
+        return reply({ resourceTemplates: [] });
+      case "prompts/list":
+        return reply({ prompts: [] });
+      case "tools/call":
+        return reply({ content: [{ type: "text", text: NOT_RUNNING_MESSAGE }], isError: true });
+      default:
+        this.opts.send({ jsonrpc: "2.0", id: msg.id, error: { code: -32e3, message: NOT_RUNNING_MESSAGE } });
+    }
+  }
+  // ── From the server ───────────────────────────────────────────────
+  handleUpstreamMessage(up, msg) {
+    if (up !== this.upstream) return;
+    if (isResponse(msg)) {
+      const id = msg.id;
+      if (typeof id === "string" && id.startsWith(REPLAY_ID_PREFIX)) {
+        this.replayWaiters.get(id)?.(msg);
+        return;
+      }
+      const key = idKey(id);
+      this.pending.delete(key);
+      if (key === this.clientInitInFlight) {
+        this.clientInitInFlight = null;
+        if (!msg.error) this.ready = true;
+      }
+    }
+    this.opts.send(msg);
+  }
+  handleUpstreamClosed(up) {
+    if (up !== this.upstream) return;
+    this.upstream = null;
+    this.ready = false;
+    for (const key of this.pending) {
+      this.opts.send({ jsonrpc: "2.0", id: JSON.parse(key), error: { code: -32e3, message: LOST_MESSAGE } });
+    }
+    this.pending.clear();
+    this.clientInitInFlight = null;
+    for (const resolve of this.replayWaiters.values()) resolve(null);
+    this.replayWaiters.clear();
+    this.opts.log("Lost the connection to CodeTrellis; reconnecting.");
+    this.scheduleRetry();
+  }
+  // ── Connection lifecycle ──────────────────────────────────────────
+  async connectOnce() {
+    if (this.stopped || this.upstream) return;
+    let up;
+    try {
+      up = await this.opts.connect();
+    } catch (err) {
+      if (!this.announcedDown) {
+        this.opts.log(`Waiting for CodeTrellis (${err instanceof Error ? err.message : String(err)}).`);
+        this.announcedDown = true;
+      }
+      this.scheduleRetry();
+      return;
+    }
+    if (this.stopped) {
+      up.close();
+      return;
+    }
+    this.upstream = up;
+    this.ready = false;
+    this.retryMs = this.opts.retryMinMs;
+    this.announcedDown = false;
+    up.onmessage = (m) => this.handleUpstreamMessage(up, m);
+    up.onclose = () => this.handleUpstreamClosed(up);
+    this.opts.log("Connected to CodeTrellis.");
+    if (this.initRequest && this.clientInitInFlight === null && !this.deciding) {
+      await this.replayInitialize(up);
+    }
+  }
+  async replayInitialize(up) {
+    const id = `${REPLAY_ID_PREFIX}${++this.replaySeq}`;
+    const reply = new Promise((resolve) => {
+      const timer = setTimeout(() => resolve(null), this.opts.replayTimeoutMs);
+      this.replayWaiters.set(id, (m) => {
+        clearTimeout(timer);
+        this.replayWaiters.delete(id);
+        resolve(m);
+      });
+    });
+    try {
+      await up.send({ jsonrpc: "2.0", id, method: "initialize", params: this.initRequest.params });
+    } catch {
+      up.close();
+      return;
+    }
+    const answer = await reply;
+    if (up !== this.upstream) return;
+    if (!answer || answer.error) {
+      this.opts.log(`CodeTrellis refused the handshake${answer?.error ? `: ${answer.error.message}` : " (timed out)"}; retrying.`);
+      up.close();
+      return;
+    }
+    try {
+      await up.send({ jsonrpc: "2.0", method: "notifications/initialized" });
+    } catch {
+      up.close();
+      return;
+    }
+    this.ready = true;
+    this.opts.send({ jsonrpc: "2.0", method: "notifications/tools/list_changed" });
+    this.opts.send({ jsonrpc: "2.0", method: "notifications/resources/list_changed" });
+  }
+  scheduleRetry() {
+    if (this.stopped || this.retryTimer) return;
+    const wait = this.retryMs;
+    this.retryMs = Math.min(this.retryMs * 2, this.opts.retryMaxMs);
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      void this.connectOnce();
+    }, wait);
+  }
+  async forward(msg) {
+    const up = this.upstream;
+    if (!up) return;
+    try {
+      await up.send(msg);
+    } catch {
+      up.close();
+      this.handleUpstreamClosed(up);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConnectorCore,
+  LOST_MESSAGE,
+  NOT_RUNNING_MESSAGE
+});