@libtmux/workspace-cli 0.1.0-alpha.11

package/dist/main-gh3pafqb.js

@@ -0,0 +1,369 @@
+// src/output.ts
+class CliError extends Error {
+  code;
+  exitCode;
+  constructor(code, message, exitCode = 1) {
+    super(message);
+    this.code = code;
+    this.exitCode = exitCode;
+  }
+}
+
+class OutputClosedError extends Error {
+}
+async function write(stream, text, signal) {
+  signal?.throwIfAborted();
+  if (stream.destroyed || stream.writableEnded)
+    throw stream.errored ?? new OutputClosedError("Output stream closed");
+  await new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (error) => {
+      stream.off("close", closed);
+      signal?.removeEventListener("abort", aborted);
+      if (error) {
+        setImmediate(() => {
+          stream.off("error", failed);
+        });
+      } else {
+        stream.off("error", failed);
+      }
+      if (settled)
+        return;
+      settled = true;
+      if (error)
+        reject(error);
+      else
+        resolve();
+    };
+    const failed = (error) => {
+      finish(error);
+    };
+    const closed = () => {
+      finish(new OutputClosedError("Output stream closed before the write completed"));
+    };
+    const aborted = () => {
+      if (settled)
+        return;
+      settled = true;
+      signal?.removeEventListener("abort", aborted);
+      reject(signal?.reason);
+    };
+    stream.once("error", failed);
+    stream.once("close", closed);
+    signal?.addEventListener("abort", aborted, { once: true });
+    try {
+      stream.write(text, (error) => {
+        finish(error);
+      });
+    } catch (error) {
+      finish(error);
+    }
+  });
+}
+function colorEnabled(mode, choice, env, tty) {
+  if (mode !== "human" || env.NO_COLOR || choice === "never")
+    return false;
+  if (choice === "always")
+    return true;
+  if (env.FORCE_COLOR === "0")
+    return false;
+  if (env.FORCE_COLOR)
+    return true;
+  if (env.CLICOLOR_FORCE && env.CLICOLOR_FORCE !== "0")
+    return true;
+  return env.CLICOLOR === "0" ? false : tty;
+}
+var styles = {
+  heading: "1;36",
+  subject: "1;35",
+  info: "36",
+  success: "32",
+  warning: "33",
+  error: "31",
+  secondary: "2"
+};
+function styled(role, value, color) {
+  const text = String(value).replace(/[\u0000-\u001f\u007f]/g, (character) => JSON.stringify(character).slice(1, -1));
+  return color ? `\x1B[${styles[role]}m${text}\x1B[0m` : text;
+}
+async function emitJson(stream, value, pretty = false, signal) {
+  await write(stream, JSON.stringify(value, null, pretty ? 2 : undefined) + `
+`, signal);
+}
+
+class OperationOutput {
+  sequence = 0;
+  finished = false;
+  command;
+  mode;
+  stdout;
+  signal;
+  get isFinished() {
+    return this.finished;
+  }
+  observe;
+  constructor(command, mode, stdout, signal, observe) {
+    this.command = command;
+    this.mode = mode;
+    this.stdout = stdout;
+    this.signal = signal;
+    if (observe !== undefined)
+      this.observe = observe;
+  }
+  async event(event, data = {}) {
+    if (this.finished)
+      throw new Error("Cannot emit after the terminal result");
+    const terminal = ["completed", "failed"].includes(event);
+    if (!terminal)
+      this.signal?.throwIfAborted();
+    const handled = !this.signal?.aborted && await this.observe?.(event, data);
+    if (terminal)
+      this.finished = true;
+    if (this.mode === "ndjson")
+      await emitJson(this.stdout, {
+        schema_version: 1,
+        command: this.command,
+        event,
+        sequence: ++this.sequence,
+        ...data
+      }, false, this.completionSignal(terminal));
+    return handled === true;
+  }
+  async result(data) {
+    const event = data.status === "error" || data.status === "partial" ? "failed" : "completed";
+    if (this.mode === "ndjson") {
+      await this.event(event, data);
+      return;
+    }
+    if (this.finished)
+      throw new Error("Cannot emit after the terminal result");
+    if (!this.signal?.aborted)
+      await this.observe?.(event, data);
+    this.finished = true;
+    if (this.mode === "json")
+      await emitJson(this.stdout, { schema_version: 1, command: this.command, ...data }, false, this.completionSignal(true));
+  }
+  completionSignal(terminal) {
+    return terminal && this.signal?.aborted ? AbortSignal.timeout(100) : this.signal;
+  }
+}
+
+// src/documents.ts
+import { randomUUID } from "node:crypto";
+import { link, open, readFile, readdir, rename, stat, unlink } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, extname, isAbsolute, join, resolve, sep } from "node:path";
+var extensions = [".yaml", ".yml", ".json"];
+function home(context) {
+  return context.env.HOME ?? context.env.USERPROFILE ?? homedir();
+}
+function expandPath(path, context) {
+  return path === "~" ? home(context) : path.startsWith("~/") ? join(home(context), path.slice(2)) : path;
+}
+function privatePath(path, context) {
+  const base = home(context);
+  return path === base ? "~" : path.startsWith(base + sep) ? "~" + path.slice(base.length) : path;
+}
+function mapping(value, label = "workspace") {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${label} must be a mapping`);
+  return value;
+}
+function scalarText(value) {
+  if (typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value))
+    return String(value);
+  throw new Error("Expected a string, boolean, or finite number");
+}
+function sequence(value, label) {
+  if (!Array.isArray(value))
+    throw new Error(`${label} must be a list`);
+  return value;
+}
+function ambiguousScalar(text, yamlModule) {
+  if (text.includes(`
+`))
+    return false;
+  if (text === "")
+    return true;
+  const resolves = (options) => {
+    try {
+      return yamlModule.parse(text, options) !== text;
+    } catch {
+      return true;
+    }
+  };
+  return resolves() || resolves({ version: "1.1" });
+}
+function stringifyYaml(document, yamlModule) {
+  const doc = new yamlModule.Document(document);
+  yamlModule.visit(doc, {
+    Scalar(_key, node) {
+      if (typeof node.value === "string" && ambiguousScalar(node.value, yamlModule))
+        node.type = yamlModule.Scalar.QUOTE_DOUBLE;
+    }
+  });
+  return doc.toString();
+}
+async function info(path) {
+  try {
+    return await stat(path);
+  } catch (error) {
+    if (["ENOENT", "ENOTDIR"].includes(error.code ?? ""))
+      return;
+    throw error;
+  }
+}
+function jsonData(value, active = new Set) {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return;
+  if (typeof value === "number" && Number.isFinite(value))
+    return;
+  if (typeof value !== "object" || active.has(value) || value instanceof Date)
+    throw new Error("Workspace must contain finite, acyclic JSON values");
+  active.add(value);
+  for (const entry of Object.values(value))
+    jsonData(entry, active);
+  active.delete(value);
+}
+async function readDocument(path) {
+  const source = await readFile(path, "utf8");
+  const extension = extname(path).toLowerCase();
+  if (!extensions.includes(extension))
+    throw new Error(`Unsupported workspace extension: ${extension}`);
+  const value = extension === ".json" ? JSON.parse(source) : (await import("./index-0j386v40.js")).parse(source, { merge: true, maxAliasCount: 100 });
+  jsonData(value);
+  return mapping(value);
+}
+async function saveDocument(document, path, format, force, signal) {
+  signal?.throwIfAborted();
+  jsonData(document);
+  if (!["json", "yaml"].includes(format))
+    throw new Error(`Unsupported workspace format: ${format}`);
+  const contents = format === "json" ? JSON.stringify(document, null, 2) + `
+` : stringifyYaml(document, await import("./index-0j386v40.js"));
+  signal?.throwIfAborted();
+  const temporary = join(dirname(path), `.${basename(path)}.${randomUUID()}.tmp`);
+  try {
+    const handle = await open(temporary, "wx", 384);
+    try {
+      await handle.writeFile(contents, { signal });
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    signal?.throwIfAborted();
+    if (force)
+      await rename(temporary, path);
+    else {
+      try {
+        await link(temporary, path);
+      } catch (error) {
+        if (error.code === "EEXIST")
+          throw new CliError("destination_exists", `Destination exists: ${path}; use --force to replace it`);
+        throw error;
+      }
+    }
+  } finally {
+    await unlink(temporary).catch((error) => {
+      if (error.code !== "ENOENT")
+        throw error;
+    });
+  }
+}
+async function directories(context) {
+  const entries = [];
+  const candidates = [];
+  if (context.env.TMUXP_CONFIGDIR !== undefined)
+    candidates.push([context.env.TMUXP_CONFIGDIR, "$TMUXP_CONFIGDIR"]);
+  candidates.push(context.env.XDG_CONFIG_HOME !== undefined ? [join(context.env.XDG_CONFIG_HOME, "tmuxp"), "$XDG_CONFIG_HOME/tmuxp"] : ["~/.config/tmuxp", "XDG default"]);
+  candidates.push(["~/.tmuxp", "Legacy"]);
+  for (const [path, source] of candidates) {
+    const expanded = resolve(context.cwd, expandPath(path, context));
+    if (entries.some((entry) => entry.path === expanded))
+      continue;
+    entries.push({
+      path: expanded,
+      source,
+      exists: (await info(expanded))?.isDirectory() ?? false
+    });
+  }
+  const active = entries.find((entry) => entry.exists)?.path ?? entries.at(-1).path;
+  return { entries, active };
+}
+async function resolveWorkspace(input, context, workspaceDirectory) {
+  const expanded = expandPath(input, context);
+  const pureName = !isAbsolute(expanded) && dirname(expanded) === "." && !expanded.includes(sep) && !extname(expanded) && ![".", ""].includes(expanded);
+  const target = resolve(context.cwd, expanded);
+  let candidates;
+  if (pureName) {
+    const active = workspaceDirectory ?? (await directories(context)).active;
+    candidates = extensions.map((extension) => resolve(context.cwd, active, expanded + extension));
+  } else if ((await info(target))?.isDirectory() || !extname(expanded)) {
+    candidates = extensions.map((extension) => join(target, `.tmuxp${extension}`));
+  } else
+    candidates = [target];
+  for (const candidate of candidates)
+    if ((await info(candidate))?.isFile())
+      return candidate;
+  throw new CliError("workspace_not_found", `Workspace not found: ${input}`);
+}
+async function discover(context, full = false) {
+  const files = [];
+  let current = resolve(context.cwd);
+  while (true) {
+    for (const extension of extensions) {
+      const path = join(current, `.tmuxp${extension}`);
+      if ((await info(path))?.isFile()) {
+        files.push({ path, source: "local" });
+        break;
+      }
+    }
+    const parent = dirname(current);
+    if (current === parent || current === resolve(home(context)))
+      break;
+    current = parent;
+  }
+  const { entries, active } = await directories(context);
+  const global_workspace_dirs = [];
+  for (const entry of entries) {
+    const names = entry.exists ? (await readdir(entry.path)).sort() : [];
+    const eligible = names.filter((name) => !name.startsWith(".") && extensions.includes(extname(name).toLowerCase()));
+    global_workspace_dirs.push({
+      ...entry,
+      path: privatePath(entry.path, context),
+      workspace_count: eligible.length,
+      active: entry.path === active
+    });
+    if (entry.path === active)
+      for (const name of eligible) {
+        const path = join(entry.path, name);
+        if ((await info(path))?.isFile())
+          files.push({ path, source: "global" });
+      }
+  }
+  const workspaces = [];
+  for (const file of files) {
+    const details = await info(file.path);
+    if (!details)
+      continue;
+    let config = null;
+    try {
+      config = await readDocument(file.path);
+    } catch {}
+    const record = {
+      name: basename(file.path, extname(file.path)),
+      path: privatePath(file.path, context),
+      format: extname(file.path).toLowerCase() === ".json" ? "json" : "yaml",
+      size: details.size,
+      mtime: details.mtime.toISOString(),
+      session_name: config?.session_name ?? null,
+      source: file.source
+    };
+    if (full)
+      record.config = config;
+    workspaces.push(record);
+  }
+  return { workspaces, global_workspace_dirs };
+}
+
+export { CliError, write, colorEnabled, styled, emitJson, OperationOutput, home, expandPath, privatePath, mapping, scalarText, sequence, readDocument, saveDocument, resolveWorkspace, discover };

package/dist/main.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import {
+  __require
+} from "./main-1de529jm.js";
+
+// src/main.ts
+if (process.env.NO_COLOR)
+  delete process.env.FORCE_COLOR;
+else if (process.env.NO_COLOR === "")
+  delete process.env.NO_COLOR;
+var controller = new AbortController;
+var pipeClosed = false;
+process.once("SIGINT", () => controller.abort());
+process.once("SIGTERM", () => controller.abort());
+for (const stream of [process.stdout, process.stderr])
+  stream.on("error", (error) => {
+    if (error.code === "EPIPE") {
+      pipeClosed = true;
+      controller.abort();
+      process.exitCode = 141;
+    } else
+      throw error;
+  });
+var { run } = await import("./app-w7cbtf0n.js");
+var exitCode = await run(process.argv.slice(2), {
+  cwd: process.cwd(),
+  env: process.env,
+  stdout: process.stdout,
+  stderr: process.stderr,
+  stdin: process.stdin,
+  signal: controller.signal
+});
+process.exitCode = pipeClosed ? 141 : controller.signal.aborted ? 130 : exitCode;
+if (controller.signal.aborted)
+  process.exit(process.exitCode);