@zswarm/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 zSwarm contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,36 @@
+# @zswarm/core
+
+Zellij client and the shared `dispatchZswarm` ops layer. Everything else is a
+thin shell over it. One table in `src/schema.ts` generates the MCP tool schema,
+the CLI flags, and the CLI help, so they cannot drift.
+
+## Install
+
+```bash
+npm install @zswarm/core
+```
+
+From a checkout of this repo:
+
+```bash
+npm install ./packages/core
+```
+
+Requires Zellij >= 0.42 and Node >= 20.
+
+## Usage
+
+```js
+import { dispatchZswarm } from "@zswarm/core";
+
+const result = await dispatchZswarm({ op: "list" });
+```
+
+`dispatchZswarm` builds a Zellij client unless you pass one. The result is
+`{ ok, data }` or `{ ok: false, error }`.
+
+Ops, env, and the event bus: the [zswarm README](../../README.md).
+
+## License
+
+MIT

package/dist/errors.d.ts

@@ -0,0 +1,5 @@
+/** Every zSwarm failure carries a stable machine-readable code. */
+export declare class ZellijError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}

package/dist/errors.js

@@ -0,0 +1,9 @@
+/** Every zSwarm failure carries a stable machine-readable code. */
+export class ZellijError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "ZellijError";
+        this.code = code;
+    }
+}

package/dist/exec.d.ts

@@ -0,0 +1,32 @@
+export type ExecResult = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+export type ExecOptions = {
+    timeoutMs: number;
+    cwd?: string;
+    /**
+     * Stop as soon as the accumulated stdout satisfies this, instead of waiting
+     * for the process to exit. `zellij pipe` answers in milliseconds but stays
+     * resident when it has no terminal, so waiting for exit means waiting for the
+     * timeout.
+     */
+    until?: (stdout: string) => boolean;
+};
+export type ExecFn = (args: string[], options: ExecOptions) => Promise<ExecResult>;
+export declare const NOT_FOUND_EXIT = 127;
+/** POSIX single-quoting, for building a command line the remote shell parses. */
+export declare function shellQuote(arg: string): string;
+export type SshTarget = {
+    ssh: string;
+    host: string;
+    remoteBin: string;
+    options: string[];
+};
+/**
+ * Run the remote zellij over ssh. The whole invocation is quoted into a single
+ * command string, because the remote login shell re-parses it.
+ */
+export declare function createSshExec(target: SshTarget, env: NodeJS.ProcessEnv): ExecFn;
+export declare function createExec(binPath: string, env: NodeJS.ProcessEnv): ExecFn;

package/dist/exec.js

