adhdev 0.8.50 → 0.8.52

package/vendor/terminal-mux-cli/node_modules/@adhdev/terminal-mux-control/chunk-XZWWVN5W.mjs

@@ -0,0 +1,164 @@
+import {
+  getWorkspaceControlEndpoint
+} from "./chunk-7RNMRPVZ.mjs";
+
+// src/control-socket.ts
+import net from "net";
+import fs from "fs";
+function serializeEnvelope(envelope) {
+  return `${JSON.stringify(envelope)}
+`;
+}
+function createControlLineParser(onEnvelope) {
+  let buffer = "";
+  return (chunk) => {
+    buffer += chunk.toString();
+    let newlineIndex = buffer.indexOf("\n");
+    while (newlineIndex >= 0) {
+      const rawLine = buffer.slice(0, newlineIndex).trim();
+      buffer = buffer.slice(newlineIndex + 1);
+      if (rawLine) {
+        onEnvelope(JSON.parse(rawLine));
+      }
+      newlineIndex = buffer.indexOf("\n");
+    }
+  };
+}
+var AdhMuxControlClient = class {
+  endpoint;
+  socket = null;
+  waiters = /* @__PURE__ */ new Map();
+  eventListeners = /* @__PURE__ */ new Set();
+  constructor(workspaceName) {
+    this.endpoint = getWorkspaceControlEndpoint(workspaceName);
+  }
+  async connect() {
+    if (this.socket && !this.socket.destroyed) return;
+    const socket = net.createConnection(this.endpoint.path);
+    this.socket = socket;
+    socket.on("data", createControlLineParser((envelope) => {
+      if (envelope.kind === "response") {
+        const waiter = this.waiters.get(envelope.requestId);
+        if (!waiter) return;
+        this.waiters.delete(envelope.requestId);
+        waiter.resolve(envelope.response);
+        return;
+      }
+      if (envelope.kind === "event") {
+        for (const listener of this.eventListeners) listener(envelope.event);
+      }
+    }));
+    socket.on("error", (error) => {
+      for (const waiter of this.waiters.values()) {
+        waiter.reject(error);
+      }
+      this.waiters.clear();
+    });
+    await new Promise((resolve, reject) => {
+      socket.once("connect", () => resolve());
+      socket.once("error", reject);
+    });
+  }
+  async request(request) {
+    await this.connect();
+    if (!this.socket) throw new Error("adhmux control socket unavailable");
+    const requestId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const envelope = { kind: "request", requestId, request };
+    const response = await new Promise((resolve, reject) => {
+      this.waiters.set(requestId, { resolve, reject });
+      this.socket?.write(serializeEnvelope(envelope));
+    });
+    return response;
+  }
+  onEvent(listener) {
+    this.eventListeners.add(listener);
+    return () => {
+      this.eventListeners.delete(listener);
+    };
+  }
+  async close() {
+    if (!this.socket) return;
+    const socket = this.socket;
+    this.socket = null;
+    for (const waiter of this.waiters.values()) {
+      waiter.reject(new Error("adhmux control client closed"));
+    }
+    this.waiters.clear();
+    await new Promise((resolve) => {
+      let settled = false;
+      const done = () => {
+        if (settled) return;
+        settled = true;
+        resolve();
+      };
+      socket.once("close", done);
+      socket.end();
+      socket.destroy();
+      setTimeout(done, 50);
+    });
+  }
+};
+async function withAdhMuxControlClient(workspaceName, fn) {
+  const client = new AdhMuxControlClient(workspaceName);
+  try {
+    return await fn(client);
+  } finally {
+    await client.close();
+  }
+}
+var AdhMuxControlServer = class {
+  endpoint;
+  sockets = /* @__PURE__ */ new Set();
+  server;
+  constructor(workspaceName, handle) {
+    this.endpoint = getWorkspaceControlEndpoint(workspaceName);
+    if (this.endpoint.kind === "unix" && fs.existsSync(this.endpoint.path)) {
+      fs.unlinkSync(this.endpoint.path);
+    }
+    this.server = net.createServer((socket) => {
+      this.sockets.add(socket);
+      socket.on("close", () => {
+        this.sockets.delete(socket);
+      });
+      socket.on("data", createControlLineParser(async (envelope) => {
+        if (envelope.kind !== "request") return;
+        const response = await handle(envelope.request).catch((error) => ({
+          success: false,
+          error: error?.message || String(error)
+        }));
+        socket.write(
+          serializeEnvelope({
+            kind: "response",
+            requestId: envelope.requestId,
+            response
+          })
+        );
+      }));
+    });
+    this.server.listen(this.endpoint.path);
+    this.server.on("close", () => {
+      if (this.endpoint.kind === "unix" && fs.existsSync(this.endpoint.path)) {
+        fs.unlinkSync(this.endpoint.path);
+      }
+    });
+  }
+  broadcast(event) {
+    const envelope = serializeEnvelope({ kind: "event", event });
+    for (const socket of this.sockets) {
+      if (!socket.destroyed) socket.write(envelope);
+    }
+  }
+  close() {
+    this.server.close();
+  }
+};
+function createAdhMuxControlServer(workspaceName, handle) {
+  return new AdhMuxControlServer(workspaceName, handle);
+}
+
+export {
+  AdhMuxControlClient,
+  withAdhMuxControlClient,
+  AdhMuxControlServer,
+  createAdhMuxControlServer
+};

