@zswarm/core 0.1.5 → 0.1.7

package/dist/zellij/args.d.ts

@@ -1,6 +1,7 @@
 export type PaneDirection = "right" | "left" | "up" | "down";
 export type NewPaneInput = {
     session: string;
+    timeoutMs?: number;
     command?: string[];
     cwd?: string | null;
     name?: string | null;
@@ -13,6 +14,7 @@ export type NewPaneInput = {
 };
 export type NewTabInput = {
     session: string;
+    timeoutMs?: number;
     command?: string[];
     cwd?: string | null;
     name?: string | null;

package/dist/zellij/binary.d.ts

@@ -6,6 +6,53 @@ export declare const DEFAULT_TIMEOUT_MS = 15000;
 export { NOT_FOUND_EXIT };
 /** Expand a leading `~/` or `~\` using USERPROFILE/HOME. */
 export declare function expandHomePath(input: string, env?: NodeJS.ProcessEnv): string;
+/**
+ * True when a path (or basename) is the zswarm CLI rather than Zellij.
+ * Setting ZSWARM_BIN to zswarm makes `list-sessions --short` fail with
+ * "unknown arg: --short" because zswarm re-parses argv as its own CLI.
+ */
+export declare function looksLikeZswarmBinary(path: string): boolean;
+export declare function assertZellijBinaryPath(path: string): void;
+/**
+ * ZSWARM_SSH is a destination, not a full ssh argv.
+ * Accept `user@host` or an SSH config alias; put flags in ZSWARM_SSH_OPTS.
+ */
+export declare function validateSshDestination(raw: string): string;
+export declare function validateSshMode(raw: string): "ssh" | "interactive";
+/** True when `--version` output is positively Zellij. */
+export declare function isZellijVersionOutput(stdout: string, stderr?: string): boolean;
+/**
+ * Cache key covering the resolved binary and SSH routing that can change the
+ * actual remote executable (opts, mode, remote bin).
+ */
+export declare function identityCacheKey(zellijPath: string, ssh?: {
+    host: string;
+    options: string[];
+    mode?: string;
+    remoteBin?: string;
+    /** SSH client binary (`SshTarget.ssh`). */
+    ssh?: string;
+    sshBin?: string;
+    remoteShell?: string;
+} | null): string;
+/**
+ * Confirm the resolved binary is Zellij. Only verified identities are cached.
+ * Transport timeouts leave the cache empty so a later call can retry.
+ * Returns false when verification is unresolved; only true is cached.
+ * In-flight probes are never shared — each caller supplies its own timeout.
+ */
+export declare function ensureZellijIdentity(exec: ExecFn, zellijPath: string, timeoutMs?: number, cacheKey?: string, signal?: AbortSignal): Promise<boolean>;
+export declare function ensureZellijCapabilities(exec: ExecFn, zellijPath: string, timeoutMs?: number, cacheKey?: string, signal?: AbortSignal): Promise<boolean>;
+/**
+ * Identity and capability are independent reads. Run them together under one
+ * remaining budget; do not share in-flight work with another caller.
+ */
+export declare function ensureZellijProbes(exec: ExecFn, zellijPath: string, timeoutMs?: number, cacheKey?: string, signal?: AbortSignal): Promise<{
+    identity: boolean;
+    capabilities: boolean;
+}>;
+/** Test helper: drop cached identity/capability probes. */
+export declare function resetZellijIdentityCache(): void;
 export declare function resolveZellijBinary(env?: NodeJS.ProcessEnv): string;
 export declare function sanitizeZellijEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 /**

package/dist/zellij/binary.js

@@ -1,6 +1,7 @@
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { delimiter, join } from "node:path";
+import { basename, delimiter, join } from "node:path";
+import { ZellijError } from "../errors.js";
 import { createExec, createSshExec, NOT_FOUND_EXIT, } from "../exec.js";
 import { applyIpcTmpEnv } from "./ipc.js";
 export { createSshExec };
@@ -16,15 +17,206 @@ export function expandHomePath(input, env = process.env) {
         return trimmed;
     return join(home, trimmed.slice(2));
 }
+/**
+ * True when a path (or basename) is the zswarm CLI rather than Zellij.
+ * Setting ZSWARM_BIN to zswarm makes `list-sessions --short` fail with
+ * "unknown arg: --short" because zswarm re-parses argv as its own CLI.
+ */
+export function looksLikeZswarmBinary(path) {
+    const trimmed = path.trim();
+    const base = basename(trimmed).toLowerCase();
+    // Windows paths on a Linux host still use backslashes in env values.
+    const winBase = trimmed.replace(/\\/g, "/").split("/").pop()?.toLowerCase() ?? base;
+    const name = winBase || base;
+    if (/^zswarm(\.(exe|cmd|js|mjs|cjs))?$/.test(name))
+        return true;
+    // Native binaries are never the Node CLI wrapper.
+    if (/\.(exe|dll|so|dylib)$/i.test(name))
+        return false;
+    if (name === "zellij")
+        return false;
+    // Shebang wrappers may keep another basename; sniff a short readable prefix.
+    try {
+        if (!existsSync(trimmed))
+            return false;
+        const head = readFileSync(trimmed, { encoding: "utf8" }).slice(0, 400);
+        if (head.includes("\0"))
+            return false;
+        return /@zswarm\/cli/.test(head) || /usage:\s*zswarm/i.test(head);
+    }
+    catch {
+        return false;
+    }
+}
+export function assertZellijBinaryPath(path) {
+    if (!looksLikeZswarmBinary(path))
+        return;
+    throw new ZellijError("zellij_wrong_bin", `ZSWARM_BIN/ZSWARM_PATH points at zswarm (${path}), not Zellij. Set it to the zellij binary (e.g. ~/.local/bin/zellij)`);
+}
+/**
+ * ZSWARM_SSH is a destination, not a full ssh argv.
+ * Accept `user@host` or an SSH config alias; put flags in ZSWARM_SSH_OPTS.
+ */
+export function validateSshDestination(raw) {
+    const host = raw.trim();
+    if (!host) {
+        throw new ZellijError("bad_ssh", "ZSWARM_SSH is empty");
+    }
+    if (/^ssh(\s|$)/i.test(host)) {
+        throw new ZellijError("bad_ssh", `ZSWARM_SSH should be user@host or an SSH alias, not a full ssh command. Put flags in ZSWARM_SSH_OPTS. Got: ${JSON.stringify(host)}`);
+    }
+    // Leading dashes are SSH options (`-V`, `-F…`, `-o…`), not destinations.
+    if (host.startsWith("-")) {
+        throw new ZellijError("bad_ssh", `ZSWARM_SSH looks like an SSH option (${JSON.stringify(host)}); put flags in ZSWARM_SSH_OPTS and set ZSWARM_SSH to user@host or an alias`);
+    }
+    if (/\s/.test(host)) {
+        throw new ZellijError("bad_ssh", `ZSWARM_SSH must be a single destination (user@host or alias); put options in ZSWARM_SSH_OPTS. Got: ${JSON.stringify(host)}`);
+    }
+    if (/[;|&$<>()]/.test(host)) {
+        throw new ZellijError("bad_ssh", `ZSWARM_SSH contains shell metacharacters; expected user@host or an SSH alias. Got: ${JSON.stringify(host)}`);
+    }
+    return host;
+}
+export function validateSshMode(raw) {
+    const mode = raw.trim().toLowerCase();
+    if (!mode || mode === "ssh")
+        return "ssh";
+    if (mode === "interactive")
+        return "interactive";
+    throw new ZellijError("bad_ssh_mode", `ZSWARM_SSH_MODE must be "interactive" or "ssh" (or unset); got ${JSON.stringify(raw.trim())}`);
+}
+/** Cache of verified `zellij --version` probes keyed by target identity. */
+const identityCache = new Set();
+/** True when `--version` output is positively Zellij. */
+export function isZellijVersionOutput(stdout, stderr = "") {
+    const text = `${stdout}\n${stderr}`;
+    return /\bzellij\s+\d+\.\d+/i.test(text) || /^\s*zellij\b/im.test(stdout);
+}
+/**
+ * Cache key covering the resolved binary and SSH routing that can change the
+ * actual remote executable (opts, mode, remote bin).
+ */
+export function identityCacheKey(zellijPath, ssh) {
+    if (!ssh)
+        return JSON.stringify([zellijPath]);
+    return JSON.stringify([
+        zellijPath,
+        ssh.host,
+        ssh.remoteBin ?? "",
+        ssh.mode ?? "ssh",
+        ssh.options,
+        ssh.sshBin ?? ssh.ssh ?? "",
+        ssh.remoteShell ?? "",
+    ]);
+}
+/**
+ * Confirm the resolved binary is Zellij. Only verified identities are cached.
+ * Transport timeouts leave the cache empty so a later call can retry.
+ * Returns false when verification is unresolved; only true is cached.
+ * In-flight probes are never shared — each caller supplies its own timeout.
+ */
+export async function ensureZellijIdentity(exec, zellijPath, timeoutMs = 3_000, cacheKey = zellijPath, signal) {
+    if (identityCache.has(cacheKey))
+        return true;
+    if (signal?.aborted)
+        return false;
+    assertZellijBinaryPath(zellijPath);
+    const result = await exec(["--version"], {
+        timeoutMs: Math.min(timeoutMs, 5_000),
+        signal,
+    });
+    const text = `${result.stdout}\n${result.stderr}`;
+    if (/usage:\s*zswarm/i.test(text) || /unknown arg:/i.test(text)) {
+        throw new ZellijError("zellij_wrong_bin", `resolved binary is zswarm, not Zellij (${zellijPath}). Set ZSWARM_BIN to the zellij executable`);
+    }
+    if (result.code === NOT_FOUND_EXIT) {
+        throw new ZellijError("zellij_missing", `zellij binary not found (${zellijPath}); install Zellij ≥ 0.42, add it to PATH, or set ZSWARM_BIN / ZSWARM_PATH`);
+    }
+    if (result.code === 0) {
+        if (signal?.aborted)
+            return false;
+        if (isZellijVersionOutput(result.stdout, result.stderr)) {
+            identityCache.add(cacheKey);
+            return true;
+        }
+        throw new ZellijError("zellij_wrong_bin", `resolved binary is not Zellij (${zellijPath}); --version returned: ${result.stdout.trim() || result.stderr.trim() || "empty"}`);
+    }
+    // Timeout / transport failure: leave unresolved so a later call retries.
+    return false;
+}
+/**
+ * Probe that the target understands the session-list flags we rely on.
+ * Cached with the same key as identity once verified.
+ * Returns false when the transport cannot verify support.
+ */
+const capabilityCache = new Set();
+export async function ensureZellijCapabilities(exec, zellijPath, timeoutMs = 3_000, cacheKey = zellijPath, signal) {
+    if (capabilityCache.has(cacheKey))
+        return true;
+    if (signal?.aborted)
+        return false;
+    const result = await exec(["list-sessions", "--help"], {
+        timeoutMs: Math.min(timeoutMs, 5_000),
+        signal,
+    });
+    const text = `${result.stdout}\n${result.stderr}`;
+    if (/usage:\s*zswarm/i.test(text)) {
+        throw new ZellijError("zellij_wrong_bin", `resolved binary is zswarm, not Zellij (${zellijPath})`);
+    }
+    if (result.code === NOT_FOUND_EXIT) {
+        throw new ZellijError("zellij_missing", `zellij binary not found (${zellijPath})`);
+    }
+    // Require the flags this client always passes.
+    if (result.code === 0 &&
+        /--no-formatting/i.test(text) &&
+        /list-sessions/i.test(text)) {
+        if (signal?.aborted)
+            return false;
+        capabilityCache.add(cacheKey);
+        return true;
+    }
+    if (result.code === 0) {
+        throw new ZellijError("zellij_incompatible", `Zellij at ${zellijPath} does not advertise list-sessions --no-formatting; upgrade Zellij (≥ 0.42) or zswarm`);
+    }
+    // Soft: leave unresolved on transport failure.
+    return false;
+}
+/**
+ * Identity and capability are independent reads. Run them together under one
+ * remaining budget; do not share in-flight work with another caller.
+ */
+export async function ensureZellijProbes(exec, zellijPath, timeoutMs = 3_000, cacheKey = zellijPath, signal) {
+    if (signal?.aborted)
+        return { identity: false, capabilities: false };
+    const probeTimeout = Math.min(timeoutMs, 5_000);
+    // Settle both so a wrong-bin throw does not leave the other SSH probe running.
+    const settled = await Promise.allSettled([
+        ensureZellijIdentity(exec, zellijPath, probeTimeout, cacheKey, signal),
+        ensureZellijCapabilities(exec, zellijPath, probeTimeout, cacheKey, signal),
+    ]);
+    if (settled[0].status === "rejected")
+        throw settled[0].reason;
+    if (settled[1].status === "rejected")
+        throw settled[1].reason;
+    return { identity: settled[0].value, capabilities: settled[1].value };
+}
+/** Test helper: drop cached identity/capability probes. */
+export function resetZellijIdentityCache() {
+    identityCache.clear();
+    capabilityCache.clear();
+}
 export function resolveZellijBinary(env = process.env) {
     const fromEnv = expandHomePath((env.ZSWARM_BIN ?? env.ZSWARM_PATH ?? env.ZELLIJ_BIN ?? "")
         .trim()
         .replace(/^['"]|['"]$/g, ""), env);
     if (fromEnv && existsSync(fromEnv)) {
+        assertZellijBinaryPath(fromEnv);
         if (/\.cmd$/i.test(fromEnv)) {
             const exe = fromEnv.replace(/\.cmd$/i, ".exe");
-            if (existsSync(exe))
+            if (existsSync(exe)) {
+                assertZellijBinaryPath(exe);
                 return exe;
+            }
             const wingetExe = join(env.LOCALAPPDATA ||
                 join(env.USERPROFILE || env.HOME || homedir(), "AppData", "Local"), "Zellij", "zellij.exe");
             if (existsSync(wingetExe))
@@ -112,17 +304,18 @@ export function parseSshOpts(raw) {
     return out;
 }
 export function resolveSshTarget(env = process.env) {
-    const host = env.ZSWARM_SSH?.trim();
-    if (!host)
+    const raw = env.ZSWARM_SSH?.trim();
+    if (!raw)
         return null;
+    const host = validateSshDestination(raw);
     const options = parseSshOpts(env.ZSWARM_SSH_OPTS ?? "");
     if (!options.some((o) => o.startsWith("BatchMode"))) {
         options.unshift("-o", "BatchMode=yes");
     }
     const shellRaw = (env.ZSWARM_REMOTE_SHELL ?? "").trim().toLowerCase();
-    const modeRaw = (env.ZSWARM_SSH_MODE ?? "").trim().toLowerCase();
+    const mode = validateSshMode(env.ZSWARM_SSH_MODE ?? "");
     const tmpRaw = env.ZSWARM_TMP?.trim();
-    const interactive = modeRaw === "interactive";
+    const interactive = mode === "interactive";
     return {
         ssh: env.ZSWARM_SSH_BIN?.trim() || "ssh",
         host,
@@ -130,7 +323,7 @@ export function resolveSshTarget(env = process.env) {
         options,
         // Interactive tasks do not inherit the desktop TEMP; discover it unless set.
         tmp: tmpRaw || (interactive ? "auto" : undefined),
-        mode: interactive ? "interactive" : "ssh",
+        mode,
         remoteShell: shellRaw === "cmd" || shellRaw === "sh" ? shellRaw : undefined,
     };
 }

package/dist/zellij/bus.d.ts

@@ -23,6 +23,8 @@ export type BusSnapshot = {
     paneUpdates: number;
     tabUpdates: number;
     tabs: string[];
+    /** Stable IDs by tab position; absent on older running plugin instances. */
+    tabIds?: (number | null)[];
     panes: BusPane[];
 };
 export type BusMarker = {

package/dist/zellij/bus.js

@@ -74,7 +74,7 @@ export function parseChangedReply(stdout) {
             if (!row || typeof row !== "object")
                 continue;
             const p = row;
-            if (typeof p.id !== "string")
+            if (typeof p.id !== "string" || typeof p.changed !== "boolean" || typeof p.first !== "boolean" || !Array.isArray(p.viewport))
                 continue;
             panes.push({
                 id: p.id,
@@ -186,6 +186,7 @@ function toSnapshot(value) {
         tabs: Array.isArray(value.tabs)
             ? value.tabs.filter((t) => typeof t === "string")
             : [],
+        ...(Array.isArray(value.tabIds) ? { tabIds: value.tabIds.map((id) => typeof id === "number" && Number.isInteger(id) && id >= 0 ? id : null) } : {}),
         panes,
     };
 }
@@ -290,7 +291,7 @@ export function busToPanes(snapshot) {
             command: pane.command,
             cwd: null,
             tabName: snapshot.tabs[pane.tab] ?? null,
-            tabId: pane.tab,
+            tabId: snapshot.tabIds?.[pane.tab] ?? null,
             focused: pane.focused,
             exited: pane.exited,
             floating: false,

package/dist/zellij/cache.d.ts

@@ -0,0 +1,24 @@
+/** Short-lived, completed observations only. Never shares a caller's promise or budget. */
+export declare class ListingCache {
+    private readonly limit;
+    private entries;
+    private scopes;
+    constructor(limit?: number);
+    begin(scope: string): {
+        state: {
+            version: number;
+            revision?: string;
+        };
+        version: number;
+    };
+    get<T>(key: string, now: number): T | undefined;
+    put<T>(key: string, scope: string, ticket: ReturnType<ListingCache["begin"]>, value: T, ttl: number, now: number): void;
+    invalidate(scope: string): void;
+    observe(scope: string, revision: string): boolean;
+    clear(): void;
+}
+export declare const sharedListings: ListingCache;
+export declare function executorIdentity(exec?: object): number | null;
+/** Environment fields that select local sockets or an SSH identity/config. */
+export declare function routingEnvironment(env: NodeJS.ProcessEnv): Record<string, string | null>;
+export declare function listingTtl(env: NodeJS.ProcessEnv): number;

package/dist/zellij/cache.js

@@ -0,0 +1,90 @@
+/** Short-lived, completed observations only. Never shares a caller's promise or budget. */
+export class ListingCache {
+    limit;
+    entries = new Map();
+    scopes = new Map();
+    constructor(limit = 512) {
+        this.limit = limit;
+    }
+    begin(scope) {
+        let state = this.scopes.get(scope);
+        if (!state) {
+            state = { version: 0 };
+            this.scopes.set(scope, state);
+            if (this.scopes.size > this.limit) {
+                const oldest = this.scopes.keys().next().value;
+                this.scopes.delete(oldest);
+                for (const [key, entry] of this.entries)
+                    if (entry.scope === oldest)
+                        this.entries.delete(key);
+            }
+        }
+        return { state, version: state.version };
+    }
+    get(key, now) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return undefined;
+        if (now >= entry.expiresAt) {
+            this.entries.delete(key);
+            return undefined;
+        }
+        return structuredClone(entry.value);
+    }
+    put(key, scope, ticket, value, ttl, now) {
+        // A mutation/event during this read must not resurrect an older manifest.
+        if (ttl <= 0 || this.scopes.get(scope) !== ticket.state || ticket.state.version !== ticket.version)
+            return;
+        this.entries.delete(key);
+        this.entries.set(key, { scope, value: structuredClone(value), expiresAt: now + ttl });
+        while (this.entries.size > this.limit)
+            this.entries.delete(this.entries.keys().next().value);
+    }
+    invalidate(scope) {
+        this.begin(scope).state.version++;
+        for (const [key, entry] of this.entries)
+            if (entry.scope === scope)
+                this.entries.delete(key);
+    }
+    observe(scope, revision) {
+        const { state } = this.begin(scope);
+        if (state.revision === revision)
+            return false;
+        this.invalidate(scope);
+        state.revision = revision;
+        return true;
+    }
+    clear() {
+        this.entries.clear();
+        this.scopes.clear();
+    }
+}
+export const sharedListings = new ListingCache();
+const executors = new WeakMap();
+let nextExecutor = 0;
+export function executorIdentity(exec) {
+    if (!exec)
+        return null;
+    let id = executors.get(exec);
+    if (id === undefined) {
+        id = ++nextExecutor;
+        executors.set(exec, id);
+    }
+    return id;
+}
+/** Environment fields that select local sockets or an SSH identity/config. */
+export function routingEnvironment(env) {
+    return Object.fromEntries([
+        "ZSWARM_TMP", "ZELLIJ_SOCKET_DIR", "TMPDIR", "TEMP", "TMP", "XDG_RUNTIME_DIR",
+        "HOME", "USERPROFILE", "USER", "USERNAME", "LOGNAME", "USERDOMAIN", "SSH_AUTH_SOCK",
+        "PATH", "Path", "PATHEXT", "XDG_CONFIG_HOME", "ZELLIJ_CONFIG_DIR",
+        "ZELLIJ_SESSION_NAME", "ZSWARM_SESSION",
+    ].map((key) => [key, env[key] ?? null]));
+}
+export function listingTtl(env) {
+    const value = env.ZSWARM_CACHE_TTL_MS;
+    if (value === undefined || value.trim() === "")
+        return 500;
+    const ttl = Number(value);
+    return Number.isFinite(ttl) ? Math.max(0, Math.min(5000, ttl)) : 500;
+}

package/dist/zellij/client.d.ts

@@ -1,24 +1,50 @@
+import { ListingCache } from "./cache.js";
 import { buildClosePaneArgs, buildDumpArgs, buildListPanesArgs, buildNewPaneArgs, buildNewTabArgs, buildPasteArgs, buildSendEnterArgs, buildSendKeysArgs, buildWriteCharsArgs, type WaitRequest, type LaunchPluginInput, type NewPaneInput, type NewTabInput, type PipeInput } from "./args.js";
 import { resolveTab, type ZellijTab } from "./tabs.js";
+import { type IpcDiscoveryState } from "../exec.js";
 import { type ZellijExecFn } from "./binary.js";
 import { normalizePaneId, resolvePane, type ZellijPane } from "./panes.js";
-import { type ZellijSessionResolve } from "./session.js";
+import { type ZellijSession, type ZellijSessionResolve } from "./session.js";
 export type ZellijClientOptions = {
     exec?: ZellijExecFn;
     zellijPath?: string;
     timeoutMs?: number;
     env?: NodeJS.ProcessEnv;
     signal?: AbortSignal;
+    /** Skip the one-time `zellij --version` identity probe (tests). */
+    skipIdentityProbe?: boolean;
+    /** Completed listing cache shared by long-lived MCP/serve calls; false bypasses reads. */
+    cache?: ListingCache | false;
+    /** Clock for cache TTLs; process deadlines continue using wall time. */
+    now?: () => number;
 };
-/** Thin, stateless wrapper over the `zellij` binary. */
+export type ZellijTransport = {
+    kind: "local" | "ssh";
+    mode: "local" | "ssh" | "interactive";
+    host?: string;
+    remoteBin?: string;
+    /** Configured or resolved IPC temp (`auto` until discovery succeeds). */
+    tmp?: string;
+    /** Outcome of `ZSWARM_TMP=auto` discovery when SSH routing is active. */
+    ipc?: IpcDiscoveryState;
+};
+/** Zellij wrapper with bounded caches of completed discovery observations. */
 export declare function createZellijClient(options?: ZellijClientOptions): {
     zellijPath: string;
     selfPaneId: string | null;
+    contextKey: () => string;
+    invalidateListings: (session: string) => void;
+    observeManifest: (session: string, revision: string) => void;
+    readonly transport: ZellijTransport;
     /** A `file:` plugin url only names a path on the machine running Zellij. */
     remote: boolean;
-    listSessions: () => Promise<string[]>;
-    resolveSession: (explicit?: string | null) => Promise<ZellijSessionResolve>;
-    listPanes: (session: string) => Promise<ZellijPane[]>;
+    listSessions: (callTimeoutMs?: number, opts?: {
+        fresh?: boolean;
+    }) => Promise<ZellijSession[]>;
+    resolveSession: (explicit?: string | null, callTimeoutMs?: number) => Promise<ZellijSessionResolve>;
+    listPanes: (session: string, callTimeoutMs?: number, opts?: {
+        fresh?: boolean;
+    }) => Promise<ZellijPane[]>;
     resolvePane: typeof resolvePane;
     injectPane: (input: {
         session: string;
@@ -32,6 +58,7 @@ export declare function createZellijClient(options?: ZellijClientOptions): {
         session: string;
         paneId: string;
         full?: boolean;
+        timeoutMs?: number;
     }) => Promise<{
         paneId: string;
         session: string;
@@ -75,6 +102,7 @@ export declare function createZellijClient(options?: ZellijClientOptions): {
         session: string;
         paneId: string;
         name: string;
+        timeoutMs?: number;
     }) => Promise<{
         paneId: string;
         session: string;
@@ -96,7 +124,9 @@ export declare function createZellijClient(options?: ZellijClientOptions): {
         paneId: string;
         session: string;
     }>;
-    listTabs: (session: string) => Promise<ZellijTab[]>;
+    listTabs: (session: string, callTimeoutMs?: number, opts?: {
+        fresh?: boolean;
+    }) => Promise<ZellijTab[]>;
     dumpLayout: (session: string) => Promise<string>;
     stackPanes: (input: {
         session: string;
@@ -138,6 +168,7 @@ export declare function createZellijClient(options?: ZellijClientOptions): {
         url: string;
         configKey: string;
         panes: string[];
+        timeoutMs?: number;
     }) => Promise<{
         code: number;
         stdout: string;