@libtmux/workspace-cli 0.1.0-alpha.11

package/dist/app-w7cbtf0n.js

@@ -0,0 +1,747 @@
+import {
+  expand,
+  normalize,
+  processRun,
+  tokenize
+} from "./main-c8atq2pj.js";
+import {
+  CliError,
+  OperationOutput,
+  colorEnabled,
+  discover,
+  emitJson,
+  expandPath,
+  home,
+  mapping,
+  privatePath,
+  readDocument,
+  resolveWorkspace,
+  saveDocument,
+  scalarText,
+  sequence,
+  styled,
+  write
+} from "./main-gh3pafqb.js";
+import {
+  CommanderError,
+  createParser,
+  package_default
+} from "./main-bfnr2nkj.js";
+import {
+  __require
+} from "./main-1de529jm.js";
+
+// src/app.ts
+import { basename, dirname, extname, join as join2, resolve as resolve3 } from "node:path";
+
+// src/imports.ts
+import { join, resolve } from "node:path";
+function fields(value, allowed, path) {
+  for (const key of Object.keys(value))
+    if (!allowed.includes(key))
+      throw new Error(`Unsupported import field: ${path}.${key}`);
+}
+function alias(value, current, legacy, path) {
+  if (value[current] !== undefined && value[current] !== null && value[legacy] !== undefined && value[legacy] !== null)
+    throw new Error(`Choose ${path}.${current} or ${path}.${legacy}`);
+  return value[current] ?? value[legacy];
+}
+function strings(value, path) {
+  if (value === undefined || value === null)
+    return [];
+  const entries = typeof value === "string" ? [value] : sequence(value, path);
+  return entries.map((entry) => {
+    if (typeof entry !== "string")
+      throw new Error(`${path} must contain strings`);
+    return entry;
+  });
+}
+function commands(value, path, separator) {
+  const entries = strings(value, path);
+  return (separator && entries.length ? [entries.join(separator)] : entries).map((cmd) => ({
+    cmd
+  }));
+}
+function directory(value, base, context) {
+  if (value === undefined || value === null)
+    return base;
+  if (typeof value !== "string")
+    throw new Error("Imported root must be a string");
+  return resolve(base, expand(value, context));
+}
+function copy(source, target, names) {
+  for (const name of names)
+    if (source[name] !== undefined)
+      target[name] = structuredClone(source[name]);
+}
+function focusFirst(items) {
+  const selected = items.findIndex((item) => item.focus === true);
+  for (const [index, item] of items.entries()) {
+    if (item.focus !== undefined && typeof item.focus !== "boolean")
+      throw new Error("Imported focus must be boolean");
+    if (index === (selected < 0 ? 0 : selected))
+      item.focus = true;
+    else
+      delete item.focus;
+  }
+}
+function teamocil(source, context, fallbackName) {
+  if (source.session !== undefined)
+    fields(source, ["session"], "teamocil");
+  const session = mapping(source.session ?? source, "teamocil session");
+  fields(session, ["name", "root", "windows", "description"], "session");
+  const root = directory(session.root, context.cwd, context);
+  const windows = sequence(session.windows, "session.windows").map((value, ordinal) => {
+    const path = `session.windows[${ordinal}]`;
+    const window = mapping(value, path);
+    fields(window, ["name", "root", "layout", "focus", "options", "panes", "splits", "description"], path);
+    const result2 = { window_name: window.name ?? null };
+    copy(window, result2, ["layout", "focus", "options", "description"]);
+    if (window.root !== undefined)
+      result2.start_directory = directory(window.root, root, context);
+    const panes = sequence(alias(window, "panes", "splits", path) ?? [null], `${path}.panes`).map((value2, index) => {
+      const panePath = `${path}.panes[${index}]`;
+      if (typeof value2 === "string" || value2 === null)
+        return { shell_command: commands(value2, panePath) };
+      const pane = mapping(value2, panePath);
+      fields(pane, ["commands", "cmd", "focus", "description"], panePath);
+      const result3 = {
+        shell_command: commands(alias(pane, "commands", "cmd", panePath), panePath, "; ")
+      };
+      copy(pane, result3, ["focus", "description"]);
+      return result3;
+    });
+    focusFirst(panes);
+    result2.panes = panes;
+    return result2;
+  });
+  focusFirst(windows);
+  const result = {
+    session_name: session.name ?? fallbackName ?? null,
+    start_directory: root,
+    windows
+  };
+  copy(session, result, ["description"]);
+  return result;
+}
+function tmuxinator(source, context) {
+  fields(source, [
+    "name",
+    "project_name",
+    "root",
+    "project_root",
+    "windows",
+    "tabs",
+    "pre_window",
+    "description"
+  ], "tmuxinator");
+  const root = directory(alias(source, "root", "project_root", "tmuxinator"), context.cwd, context);
+  const windows = sequence(alias(source, "windows", "tabs", "tmuxinator"), "windows").map((value, ordinal) => {
+    const path = `windows[${ordinal}]`;
+    const entries = Object.entries(mapping(value, path));
+    if (entries.length !== 1)
+      throw new Error(`${path} needs exactly one window name`);
+    const [name, definition] = entries[0];
+    const result2 = { window_name: name };
+    let panes;
+    if (typeof definition === "string" || definition === null || Array.isArray(definition)) {
+      panes = [{ shell_command: commands(definition, path) }];
+    } else {
+      const window = mapping(definition, path);
+      fields(window, ["root", "layout", "pre", "panes", "synchronize", "description"], path);
+      if (window.pre !== undefined && (!Array.isArray(window.panes) || window.panes.length === 0))
+        throw new Error(`${path}.pre requires explicit panes`);
+      copy(window, result2, ["layout", "description"]);
+      if (window.root !== undefined)
+        result2.start_directory = directory(window.root, root, context);
+      if (window.pre !== undefined)
+        result2.shell_command_before = commands(window.pre, `${path}.pre`, " && ");
+      if (window.synchronize !== undefined) {
+        const value2 = window.synchronize;
+        if (![true, false, "before", "after"].includes(value2))
+          throw new Error(`${path}.synchronize must be boolean, before, or after`);
+        result2[value2 === "after" ? "options_after" : "options"] = {
+          "synchronize-panes": value2 !== false
+        };
+      }
+      panes = sequence(window.panes ?? [null], `${path}.panes`).map((pane, index) => ({
+        shell_command: commands(pane, `${path}.panes[${index}]`)
+      }));
+    }
+    focusFirst(panes);
+    result2.panes = panes;
+    return result2;
+  });
+  focusFirst(windows);
+  const result = {
+    session_name: alias(source, "name", "project_name", "tmuxinator") ?? null,
+    start_directory: root,
+    windows
+  };
+  if (source.pre_window !== undefined)
+    result.shell_command_before = commands(source.pre_window, "pre_window", "; ");
+  copy(source, result, ["description"]);
+  return result;
+}
+function importDocument(kind, source, context, fallbackName) {
+  if (kind === "tmuxinator" && JSON.stringify(source).includes("<%"))
+    throw new Error("tmuxinator ERB templates are unsupported; expand them before import");
+  const result = kind === "teamocil" ? teamocil(source, context, fallbackName) : tmuxinator(source, context);
+  normalize(result, join(context.cwd, "imported.json"), context);
+  return result;
+}
+
+// src/search.ts
+var aliases = {
+  name: "name",
+  n: "name",
+  session: "session_name",
+  session_name: "session_name",
+  s: "session_name",
+  path: "path",
+  p: "path",
+  window: "window",
+  w: "window",
+  pane: "pane"
+};
+var defaultFields = ["name", "session_name", "path", "window", "pane"];
+function fields2(selected) {
+  if (!selected)
+    return defaultFields;
+  return [
+    ...new Set(selected.map((item) => {
+      const key = item.toLowerCase();
+      if (!Object.hasOwn(aliases, key))
+        throw new CliError("usage", `Unknown search field: ${item}`, 2);
+      return aliases[key];
+    }))
+  ];
+}
+function extract(record) {
+  const result = {
+    name: [record.name],
+    path: [record.path],
+    session_name: [pythonString(record.session_name ?? "")],
+    window: [],
+    pane: []
+  };
+  const windows = record.config?.windows;
+  if (!Array.isArray(windows))
+    return result;
+  for (const window of windows) {
+    if (!window || typeof window !== "object" || Array.isArray(window))
+      continue;
+    if (window.window_name)
+      result.window.push(pythonString(window.window_name));
+    if (Array.isArray(window.panes))
+      for (const pane of window.panes) {
+        if (typeof pane === "string")
+          result.pane.push(pane);
+        else if (pane && typeof pane === "object" && !Array.isArray(pane)) {
+          const commands2 = pane.shell_command;
+          if (typeof commands2 === "string")
+            result.pane.push(commands2);
+          else if (Array.isArray(commands2))
+            result.pane.push(...commands2.filter(Boolean).map(pythonString));
+        }
+      }
+  }
+  return result;
+}
+function pythonString(value) {
+  if (value === null)
+    return "None";
+  if (value === true)
+    return "True";
+  if (value === false)
+    return "False";
+  if (Array.isArray(value))
+    return `[${value.map(pythonString).join(", ")}]`;
+  if (typeof value === "object")
+    return `{${Object.entries(value).map(([key, value2]) => `'${key}': ${typeof value2 === "string" ? `'${value2}'` : pythonString(value2)}`).join(", ")}}`;
+  return String(value);
+}
+async function search(values, context) {
+  const selected = fields2(values.field);
+  const queries = (values.query_terms ?? []).filter(Boolean).map((term) => {
+    const colon = term.indexOf(":");
+    const prefix = colon > 0 ? term.slice(0, colon).toLowerCase() : undefined;
+    const prefixed = prefix !== undefined && Object.hasOwn(aliases, prefix) ? aliases[prefix] : undefined;
+    const pattern = prefixed ? term.slice(colon + 1) : term;
+    return { fields: prefixed ? [prefixed] : selected, pattern };
+  }).filter((term) => term.pattern);
+  if (!queries.length)
+    throw new CliError("usage", "Provide at least one search pattern", 2);
+  const patterns = queries.map((query) => {
+    let expression = values.fixed_strings ? query.pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") : query.pattern;
+    if (values.word_regexp)
+      expression = `\\b(?:${expression})\\b`;
+    try {
+      return {
+        fields: query.fields,
+        regex: new RegExp(expression, values.ignore_case || values.smart_case && !/\p{Lu}/u.test(query.pattern) ? "iu" : "u")
+      };
+    } catch (error) {
+      throw new CliError("usage", `Invalid search pattern: ${error.message}`, 2);
+    }
+  });
+  const { workspaces } = await discover(context, true);
+  const results = [];
+  for (const record of workspaces) {
+    const extracted = extract(record);
+    const matches = {};
+    const outcomes = patterns.map((pattern) => {
+      let found = false;
+      for (const field of pattern.fields)
+        for (const value of extracted[field] ?? []) {
+          const match = pattern.regex.exec(value);
+          if (match) {
+            found = true;
+            (matches[field] ??= []).push(match[0]);
+          }
+        }
+      return found;
+    });
+    const matched = values.match_any ? outcomes.some(Boolean) : outcomes.every(Boolean);
+    if (values.invert_match ? matched : !matched)
+      continue;
+    results.push({
+      name: record.name,
+      path: record.path,
+      session_name: record.session_name ?? "",
+      source: record.source,
+      matched_fields: Object.keys(matches),
+      matches
+    });
+  }
+  return results;
+}
+
+// src/commands.ts
+import { platform, release } from "node:os";
+function tty(context) {
+  return Boolean(context.stdin.isTTY);
+}
+async function edit(request, context) {
+  const file = await resolveWorkspace(scalarText(request.values.workspace_file), context);
+  const argv = [...tokenize(context.env.EDITOR || "vi"), file];
+  const child = await processRun(argv, {
+    cwd: context.cwd,
+    env: context.env,
+    terminal: tty(context),
+    ...context.signal ? { signal: context.signal } : {},
+    ...request.mode === "human" ? {
+      output: async (stream, text) => {
+        await write(context[stream], text, context.signal);
+      }
+    } : {}
+  });
+  if (request.mode !== "human")
+    await emitJson(context.stdout, {
+      schema_version: 1,
+      command: "edit",
+      status: child.code ? "error" : "ok",
+      file: privatePath(file, context),
+      child_status: child.code,
+      stdout: child.stdout,
+      stderr: child.stderr,
+      truncated: child.truncated,
+      encoding: "utf-8-with-replacement"
+    }, false, context.signal);
+  return child.code;
+}
+async function debugInfo(request, context) {
+  let tmux;
+  try {
+    const result = await processRun([context.env.TMUX_BIN || "tmux", "-V"], {
+      cwd: context.cwd,
+      env: context.env,
+      ...context.signal ? { signal: context.signal } : {}
+    });
+    tmux = result.code ? { version: null, error: result.stderr.trim() } : { version: result.stdout.trim() };
+  } catch (error) {
+    tmux = { version: null, error: String(error) };
+  }
+  const document = {
+    port: "typescript",
+    version: package_default.version,
+    platform: platform(),
+    release: release(),
+    cwd: privatePath(context.cwd, context),
+    runtime: {
+      name: process.versions.bun ? "Bun" : "Node.js",
+      version: process.versions.bun ?? process.versions.node
+    },
+    tmux,
+    paths: Object.fromEntries(["TMUXP_CONFIGDIR", "XDG_CONFIG_HOME", "SHELL", "TMUX_BIN", "TMUX_WORKSPACE_PYTHON"].flatMap((key) => context.env[key] ? [[key, privatePath(context.env[key], context)]] : []))
+  };
+  if (request.mode !== "human")
+    await emitJson(context.stdout, document, request.mode === "json", context.signal);
+  else {
+    const color = colorEnabled(request.mode, request.values.color, context.env, Boolean(context.stdout.isTTY));
+    await write(context.stdout, styled("heading", "Workspace diagnostics", color) + `
+`, context.signal);
+    for (const [label, value] of Object.entries(document))
+      await write(context.stdout, `${styled("subject", label, color)}: ${styled("info", typeof value === "string" ? value : JSON.stringify(value), color)}
+`, context.signal);
+  }
+  return 0;
+}
+async function shell(request, context) {
+  const interactive = request.values.command === null || request.values.command === undefined;
+  if (interactive && !tty(context))
+    throw new CliError("usage", "An interactive Python shell needs a terminal; use -c for captured output", 2);
+  const python = context.env.TMUX_WORKSPACE_PYTHON || "python3";
+  const signal = context.signal ? AbortSignal.any([context.signal, AbortSignal.timeout(1e4)]) : AbortSignal.timeout(1e4);
+  try {
+    const check = await processRun([python, "-c", "import importlib.metadata; print(importlib.metadata.version('tmuxp'))"], { cwd: context.cwd, env: context.env, signal });
+    if (check.code || check.stdout.trim() !== "1.74.0")
+      throw new Error("Requires tmuxp 1.74.0");
+  } catch (error) {
+    if (context.signal?.aborted)
+      throw error;
+    throw new CliError("script_failed", "The Python bridge requires tmuxp 1.74.0; set TMUX_WORKSPACE_PYTHON to its interpreter");
+  }
+  const args = [
+    python,
+    "-u",
+    "-c",
+    "from tmuxp.cli import cli; cli()",
+    "--color",
+    "never",
+    "shell"
+  ];
+  for (const [name, flag] of [
+    ["socket_path", "-S"],
+    ["socket_name", "-L"],
+    ["command", "-c"]
+  ]) {
+    const value = request.values[name];
+    if (value !== null && value !== undefined)
+      args.push(flag, scalarText(value));
+  }
+  if (request.values.shell)
+    args.push(`--${scalarText(request.values.shell)}`);
+  args.push(request.values.use_pythonrc ? "--use-pythonrc" : "--no-startup", request.values.use_vi_mode ? "--use-vi-mode" : "--no-vi-mode");
+  for (const key of ["session_name", "window_name"])
+    if (request.values[key])
+      args.push(scalarText(request.values[key]));
+  const output = new OperationOutput("shell", request.mode, context.stdout, context.signal);
+  const child = await processRun(args, {
+    cwd: context.cwd,
+    env: context.env,
+    terminal: interactive,
+    ...context.signal ? { signal: context.signal } : {},
+    output: async (stream, text) => {
+      if (request.mode === "human")
+        await write(context[stream], text, context.signal);
+      else
+        await output.event("script-output", { stream, text, encoding: "utf-8-with-replacement" });
+    }
+  });
+  await output.result({
+    status: child.code ? "error" : "ok",
+    child_status: child.code,
+    stdout: child.stdout,
+    stderr: child.stderr,
+    truncated: child.truncated,
+    encoding: "utf-8-with-replacement"
+  });
+  return child.code;
+}
+
+// src/diagnostics.ts
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+var levels = { debug: 10, info: 20, warning: 30, error: 40, critical: 50 };
+
+class Diagnostics {
+  pending = Promise.resolve();
+  failed = false;
+  level;
+  mode;
+  stderr;
+  color;
+  file;
+  signal;
+  constructor(level, mode, stderr, color, file, signal) {
+    this.level = level;
+    this.mode = mode;
+    this.stderr = stderr;
+    this.color = color;
+    this.file = file;
+    this.signal = signal;
+  }
+  static async open(values, mode, context) {
+    context.signal?.throwIfAborted();
+    let file;
+    if (values.log_file) {
+      const path = resolve2(context.cwd, expandPath(scalarText(values.log_file), context));
+      file = await open(path, constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND | constants.O_NONBLOCK, 384);
+      try {
+        if (!(await file.stat()).isFile())
+          throw new CliError("usage", "Log destination must be a regular file", 2);
+      } catch (error) {
+        await file.close();
+        throw error;
+      }
+    }
+    return new Diagnostics(values.log_level ?? "warning", mode, context.stderr, colorEnabled(mode, values.color, context.env, Boolean(context.stderr.isTTY)), file, context.signal);
+  }
+  accepts(level) {
+    return !this.failed && levels[level] >= levels[this.level];
+  }
+  async record(level, event, data = {}, echo = true) {
+    if (!this.accepts(level))
+      return;
+    const record = { ...data, schema_version: 1, level, event, time: new Date().toISOString() };
+    this.pending = this.pending.then(async () => {
+      this.signal?.throwIfAborted();
+      if (this.file)
+        await this.file.appendFile(JSON.stringify(record) + `
+`);
+      if (!echo)
+        return;
+      if (this.mode !== "human")
+        await write(this.stderr, JSON.stringify(record) + `
+`, this.signal);
+      else {
+        const role = level === "error" || level === "critical" ? "error" : level === "warning" ? "warning" : "info";
+        await write(this.stderr, `${styled(role, level, this.color)}: ${styled("subject", event, this.color)} ${styled("secondary", JSON.stringify(data), this.color)}
+`, this.signal);
+      }
+    });
+    try {
+      await this.pending;
+    } catch (error) {
+      if (this.failed)
+        return;
+      this.failed = true;
+      this.signal?.throwIfAborted();
+      const message = error instanceof Error ? error.message : String(error);
+      try {
+        await write(this.stderr, this.mode === "human" ? `tmux-workspace: logging stopped: ${message}
+` : JSON.stringify({ schema_version: 1, code: "log_error", message }) + `
+`, this.signal);
+      } catch {
+        this.signal?.throwIfAborted();
+      }
+    }
+  }
+  async close() {
+    await this.pending.catch(() => {});
+    await this.file?.close();
+  }
+}
+
+// src/app.ts
+async function run(argv, context) {
+  let diagnostics;
+  let help = "";
+  let parserError = "";
+  const parser = createParser({
+    stdout: (text) => {
+      help += text;
+    },
+    stderr: (text) => {
+      parserError += text;
+    }
+  });
+  const positional = argv.indexOf("--");
+  const options = positional < 0 ? argv : argv.slice(0, positional);
+  let mode = options.includes("--ndjson") ? "ndjson" : options.includes("--json") ? "json" : "human";
+  const report = async (code, message) => {
+    const text = mode === "human" ? `tmux-workspace: ${message}
+` : JSON.stringify({ schema_version: 1, code, message }) + `
+`;
+    await write(context.stderr, text, context.signal);
+  };
+  const reportLogFailure = async (error) => {
+    try {
+      await report("log_error", error instanceof Error ? error.message : String(error));
+    } catch {}
+  };
+  try {
+    try {
+      parser.command.parse(argv, { from: "user" });
+    } catch (error) {
+      if (error instanceof CommanderError && error.exitCode === 0) {
+        await write(context.stdout, help, context.signal);
+        return 0;
+      }
+      const first = parser.command.args[0];
+      const topLevel = new Set([...parser.commands.keys()].filter((name) => name && !name.includes(" ")));
+      if (error instanceof CommanderError && error.code === "commander.excessArguments" && first !== undefined && !topLevel.has(first)) {
+        parserError = "";
+        throw new CommanderError(2, "commander.unknownCommand", `error: unknown command '${first}'`);
+      }
+      throw error;
+    }
+    const request = parser.request();
+    mode = request.mode;
+    diagnostics = await Diagnostics.open(request.values, request.mode, context);
+    context = { ...context, diagnostics };
+    context.signal?.throwIfAborted();
+    await diagnostics.record("debug", "command-started", { command: request.command });
+    const color = colorEnabled(request.mode, request.values.color, context.env, Boolean(context.stdout.isTTY));
+    const render = (role, value) => styled(role, value, color);
+    if (!request.command || request.command === "import") {
+      if (mode !== "human")
+        throw new CliError("usage", request.command ? "Choose import teamocil or import tmuxinator." : "Choose a workspace command.", 2);
+      await write(context.stdout, parser.commands.get(request.command).helpInformation(), context.signal);
+      return 0;
+    }
+    if (request.command === "load" || request.command === "freeze") {
+      const operation = (await import("./tmux-wa2zn8z1.js"))[request.command];
+      context.signal?.throwIfAborted();
+      return await operation(request, context);
+    }
+    if (request.command === "edit")
+      return await edit(request, context);
+    if (request.command === "debug-info")
+      return await debugInfo(request, context);
+    if (request.command === "shell")
+      return await shell(request, context);
+    if (request.command === "completion") {
+      const [{ commandCatalog }, { completionScript }] = await Promise.all([
+        import("./reference-ebfxh6yp.js"),
+        import("./completions-2a9fqwq3.js")
+      ]);
+      const shell2 = request.values.shell;
+      const script = completionScript(commandCatalog(parser), shell2);
+      if (mode === "human")
+        await write(context.stdout, script, context.signal);
+      else
+        await emitJson(context.stdout, {
+          schema_version: 1,
+          command: "completion",
+          status: "ok",
+          shell: shell2,
+          script
+        }, mode === "json", context.signal);
+      return 0;
+    }
+    if (request.command === "ls") {
+      const result = await discover(context, Boolean(request.values.full));
+      if (mode === "json")
+        await emitJson(context.stdout, result, true, context.signal);
+      else if (mode === "ndjson")
+        for (const record of result.workspaces)
+          await emitJson(context.stdout, record, false, context.signal);
+      else {
+        let heading = "";
+        for (const record of result.workspaces) {
+          const group = request.values.tree ? dirname(record.path) : `${record.source === "local" ? "Local" : "Global"} workspaces`;
+          if (group !== heading) {
+            await write(context.stdout, render("heading", group) + `:
+`, context.signal);
+            heading = group;
+          }
+          await write(context.stdout, `  ${render("subject", record.name)}  ${render("info", record.path)}
+`, context.signal);
+          if (request.values.full && record.config)
+            await write(context.stdout, JSON.stringify(record.config, null, 2) + `
+`, context.signal);
+        }
+        if (!result.workspaces.length)
+          await write(context.stdout, render("warning", "No workspaces found.") + `
+`, context.signal);
+        await write(context.stdout, `
+` + render("heading", "Global workspace directories:") + `
+`, context.signal);
+        for (const entry of result.global_workspace_dirs)
+          await write(context.stdout, `  ${render("secondary", entry.source)}: ${render("info", entry.path)} (${render(entry.active ? "success" : "secondary", entry.exists ? `${entry.workspace_count} workspaces${entry.active ? ", active" : ""}` : "not found")})
+`, context.signal);
+      }
+      return 0;
+    }
+    if (request.command === "search") {
+      const results = await search(request.values, context);
+      if (mode === "json")
+        await emitJson(context.stdout, results, true, context.signal);
+      else if (mode === "ndjson")
+        for (const result of results)
+          await emitJson(context.stdout, result, false, context.signal);
+      else
+        for (const result of results)
+          await write(context.stdout, `${render("subject", result.name)}  ${render("info", result.path)}  ${render("secondary", result.matched_fields.join(", "))}
+`, context.signal);
+      return 0;
+    }
+    if (request.command === "convert" || request.command.startsWith("import ")) {
+      const kind = request.command.split(" ")[1];
+      let importerRoot;
+      if (kind === "teamocil")
+        importerRoot = join2(home(context), ".teamocil");
+      else if (kind === "tmuxinator")
+        importerRoot = expandPath(context.env.TMUXINATOR_CONFIG ?? join2(home(context), ".tmuxinator"), context);
+      const source = await resolveWorkspace(scalarText(request.values.workspace_file), context, importerRoot);
+      let document;
+      try {
+        const raw = await readDocument(source);
+        document = kind ? importDocument(kind, raw, context, basename(source, extname(source))) : raw;
+      } catch (error) {
+        if (error instanceof CliError)
+          throw error;
+        throw new CliError("invalid_workspace", error instanceof Error ? error.message : String(error));
+      }
+      let destination = request.values.save_to ? resolve3(context.cwd, expandPath(scalarText(request.values.save_to), context)) : undefined;
+      const format = scalarText(request.values.workspace_format ?? (extname(source) === ".json" ? "yaml" : "json"));
+      if (!destination && mode === "human") {
+        if (!request.values.answer_yes)
+          throw new CliError("usage", "Confirm conversion with --yes or provide --save-to", 2);
+        destination = join2(dirname(source), basename(source, extname(source)) + (format === "json" ? ".json" : ".yaml"));
+      }
+      if (destination) {
+        await saveDocument(document, destination, format, Boolean(request.values.force), context.signal);
+        const result = {
+          schema_version: 1,
+          command: request.command,
+          status: "ok",
+          destination: privatePath(destination, context),
+          format
+        };
+        if (mode === "human")
+          await write(context.stdout, `${render("success", "Saved")} ${render("info", destination)}
+`, context.signal);
+        else
+          await emitJson(context.stdout, result, false, context.signal);
+      } else if (mode === "json")
+        await emitJson(context.stdout, document, false, context.signal);
+      else
+        await emitJson(context.stdout, {
+          schema_version: 1,
+          command: request.command,
+          status: "ok",
+          workspace: document
+        }, false, context.signal);
+      return 0;
+    }
+    throw new Error(`${request.command} has no handler`);
+  } catch (error) {
+    if (context.signal?.aborted)
+      return 130;
+    const usage = error instanceof CommanderError;
+    const code = usage ? "usage" : error instanceof CliError ? error.code : "tmux_failed";
+    const message = usage ? parserError.trim() || error.message : error instanceof Error ? error.message : String(error);
+    try {
+      await report(code, message);
+    } catch {}
+    try {
+      await diagnostics?.record("error", "command-failed", { code, message }, false);
+    } catch (logError) {
+      await reportLogFailure(logError);
+    }
+    return context.signal?.aborted ? 130 : usage ? 2 : error instanceof CliError ? error.exitCode : 1;
+  } finally {
+    try {
+      await diagnostics?.close();
+    } catch (error) {
+      await reportLogFailure(error);
+    }
+  }
+}
+export {
+  run
+};