package/vendor/terminal-mux-cli/node_modules/@adhdev/terminal-mux-control/control-socket.d.mts

@@ -0,0 +1,35 @@
+import { SessionHostResponse } from '@adhdev/session-host-core';
+import { WorkspaceControlEndpoint } from './storage.mjs';
+import '@adhdev/terminal-mux-core';
+
+interface AdhMuxControlRequest {
+    type: 'workspace_state' | 'list_panes' | 'capture_pane' | 'copy_pane' | 'search_pane' | 'select_pane' | 'replace_pane' | 'split_window' | 'resize_pane' | 'select_layout' | 'swap_panes' | 'zoom_pane' | 'kill_pane' | 'send_keys' | (string & {});
+    payload?: Record<string, unknown>;
+}
+interface AdhMuxControlEvent {
+    type: 'workspace_update' | 'runtime_update';
+    payload: Record<string, unknown>;
+}
+declare class AdhMuxControlClient {
+    readonly endpoint: WorkspaceControlEndpoint;
+    private socket;
+    private waiters;
+    private eventListeners;
+    constructor(workspaceName: string);
+    connect(): Promise<void>;
+    request<T = unknown>(request: AdhMuxControlRequest): Promise<SessionHostResponse<T>>;
+    onEvent(listener: (event: AdhMuxControlEvent) => void): () => void;
+    close(): Promise<void>;
+}
+declare function withAdhMuxControlClient<T>(workspaceName: string, fn: (client: AdhMuxControlClient) => Promise<T>): Promise<T>;
+declare class AdhMuxControlServer {
+    readonly endpoint: WorkspaceControlEndpoint;
+    private readonly sockets;
+    private readonly server;
+    constructor(workspaceName: string, handle: (request: AdhMuxControlRequest) => Promise<SessionHostResponse>);
+    broadcast(event: AdhMuxControlEvent): void;
+    close(): void;
+}
+declare function createAdhMuxControlServer(workspaceName: string, handle: (request: AdhMuxControlRequest) => Promise<SessionHostResponse>): AdhMuxControlServer;
+
+export { AdhMuxControlClient, type AdhMuxControlEvent, type AdhMuxControlRequest, AdhMuxControlServer, createAdhMuxControlServer, withAdhMuxControlClient };

package/vendor/terminal-mux-cli/node_modules/@adhdev/terminal-mux-control/control-socket.d.ts

@@ -0,0 +1,35 @@
+import { SessionHostResponse } from '@adhdev/session-host-core';
+import { WorkspaceControlEndpoint } from './storage.js';
+import '@adhdev/terminal-mux-core';
+
+interface AdhMuxControlRequest {
+    type: 'workspace_state' | 'list_panes' | 'capture_pane' | 'copy_pane' | 'search_pane' | 'select_pane' | 'replace_pane' | 'split_window' | 'resize_pane' | 'select_layout' | 'swap_panes' | 'zoom_pane' | 'kill_pane' | 'send_keys' | (string & {});
+    payload?: Record<string, unknown>;
+}
+interface AdhMuxControlEvent {
+    type: 'workspace_update' | 'runtime_update';
+    payload: Record<string, unknown>;
+}
+declare class AdhMuxControlClient {
+    readonly endpoint: WorkspaceControlEndpoint;
+    private socket;
+    private waiters;
+    private eventListeners;
+    constructor(workspaceName: string);
+    connect(): Promise<void>;
+    request<T = unknown>(request: AdhMuxControlRequest): Promise<SessionHostResponse<T>>;
+    onEvent(listener: (event: AdhMuxControlEvent) => void): () => void;
+    close(): Promise<void>;
+}
+declare function withAdhMuxControlClient<T>(workspaceName: string, fn: (client: AdhMuxControlClient) => Promise<T>): Promise<T>;
+declare class AdhMuxControlServer {
+    readonly endpoint: WorkspaceControlEndpoint;
+    private readonly sockets;
+    private readonly server;
+    constructor(workspaceName: string, handle: (request: AdhMuxControlRequest) => Promise<SessionHostResponse>);
+    broadcast(event: AdhMuxControlEvent): void;
+    close(): void;
+}
+declare function createAdhMuxControlServer(workspaceName: string, handle: (request: AdhMuxControlRequest) => Promise<SessionHostResponse>): AdhMuxControlServer;
+
+export { AdhMuxControlClient, type AdhMuxControlEvent, type AdhMuxControlRequest, AdhMuxControlServer, createAdhMuxControlServer, withAdhMuxControlClient };

