@libtmux/workspace-cli 0.1.0-alpha.11

package/dist/main-c8atq2pj.js

@@ -0,0 +1,470 @@
+import {
+  CliError,
+  expandPath,
+  mapping,
+  scalarText,
+  sequence
+} from "./main-gh3pafqb.js";
+
+// src/process.ts
+import { spawn } from "node:child_process";
+import { open } from "node:fs/promises";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { StringDecoder } from "node:string_decoder";
+import { isatty } from "node:tty";
+async function openTerminal(options) {
+  const fd = [0, 1, 2].find(isatty);
+  if (fd !== undefined)
+    return open(`/dev/fd/${fd}`, "r+");
+  const query = await processRun(["ps", "-p", String(process.pid), "-o", "tty="], {
+    cwd: options.cwd,
+    env: options.env,
+    signal: AbortSignal.any([
+      ...options.signal ? [options.signal] : [],
+      AbortSignal.timeout(1000)
+    ])
+  });
+  const name = query.stdout.trim();
+  if (query.code !== 0 || !/^(?:\/dev\/)?[a-zA-Z0-9][a-zA-Z0-9/_-]*$/.test(name))
+    throw new Error("No controlling terminal");
+  return open(name.startsWith("/dev/") ? name : `/dev/${name}`, "r+");
+}
+function tokenize(value) {
+  const args = [];
+  let word = "";
+  let quote = "";
+  let active = false;
+  for (let index = 0;index < value.length; index++) {
+    const character = value[index];
+    if (character === "\\" && quote !== "'") {
+      const next = value[++index];
+      if (next === undefined)
+        throw new Error("Incomplete escape in command");
+      if (quote === '"' && !['"', "\\"].includes(next))
+        word += "\\";
+      word += next;
+      active = true;
+    } else if (quote) {
+      if (character === quote)
+        quote = "";
+      else
+        word += character;
+    } else if (character === '"' || character === "'") {
+      quote = character;
+      active = true;
+    } else if (/\s/u.test(character)) {
+      if (active)
+        args.push(word);
+      word = "";
+      active = false;
+    } else {
+      word += character;
+      active = true;
+    }
+  }
+  if (quote)
+    throw new Error("Unterminated quote in command");
+  if (active)
+    args.push(word);
+  if (!args[0])
+    throw new Error("Command needs an executable");
+  return args;
+}
+async function processRun(argv, options) {
+  options.signal?.throwIfAborted();
+  if (!argv[0])
+    throw new Error("Command needs an executable");
+  if (options.terminal && options.input !== undefined)
+    throw new Error("Terminal processes cannot also receive captured input");
+  const grouped = process.platform !== "win32";
+  const terminal = options.terminal ? await openTerminal(options) : undefined;
+  let child;
+  try {
+    options.signal?.throwIfAborted();
+    child = spawn(argv[0], argv.slice(1), {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: terminal ? options.terminal === "input" ? [terminal.fd, "pipe", "pipe"] : [terminal.fd, terminal.fd, terminal.fd] : [options.input === undefined ? "ignore" : "pipe", "pipe", "pipe"],
+      detached: grouped && !terminal
+    });
+  } catch (error) {
+    await terminal?.close();
+    throw error;
+  }
+  let failure;
+  let escalation;
+  let drainDeadline;
+  const forcedClose = { stdout: false, stderr: false };
+  let escalationDone;
+  let finishEscalation;
+  const kill = (signal) => {
+    try {
+      if (grouped && !terminal && child.pid !== undefined) {
+        process.kill(-child.pid, signal);
+        return true;
+      }
+      return child.kill(signal);
+    } catch (error) {
+      if (error.code === "ESRCH")
+        return false;
+      failure ??= error;
+      return true;
+    }
+  };
+  const stop = () => {
+    if (escalationDone)
+      return;
+    if (!kill("SIGTERM")) {
+      escalationDone = Promise.resolve();
+      return;
+    }
+    escalationDone = new Promise((resolve) => {
+      finishEscalation = resolve;
+      escalation = setTimeout(() => {
+        kill("SIGKILL");
+        resolve();
+      }, 500);
+    });
+  };
+  const closed = new Promise((resolve) => {
+    child.once("error", (error) => {
+      failure ??= error;
+    });
+    child.once("close", (code, signal) => {
+      clearTimeout(drainDeadline);
+      if (escalationDone && (!grouped || terminal || !kill(0))) {
+        clearTimeout(escalation);
+        finishEscalation?.();
+      }
+      resolve(options.signal?.aborted ? 130 : code ?? (signal ? 1 : 0));
+    });
+  });
+  if (!terminal)
+    child.once("exit", () => {
+      drainDeadline = setTimeout(() => {
+        stop();
+        escalationDone?.then(() => {
+          for (const name of ["stdout", "stderr"]) {
+            const stream = child[name];
+            if (stream && !stream.readableEnded) {
+              forcedClose[name] = true;
+              stream.destroy();
+            }
+          }
+        });
+      }, 100);
+    });
+  options.signal?.addEventListener("abort", stop, { once: true });
+  if (options.signal?.aborted)
+    stop();
+  const input = child.stdin ? pipeline(Readable.from([options.input]), child.stdin, options.signal ? { signal: options.signal } : {}).catch((error) => {
+    if (!options.signal?.aborted)
+      failure ??= error;
+    stop();
+  }) : Promise.resolve();
+  const drain = async (stream, name) => {
+    if (!stream)
+      return { text: "", truncated: false };
+    const decoder = new StringDecoder("utf8");
+    const chunks = [];
+    let bytes = 0;
+    let total = 0;
+    try {
+      for await (const chunk of stream) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        total += buffer.length;
+        const retained = buffer.subarray(0, Math.max(0, 65536 - bytes));
+        if (retained.length)
+          chunks.push(Buffer.from(retained));
+        bytes += retained.length;
+        const text = decoder.write(buffer);
+        if (text)
+          await options.output?.(name, text);
+      }
+      const final = decoder.end();
+      if (final)
+        await options.output?.(name, final);
+    } catch (error) {
+      const cancelled = options.signal?.aborted && error === options.signal.reason;
+      const stopped = forcedClose[name] && error.code === "ERR_STREAM_PREMATURE_CLOSE";
+      if (!cancelled && !stopped)
+        failure ??= error;
+      stop();
+      stream.destroy();
+    }
+    const truncated = total > bytes || forcedClose[name];
+    return {
+      text: new TextDecoder().decode(Buffer.concat(chunks), { stream: truncated }),
+      truncated
+    };
+  };
+  try {
+    const [code, stdout, stderr] = await Promise.all([
+      closed,
+      drain(child.stdout, "stdout"),
+      drain(child.stderr, "stderr"),
+      input
+    ]);
+    if (failure)
+      throw failure;
+    return {
+      code,
+      stdout: stdout.text,
+      stderr: stderr.text,
+      truncated: { stdout: stdout.truncated, stderr: stderr.truncated }
+    };
+  } finally {
+    options.signal?.removeEventListener("abort", stop);
+    await escalationDone;
+    clearTimeout(escalation);
+    clearTimeout(drainDeadline);
+    await terminal?.close();
+  }
+}
+
+// src/normalize.ts
+import { isTmuxName } from "libtmux";
+import { dirname, isAbsolute, resolve } from "node:path";
+var fields = {
+  workspace: [
+    "session_name",
+    "windows",
+    "start_directory",
+    "environment",
+    "shell_command_before",
+    "suppress_history",
+    "options",
+    "global_options",
+    "before_script",
+    "workspace_builder_options",
+    "plugins",
+    "workspace_builder",
+    "workspace_builder_paths",
+    "description"
+  ],
+  window: [
+    "window_name",
+    "window_index",
+    "panes",
+    "start_directory",
+    "environment",
+    "shell_command_before",
+    "suppress_history",
+    "options",
+    "options_after",
+    "layout",
+    "window_shell",
+    "focus",
+    "description"
+  ],
+  pane: [
+    "shell_command",
+    "shell_command_before",
+    "start_directory",
+    "environment",
+    "suppress_history",
+    "shell",
+    "focus",
+    "enter",
+    "sleep_before",
+    "sleep_after",
+    "description"
+  ],
+  command: ["cmd", "enter", "sleep_before", "sleep_after"],
+  readiness: ["pane_readiness"]
+};
+function validateFields(data, scope, path, allowExtensionFields) {
+  if (allowExtensionFields)
+    return;
+  for (const key of Object.keys(data)) {
+    if (key.startsWith("x-"))
+      continue;
+    if (!fields[scope].includes(key))
+      throw new CliError("unsupported_key", `Unsupported field: ${path}.${key} (prefix a custom key with "x-" to have it ignored)`);
+  }
+}
+function expand(value, context) {
+  return expandPath(value, context).replace(/\$\{([^}]+)\}|\$([A-Za-z_][A-Za-z_0-9]*)/g, (original, braced, bare) => context.env[braced ?? bare] ?? original);
+}
+function optionalString(value, name) {
+  if (value === undefined || value === null)
+    return;
+  if (typeof value !== "string")
+    throw new Error(`${name} must be a string`);
+  return value;
+}
+function behavior(data, base, context) {
+  if (data.focus === "true" || data.focus === "false")
+    data.focus = data.focus === "true";
+  for (const name of ["focus", "suppress_history", "enter"]) {
+    if (data[name] !== undefined && typeof data[name] !== "boolean")
+      throw new Error(`${name} must be boolean`);
+  }
+  for (const name of ["options", "global_options", "options_after"])
+    if (data[name] !== undefined) {
+      const options = mapping(data[name], name);
+      for (const [key, value] of Object.entries(options)) {
+        scalarText(value);
+        if (typeof value === "string") {
+          const expanded = expand(value, context);
+          options[key] = expanded.startsWith(".") ? resolve(base, expanded) : expanded;
+        }
+      }
+    }
+  for (const name of ["layout", "window_shell", "shell"])
+    optionalString(data[name], name);
+}
+function readiness(data, allowExtensionFields, warnings) {
+  const catalog = data.workspace_builder_options == null ? {} : mapping(data.workspace_builder_options, "workspace_builder_options");
+  if (!allowExtensionFields) {
+    for (const key of Object.keys(catalog))
+      if (!key.startsWith("x-") && !fields.readiness.includes(key))
+        warnings.push(`Ignoring unknown workspace_builder_options key: ${key}`);
+  }
+  const value = catalog.pane_readiness == null ? "auto" : scalarText(catalog.pane_readiness).trim().toLowerCase();
+  if (value === "auto")
+    return "auto";
+  if (["always", "true", "on", "yes", "1"].includes(value))
+    return "always";
+  if (["never", "false", "off", "no", "0"].includes(value))
+    return "never";
+  throw new Error("pane_readiness must be auto, always, never, or a boolean");
+}
+function directory(value, parent, base, context) {
+  const path = optionalString(value, "start_directory");
+  if (path === undefined)
+    return parent;
+  const expanded = expand(path, context);
+  return isAbsolute(expanded) ? expanded : resolve(parent ?? base, expanded);
+}
+function environment(value, base, context) {
+  if (value === undefined)
+    return {};
+  return Object.fromEntries(Object.entries(mapping(value, "environment")).map(([key, value2]) => {
+    if (!key || key.includes("=") || key.includes("\x00"))
+      throw new Error(`Invalid environment name: ${key}`);
+    const expanded = expand(optionalString(value2, `environment.${key}`) ?? "", context);
+    if (expanded.includes("\x00"))
+      throw new Error(`Invalid environment value: ${key}`);
+    return [key, expanded.startsWith(".") ? resolve(base, expanded) : expanded];
+  }));
+}
+function delays(data) {
+  for (const key of ["sleep_before", "sleep_after"]) {
+    const delay = data[key];
+    if (delay !== undefined && delay !== null && (typeof delay !== "number" || delay < 0 || !Number.isFinite(delay)))
+      throw new Error(`${key} must be a nonnegative number or null`);
+  }
+}
+function commands(value, context, path, allowExtensionFields) {
+  if (value === undefined || value === null || value === "blank" || value === "pane")
+    return [];
+  const entries = Array.isArray(value) ? value : [value];
+  if (entries.length === 1 && [null, "blank", "pane"].includes(entries[0]))
+    return [];
+  return entries.map((value2, index) => {
+    const item = typeof value2 === "string" ? { cmd: value2 } : mapping(value2, "command");
+    validateFields(item, "command", `${path}[${index}]`, allowExtensionFields);
+    if (typeof item.cmd !== "string")
+      throw new Error("A command needs a string cmd");
+    if (item.enter !== undefined && typeof item.enter !== "boolean")
+      throw new Error("enter must be boolean");
+    delays(item);
+    return { ...item, cmd: expand(item.cmd, context) };
+  });
+}
+function workspaceName(document, context, override) {
+  const name = expand(override ?? optionalString(document.session_name, "session_name") ?? "", context);
+  if (!isTmuxName(name))
+    throw new Error("session_name must be a valid tmux name");
+  return name;
+}
+function normalize(document, path, context, override, options = {}) {
+  const data = structuredClone(document);
+  const warnings = [];
+  const allowExtensionFields = options.allowExtensionFields ?? false;
+  validateFields(data, "workspace", "workspace", allowExtensionFields);
+  const name = workspaceName(data, context, override);
+  const base = dirname(path);
+  behavior(data, base, context);
+  const policy = readiness(data, allowExtensionFields, warnings);
+  const cwd = directory(data.start_directory, undefined, base, context);
+  const sessionEnvironment = environment(data.environment, base, context);
+  const sessionBefore = commands(data.shell_command_before, context, "shell_command_before", allowExtensionFields);
+  const windows = sequence(data.windows, "windows");
+  if (!windows.length)
+    throw new Error("Workspace must have at least one window");
+  const indexes = new Set;
+  const normalized = windows.map((value, ordinal) => {
+    const windowPath = `windows[${ordinal}]`;
+    const window = mapping(value, windowPath);
+    validateFields(window, "window", windowPath, allowExtensionFields);
+    behavior(window, base, context);
+    const windowName = optionalString(window.window_name, "window_name");
+    const name2 = windowName === undefined ? undefined : expand(windowName, context);
+    if (name2 !== undefined && !isTmuxName(name2))
+      throw new Error("window_name must be a valid tmux name");
+    const rawIndex = window.window_index;
+    const index = rawIndex == null ? undefined : typeof rawIndex === "number" ? rawIndex : typeof rawIndex === "string" && /^\d+$/.test(rawIndex) ? Number(rawIndex) : Number.NaN;
+    if (index !== undefined && (!Number.isSafeInteger(index) || index < 0 || index > 2147483647 || indexes.has(index)))
+      throw new Error("window_index must be a distinct integer from 0 through 2147483647");
+    if (index !== undefined)
+      indexes.add(index);
+    const windowDirectory = directory(window.start_directory, cwd, base, context);
+    const windowEnvironment = environment(window.environment, base, context);
+    const before = [
+      ...sessionBefore,
+      ...commands(window.shell_command_before, context, `${windowPath}.shell_command_before`, allowExtensionFields)
+    ];
+    const declared = sequence(window.panes ?? [null], "panes");
+    const panes = declared.length === 0 ? [null] : declared;
+    return {
+      data: window,
+      name: name2,
+      index,
+      panes: panes.map((value2, paneIndex) => {
+        const panePath = `${windowPath}.panes[${paneIndex}]`;
+        const pane = typeof value2 === "string" || Array.isArray(value2) || value2 === null ? { shell_command: value2 } : mapping(value2, "pane");
+        validateFields(pane, "pane", panePath, allowExtensionFields);
+        const own = commands(pane.shell_command, context, `${panePath}.shell_command`, allowExtensionFields);
+        behavior(pane, base, context);
+        delays(pane);
+        return {
+          data: pane,
+          commands: [
+            ...before,
+            ...commands(pane.shell_command_before, context, `${panePath}.shell_command_before`, allowExtensionFields),
+            ...own
+          ],
+          directory: directory(pane.start_directory, windowDirectory, base, context),
+          environment: {
+            ...sessionEnvironment,
+            ...pane.environment !== undefined ? environment(pane.environment, base, context) : windowEnvironment
+          },
+          shell: optionalString(pane.shell ?? window.window_shell, "shell"),
+          suppress: Boolean(pane.suppress_history ?? window.suppress_history ?? data.suppress_history ?? true)
+        };
+      })
+    };
+  });
+  const beforeScript = optionalString(data.before_script, "before_script");
+  let bootstrap;
+  if (beforeScript !== undefined) {
+    bootstrap = tokenize(expand(beforeScript, context));
+    if (bootstrap[0].startsWith("."))
+      bootstrap[0] = resolve(base, bootstrap[0]);
+  }
+  return {
+    data,
+    name,
+    directory: cwd,
+    environment: sessionEnvironment,
+    windows: normalized,
+    bootstrap,
+    readiness: policy,
+    warnings
+  };
+}
+
+export { openTerminal, tokenize, processRun, expand, workspaceName, normalize };