@libtmux/workspace-cli 0.1.0-alpha.11

package/dist/completions-2a9fqwq3.js

@@ -0,0 +1,282 @@
+import"./main-1de529jm.js";
+
+// src/completions.ts
+var quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+var fishQuote = (value) => `'${value.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+function entries(catalog) {
+  return catalog.commands.flatMap((command, node) => {
+    const flags = (option) => [option.short, option.long].filter((flag) => !!flag);
+    return [
+      ...command.options.map((option) => ({
+        keys: flags(option).map((flag) => `${node}:${flag}`),
+        kind: option.value,
+        ...option
+      })),
+      ...command.arguments.map((argument, index) => ({
+        keys: [`${node}:@${index}`],
+        kind: "argument",
+        ...argument
+      })),
+      ...command.subcommands.map((name) => ({
+        keys: [`${node}:>${name}`],
+        kind: "command",
+        next: catalog.commands.findIndex((candidate) => candidate.path.join(" ") === [...command.path, name].join(" "))
+      })),
+      { keys: [`${node}:flags`], kind: "flags", choices: command.options.flatMap(flags) },
+      { keys: [`${node}:commands`], kind: "commands", choices: command.subcommands }
+    ];
+  });
+}
+function shScript(catalog, shell, name) {
+  const lookup = entries(catalog).map((entry) => `    ${entry.keys.map(quote).join("|")}) kind=${quote(entry.kind)}; files=${quote(entry.completion ?? "")}; many=${entry.variadic ? 1 : 0}; next=${entry.next ?? -1}; candidates=(${(entry.choices ?? []).map(quote).join(" ")});;`).join(`
+`);
+  const setup = shell === "bash" ? `local -a words=()
+  local raw line=$COMP_LINE join_next=0 end=-1 index trim=
+  for ((index=0; index<=COMP_CWORD; index++)); do
+    raw=\${COMP_WORDS[index]}
+    if [[ -n $raw && $raw != *[!=:]* ]]; then
+      if [[ $end -lt 1 || $line == [[:blank:]]* ]]; then end=$((end + 1)); fi
+      words[end]=\${words[end]}$raw
+      line=\${line#*"$raw"}
+      join_next=1
+      [[ $line == [[:blank:]]* ]] && join_next=0
+    else
+      [[ $join_next == 1 ]] || end=$((end + 1))
+      words[end]=\${words[end]}$raw
+      line=\${line#*"$raw"}
+      join_next=0
+    fi
+  done
+  raw=\${COMP_WORDS[COMP_CWORD]}
+  if [[ -n $raw && $raw != *[!=:]* ]]; then trim=\${words[end]}; else trim=\${words[end]%"$raw"}; fi
+  COMPREPLY=()` : `setopt localoptions KSH_ARRAYS
+  local -a words=("\${words[@]}")
+  local end=$((CURRENT - 1))`;
+  const emit = shell === "bash" ? `for candidate in "\${candidates[@]}"; do
+    if [[ $candidate == "$cur"* ]]; then candidate=$prefix$candidate; COMPREPLY+=("\${candidate#"$trim"}"); fi
+  done
+  if [[ -n $files ]]; then
+    local action=file
+    [[ $files == directory ]] && action=directory
+    while IFS= read -r candidate; do candidate=$prefix$candidate; COMPREPLY+=("\${candidate#"$trim"}"); done < <(compgen -A "$action" -- "$cur")
+  fi` : `unsetopt KSH_ARRAYS
+  if (( \${#candidates[@]} )); then compadd -p "$prefix" -- "\${candidates[@]}"; fi
+  if [[ -n $files ]]; then
+    [[ -z $prefix ]] || compset -P "$prefix"
+    if [[ $files == directory ]]; then _files -/; else _files; fi
+  fi`;
+  return `${shell === "zsh" ? `#compdef ${catalog.program}
+` : `# Bash 3.2 or newer.
+`}${name}_lookup() {
+  kind=; files=; many=0; next=-1; candidates=()
+  case "$node:$1" in
+${lookup}
+  esac
+}
+${name}() {
+  ${setup}
+  local node=0 pos=0 stop=0 pending= kind= files= many=0 next=-1
+  local w key tail prefix= cur candidate i
+  local -a candidates=()
+  for ((i=1; i<end; i++)); do
+    w=\${words[i]}
+    if [[ -n $pending ]]; then
+      if [[ $pending == required || $w != -* || $w == - ]]; then
+        [[ $many == 1 ]] && pending=optional || pending=
+        continue
+      fi
+      pending=
+    fi
+    if [[ $stop == 0 && $w == -- ]]; then stop=1; continue; fi
+    if [[ $stop == 0 && $w == --* ]]; then
+      key=\${w%%=*}; ${name}_lookup "$key"
+      if [[ $kind == required || $kind == optional ]]; then
+        if [[ $w == *=* ]]; then [[ $many == 1 ]] && pending=optional; else pending=$kind; fi
+      fi
+      continue
+    fi
+    if [[ $stop == 0 && $w == -?* ]]; then
+      tail=\${w#-}
+      while [[ -n $tail ]]; do
+        key=-\${tail:0:1}; tail=\${tail:1}; ${name}_lookup "$key"
+        if [[ $kind == required || $kind == optional ]]; then
+          if [[ -n $tail ]]; then [[ $many == 1 ]] && pending=optional; else pending=$kind; fi
+          break
+        fi
+      done
+      continue
+    fi
+    if [[ $stop == 0 && $pos == 0 ]]; then
+      ${name}_lookup ">$w"
+      if [[ $next -ge 0 ]]; then node=$next; pos=0; continue; fi
+    fi
+    ${name}_lookup "@$pos"
+    [[ $many == 1 ]] || pos=$((pos + 1))
+  done
+  cur=\${words[end]}
+  if [[ $pending == optional && $cur == -?* ]]; then pending=; fi
+  if [[ -z $pending && $stop == 0 && $cur == --*=* ]]; then
+    key=\${cur%%=*}; ${name}_lookup "$key"
+    if [[ $kind == required || $kind == optional ]]; then prefix=$key=; cur=\${cur#*=}; pending=$kind; fi
+  elif [[ -z $pending && $stop == 0 && $cur == -?* && $cur != --* ]]; then
+    tail=\${cur#-}; prefix=-
+    while [[ -n $tail ]]; do
+      key=-\${tail:0:1}; prefix=$prefix\${tail:0:1}; tail=\${tail:1}; ${name}_lookup "$key"
+      if [[ $kind == required || $kind == optional ]]; then cur=$tail; pending=$kind; break; fi
+    done
+    [[ -n $pending ]] || prefix=
+  fi
+  if [[ -z $pending ]]; then
+    if [[ $stop == 0 && $cur == -* ]]; then
+      ${name}_lookup flags
+    else
+      ${name}_lookup "@$pos"
+      if [[ $stop == 0 && $pos == 0 ]]; then
+        local -a positional=("\${candidates[@]}")
+        local positional_files=$files
+        ${name}_lookup commands
+        candidates+=("\${positional[@]}"); files=$positional_files
+      fi
+    fi
+  fi
+  ${emit}
+  return 0
+}
+${shell === "bash" ? `complete -o filenames -F ${name} ${quote(catalog.program)}` : `compdef ${name} ${quote(catalog.program)}
+if [[ \${funcstack[1]} == ${quote("_" + catalog.program)} ]]; then ${name}; fi`}
+`;
+}
+function fishScript(catalog, name) {
+  const lookup = entries(catalog).map((entry) => `    case ${entry.keys.map(fishQuote).join(" ")}
+      printf '%s\\n' ${[entry.kind, entry.completion ?? "_", entry.variadic ? "1" : "0", String(entry.next ?? -1), ...entry.choices ?? []].map(fishQuote).join(" ")}`).join(`
+`);
+  return `function ${name}_lookup
+  switch "$argv[1]:$argv[2]"
+${lookup}
+    case '*'
+      printf '%s\\n' _ _ 0 -1
+  end
+end
+function ${name}
+  set -l words (commandline -opc)
+  set -l cur (string unescape -- (commandline -ct))
+  set -l node 0
+  set -l pos 0
+  set -l stop 0
+  set -l pending
+  set -l info _ _ 0 -1
+  set -l prefix ''
+  for w in $words[2..-1]
+    if test -n "$pending"
+      if test "$pending" = required; or not string match -rq -- '^-.' "$w"
+        set pending
+        if test "$info[3]" = 1; set pending optional; end
+        continue
+      end
+      set pending
+    end
+    if test $stop = 0; and test "$w" = --
+      set stop 1
+      continue
+    end
+    if test $stop = 0; and string match -q -- '--*' "$w"
+      set -l key (string split -m 1 = -- "$w")[1]
+      set info (${name}_lookup $node "$key")
+      if contains -- "$info[1]" required optional
+        if string match -q '*=*' -- "$w"
+          if test "$info[3]" = 1; set pending optional; end
+        else
+          set pending $info[1]
+        end
+      end
+      continue
+    end
+    if test $stop = 0; and string match -rq -- '^-.' "$w"
+      set -l tail (string sub -s 2 -- "$w")
+      while test -n "$tail"
+        set -l key -(string sub -l 1 -- "$tail")
+        set tail (string sub -s 2 -- "$tail")
+        set info (${name}_lookup $node "$key")
+        if contains -- "$info[1]" required optional
+          if test -n "$tail"
+            if test "$info[3]" = 1; set pending optional; end
+          else
+            set pending $info[1]
+          end
+          break
+        end
+      end
+      continue
+    end
+    if test $stop = 0; and test $pos = 0
+      set info (${name}_lookup $node ">$w")
+      if test "$info[4]" -ge 0
+        set node $info[4]
+        set pos 0
+        continue
+      end
+    end
+    set info (${name}_lookup $node "@$pos")
+    if test "$info[3]" != 1; set pos (math $pos + 1); end
+  end
+  if test "$pending" = optional; and string match -rq -- '^-.' "$cur"; set pending; end
+  if test -z "$pending"; and test $stop = 0; and string match -q -- '--*=*' "$cur"
+    set -l parts (string split -m 1 = -- "$cur")
+    set info (${name}_lookup $node "$parts[1]")
+    if contains -- "$info[1]" required optional
+      set prefix "$parts[1]="
+      set cur "$parts[2]"
+      set pending $info[1]
+    end
+  else if test -z "$pending"; and test $stop = 0; and string match -rq -- '^-.' "$cur"; and not string match -q -- '--*' "$cur"
+    set -l tail (string sub -s 2 -- "$cur")
+    set prefix -
+    while test -n "$tail"
+      set -l char (string sub -l 1 -- "$tail")
+      set prefix "$prefix$char"
+      set tail (string sub -s 2 -- "$tail")
+      set info (${name}_lookup $node "-$char")
+      if contains -- "$info[1]" required optional
+        set cur "$tail"
+        set pending $info[1]
+        break
+      end
+    end
+    if test -z "$pending"; set prefix ''; end
+  end
+  if test -z "$pending"
+    if test $stop = 0; and string match -q -- '-*' "$cur"
+      set info (${name}_lookup $node flags)
+    else
+      set info (${name}_lookup $node "@$pos")
+      if test $stop = 0; and test $pos = 0
+        set -l children (${name}_lookup $node commands)
+        set -a info $children[5..-1]
+      end
+    end
+  end
+  for candidate in $info[5..-1]
+    if test (string sub -l (string length -- "$cur") -- "$candidate") = "$cur"
+      printf '%s\\n' "$prefix$candidate"
+    end
+  end
+  if contains -- "$info[2]" file directory
+    set -l paths (__fish_complete_path (string escape -- "$cur"))
+    for path in $paths
+      set -l value (string split -m 1 \\t -- "$path")[1]
+      if test "$info[2]" = file; or string match -q '*/' -- "$value"
+        printf '%s\\n' "$prefix$value"
+      end
+    end
+  end
+end
+complete -c ${fishQuote(catalog.program)} -f -a '(${name})'
+`;
+}
+function completionScript(catalog, shell) {
+  const name = `_${catalog.program.replaceAll(/[^a-zA-Z0-9_]/g, "_")}`;
+  return shell === "fish" ? fishScript(catalog, name) : shScript(catalog, shell, name);
+}
+export {
+  completionScript
+};

package/dist/extensions-8v6mfszj.js

@@ -0,0 +1,268 @@
+import {
+  expand,
+  normalize,
+  processRun,
+  workspaceName
+} from "./main-c8atq2pj.js";
+import {
+  CliError,
+  privatePath,
+  write
+} from "./main-gh3pafqb.js";
+import"./main-1de529jm.js";
+
+// src/extensions.ts
+import {
+  TmuxCommandError
+} from "libtmux";
+import { constants } from "node:fs";
+import { mkdtemp, open, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+async function extensionPlan(data, path, context, append, override) {
+  const plugins = data.plugins ?? [];
+  if (!Array.isArray(plugins) || plugins.some((item) => typeof item !== "string" || !/^\w+(?:\.\w+)+$/.test(item)))
+    throw new CliError("invalid_workspace", "plugins must be an array of Python dotted class names");
+  const builder = data.workspace_builder ?? "";
+  if (typeof builder !== "string" || builder.includes("\x00"))
+    throw new CliError("invalid_workspace", "workspace_builder must be a string");
+  const rawPaths = data.workspace_builder_paths ?? [];
+  const paths = typeof rawPaths === "string" ? [rawPaths] : rawPaths;
+  if (!Array.isArray(paths) || paths.some((entry) => typeof entry !== "string" || entry.includes("\x00")))
+    throw new CliError("invalid_workspace", "workspace_builder_paths must contain directory paths");
+  for (const entry of paths) {
+    const directory = resolve(dirname(path), expand(entry, context));
+    if (!(await stat(directory).catch(() => {
+      return;
+    }))?.isDirectory())
+      throw new CliError("invalid_workspace", `Builder import directory does not exist: ${privatePath(directory, context)}`);
+  }
+  if (!plugins.length && !builder.trim())
+    return;
+  if (append && Object.hasOwn(data, "before_script"))
+    throw new CliError("invalid_workspace", "Python extension append cannot use before_script; run the script separately");
+  const name = workspaceName(data, context, override);
+  if (!builder.trim())
+    normalize(data, path, context, override, { allowExtensionFields: true });
+  const config = structuredClone(data);
+  if (!builder.trim())
+    delete config.workspace_builder;
+  return { data: config, name };
+}
+var runtimeCheck = `
+from importlib.metadata import version
+import inspect
+if version("tmuxp") != "1.74.0":
+    raise RuntimeError("tmuxp 1.74.0 is required")
+from libtmux import Server
+from tmuxp.workspace.builder import prepended_sys_path, resolve_builder_class, resolve_builder_paths
+if "tmux_bin" not in inspect.signature(Server).parameters:
+    raise RuntimeError("libtmux Server must accept tmux_bin")
+`;
+async function extensionRuntime(context) {
+  const python = context.env.TMUX_WORKSPACE_PYTHON || "python3";
+  const timeout = AbortSignal.timeout(1e4);
+  try {
+    const result = await processRun([python, "-c", runtimeCheck], {
+      cwd: context.cwd,
+      env: context.env,
+      signal: context.signal ? AbortSignal.any([context.signal, timeout]) : timeout
+    });
+    if (result.code !== 0)
+      throw new Error(result.stderr.trim());
+  } catch (error) {
+    context.signal?.throwIfAborted();
+    throw new CliError("script_failed", `Python extensions require tmuxp 1.74.0 and its builder registry: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return python;
+}
+var adapter = String.raw`
+import importlib
+import json
+import os
+import re
+import shutil
+import sys
+from pathlib import Path
+
+request = json.load(sys.stdin)
+executable = shutil.which(request["server"]["tmux_bin"])
+if executable is None:
+    raise RuntimeError("selected tmux executable was not found")
+binary = Path(request["state_path"]).parent / "tmux"
+request["server"]["tmux_bin"] = str(Path(executable).resolve())
+binary.symlink_to(request["server"]["tmux_bin"])
+for key in ("socket_path", "config_file"):
+    if request["server"].get(key):
+        request["server"][key] = str(Path(request["server"][key]).absolute())
+os.environ["PATH"] = str(binary.parent) + os.pathsep + os.environ.get("PATH", "")
+
+from libtmux import Server
+from tmuxp.workspace import loader
+from tmuxp.workspace.builder import prepended_sys_path, resolve_builder_class, resolve_builder_paths
+
+config = request["config"]
+custom = bool((config.get("workspace_builder") or "").strip())
+config["session_name"] = request["session_name"]
+config = loader.expand(config, cwd=str(Path(request["source"]).parent))
+if not custom or "windows" in config:
+    config = loader.trickle(config)
+config["session_name"] = request["session_name"]
+server = Server(**request["server"])
+borrowed = request.get("borrowed")
+builder = None
+
+def authenticate():
+    if borrowed is None:
+        return None
+    identity = borrowed["daemon"]
+    expected = f"{identity['pid']}:{identity['startTime']}"
+    if server.cmd("display-message", "-p", "#{pid}:#{start_time}").stdout != [expected]:
+        raise RuntimeError("authenticated append daemon changed")
+    session = server.sessions.get(session_id=borrowed["session_id"], default=None)
+    if session is None:
+        raise RuntimeError("authenticated append session disappeared")
+    return session
+
+try:
+    authenticate()
+    with prepended_sys_path(resolve_builder_paths(config, request["source"])):
+        plugins = []
+        for target in config.get("plugins") or []:
+            module, _, name = target.rpartition(".")
+            plugins.append(getattr(importlib.import_module(module), name)())
+        builder = resolve_builder_class(config)(session_config=config, server=server, plugins=plugins)
+        session = authenticate()
+        builder.build(session=session, append=session is not None)
+        for plugin in builder.plugins:
+            plugin.before_script(builder.session)
+finally:
+    session_id = borrowed["session_id"] if borrowed is not None else None
+    if builder is not None:
+        try:
+            session_id = builder.session.id
+        except Exception:
+            pass
+    if not isinstance(session_id, str) or not re.fullmatch(r"\$\d+", session_id):
+        session_id = None
+    Path(request["state_path"]).write_text(json.dumps({"session_id": session_id}), encoding="utf-8")
+`;
+async function sessionHint(path) {
+  const file = await open(path, constants.O_RDONLY | constants.O_NONBLOCK | constants.O_NOFOLLOW);
+  try {
+    if (!(await file.stat()).isFile())
+      throw new Error("Extension state is not a regular file");
+    const buffer = Buffer.alloc(4097);
+    const { bytesRead } = await file.read(buffer);
+    if (bytesRead > 4096)
+      throw new Error("Extension state exceeds 4 KiB");
+    const state = JSON.parse(buffer.subarray(0, bytesRead).toString("utf8"));
+    const id = state && typeof state === "object" && "session_id" in state ? state.session_id : undefined;
+    if (id === null)
+      return;
+    if (typeof id !== "string" || !/^\$\d+$/.test(id))
+      throw new Error("Invalid extension session ID");
+    return id;
+  } finally {
+    await file.close();
+  }
+}
+function sameDaemon(left, right) {
+  return left.pid === right.pid && left.startTime === right.startTime;
+}
+async function baseline(server, signal) {
+  try {
+    await server.cmd("list-sessions", [], signal ? { signal } : {});
+  } catch (error) {
+    if (error instanceof TmuxCommandError && error.exitCode === 1 && !error.stdout.length && error.stderr.length === 1 && /^(?:no server running on .+|error connecting to .+ \((?:No such file or directory|Connection refused)\))$/.test(error.stderr[0]))
+      return;
+    throw error;
+  }
+  return server.snapshot(signal ? { signal } : {});
+}
+async function buildExtension(python, spec, source, server, context, output, result, borrowed) {
+  const before = await baseline(server, context.signal);
+  if (borrowed && (!before || !sameDaemon(borrowed.daemon, before.daemonIdentity) || !before.sessions.toArray().some((session2) => session2.id === borrowed.session.id)))
+    throw new CliError("tmux_failed", "The authenticated append session or daemon changed");
+  const existing = !borrowed && before?.sessions.toArray().find((session2) => session2.name === spec.name);
+  if (existing) {
+    result.reused = true;
+    return existing;
+  }
+  const directory = await mkdtemp(join(tmpdir(), "ltx-workspace-extension-"));
+  const statePath = join(directory, "state.json");
+  result.stage = "extension-build";
+  result.effects_scope = "observed";
+  result.observed_windows = [];
+  result.observed_panes = [];
+  let session;
+  let failed;
+  try {
+    await output.event("extension-started", { input_index: result.input_index });
+    result.effects_unknown = true;
+    try {
+      result.script_output = await processRun([python, "-u", "-c", adapter], {
+        cwd: context.cwd,
+        env: { ...context.env, TMUX: undefined, TMUX_PANE: undefined },
+        ...context.signal ? { signal: context.signal } : {},
+        input: JSON.stringify({
+          config: spec.data,
+          source,
+          session_name: spec.name,
+          state_path: statePath,
+          server: {
+            tmux_bin: server.tmuxBin,
+            socket_path: server.socketPath,
+            socket_name: server.socketName,
+            config_file: server.configFile,
+            colors: server.colors
+          },
+          ...borrowed ? { borrowed: { session_id: borrowed.session.id, daemon: borrowed.daemon } } : {}
+        }),
+        output: async (stream, text) => {
+          const handled = await output.event("script-output", {
+            input_index: result.input_index,
+            stream,
+            text
+          });
+          if (output.mode === "human" && !handled)
+            await write(context[stream], text, context.signal);
+        }
+      });
+      if (result.script_output.code !== 0)
+        throw new CliError("script_failed", `Python extension exited with status ${result.script_output.code}`);
+    } catch (error) {
+      failed = error;
+    }
+    try {
+      const after = await server.snapshot({ signal: AbortSignal.timeout(1e4) });
+      if (before && !sameDaemon(before.daemonIdentity, after.daemonIdentity))
+        throw new Error("Daemon changed during extension execution");
+      const oldWindows = new Set(before?.windows.toArray().map((window) => window.id));
+      const oldPanes = new Set(before?.panes.toArray().map((pane) => pane.id));
+      result.observed_windows = after.windows.toArray().map((window) => window.id).filter((id) => !oldWindows.has(id));
+      result.observed_panes = after.panes.toArray().map((pane) => pane.id).filter((id) => !oldPanes.has(id));
+      const hint = borrowed?.session.id ?? await sessionHint(statePath);
+      session = after.sessions.toArray().find((item) => item.id === hint);
+      if (!session)
+        throw new Error("Extension did not identify a surviving session");
+      result.session_id = session.id;
+      result.session_name = session.name ?? spec.name;
+    } catch (error) {
+      result.observation_error = error instanceof Error ? error.message : String(error);
+      failed ??= new CliError("tmux_failed", result.observation_error);
+    }
+    if (failed !== undefined)
+      throw failed;
+    result.completed_stages.push("extension-built");
+    await output.event("extension-completed", { input_index: result.input_index });
+    return session;
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+}
+export {
+  buildExtension,
+  extensionPlan,
+  extensionRuntime
+};