package/vendor/terminal-mux-cli/node_modules/@adhdev/terminal-mux-control/control-socket.js

@@ -0,0 +1,219 @@
+"use strict";
+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);
+
+// src/control-socket.ts
+var control_socket_exports = {};
+__export(control_socket_exports, {
+  AdhMuxControlClient: () => AdhMuxControlClient,
+  AdhMuxControlServer: () => AdhMuxControlServer,
+  createAdhMuxControlServer: () => createAdhMuxControlServer,
+  withAdhMuxControlClient: () => withAdhMuxControlClient
+});
+module.exports = __toCommonJS(control_socket_exports);
+var import_net = __toESM(require("net"));
+var import_fs = __toESM(require("fs"));
+
+// src/storage.ts
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+function sanitizeWorkspaceName(name) {
+  return name.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+function getWorkspaceControlEndpoint(name) {
+  const sanitized = sanitizeWorkspaceName(name);
+  if (process.platform === "win32") {
+    return {
+      kind: "pipe",
+      path: `\\\\.\\pipe\\adhmux-${sanitized}`
+    };
+  }
+  return {
+    kind: "unix",
+    path: import_path.default.join(import_os.default.tmpdir(), `adhmux-${sanitized}.sock`)
+  };
+}
+
+// src/control-socket.ts
+function serializeEnvelope(envelope) {
+  return `${JSON.stringify(envelope)}
+`;
+}
+function createControlLineParser(onEnvelope) {
+  let buffer = "";
+  return (chunk) => {
+    buffer += chunk.toString();
+    let newlineIndex = buffer.indexOf("\n");
+    while (newlineIndex >= 0) {
+      const rawLine = buffer.slice(0, newlineIndex).trim();
+      buffer = buffer.slice(newlineIndex + 1);
+      if (rawLine) {
+        onEnvelope(JSON.parse(rawLine));
+      }
+      newlineIndex = buffer.indexOf("\n");
+    }
+  };
+}
+var AdhMuxControlClient = class {
+  endpoint;
+  socket = null;
+  waiters = /* @__PURE__ */ new Map();
+  eventListeners = /* @__PURE__ */ new Set();
+  constructor(workspaceName) {
+    this.endpoint = getWorkspaceControlEndpoint(workspaceName);
+  }
+  async connect() {
+    if (this.socket && !this.socket.destroyed) return;
+    const socket = import_net.default.createConnection(this.endpoint.path);
+    this.socket = socket;
+    socket.on("data", createControlLineParser((envelope) => {
+      if (envelope.kind === "response") {
+        const waiter = this.waiters.get(envelope.requestId);
+        if (!waiter) return;
+        this.waiters.delete(envelope.requestId);
+        waiter.resolve(envelope.response);
+        return;
+      }
+      if (envelope.kind === "event") {
+        for (const listener of this.eventListeners) listener(envelope.event);
+      }
+    }));
+    socket.on("error", (error) => {
+      for (const waiter of this.waiters.values()) {
+        waiter.reject(error);
+      }
+      this.waiters.clear();
+    });
+    await new Promise((resolve, reject) => {
+      socket.once("connect", () => resolve());
+      socket.once("error", reject);
+    });
+  }
+  async request(request) {
+    await this.connect();
+    if (!this.socket) throw new Error("adhmux control socket unavailable");
+    const requestId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const envelope = { kind: "request", requestId, request };
+    const response = await new Promise((resolve, reject) => {
+      this.waiters.set(requestId, { resolve, reject });
+      this.socket?.write(serializeEnvelope(envelope));
+    });
+    return response;
+  }
+  onEvent(listener) {
+    this.eventListeners.add(listener);
+    return () => {
+      this.eventListeners.delete(listener);
+    };
+  }
+  async close() {
+    if (!this.socket) return;
+    const socket = this.socket;
+    this.socket = null;
+    for (const waiter of this.waiters.values()) {
+      waiter.reject(new Error("adhmux control client closed"));
+    }
+    this.waiters.clear();
+    await new Promise((resolve) => {
+      let settled = false;
+      const done = () => {
+        if (settled) return;
+        settled = true;
+        resolve();
+      };
+      socket.once("close", done);
+      socket.end();
+      socket.destroy();
+      setTimeout(done, 50);
+    });
+  }
+};
+async function withAdhMuxControlClient(workspaceName, fn) {
+  const client = new AdhMuxControlClient(workspaceName);
+  try {
+    return await fn(client);
+  } finally {
+    await client.close();
+  }
+}
+var AdhMuxControlServer = class {
+  endpoint;
+  sockets = /* @__PURE__ */ new Set();
+  server;
+  constructor(workspaceName, handle) {
+    this.endpoint = getWorkspaceControlEndpoint(workspaceName);
+    if (this.endpoint.kind === "unix" && import_fs.default.existsSync(this.endpoint.path)) {
+      import_fs.default.unlinkSync(this.endpoint.path);
+    }
+    this.server = import_net.default.createServer((socket) => {
+      this.sockets.add(socket);
+      socket.on("close", () => {
+        this.sockets.delete(socket);
+      });
+      socket.on("data", createControlLineParser(async (envelope) => {
+        if (envelope.kind !== "request") return;
+        const response = await handle(envelope.request).catch((error) => ({
+          success: false,
+          error: error?.message || String(error)
+        }));
+        socket.write(
+          serializeEnvelope({
+            kind: "response",
+            requestId: envelope.requestId,
+            response
+          })
+        );
+      }));
+    });
+    this.server.listen(this.endpoint.path);
+    this.server.on("close", () => {
+      if (this.endpoint.kind === "unix" && import_fs.default.existsSync(this.endpoint.path)) {
+        import_fs.default.unlinkSync(this.endpoint.path);
+      }
+    });
+  }
+  broadcast(event) {
+    const envelope = serializeEnvelope({ kind: "event", event });
+    for (const socket of this.sockets) {
+      if (!socket.destroyed) socket.write(envelope);
+    }
+  }
+  close() {
+    this.server.close();
+  }
+};
+function createAdhMuxControlServer(workspaceName, handle) {
+  return new AdhMuxControlServer(workspaceName, handle);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdhMuxControlClient,
+  AdhMuxControlServer,
+  createAdhMuxControlServer,
+  withAdhMuxControlClient
+});

