tmux-ide 1.2.1 → 1.3.1

package/dist/lib/session-monitor.js

@@ -0,0 +1,160 @@
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { resolve } from "node:path";
+const INTERVAL = 1000;
+const SPINNERS = /^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏⠂⠒⠢⠆⠐⠠⠄◐◓◑◒|/\\-] /;
+// --- Port detection (pure helpers) ---
+function getListeningPids() {
+    // Returns Set of PIDs that have a listening TCP port in range 1024-20000
+    try {
+        const raw = execFileSync("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN", "-FpPn"], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        const pids = new Set();
+        let currentPid = null;
+        for (const line of raw.split("\n")) {
+            if (line.startsWith("p")) {
+                currentPid = line.slice(1);
+            }
+            else if (line.startsWith("n") && currentPid) {
+                const match = line.match(/:(\d+)$/);
+                if (match) {
+                    const port = parseInt(match[1], 10);
+                    if (port >= 1024 && port <= 20000)
+                        pids.add(currentPid);
+                }
+            }
+        }
+        return pids;
+    }
+    catch {
+        return new Set();
+    }
+}
+function getProcessTree() {
+    // Returns Map<pid, ppid>
+    try {
+        const raw = execFileSync("ps", ["-axo", "pid=,ppid="], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        const tree = new Map();
+        for (const line of raw.trim().split("\n")) {
+            const parts = line.trim().split(/\s+/);
+            if (parts.length === 2)
+                tree.set(parts[0], parts[1]);
+        }
+        return tree;
+    }
+    catch {
+        return new Map();
+    }
+}
+export function computePortPanes(panes, { listeners, tree } = {}) {
+    // Walk up from each listening PID to find which pane owns it
+    const resolvedListeners = listeners ?? getListeningPids();
+    const resolvedTree = tree ?? getProcessTree();
+    if (resolvedListeners.size === 0)
+        return new Set();
+    const panePids = new Map(panes.map((p) => [p.pid, p.id]));
+    const result = new Set();
+    for (const listenerPid of resolvedListeners) {
+        let pid = listenerPid;
+        while (pid && pid !== "0") {
+            if (panePids.has(pid)) {
+                result.add(panePids.get(pid));
+                break;
+            }
+            pid = resolvedTree.get(pid);
+        }
+    }
+    return result;
+}
+// --- Agent detection ---
+export function computeAgentStates(panes) {
+    // Returns Map<paneId, "busy" | "idle" | null>
+    const states = new Map();
+    for (const pane of panes) {
+        const cmd = (pane.cmd ?? "").toLowerCase();
+        if (!cmd.includes("claude") && !cmd.includes("codex")) {
+            states.set(pane.id, null);
+            continue;
+        }
+        states.set(pane.id, SPINNERS.test(pane.title ?? "") ? "busy" : "idle");
+    }
+    return states;
+}
+// --- Main loop (only runs when executed directly) ---
+const isMainModule = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMainModule) {
+    const session = process.argv[2];
+    if (!session)
+        process.exit(1);
+    function tmux(...args) {
+        return execFileSync("tmux", args, { encoding: "utf-8" }).trim();
+    }
+    function tmuxSilent(...args) {
+        try {
+            return tmux(...args);
+        }
+        catch {
+            return "";
+        }
+    }
+    function sessionExists() {
+        try {
+            tmux("has-session", "-t", session);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    function hasClients() {
+        return tmuxSilent("list-clients").length > 0;
+    }
+    function listPanes() {
+        const raw = tmuxSilent("list-panes", "-t", session, "-F", "#{pane_id}\t#{pane_pid}\t#{pane_current_command}\t#{pane_title}");
+        if (!raw)
+            return [];
+        return raw.split("\n").map((line) => {
+            const [id, pid, cmd, title] = line.split("\t");
+            return { id: id, pid: pid, cmd, title };
+        });
+    }
+    let lastState = "";
+    function tick() {
+        if (!sessionExists())
+            process.exit(0);
+        if (!hasClients())
+            return; // skip when nobody is watching
+        const panes = listPanes();
+        if (panes.length === 0)
+            return;
+        const portPanes = computePortPanes(panes);
+        const agentStates = computeAgentStates(panes);
+        // Build state fingerprint for change detection
+        const stateKey = panes
+            .map((p) => {
+            const port = portPanes.has(p.id) ? "1" : "0";
+            const agent = agentStates.get(p.id) ?? "-";
+            return `${p.id}:${port}:${agent}`;
+        })
+            .join("|");
+        if (stateKey === lastState)
+            return;
+        // Apply changes
+        for (const pane of panes) {
+            const hasPort = portPanes.has(pane.id) ? "1" : "0";
+            const agent = agentStates.get(pane.id);
+            tmuxSilent("set-option", "-pqt", pane.id, "@has_port", hasPort);
+            tmuxSilent("set-option", "-pqt", pane.id, "@agent_busy", agent === "busy" ? "1" : "0");
+            tmuxSilent("set-option", "-pqt", pane.id, "@agent_idle", agent === "idle" ? "1" : "0");
+        }
+        tmuxSilent("refresh-client", "-S");
+        lastState = stateKey;
+    }
+    setInterval(tick, INTERVAL);
+    tick(); // run immediately
+}

package/dist/lib/session-options.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Composable builders for tmux session configuration.
+ * Each returns an array of tmux command arrays.
+ */
+import type { ThemeConfig, TmuxCommand } from "../types.ts";
+export declare function buildSessionOptions(session: string, { theme }?: {
+    theme?: ThemeConfig;
+}): TmuxCommand[];
+export declare function themeOptions(session: string, theme: ThemeConfig): TmuxCommand[];
+export declare function borderOptions(session: string, theme: ThemeConfig): TmuxCommand[];
+export declare function behaviorOptions(session: string): TmuxCommand[];
+export declare function statusBarOptions(session: string, theme: ThemeConfig): TmuxCommand[];
+export declare function keyBindings(): TmuxCommand[];

package/dist/lib/session-options.js

@@ -0,0 +1,85 @@
+/**
+ * Composable builders for tmux session configuration.
+ * Each returns an array of tmux command arrays.
+ */
+export function buildSessionOptions(session, { theme = {} } = {}) {
+    return [
+        ...themeOptions(session, theme),
+        ...borderOptions(session, theme),
+        ...behaviorOptions(session),
+        ...statusBarOptions(session, theme),
+        ...keyBindings(),
+    ];
+}
+export function themeOptions(session, theme) {
+    const accent = theme.accent ?? "colour75";
+    const border = theme.border ?? "colour238";
+    const bg = theme.bg ?? "colour235";
+    const fg = theme.fg ?? "colour248";
+    return [
+        ["set-option", "-t", session, "status-style", `bg=${bg},fg=${fg}`],
+        ["set-option", "-t", session, "pane-border-style", `fg=${border}`],
+        ["set-option", "-t", session, "pane-active-border-style", `fg=${accent}`],
+    ];
+}
+export function borderOptions(session, theme) {
+    const accent = theme.accent ?? "colour75";
+    const border = theme.border ?? "colour238";
+    const fg = theme.fg ?? "colour248";
+    return [
+        ["set-option", "-t", session, "pane-border-status", "top"],
+        [
+            "set-option",
+            "-t",
+            session,
+            "pane-border-format",
+            ` #{?pane_active,#[fg=${accent}#,bold]▸ #T  #[fg=${fg}]#{pane_current_path},#[fg=${border}]· #T  #{pane_current_path}} `,
+        ],
+    ];
+}
+export function behaviorOptions(session) {
+    return [
+        ["set-option", "-t", session, "mouse", "on"],
+        ["set-option", "-t", session, "escape-time", "0"],
+        ["set-option", "-t", session, "status-interval", "1"],
+    ];
+}
+export function statusBarOptions(session, theme) {
+    const accent = theme.accent ?? "colour75";
+    const border = theme.border ?? "colour238";
+    const fg = theme.fg ?? "colour248";
+    // Pane tab components — each is a self-contained piece
+    const agentIndicator = [
+        `#{?#{==:#{@agent_busy},1},#[fg=${accent}]⏺ ,`,
+        `#{?#{==:#{@agent_idle},1},#[fg=${border}]● ,}}`,
+    ].join("");
+    const portIndicator = `#{?#{==:#{@has_port},1},#[fg=green]⏺ ,}`;
+    const paneStyle = `#{?pane_active,#[fg=${accent}],#[fg=${border}]}`;
+    const paneTab = `${agentIndicator}${portIndicator}${paneStyle}#[range=pane|#{pane_id}] #T #[norange]#[default]`;
+    const separator = `#{?loop_last_flag,,#[fg=${border}]│}`;
+    return [
+        [
+            "set-option",
+            "-t",
+            session,
+            "status-left",
+            `#[fg=colour0,bg=${accent},bold]  ${session.toUpperCase()} IDE #[default] `,
+        ],
+        ["set-option", "-t", session, "status-left-length", "30"],
+        [
+            "set-option",
+            "-t",
+            session,
+            "status-right",
+            `#[fg=colour243]%H:%M #[fg=${accent}]│ #[fg=${fg}]%b %d `,
+        ],
+        ["set-option", "-t", session, "status-justify", "centre"],
+        ["set-option", "-t", session, "window-status-current-format", `#[fg=${accent},bold]●`],
+        ["set-option", "-t", session, "window-status-format", `#[fg=${border}]○`],
+        ["set-option", "-t", session, "status", "2"],
+        ["set-option", "-t", session, "status-format[1]", `  #{P:${paneTab}${separator}}`],
+    ];
+}
+export function keyBindings() {
+    return [["bind-key", "-n", "MouseDown1StatusDefault", "select-pane", "-t", "="]];
+}

package/dist/lib/sizes.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Compute absolute sizes for items where some have explicit sizes and others don't.
+ * Items with `size` (e.g. "70%") keep their value; remaining space is split equally
+ * among items without a size.
+ */
+export declare function computeSizes(items: {
+    size?: string;
+}[]): number[];
+/**
+ * Convert absolute sizes (e.g. [70, 30]) to tmux split percentages for sequential splits.
+ * Returns array of -p values (one per split after the first item).
+ *
+ * Each tmux split divides the current pane. The percentage given to -p is
+ * the portion allocated to the NEW (bottom/right) pane.
+ */
+export declare function toSplitPercents(sizes: number[]): number[];

package/dist/lib/sizes.js

@@ -0,0 +1,36 @@
+/**
+ * Compute absolute sizes for items where some have explicit sizes and others don't.
+ * Items with `size` (e.g. "70%") keep their value; remaining space is split equally
+ * among items without a size.
+ */
+export function computeSizes(items) {
+    let claimed = 0;
+    let unclaimed = 0;
+    for (const item of items) {
+        if (item.size) {
+            claimed += parseFloat(item.size);
+        }
+        else {
+            unclaimed++;
+        }
+    }
+    const remaining = Math.max(0, 100 - claimed);
+    const defaultSize = unclaimed > 0 ? remaining / unclaimed : 0;
+    return items.map((item) => (item.size ? parseFloat(item.size) : defaultSize));
+}
+/**
+ * Convert absolute sizes (e.g. [70, 30]) to tmux split percentages for sequential splits.
+ * Returns array of -p values (one per split after the first item).
+ *
+ * Each tmux split divides the current pane. The percentage given to -p is
+ * the portion allocated to the NEW (bottom/right) pane.
+ */
+export function toSplitPercents(sizes) {
+    const percents = [];
+    for (let i = 1; i < sizes.length; i++) {
+        const remaining = sizes.slice(i - 1).reduce((a, b) => a + b, 0);
+        const topShare = sizes[i - 1];
+        percents.push(Math.round(((remaining - topShare) / remaining) * 100));
+    }
+    return percents;
+}

package/dist/lib/tmux.d.ts

@@ -0,0 +1,42 @@
+import { execFileSync, spawn } from "node:child_process";
+import { TmuxError } from "./errors.ts";
+import type { SessionState } from "../types.ts";
+export { TmuxError };
+export declare function getSessionState(session: string): SessionState;
+export declare function attachSession(session: string): void;
+export declare function hasSession(session: string): boolean;
+export declare function killSession(session: string): {
+    stopped: boolean;
+    reason: string | null;
+};
+export declare function listPanes(session: string): {
+    index: number;
+    title: string | undefined;
+    width: number;
+    height: number;
+    active: boolean;
+}[];
+export declare function createDetachedSession(session: string, cwd: string, { cols, lines }?: {
+    cols?: number;
+    lines?: number;
+}): string;
+export declare function setSessionEnvironment(session: string, key: string, value: string | number): void;
+export declare function splitPane(targetPane: string, direction: string, cwd: string, percent: number): string;
+export declare function sendLiteral(targetPane: string, text: string): void;
+export declare function getPaneCurrentCommand(targetPane: string): string;
+export declare function selectPane(targetPane: string): void;
+export declare function setPaneTitle(targetPane: string, title: string): void;
+export declare function runSessionCommand(args: string[]): void;
+export declare function startSessionMonitor(session: string, monitorScript: string): void;
+export declare function stopSessionMonitor(session: string): void;
+export declare function getSessionVariable(session: string, name: string): string | null;
+export declare function setSessionVariable(session: string, name: string, value: string): void;
+type Executor = typeof execFileSync;
+type Spawner = typeof spawn;
+/** @internal Replace the executor for testing. Returns a restore function. */
+export declare function _setExecutor(fn: Executor): () => void;
+/** @internal Replace the spawner for testing. Returns a restore function. */
+export declare function _setSpawner(fn: Spawner): () => void;
+declare global {
+    var __tmuxIdeVerbose: boolean | undefined;
+}

package/dist/lib/tmux.js

@@ -0,0 +1,225 @@
+import { execFileSync, spawn } from "node:child_process";
+import { TmuxError } from "./errors.js";
+const DEBUG = process.env.TMUX_IDE_DEBUG === "1";
+const SESSION_NOT_FOUND_PATTERNS = ["can't find session", "can't find window", "unknown target"];
+const TMUX_UNAVAILABLE_PATTERNS = [
+    "failed to connect to server",
+    "no server running",
+    "error connecting to",
+    "connection refused",
+];
+export { TmuxError };
+export function getSessionState(session) {
+    try {
+        runTmux(["has-session", "-t", session]);
+        return { running: true, reason: null };
+    }
+    catch (error) {
+        if (error instanceof TmuxError) {
+            if (error.code === "SESSION_NOT_FOUND") {
+                return { running: false, reason: "SESSION_NOT_FOUND" };
+            }
+            if (error.code === "TMUX_UNAVAILABLE") {
+                return { running: false, reason: "TMUX_UNAVAILABLE" };
+            }
+        }
+        throw error;
+    }
+}
+export function attachSession(session) {
+    runTmux(["attach", "-t", session], { stdio: "inherit" });
+}
+export function hasSession(session) {
+    try {
+        runTmux(["has-session", "-t", session]);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof TmuxError &&
+            (error.code === "SESSION_NOT_FOUND" || error.code === "TMUX_UNAVAILABLE")) {
+            return false;
+        }
+        throw error;
+    }
+}
+export function killSession(session) {
+    try {
+        runTmux(["kill-session", "-t", session]);
+        return { stopped: true, reason: null };
+    }
+    catch (error) {
+        if (error instanceof TmuxError) {
+            if (error.code === "SESSION_NOT_FOUND") {
+                return { stopped: false, reason: "SESSION_NOT_FOUND" };
+            }
+            if (error.code === "TMUX_UNAVAILABLE") {
+                return { stopped: false, reason: "TMUX_UNAVAILABLE" };
+            }
+        }
+        throw error;
+    }
+}
+export function listPanes(session) {
+    const raw = runTmux([
+        "list-panes",
+        "-t",
+        session,
+        "-F",
+        "#{pane_index}|#{pane_title}|#{pane_width}|#{pane_height}|#{pane_active}",
+    ], { encoding: "utf-8" }).trim();
+    if (!raw)
+        return [];
+    return raw.split("\n").map((line) => {
+        const [index, title, width, height, active] = line.split("|");
+        return {
+            index: Number.parseInt(index, 10),
+            title,
+            width: Number.parseInt(width, 10),
+            height: Number.parseInt(height, 10),
+            active: active === "1",
+        };
+    });
+}
+export function createDetachedSession(session, cwd, { cols, lines } = {}) {
+    return runTmux([
+        "new-session",
+        "-d",
+        "-P",
+        "-F",
+        "#{pane_id}",
+        "-s",
+        session,
+        "-c",
+        cwd,
+        "-x",
+        String(cols ?? 200),
+        "-y",
+        String(lines ?? 50),
+    ], { encoding: "utf-8" }).trim();
+}
+export function setSessionEnvironment(session, key, value) {
+    runTmux(["set-environment", "-t", session, key, String(value)]);
+}
+export function splitPane(targetPane, direction, cwd, percent) {
+    return runTmux([
+        "split-window",
+        "-P",
+        "-F",
+        "#{pane_id}",
+        "-t",
+        targetPane,
+        direction === "vertical" ? "-v" : "-h",
+        "-c",
+        cwd,
+        "-p",
+        String(percent),
+    ], { encoding: "utf-8" }).trim();
+}
+export function sendLiteral(targetPane, text) {
+    runTmux(["send-keys", "-t", targetPane, "-l", "--", text], { stdio: "inherit" });
+    runTmux(["send-keys", "-t", targetPane, "Enter"], { stdio: "inherit" });
+}
+export function getPaneCurrentCommand(targetPane) {
+    return runTmux(["display-message", "-p", "-t", targetPane, "#{pane_current_command}"], {
+        encoding: "utf-8",
+    }).trim();
+}
+export function selectPane(targetPane) {
+    runTmux(["select-pane", "-t", targetPane], { stdio: "inherit" });
+}
+export function setPaneTitle(targetPane, title) {
+    runTmux(["select-pane", "-t", targetPane, "-T", title], { stdio: "inherit" });
+}
+export function runSessionCommand(args) {
+    runTmux(args, { stdio: "inherit" });
+}
+export function startSessionMonitor(session, monitorScript) {
+    const child = _spawner("node", [monitorScript, session], {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+    // Store PID as tmux session variable for later cleanup
+    runTmux(["set-option", "-t", session, "@monitor_pid", String(child.pid)]);
+}
+export function stopSessionMonitor(session) {
+    try {
+        const pid = runTmux(["show-option", "-gqvt", session, "@monitor_pid"], {
+            encoding: "utf-8",
+        }).trim();
+        if (pid)
+            process.kill(parseInt(pid, 10));
+    }
+    catch {
+        /* session or process already gone */
+    }
+}
+export function getSessionVariable(session, name) {
+    try {
+        const raw = runTmux(["show-option", "-gqvt", session, name], {
+            encoding: "utf-8",
+        });
+        return raw.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function setSessionVariable(session, name, value) {
+    runTmux(["set-option", "-t", session, name, value]);
+}
+let _executor = execFileSync;
+let _spawner = spawn;
+/** @internal Replace the executor for testing. Returns a restore function. */
+export function _setExecutor(fn) {
+    const prev = _executor;
+    _executor = fn;
+    return () => {
+        _executor = prev;
+    };
+}
+/** @internal Replace the spawner for testing. Returns a restore function. */
+export function _setSpawner(fn) {
+    const prev = _spawner;
+    _spawner = fn;
+    return () => {
+        _spawner = prev;
+    };
+}
+function runTmux(args, options = {}) {
+    if (DEBUG || globalThis.__tmuxIdeVerbose) {
+        console.error(`  [tmux] ${args.join(" ")}`);
+    }
+    const execOptions = {
+        stdio: ["ignore", "pipe", "pipe"],
+        ...options,
+    };
+    try {
+        return _executor("tmux", args, execOptions);
+    }
+    catch (error) {
+        throw classifyTmuxError(error);
+    }
+}
+function classifyTmuxError(error) {
+    const detail = getErrorDetail(error).toLowerCase();
+    if (SESSION_NOT_FOUND_PATTERNS.some((pattern) => detail.includes(pattern))) {
+        return new TmuxError("tmux session was not found", "SESSION_NOT_FOUND", {
+            cause: error,
+        });
+    }
+    if (TMUX_UNAVAILABLE_PATTERNS.some((pattern) => detail.includes(pattern))) {
+        return new TmuxError("tmux is unavailable or its socket is inaccessible", "TMUX_UNAVAILABLE", {
+            cause: error,
+        });
+    }
+    return new TmuxError("tmux command failed", "TMUX_ERROR", { cause: error });
+}
+function getErrorDetail(error) {
+    const stderr = error?.stderr;
+    if (typeof stderr === "string" && stderr.length > 0)
+        return stderr;
+    if (Buffer.isBuffer(stderr) && stderr.length > 0)
+        return stderr.toString("utf-8");
+    return error?.message ?? "";
+}

package/dist/lib/yaml-io.d.ts

@@ -0,0 +1,10 @@
+import type { IdeConfig } from "../types.ts";
+export declare function readConfig(dir: string): {
+    config: IdeConfig;
+    configPath: string;
+};
+export declare function writeConfig(dir: string, config: IdeConfig): string;
+export declare function getSessionName(dir: string): {
+    name: string;
+    source: "config" | "fallback";
+};

package/dist/lib/yaml-io.js

@@ -0,0 +1,24 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { resolve, basename } from "node:path";
+import yaml from "js-yaml";
+export function readConfig(dir) {
+    const configPath = resolve(dir, "ide.yml");
+    const raw = readFileSync(configPath, "utf-8");
+    const config = yaml.load(raw);
+    return { config, configPath };
+}
+export function writeConfig(dir, config) {
+    const configPath = resolve(dir, "ide.yml");
+    const out = yaml.dump(config, { lineWidth: -1, noRefs: true, quotingType: '"' });
+    writeFileSync(configPath, out);
+    return configPath;
+}
+export function getSessionName(dir) {
+    try {
+        const { config } = readConfig(dir);
+        return { name: config.name ?? basename(dir), source: config.name ? "config" : "fallback" };
+    }
+    catch {
+        return { name: basename(dir), source: "fallback" };
+    }
+}

package/dist/ls.d.ts

@@ -0,0 +1,3 @@
+export declare function ls({ json }?: {
+    json?: boolean;
+}): Promise<void>;

package/dist/ls.js

@@ -0,0 +1,35 @@
+import { execSync } from "node:child_process";
+export async function ls({ json } = {}) {
+    let raw;
+    try {
+        raw = execSync('tmux list-sessions -F "#{session_name}|#{session_created}|#{session_attached}"', { encoding: "utf-8" }).trim();
+    }
+    catch {
+        if (json) {
+            console.log(JSON.stringify({ sessions: [] }));
+        }
+        else {
+            console.log("No tmux sessions running.");
+        }
+        return;
+    }
+    const sessions = raw.split("\n").map((line) => {
+        const [name, created, attached] = line.split("|");
+        return {
+            name,
+            created: new Date(parseInt(created) * 1000).toISOString(),
+            attached: attached !== "0",
+        };
+    });
+    if (json) {
+        console.log(JSON.stringify({ sessions }, null, 2));
+        return;
+    }
+    // Table output
+    console.log("SESSION".padEnd(24) + "CREATED".padEnd(22) + "ATTACHED");
+    console.log("─".repeat(54));
+    for (const s of sessions) {
+        const date = new Date(s.created).toLocaleString();
+        console.log(s.name.padEnd(24) + date.padEnd(22) + (s.attached ? "yes" : "no"));
+    }
+}

package/dist/restart.d.ts

@@ -0,0 +1,4 @@
+export declare function restart(targetDir: string | undefined, { json, attach }?: {
+    json?: boolean;
+    attach?: boolean;
+}): Promise<void>;

package/dist/restart.js

@@ -0,0 +1,13 @@
+import { resolve } from "node:path";
+import { getSessionName } from "./lib/yaml-io.js";
+import { launch } from "./launch.js";
+import { killSession } from "./lib/tmux.js";
+export async function restart(targetDir, { json, attach } = {}) {
+    const dir = resolve(targetDir ?? ".");
+    const { name: session } = getSessionName(dir);
+    const result = killSession(session);
+    if (result.stopped) {
+        console.log(`Stopped session "${session}"`);
+    }
+    await launch(dir, { json, attach });
+}

package/dist/status.d.ts

@@ -0,0 +1,3 @@
+export declare function status(targetDir: string | undefined, { json }?: {
+    json?: boolean;
+}): Promise<void>;