adhdev 0.8.50 → 0.8.54

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

@@ -0,0 +1,427 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AdhMuxControlClient: () => AdhMuxControlClient,
+  AdhMuxControlServer: () => AdhMuxControlServer,
+  TerminalMuxStorage: () => TerminalMuxStorage,
+  buildWorkspaceName: () => buildWorkspaceName,
+  createAdhMuxControlServer: () => createAdhMuxControlServer,
+  getRootDir: () => getRootDir,
+  getWorkspaceControlEndpoint: () => getWorkspaceControlEndpoint,
+  getWorkspaceSocketInfo: () => getWorkspaceSocketInfo,
+  getWorkspaceState: () => getWorkspaceState,
+  requestWorkspaceControl: () => requestWorkspaceControl,
+  sanitizeWorkspaceName: () => sanitizeWorkspaceName,
+  toWorkspaceRef: () => toWorkspaceRef,
+  withAdhMuxControlClient: () => withAdhMuxControlClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/control-socket.ts
+var import_net = __toESM(require("net"));
+var import_fs2 = __toESM(require("fs"));
+
+// src/storage.ts
+var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+function getRootDir() {
+  return import_path.default.join(import_os.default.homedir(), ".adhdev", "terminal-mux");
+}
+var WINDOW_MARKER = "--w--";
+function getWorkspacesDir() {
+  return import_path.default.join(getRootDir(), "workspaces");
+}
+function getStatePath() {
+  return import_path.default.join(getRootDir(), "state.json");
+}
+function sanitizeWorkspaceName(name) {
+  return name.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+function toWorkspaceRef(name) {
+  const workspaceName = sanitizeWorkspaceName(name);
+  const markerIndex = workspaceName.indexOf(WINDOW_MARKER);
+  if (markerIndex < 0) {
+    return {
+      sessionName: workspaceName,
+      windowName: workspaceName,
+      workspaceName
+    };
+  }
+  return {
+    sessionName: workspaceName.slice(0, markerIndex),
+    windowName: workspaceName.slice(markerIndex + WINDOW_MARKER.length),
+    workspaceName
+  };
+}
+function buildWorkspaceName(sessionName, windowName) {
+  const session = sanitizeWorkspaceName(sessionName);
+  const window = sanitizeWorkspaceName(windowName);
+  if (!session || session === window) return window;
+  return `${session}${WINDOW_MARKER}${window}`;
+}
+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`)
+  };
+}
+var TerminalMuxStorage = class {
+  workspacesDir = getWorkspacesDir();
+  statePath = getStatePath();
+  listWorkspaceNames() {
+    return this.listWorkspaces().map((workspace) => workspace.name);
+  }
+  listWorkspaces() {
+    if (!import_fs.default.existsSync(this.workspacesDir)) return [];
+    return import_fs.default.readdirSync(this.workspacesDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).flatMap((entry) => {
+      const name = entry.name.replace(/\.json$/, "");
+      const filePath = this.getWorkspacePath(name);
+      let title = name;
+      let paneCount = 0;
+      let updatedAt = 0;
+      try {
+        const parsed = JSON.parse(import_fs.default.readFileSync(filePath, "utf8"));
+        title = parsed.title || name;
+        paneCount = Object.keys(parsed.panes || {}).length;
+        updatedAt = import_fs.default.statSync(filePath).mtimeMs;
+      } catch {
+        return [];
+      }
+      return [{
+        name,
+        title,
+        paneCount,
+        updatedAt
+      }];
+    }).sort((a, b) => b.updatedAt - a.updatedAt || a.name.localeCompare(b.name));
+  }
+  listSessions() {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const workspace of this.listWorkspaces()) {
+      const ref = toWorkspaceRef(workspace.name);
+      const items = grouped.get(ref.sessionName) || [];
+      items.push(workspace);
+      grouped.set(ref.sessionName, items);
+    }
+    return Array.from(grouped.entries()).map(([sessionName, workspaces]) => {
+      const sorted = [...workspaces].sort((a, b) => b.updatedAt - a.updatedAt || a.name.localeCompare(b.name));
+      const active = sorted[0];
+      return {
+        name: sessionName,
+        title: toWorkspaceRef(active.name).sessionName,
+        windowCount: workspaces.length,
+        updatedAt: active.updatedAt,
+        activeWindowName: toWorkspaceRef(active.name).windowName
+      };
+    }).sort((a, b) => b.updatedAt - a.updatedAt || a.name.localeCompare(b.name));
+  }
+  listSessionWindows(sessionName) {
+    const normalizedSession = sanitizeWorkspaceName(sessionName);
+    return this.listWorkspaces().filter((workspace) => toWorkspaceRef(workspace.name).sessionName === normalizedSession);
+  }
+  resolveSessionWindowWorkspace(sessionName, windowName) {
+    const windows = this.listSessionWindows(sessionName);
+    if (windows.length === 0) return null;
+    if (!windowName) return windows[0].name;
+    const normalizedWindow = sanitizeWorkspaceName(windowName);
+    const exact = windows.find((workspace) => toWorkspaceRef(workspace.name).windowName === normalizedWindow);
+    return exact?.name || null;
+  }
+  loadWorkspace(name) {
+    const filePath = this.getWorkspacePath(name);
+    if (!import_fs.default.existsSync(filePath)) return null;
+    const parsed = JSON.parse(import_fs.default.readFileSync(filePath, "utf8"));
+    return parsed?.workspaceId ? parsed : null;
+  }
+  saveWorkspace(name, workspace) {
+    import_fs.default.mkdirSync(this.workspacesDir, { recursive: true });
+    import_fs.default.writeFileSync(this.getWorkspacePath(name), JSON.stringify(workspace, null, 2), "utf8");
+  }
+  renameWorkspace(fromName, toName) {
+    const fromPath = this.getWorkspacePath(fromName);
+    const toPath = this.getWorkspacePath(toName);
+    if (!import_fs.default.existsSync(fromPath)) {
+      throw new Error(`Workspace not found: ${fromName}`);
+    }
+    import_fs.default.mkdirSync(this.workspacesDir, { recursive: true });
+    import_fs.default.renameSync(fromPath, toPath);
+  }
+  deleteWorkspace(name) {
+    const filePath = this.getWorkspacePath(name);
+    if (!import_fs.default.existsSync(filePath)) {
+      throw new Error(`Workspace not found: ${name}`);
+    }
+    import_fs.default.unlinkSync(filePath);
+    const state = this.loadClientState();
+    if (state.lastWorkspace === sanitizeWorkspaceName(name)) {
+      this.saveClientState({ ...state, lastWorkspace: void 0, updatedAt: Date.now() });
+    }
+  }
+  getLastWorkspace() {
+    const state = this.loadClientState();
+    return state.lastWorkspace || null;
+  }
+  setLastWorkspace(name) {
+    this.saveClientState({
+      ...this.loadClientState(),
+      lastWorkspace: sanitizeWorkspaceName(name),
+      updatedAt: Date.now()
+    });
+  }
+  getWorkspacePath(name) {
+    return import_path.default.join(this.workspacesDir, `${sanitizeWorkspaceName(name)}.json`);
+  }
+  loadClientState() {
+    if (!import_fs.default.existsSync(this.statePath)) {
+      return { updatedAt: 0 };
+    }
+    try {
+      const parsed = JSON.parse(import_fs.default.readFileSync(this.statePath, "utf8"));
+      return typeof parsed === "object" && parsed ? parsed : { updatedAt: 0 };
+    } catch {
+      return { updatedAt: 0 };
+    }
+  }
+  saveClientState(state) {
+    import_fs.default.mkdirSync(getRootDir(), { recursive: true });
+    import_fs.default.writeFileSync(this.statePath, JSON.stringify(state, null, 2), "utf8");
+  }
+};
+
+// 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_fs2.default.existsSync(this.endpoint.path)) {
+      import_fs2.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_fs2.default.existsSync(this.endpoint.path)) {
+        import_fs2.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);
+}
+
+// src/api.ts
+function isControlSocketUnavailable(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /ENOENT|ECONNREFUSED|EPIPE|socket/i.test(message);
+}
+async function requestWorkspaceControl(workspaceName, request) {
+  try {
+    return await withAdhMuxControlClient(workspaceName, (client) => client.request(request));
+  } catch (error) {
+    if (isControlSocketUnavailable(error)) return null;
+    throw error;
+  }
+}
+async function getWorkspaceState(workspaceName) {
+  return requestWorkspaceControl(workspaceName, { type: "workspace_state" });
+}
+async function getWorkspaceSocketInfo(workspaceName) {
+  const endpoint = getWorkspaceControlEndpoint(workspaceName);
+  const client = new AdhMuxControlClient(workspaceName);
+  try {
+    await client.connect();
+    return { workspaceName, live: true, endpoint };
+  } catch (error) {
+    if (isControlSocketUnavailable(error)) {
+      return { workspaceName, live: false, endpoint };
+    }
+    throw error;
+  } finally {
+    await client.close().catch(() => {
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdhMuxControlClient,
+  AdhMuxControlServer,
+  TerminalMuxStorage,
+  buildWorkspaceName,
+  createAdhMuxControlServer,
+  getRootDir,
+  getWorkspaceControlEndpoint,
+  getWorkspaceSocketInfo,
+  getWorkspaceState,
+  requestWorkspaceControl,
+  sanitizeWorkspaceName,
+  toWorkspaceRef,
+  withAdhMuxControlClient
+});

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

@@ -0,0 +1,34 @@
+import {
+  getWorkspaceSocketInfo,
+  getWorkspaceState,
+  requestWorkspaceControl
+} from "./chunk-R4EFW6W3.mjs";
+import {
+  AdhMuxControlClient,
+  AdhMuxControlServer,
+  createAdhMuxControlServer,
+  withAdhMuxControlClient
+} from "./chunk-XZWWVN5W.mjs";
+import {
+  TerminalMuxStorage,
+  buildWorkspaceName,
+  getRootDir,
+  getWorkspaceControlEndpoint,
+  sanitizeWorkspaceName,
+  toWorkspaceRef
+} from "./chunk-7RNMRPVZ.mjs";
+export {
+  AdhMuxControlClient,
+  AdhMuxControlServer,
+  TerminalMuxStorage,
+  buildWorkspaceName,
+  createAdhMuxControlServer,
+  getRootDir,
+  getWorkspaceControlEndpoint,
+  getWorkspaceSocketInfo,
+  getWorkspaceState,
+  requestWorkspaceControl,
+  sanitizeWorkspaceName,
+  toWorkspaceRef,
+  withAdhMuxControlClient
+};

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

@@ -0,0 +1,33 @@
+{
+  "name": "@adhdev/terminal-mux-control",
+  "private": true,
+  "main": "./index.js",
+  "module": "./index.mjs",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.mjs",
+      "require": "./index.js",
+      "default": "./index.js"
+    },
+    "./api": {
+      "types": "./api.d.ts",
+      "import": "./api.mjs",
+      "require": "./api.js",
+      "default": "./api.js"
+    },
+    "./storage": {
+      "types": "./storage.d.ts",
+      "import": "./storage.mjs",
+      "require": "./storage.js",
+      "default": "./storage.js"
+    },
+    "./control-socket": {
+      "types": "./control-socket.d.ts",
+      "import": "./control-socket.mjs",
+      "require": "./control-socket.js",
+      "default": "./control-socket.js"
+    }
+  }
+}

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

@@ -0,0 +1,49 @@
+import { PersistedMuxWorkspaceState } from '@adhdev/terminal-mux-core';
+
+interface StoredWorkspaceInfo {
+    name: string;
+    title: string;
+    paneCount: number;
+    updatedAt: number;
+}
+interface StoredSessionInfo {
+    name: string;
+    title: string;
+    windowCount: number;
+    updatedAt: number;
+    activeWindowName: string;
+}
+declare function getRootDir(): string;
+declare function sanitizeWorkspaceName(name: string): string;
+interface WorkspaceRef {
+    sessionName: string;
+    windowName: string;
+    workspaceName: string;
+}
+declare function toWorkspaceRef(name: string): WorkspaceRef;
+declare function buildWorkspaceName(sessionName: string, windowName: string): string;
+interface WorkspaceControlEndpoint {
+    kind: 'unix' | 'pipe';
+    path: string;
+}
+declare function getWorkspaceControlEndpoint(name: string): WorkspaceControlEndpoint;
+declare class TerminalMuxStorage {
+    private readonly workspacesDir;
+    private readonly statePath;
+    listWorkspaceNames(): string[];
+    listWorkspaces(): StoredWorkspaceInfo[];
+    listSessions(): StoredSessionInfo[];
+    listSessionWindows(sessionName: string): StoredWorkspaceInfo[];
+    resolveSessionWindowWorkspace(sessionName: string, windowName?: string): string | null;
+    loadWorkspace(name: string): PersistedMuxWorkspaceState | null;
+    saveWorkspace(name: string, workspace: PersistedMuxWorkspaceState): void;
+    renameWorkspace(fromName: string, toName: string): void;
+    deleteWorkspace(name: string): void;
+    getLastWorkspace(): string | null;
+    setLastWorkspace(name: string): void;
+    private getWorkspacePath;
+    private loadClientState;
+    private saveClientState;
+}
+
+export { type StoredSessionInfo, type StoredWorkspaceInfo, TerminalMuxStorage, type WorkspaceControlEndpoint, type WorkspaceRef, buildWorkspaceName, getRootDir, getWorkspaceControlEndpoint, sanitizeWorkspaceName, toWorkspaceRef };

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

@@ -0,0 +1,49 @@
+import { PersistedMuxWorkspaceState } from '@adhdev/terminal-mux-core';
+
+interface StoredWorkspaceInfo {
+    name: string;
+    title: string;
+    paneCount: number;
+    updatedAt: number;
+}
+interface StoredSessionInfo {
+    name: string;
+    title: string;
+    windowCount: number;
+    updatedAt: number;
+    activeWindowName: string;
+}
+declare function getRootDir(): string;
+declare function sanitizeWorkspaceName(name: string): string;
+interface WorkspaceRef {
+    sessionName: string;
+    windowName: string;
+    workspaceName: string;
+}
+declare function toWorkspaceRef(name: string): WorkspaceRef;
+declare function buildWorkspaceName(sessionName: string, windowName: string): string;
+interface WorkspaceControlEndpoint {
+    kind: 'unix' | 'pipe';
+    path: string;
+}
+declare function getWorkspaceControlEndpoint(name: string): WorkspaceControlEndpoint;
+declare class TerminalMuxStorage {
+    private readonly workspacesDir;
+    private readonly statePath;
+    listWorkspaceNames(): string[];
+    listWorkspaces(): StoredWorkspaceInfo[];
+    listSessions(): StoredSessionInfo[];
+    listSessionWindows(sessionName: string): StoredWorkspaceInfo[];
+    resolveSessionWindowWorkspace(sessionName: string, windowName?: string): string | null;
+    loadWorkspace(name: string): PersistedMuxWorkspaceState | null;
+    saveWorkspace(name: string, workspace: PersistedMuxWorkspaceState): void;
+    renameWorkspace(fromName: string, toName: string): void;
+    deleteWorkspace(name: string): void;
+    getLastWorkspace(): string | null;
+    setLastWorkspace(name: string): void;
+    private getWorkspacePath;
+    private loadClientState;
+    private saveClientState;
+}
+
+export { type StoredSessionInfo, type StoredWorkspaceInfo, TerminalMuxStorage, type WorkspaceControlEndpoint, type WorkspaceRef, buildWorkspaceName, getRootDir, getWorkspaceControlEndpoint, sanitizeWorkspaceName, toWorkspaceRef };