package/vendor/terminal-mux-cli/node_modules/@adhdev/terminal-mux-control/control-socket.mjs

@@ -0,0 +1,13 @@
+import {
+  AdhMuxControlClient,
+  AdhMuxControlServer,
+  createAdhMuxControlServer,
+  withAdhMuxControlClient
+} from "./chunk-XZWWVN5W.mjs";
+import "./chunk-7RNMRPVZ.mjs";
+export {
+  AdhMuxControlClient,
+  AdhMuxControlServer,
+  createAdhMuxControlServer,
+  withAdhMuxControlClient
+};

package/vendor/terminal-mux-cli/node_modules/@adhdev/terminal-mux-control/index.d.mts

@@ -0,0 +1,5 @@
+export { AdhMuxSocketInfo, getWorkspaceSocketInfo, getWorkspaceState, requestWorkspaceControl } from './api.mjs';
+export { StoredSessionInfo, StoredWorkspaceInfo, TerminalMuxStorage, WorkspaceControlEndpoint, WorkspaceRef, buildWorkspaceName, getRootDir, getWorkspaceControlEndpoint, sanitizeWorkspaceName, toWorkspaceRef } from './storage.mjs';
+export { AdhMuxControlClient, AdhMuxControlEvent, AdhMuxControlRequest, AdhMuxControlServer, createAdhMuxControlServer, withAdhMuxControlClient } from './control-socket.mjs';
+import '@adhdev/session-host-core';
+import '@adhdev/terminal-mux-core';

package/vendor/terminal-mux-cli/node_modules/@adhdev/terminal-mux-control/index.d.ts

@@ -0,0 +1,5 @@
+export { AdhMuxSocketInfo, getWorkspaceSocketInfo, getWorkspaceState, requestWorkspaceControl } from './api.js';
+export { StoredSessionInfo, StoredWorkspaceInfo, TerminalMuxStorage, WorkspaceControlEndpoint, WorkspaceRef, buildWorkspaceName, getRootDir, getWorkspaceControlEndpoint, sanitizeWorkspaceName, toWorkspaceRef } from './storage.js';
+export { AdhMuxControlClient, AdhMuxControlEvent, AdhMuxControlRequest, AdhMuxControlServer, createAdhMuxControlServer, withAdhMuxControlClient } from './control-socket.js';
+import '@adhdev/session-host-core';
+import '@adhdev/terminal-mux-core';