@@ -0,0 +1,118 @@
+import { execFile, spawn } from "node:child_process";
+export const NOT_FOUND_EXIT = 127;
+/** POSIX single-quoting, for building a command line the remote shell parses. */
+export function shellQuote(arg) {
+    if (arg === "")
+        return "''";
+    if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(arg))
+        return arg;
+    return `'${arg.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * Run the remote zellij over ssh. The whole invocation is quoted into a single
+ * command string, because the remote login shell re-parses it.
+ */
+export function createSshExec(target, env) {
+    const runner = createExec(target.ssh, env);
+    return (args, options) => {
+        const remote = [target.remoteBin, ...args].map(shellQuote).join(" ");
+        return runner([...target.options, target.host, remote], options);
+    };
+}
+/** Read stdout until the answer is in hand, then stop caring about the child. */
+function runUntil(binPath, args, env, options) {
+    return new Promise((resolve) => {
+        const child = spawn(binPath, args, {
+            env,
+            cwd: options.cwd,
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.kill();
+            resolve(result);
+        };
+        const timer = setTimeout(() => finish({
+            code: -1,
+            stdout,
+            stderr: `${binPath} timed out after ${options.timeoutMs}ms`,
+        }), options.timeoutMs);
+        child.on("error", (err) => {
+            const missing = err.code === "ENOENT" || err.code === "ENOTDIR";
+            finish({
+                code: missing ? NOT_FOUND_EXIT : 1,
+                stdout: "",
+                stderr: `${err.code ?? "error"}: ${err.message} (bin=${binPath})`,
+            });
+        });
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+            if (options.until(stdout))
+                finish({ code: 0, stdout, stderr });
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("close", (code) => finish({ code: code ?? 0, stdout, stderr }));
+    });
+}
+/**
+ * execFile-backed runner for a fixed binary. Never rejects — callers branch on
+ * `code`, and a missing binary surfaces as NOT_FOUND_EXIT.
+ */
+function runToExit(binPath, args, env, options) {
+    return new Promise((resolve) => {
+        execFile(binPath, args, {
+            timeout: options.timeoutMs,
+            cwd: options.cwd,
+            maxBuffer: 8 * 1024 * 1024,
+            windowsHide: true,
+            env,
+        }, (error, stdout, stderr) => {
+            const failure = error;
+            if (failure && typeof failure.code === "string") {
+                const missing = failure.code === "ENOENT" || failure.code === "ENOTDIR";
+                resolve({
+                    code: missing ? NOT_FOUND_EXIT : 1,
+                    stdout: "",
+                    stderr: `${failure.code}: ${failure.message} (bin=${binPath})`,
+                });
+                return;
+            }
+            if (failure &&
+                (failure.killed === true || typeof failure.signal === "string")) {
+                resolve({
+                    code: -1,
+                    stdout: String(stdout ?? ""),
+                    stderr: `${binPath} timed out after ${options.timeoutMs}ms`,
+                });
+                return;
+            }
+            const code = failure && typeof failure.code === "number"
+                ? failure.code
+                : failure
+                    ? 1
+                    : 0;
+            resolve({
+                code,
+                stdout: String(stdout ?? ""),
+                stderr: String(stderr ?? ""),
+            });
+        });
+    });
+}
+export function createExec(binPath, env) {
+    return (args, options) => {
+        const until = options.until;
+        return until
+            ? runUntil(binPath, args, env, { ...options, until })
+            : runToExit(binPath, args, env, options);
+    };
+}

package/dist/git.d.ts

@@ -0,0 +1,51 @@
+import { type ExecFn } from "./exec.js";
+export type Worktree = {
+    path: string;
+    head: string | null;
+    branch: string | null;
+    bare: boolean;
+    detached: boolean;
+    locked: boolean;
+    prunable: boolean;
+};
+/** Compare paths across separators and case, so pane cwds match git output. */
+export declare function normalizeRepoPath(input: string): string;
+/** Branch names may contain `/`; directory names may not. */
+export declare function worktreeDirName(branch: string): string;
+/** Sibling of the repo, matching the common `<repo>-worktrees` convention. */
+export declare function defaultWorktreeRoot(repoRoot: string): string;
+export declare function parseWorktreeList(stdout: string): Worktree[];
+export type GitClientOptions = {
+    exec?: ExecFn;
+    gitPath?: string;
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+};
+export declare function createGitClient(options?: GitClientOptions): {
+    gitPath: string;
+    repoRoot: (cwd: string) => Promise<string>;
+    branchExists: (root: string, branch: string) => Promise<boolean>;
+    listWorktrees: (root: string) => Promise<Worktree[]>;
+    addWorktree: (input: {
+        root: string;
+        path: string;
+        branch: string;
+        baseRef?: string | null;
+        createBranch: boolean;
+    }) => Promise<void>;
+    removeWorktree: (input: {
+        root: string;
+        path: string;
+        force?: boolean;
+    }) => Promise<void>;
+    isDirty: (path: string) => Promise<boolean>;
+    diffStat: (path: string) => Promise<string>;
+    diffPatch: (path: string, maxChars: number) => Promise<{
+        patch: string;
+        truncated: boolean;
+        chars: number;
+    }>;
+    commitAll: (path: string, message: string) => Promise<string>;
+    headSha: (path: string) => Promise<string>;
+};
+export type GitClient = ReturnType<typeof createGitClient>;

package/dist/git.js

@@ -0,0 +1,190 @@
+import { basename, dirname, join } from "node:path";
+import { ZellijError } from "./errors.js";
+import { createExec, NOT_FOUND_EXIT } from "./exec.js";
+const DEFAULT_TIMEOUT_MS = 20_000;
+/** Compare paths across separators and case, so pane cwds match git output. */
+export function normalizeRepoPath(input) {
+    return input
+        .trim()
+        .replace(/\\/g, "/")
+        .replace(/\/+$/, "")
+        .toLowerCase();
+}
+/** Branch names may contain `/`; directory names may not. */
+export function worktreeDirName(branch) {
+    const cleaned = branch
+        .trim()
+        .replace(/^refs\/heads\//, "")
+        .replace(/[\\/]+/g, "-")
+        .replace(/[^A-Za-z0-9._-]/g, "-")
+        .replace(/^-+|-+$/g, "");
+    if (!cleaned) {
+        throw new ZellijError("bad_branch", `branch "${branch}" has no usable name`);
+    }
+    return cleaned;
+}
+/** Sibling of the repo, matching the common `<repo>-worktrees` convention. */
+export function defaultWorktreeRoot(repoRoot) {
+    return join(dirname(repoRoot), `${basename(repoRoot)}-worktrees`);
+}
+export function parseWorktreeList(stdout) {
+    const trees = [];
+    let current = null;
+    const push = () => {
+        if (current)
+            trees.push(current);
+        current = null;
+    };
+    for (const raw of stdout.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line) {
+            push();
+            continue;
+        }
+        if (line.startsWith("worktree ")) {
+            push();
+            current = {
+                path: line.slice("worktree ".length),
+                head: null,
+                branch: null,
+                bare: false,
+                detached: false,
+                locked: false,
+                prunable: false,
+            };
+            continue;
+        }
+        if (!current)
+            continue;
+        if (line.startsWith("HEAD "))
+            current.head = line.slice("HEAD ".length);
+        else if (line.startsWith("branch "))
+            current.branch = line.slice("branch ".length).replace(/^refs\/heads\//, "");
+        else if (line === "bare")
+            current.bare = true;
+        else if (line === "detached")
+            current.detached = true;
+        else if (line.startsWith("locked"))
+            current.locked = true;
+        else if (line.startsWith("prunable"))
+            current.prunable = true;
+    }
+    push();
+    return trees;
+}
+export function createGitClient(options = {}) {
+    const env = options.env ?? process.env;
+    const gitPath = options.gitPath ?? env.ZSWARM_GIT_BIN?.trim() ?? "git";
+    const exec = options.exec ?? createExec(gitPath, env);
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    async function run(args, cwd, label) {
+        const result = await exec(args, { timeoutMs, cwd });
+        if (result.code === NOT_FOUND_EXIT) {
+            throw new ZellijError("git_missing", `git not found (${gitPath}); install git or set ZSWARM_GIT_BIN`);
+        }
+        if (result.code !== 0) {
+            throw new ZellijError("git_failed", `${label} failed (exit ${result.code}): ${result.stderr.trim() || result.stdout.trim() || "no output"}`);
+        }
+        return result;
+    }
+    /** Top level of the working tree containing `cwd`. */
+    async function repoRoot(cwd) {
+        const result = await exec(["rev-parse", "--show-toplevel"], {
+            timeoutMs,
+            cwd,
+        });
+        if (result.code === NOT_FOUND_EXIT) {
+            throw new ZellijError("git_missing", `git not found (${gitPath}); install git or set ZSWARM_GIT_BIN`);
+        }
+        if (result.code !== 0) {
+            throw new ZellijError("not_a_repo", `${cwd} is not inside a git repository`);
+        }
+        return result.stdout.trim();
+    }
+    async function branchExists(root, branch) {
+        const result = await exec(["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], { timeoutMs, cwd: root });
+        return result.code === 0;
+    }
+    async function listWorktrees(root) {
+        const result = await run(["worktree", "list", "--porcelain"], root, "git worktree list");
+        return parseWorktreeList(result.stdout);
+    }
+    async function addWorktree(input) {
+        const args = ["worktree", "add"];
+        if (input.createBranch)
+            args.push("-b", input.branch);
+        args.push(input.path);
+        if (input.createBranch) {
+            if (input.baseRef)
+                args.push(input.baseRef);
+        }
+        else {
+            args.push(input.branch);
+        }
+        await run(args, input.root, "git worktree add");
+    }
+    async function removeWorktree(input) {
+        const args = ["worktree", "remove"];
+        if (input.force)
+            args.push("--force");
+        args.push(input.path);
+        await run(args, input.root, "git worktree remove");
+    }
+    /** Uncommitted changes, including untracked files. */
+    async function isDirty(path) {
+        const result = await run(["status", "--porcelain"], path, "git status");
+        return result.stdout.trim().length > 0;
+    }
+    /**
+     * Stage untracked paths as intent-to-add so they appear in `git diff`
+     * (without copying blob contents into the object database).
+     */
+    async function intentAddUntracked(path) {
+        await run(["add", "-A", "--intent-to-add"], path, "git add --intent-to-add");
+    }
+    /** `git diff --stat HEAD`, including untracked via `--intent-to-add`. */
+    async function diffStat(path) {
+        await intentAddUntracked(path);
+        const result = await run(["diff", "--stat", "HEAD"], path, "git diff --stat");
+        return result.stdout;
+    }
+    /**
+     * `git diff HEAD`, including untracked via `--intent-to-add`.
+     * When `maxChars > 0` and the patch is longer, keep the head and set
+     * `truncated`. `chars` is always the full patch length before truncating.
+     */
+    async function diffPatch(path, maxChars) {
+        await intentAddUntracked(path);
+        const result = await run(["diff", "HEAD"], path, "git diff");
+        const full = result.stdout;
+        const chars = full.length;
+        if (maxChars <= 0 || chars <= maxChars) {
+            return { patch: full, truncated: false, chars };
+        }
+        return { patch: full.slice(0, maxChars), truncated: true, chars };
+    }
+    /** `git add -A` then `git commit -m`; returns the new short HEAD sha. */
+    async function commitAll(path, message) {
+        await run(["add", "-A"], path, "git add");
+        await run(["commit", "-m", message], path, "git commit");
+        return headSha(path);
+    }
+    /** Short sha of HEAD. */
+    async function headSha(path) {
+        const result = await run(["rev-parse", "--short", "HEAD"], path, "git rev-parse");
+        return result.stdout.trim();
+    }
+    return {
+        gitPath,
+        repoRoot,
+        branchExists,
+        listWorktrees,
+        addWorktree,
+        removeWorktree,
+        isDirty,
+        diffStat,
+        diffPatch,
+        commitAll,
+        headSha,
+    };
+}

package/dist/harness.d.ts

@@ -0,0 +1,21 @@
+export type SubmitStrategy = "auto" | "double-enter";
+export type HarnessProfile = {
+    /** Stable id: "codex" | "cursor" | "opencode" | "gemini" | "pi" | "unknown" */
+    name: string;
+    /** What `send` should do when the caller did not pass submit= explicitly. */
+    submit: SubmitStrategy;
+    /**
+     * Approval-prompt UI this harness pins on screen. `status` matches these
+     * against the trailing lines; a hit means the pane wants input, not time.
+     */
+    waiting: readonly RegExp[];
+};
+/**
+ * Identify the harness from a pane's command and title, case-insensitively.
+ * The command is the executable that spawned the pane, so it wins; the title
+ * is the fallback for panes launched from a generic shell. Never throws.
+ */
+export declare function resolveHarness(pane: {
+    command?: string | null;
+    title?: string | null;
+}): HarnessProfile;

package/dist/harness.js

@@ -0,0 +1,98 @@
+/** Command and title needles observed on real panes in one live session. */
+const PROFILES = [
+    { name: "codex", command: ["codex"], title: ["agent-codex"] },
+    { name: "cursor", command: ["cursor-agent"], title: ["agent-cursor"] },
+    { name: "opencode", command: ["opencode"], title: ["agent-opencode"] },
+    { name: "gemini", command: ["agy", "gemini"], title: ["agent-gemini"] },
+    { name: "pi", command: ["pi"], title: ["agent-pi"] },
+];
+/**
+ * Only codex needs a second Enter to submit: its composer keeps the pasted
+ * message (`› [zswarm from=...]`) until an extra Enter lands — verified live
+ * on all five harnesses. The other four submit on the paste itself.
+ */
+const SUBMIT = {
+    codex: "double-enter",
+    cursor: "auto",
+    opencode: "auto",
+    gemini: "auto",
+    pi: "auto",
+};
+/**
+ * Prompt shapes any CLI can show, so every profile carries these as a base.
+ * They are named UI, never guesses: nothing here matches on a bare "?", the
+ * word "confirm", or a lone "y".
+ */
+const GENERIC_WAITING = [
+    /\(y\/n\)/i,
+    /\[y\/n\]/i,
+    /press enter to continue/i,
+];
+/**
+ * Per-harness approval UI observed in this live session. Only gemini and
+ * opencode showed full-screen prompts worth naming; codex, cursor, and pi
+ * show only the generic shapes so far, and unknown panes get the generic set
+ * and nothing else. Mislabelling a working pane as waiting makes a dispatcher
+ * type into it, so unobserved prompts stay undetected.
+ */
+const WAITING = {
+    codex: GENERIC_WAITING,
+    cursor: GENERIC_WAITING,
+    opencode: [...GENERIC_WAITING, /Permission required/i, /Allow once/i],
+    gemini: [
+        ...GENERIC_WAITING,
+        /Do you want to proceed\?/i,
+        /Accept this file edit\?/i,
+    ],
+    pi: GENERIC_WAITING,
+};
+const UNKNOWN = {
+    name: "unknown",
+    submit: "auto",
+    waiting: GENERIC_WAITING,
+};
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Word-boundary match, never a bare `includes`: a raw `pi` substring appears
+ * in plenty of real paths (`pip.exe`, `spike/`, `pipeline`), so it would
+ * misidentify nearly every pane. `\b` still finds `pi.cmd`, `agent-pi`, and a
+ * bare `pi`, but requires the needle to stand alone.
+ */
+function hasWord(haystack, needle) {
+    return new RegExp(`\\b${escapeRegExp(needle)}\\b`, "i").test(haystack);
+}
+function matchCommand(command) {
+    if (!command)
+        return null;
+    for (const profile of PROFILES) {
+        for (const needle of profile.command) {
+            if (hasWord(command, needle))
+                return profile.name;
+        }
+    }
+    return null;
+}
+function matchTitle(title) {
+    if (!title)
+        return null;
+    for (const profile of PROFILES) {
+        for (const needle of profile.title) {
+            if (hasWord(title, needle))
+                return profile.name;
+        }
+    }
+    return null;
+}
+/**
+ * Identify the harness from a pane's command and title, case-insensitively.
+ * The command is the executable that spawned the pane, so it wins; the title
+ * is the fallback for panes launched from a generic shell. Never throws.
+ */
+export function resolveHarness(pane) {
+    const name = matchCommand(pane.command) ?? matchTitle(pane.title) ?? "unknown";
+    if (name === "unknown")
+        return UNKNOWN;
+    return { name, submit: SUBMIT[name], waiting: WAITING[name] };
+}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export { ZellijError } from "./errors.js";
+export { createExec, NOT_FOUND_EXIT, type ExecFn, type ExecOptions, type ExecResult, } from "./exec.js";
+export { createGitClient, defaultWorktreeRoot, normalizeRepoPath, parseWorktreeList, worktreeDirName, type GitClient, type GitClientOptions, type Worktree, } from "./git.js";
+export { expandHomePath, resolveZellijBinary, sanitizeZellijEnv, type ZellijExecFn, type ZellijExecResult, } from "./zellij/binary.js";
+export { normalizePaneId, parsePaneList, resolvePane, type ZellijPane, } from "./zellij/panes.js";
+export { parseSessionList, resolveSelfPaneId, type ZellijSessionResolve, } from "./zellij/session.js";
+export { buildClosePaneArgs, buildDumpArgs, buildLaunchPluginArgs, buildListPanesArgs, buildNewPaneArgs, buildNewTabArgs, buildPasteArgs, buildPipeArgs, buildSendEnterArgs, buildSendKeysArgs, buildWriteCharsArgs, scrollbackPayload, type LaunchPluginInput, type NewPaneInput, type NewTabInput, type PaneDirection, type PipeInput, type ScrollbackRequest, } from "./zellij/args.js";
+export { busPluginUrl, busToPanes, nextConfigKey, parseBusReply, parseScrollbackReply, resolveBusPlugin, scrollbackToScreen, BUS_PIPE_NAME, DEFAULT_BUS_KEY, DEFAULT_BUS_TIMEOUT_MS, type BusMarker, type BusPane, type BusScrollback, type BusScrollbackPane, type BusSnapshot, } from "./zellij/bus.js";
+export { busSnapshot, planBus, resetBusCache, type BusPlan, } from "./ops/bus.js";
+export { createZellijClient, type ZellijClient, type ZellijClientOptions, } from "./zellij/client.js";
+export { createStateStore, defaultStateDir, type LogEntry, type SignalChannel, type StateStore, type StateStoreOptions, } from "./state.js";
+export { dispatchZswarm } from "./ops/dispatch.js";
+export { assertOpAllowed, assertPaneAllowed, isWriteOp, loadPolicy, type Policy, } from "./policy.js";
+export { createSshExec, shellQuote, type SshTarget } from "./exec.js";
+export { resolveSshTarget } from "./zellij/binary.js";
+export { parseTabList, resolveTab, type ZellijTab } from "./zellij/tabs.js";
+export { selectTargets } from "./ops/broadcast.js";
+export { diffScreens, cursorKey } from "./ops/tail.js";
+export { classify, lastLine, type PeerState } from "./ops/status.js";
+export { normalizeScreen, truncateDumpText, DEFAULT_DUMP_MAX_CHARS, DEFAULT_WAIT_MAX_CHARS, } from "./ops/util.js";
+export type { DispatchDeps, OpsResult } from "./ops/types.js";
+export { normalizeKey, normalizeKeys, tokenizeCommand } from "./keys.js";
+export { cliUsage, mcpInputSchema, parseCliArgv, MCP_TOOL_DESCRIPTION, OP_NAMES, PARAMS, TARGET_OPS, type OpName, type ParamSpec, type ParamType, } from "./schema.js";

package/dist/index.js

@@ -0,0 +1,22 @@
+export { ZellijError } from "./errors.js";
+export { createExec, NOT_FOUND_EXIT, } from "./exec.js";
+export { createGitClient, defaultWorktreeRoot, normalizeRepoPath, parseWorktreeList, worktreeDirName, } from "./git.js";
+export { expandHomePath, resolveZellijBinary, sanitizeZellijEnv, } from "./zellij/binary.js";
+export { normalizePaneId, parsePaneList, resolvePane, } from "./zellij/panes.js";
+export { parseSessionList, resolveSelfPaneId, } from "./zellij/session.js";
+export { buildClosePaneArgs, buildDumpArgs, buildLaunchPluginArgs, buildListPanesArgs, buildNewPaneArgs, buildNewTabArgs, buildPasteArgs, buildPipeArgs, buildSendEnterArgs, buildSendKeysArgs, buildWriteCharsArgs, scrollbackPayload, } from "./zellij/args.js";
+export { busPluginUrl, busToPanes, nextConfigKey, parseBusReply, parseScrollbackReply, resolveBusPlugin, scrollbackToScreen, BUS_PIPE_NAME, DEFAULT_BUS_KEY, DEFAULT_BUS_TIMEOUT_MS, } from "./zellij/bus.js";
+export { busSnapshot, planBus, resetBusCache, } from "./ops/bus.js";
+export { createZellijClient, } from "./zellij/client.js";
+export { createStateStore, defaultStateDir, } from "./state.js";
+export { dispatchZswarm } from "./ops/dispatch.js";
+export { assertOpAllowed, assertPaneAllowed, isWriteOp, loadPolicy, } from "./policy.js";
+export { createSshExec, shellQuote } from "./exec.js";
+export { resolveSshTarget } from "./zellij/binary.js";
+export { parseTabList, resolveTab } from "./zellij/tabs.js";
+export { selectTargets } from "./ops/broadcast.js";
+export { diffScreens, cursorKey } from "./ops/tail.js";
+export { classify, lastLine } from "./ops/status.js";
+export { normalizeScreen, truncateDumpText, DEFAULT_DUMP_MAX_CHARS, DEFAULT_WAIT_MAX_CHARS, } from "./ops/util.js";
+export { normalizeKey, normalizeKeys, tokenizeCommand } from "./keys.js";
+export { cliUsage, mcpInputSchema, parseCliArgv, MCP_TOOL_DESCRIPTION, OP_NAMES, PARAMS, TARGET_OPS, } from "./schema.js";

package/dist/keys.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Normalize one key spec into Zellij's `send-keys` spelling.
+ * Accepts `ctrl+c`, `Ctrl-C`, `^C`, `esc`, `Alt Shift b`, `f1`.
+ */
+export declare function normalizeKey(raw: string): string;
+/**
+ * Normalize a key list. Arrays hold one spec per entry; a string is a single
+ * spec unless it is comma separated (`"Esc,Enter"`), since `"Ctrl c"` is one key.
+ */
+export declare function normalizeKeys(input: unknown): string[];
+/**
+ * Split a command line into argv. Arrays pass through; strings honour single
+ * and double quotes. Zellij runs the command directly — there is no shell.
+ */
+export declare function tokenizeCommand(input: unknown): string[];