tmux-ide 1.2.1 → 1.3.1

package/bin/cli.js

@@ -1,20 +1,20 @@
 #!/usr/bin/env node
 import { parseArgs } from "node:util";
 import { createRequire } from "node:module";
-import { launch } from "../src/launch.js";
-import { init } from "../src/init.js";
-import { stop } from "../src/stop.js";
-import { attach } from "../src/attach.js";
-import { ls } from "../src/ls.js";
-import { doctor } from "../src/doctor.js";
-import { status } from "../src/status.js";
-import { inspect } from "../src/inspect.js";
-import { validate } from "../src/validate.js";
-import { detect } from "../src/detect.js";
-import { config } from "../src/config.js";
-import { restart } from "../src/restart.js";
-import { IdeError } from "../src/lib/errors.js";
-import { printCommandError } from "../src/lib/output.js";
+import { launch } from "../dist/launch.js";
+import { init } from "../dist/init.js";
+import { stop } from "../dist/stop.js";
+import { attach } from "../dist/attach.js";
+import { ls } from "../dist/ls.js";
+import { doctor } from "../dist/doctor.js";
+import { status } from "../dist/status.js";
+import { inspect } from "../dist/inspect.js";
+import { validate } from "../dist/validate.js";
+import { detect } from "../dist/detect.js";
+import { config } from "../dist/config.js";
+import { restart } from "../dist/restart.js";
+import { IdeError } from "../dist/lib/errors.js";
+import { printCommandError } from "../dist/lib/output.js";
 
 const { positionals, values } = parseArgs({
   allowPositionals: true,

package/dist/attach.d.ts

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

package/dist/attach.js

@@ -0,0 +1,14 @@
+import { resolve } from "node:path";
+import { getSessionName } from "./lib/yaml-io.js";
+import { outputError } from "./lib/output.js";
+import { attachSession, getSessionState } from "./lib/tmux.js";
+export async function attach(targetDir, { json: _json } = {}) {
+    const dir = resolve(targetDir ?? ".");
+    const { name: session } = getSessionName(dir);
+    const state = getSessionState(session);
+    if (!state.running) {
+        outputError(`Session "${session}" is not running. Start it with: tmux-ide`, "NOT_RUNNING");
+        return;
+    }
+    attachSession(session);
+}

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+export declare function config(targetDir: string | null, { json, action, args }?: {
+    json?: boolean;
+    action?: string;
+    args?: string[];
+}): Promise<void>;

package/dist/config.js

@@ -0,0 +1,269 @@
+import { resolve } from "node:path";
+import { readConfig, writeConfig } from "./lib/yaml-io.js";
+import { setByPath } from "./lib/dot-path.js";
+import { outputError } from "./lib/output.js";
+/**
+ * Read config safely (read-only, no write). Returns config or undefined on error.
+ */
+function readConfigSafe(dir) {
+    let cfg;
+    try {
+        ({ config: cfg } = readConfig(dir));
+    }
+    catch (e) {
+        outputError(`Cannot read ide.yml: ${e.message}`, "READ_ERROR");
+        return;
+    }
+    return cfg;
+}
+/**
+ * Read config, validate it's an object, run mutator, then write back.
+ * Returns the mutator's return value, or undefined on error.
+ */
+function withConfig(dir, mutator) {
+    const cfg = readConfigSafe(dir);
+    if (cfg === undefined)
+        return;
+    if (!isConfigObject(cfg)) {
+        outputError("Invalid ide.yml: config root must be an object", "INVALID_CONFIG");
+        return;
+    }
+    const result = mutator(cfg);
+    writeConfig(dir, cfg);
+    return result;
+}
+export async function config(targetDir, { json, action, args } = {}) {
+    const dir = resolve(targetDir ?? ".");
+    switch (action) {
+        case "dump":
+            return dumpConfig(dir, { json });
+        case "set":
+            return setConfig(dir, args ?? [], { json });
+        case "add-pane":
+            return addPane(dir, args ?? [], { json });
+        case "remove-pane":
+            return removePane(dir, args ?? [], { json });
+        case "add-row":
+            return addRow(dir, args ?? [], { json });
+        case "enable-team":
+            return enableTeam(dir, args ?? [], { json });
+        case "disable-team":
+            return disableTeam(dir, { json });
+        default:
+            return dumpConfig(dir, { json });
+    }
+}
+function dumpConfig(dir, { json }) {
+    const cfg = readConfigSafe(dir);
+    if (cfg === undefined)
+        return;
+    if (json) {
+        console.log(JSON.stringify(cfg, null, 2));
+    }
+    else {
+        console.log(JSON.stringify(cfg, null, 2));
+    }
+}
+function setConfig(dir, args, { json }) {
+    const [dotpath, ...rest] = args;
+    if (!dotpath || rest.length === 0) {
+        outputError("Usage: tmux-ide config set <dotpath> <value>", "USAGE");
+        return;
+    }
+    let value = rest.join(" ");
+    if (value === "true")
+        value = true;
+    else if (value === "false")
+        value = false;
+    else if (/^\d+$/.test(value))
+        value = parseInt(value);
+    withConfig(dir, (cfg) => {
+        setByPath(cfg, dotpath, value);
+    });
+    if (json) {
+        console.log(JSON.stringify({ ok: true, path: dotpath, value }, null, 2));
+    }
+    else {
+        console.log(`Set ${dotpath} = ${JSON.stringify(value)}`);
+    }
+}
+function addPane(dir, args, { json }) {
+    const { row, title, command, size } = parseNamedArgs(args);
+    if (row === undefined) {
+        outputError("Usage: tmux-ide config add-pane --row <N> --title <T> [--command <C>] [--size <S>]", "USAGE");
+        return;
+    }
+    const rowIdx = parseIndex(row);
+    if (rowIdx == null) {
+        outputError(`Invalid row index "${row}"`, "USAGE");
+        return;
+    }
+    const pane = {};
+    if (title)
+        pane.title = title;
+    if (command)
+        pane.command = command;
+    if (size)
+        pane.size = size;
+    withConfig(dir, (cfg) => {
+        if (!Array.isArray(cfg.rows)) {
+            outputError("Invalid ide.yml: 'rows' must be an array", "INVALID_CONFIG");
+        }
+        if (!cfg.rows[rowIdx]) {
+            outputError(`Row ${rowIdx} does not exist`, "INVALID_ROW");
+        }
+        if (!Array.isArray(cfg.rows[rowIdx].panes)) {
+            outputError(`Invalid ide.yml: row ${rowIdx} panes must be an array`, "INVALID_CONFIG");
+        }
+        cfg.rows[rowIdx].panes.push(pane);
+    });
+    if (json) {
+        console.log(JSON.stringify({ ok: true, row: rowIdx, pane }, null, 2));
+    }
+    else {
+        console.log(`Added pane "${title ?? "untitled"}" to row ${rowIdx}`);
+    }
+}
+function removePane(dir, args, { json }) {
+    const { row, pane } = parseNamedArgs(args);
+    if (row === undefined || pane === undefined) {
+        outputError("Usage: tmux-ide config remove-pane --row <N> --pane <M>", "USAGE");
+        return;
+    }
+    const rowIdx = parseIndex(row);
+    const paneIdx = parseIndex(pane);
+    if (rowIdx == null || paneIdx == null) {
+        outputError("Usage: tmux-ide config remove-pane --row <N> --pane <M>", "USAGE");
+        return;
+    }
+    let removed;
+    withConfig(dir, (cfg) => {
+        if (!Array.isArray(cfg.rows)) {
+            outputError("Invalid ide.yml: 'rows' must be an array", "INVALID_CONFIG");
+        }
+        if (!Array.isArray(cfg.rows[rowIdx]?.panes)) {
+            outputError(`Invalid ide.yml: row ${rowIdx} panes must be an array`, "INVALID_CONFIG");
+        }
+        if (!cfg.rows[rowIdx].panes[paneIdx]) {
+            outputError(`Pane ${paneIdx} in row ${rowIdx} does not exist`, "INVALID_PANE");
+        }
+        removed = cfg.rows[rowIdx].panes.splice(paneIdx, 1)[0];
+    });
+    if (json) {
+        console.log(JSON.stringify({ ok: true, row: rowIdx, pane: paneIdx, removed }, null, 2));
+    }
+    else {
+        console.log(`Removed pane ${paneIdx} ("${removed?.title ?? "untitled"}") from row ${rowIdx}`);
+    }
+}
+function addRow(dir, args, { json }) {
+    const { size } = parseNamedArgs(args);
+    let rowIdx;
+    withConfig(dir, (cfg) => {
+        if (cfg.rows !== undefined && !Array.isArray(cfg.rows)) {
+            outputError("Invalid ide.yml: 'rows' must be an array", "INVALID_CONFIG");
+        }
+        const row = { panes: [{ title: "Shell" }] };
+        if (size)
+            row.size = size;
+        cfg.rows = cfg.rows ?? [];
+        cfg.rows.push(row);
+        rowIdx = cfg.rows.length - 1;
+    });
+    if (json) {
+        console.log(JSON.stringify({ ok: true, row: rowIdx, size: size ?? null }, null, 2));
+    }
+    else {
+        console.log(`Added row ${rowIdx}${size ? ` (${size})` : ""}`);
+    }
+}
+function enableTeam(dir, args, { json }) {
+    const { name } = parseNamedArgs(args);
+    let teamName;
+    let result;
+    withConfig(dir, (cfg) => {
+        if (cfg.rows !== undefined && !Array.isArray(cfg.rows)) {
+            outputError("Invalid ide.yml: 'rows' must be an array", "INVALID_CONFIG");
+        }
+        teamName = name ?? cfg.name ?? "my-team";
+        cfg.team = { name: teamName };
+        let leadAssigned = false;
+        for (const row of cfg.rows ?? []) {
+            for (const pane of row.panes ?? []) {
+                if (pane.command === "claude" || pane.role === "lead" || pane.role === "teammate") {
+                    if (!leadAssigned) {
+                        pane.role = "lead";
+                        leadAssigned = true;
+                    }
+                    else {
+                        pane.role = "teammate";
+                    }
+                }
+            }
+        }
+        if (!leadAssigned) {
+            delete cfg.team;
+            outputError("Cannot enable agent team: no Claude panes found", "INVALID_CONFIG");
+        }
+        result = { team: cfg.team, roles: summarizeRoles(cfg) };
+    });
+    if (json) {
+        console.log(JSON.stringify({ ok: true, ...result }, null, 2));
+    }
+    else {
+        console.log(`Enabled agent team "${teamName}"`);
+    }
+}
+function disableTeam(dir, { json }) {
+    withConfig(dir, (cfg) => {
+        if (cfg.rows !== undefined && !Array.isArray(cfg.rows)) {
+            outputError("Invalid ide.yml: 'rows' must be an array", "INVALID_CONFIG");
+        }
+        delete cfg.team;
+        for (const row of cfg.rows ?? []) {
+            if (!Array.isArray(row?.panes))
+                continue;
+            for (const pane of row.panes) {
+                delete pane.role;
+                delete pane.task;
+            }
+        }
+    });
+    if (json) {
+        console.log(JSON.stringify({ ok: true, disabled: true }, null, 2));
+    }
+    else {
+        console.log("Disabled agent team");
+    }
+}
+function summarizeRoles(cfg) {
+    const roles = [];
+    for (let i = 0; i < (cfg.rows ?? []).length; i++) {
+        for (let j = 0; j < (cfg.rows[i].panes ?? []).length; j++) {
+            const p = cfg.rows[i].panes[j];
+            if (p.role) {
+                roles.push({ row: i, pane: j, title: p.title ?? null, role: p.role });
+            }
+        }
+    }
+    return roles;
+}
+function parseNamedArgs(args) {
+    const result = {};
+    for (let i = 0; i < args.length; i++) {
+        if (args[i].startsWith("--") && i + 1 < args.length) {
+            const key = args[i].slice(2);
+            result[key] = args[i + 1];
+            i++;
+        }
+    }
+    return result;
+}
+function isConfigObject(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function parseIndex(value) {
+    if (!/^\d+$/.test(String(value)))
+        return null;
+    return Number.parseInt(value, 10);
+}

package/dist/detect.d.ts

@@ -0,0 +1,15 @@
+import type { IdeConfig } from "./types.ts";
+interface DetectedStack {
+    packageManager: string | null;
+    frameworks: string[];
+    devCommand: string | null;
+    language: string | null;
+    reasons: string[];
+}
+export declare function detectStack(dir: string): DetectedStack;
+export declare function suggestConfig(dir: string, detected: DetectedStack): IdeConfig;
+export declare function detect(targetDir: string | undefined, { json, write }?: {
+    json?: boolean;
+    write?: boolean;
+}): Promise<void>;
+export {};

package/dist/detect.js

@@ -0,0 +1,228 @@
+import { resolve, basename } from "node:path";
+import { readFileSync, existsSync } from "node:fs";
+import { writeConfig } from "./lib/yaml-io.js";
+function fileExists(dir, name) {
+    return existsSync(resolve(dir, name));
+}
+function readJson(dir, name) {
+    try {
+        return JSON.parse(readFileSync(resolve(dir, name), "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function detectStack(dir) {
+    const detected = {
+        packageManager: null,
+        frameworks: [],
+        devCommand: null,
+        language: null,
+        reasons: [],
+    };
+    // Detect package manager from lockfile
+    if (fileExists(dir, "pnpm-lock.yaml")) {
+        detected.packageManager = "pnpm";
+        detected.reasons.push('Detected pnpm from "pnpm-lock.yaml".');
+    }
+    else if (fileExists(dir, "bun.lockb") || fileExists(dir, "bun.lock")) {
+        detected.packageManager = "bun";
+        detected.reasons.push('Detected bun from "bun.lockb" or "bun.lock".');
+    }
+    else if (fileExists(dir, "yarn.lock")) {
+        detected.packageManager = "yarn";
+        detected.reasons.push('Detected yarn from "yarn.lock".');
+    }
+    else if (fileExists(dir, "package-lock.json")) {
+        detected.packageManager = "npm";
+        detected.reasons.push('Detected npm from "package-lock.json".');
+    }
+    const pkg = readJson(dir, "package.json");
+    if (pkg) {
+        detected.language = "javascript";
+        detected.reasons.push('Detected JavaScript from "package.json".');
+        const deps = {
+            ...pkg.dependencies,
+            ...pkg.devDependencies,
+        };
+        if (deps["next"])
+            pushFramework(detected, "next", 'Found dependency "next".');
+        if (deps["convex"])
+            pushFramework(detected, "convex", 'Found dependency "convex".');
+        if (deps["vite"])
+            pushFramework(detected, "vite", 'Found dependency "vite".');
+        if (deps["remix"] || deps["@remix-run/node"])
+            pushFramework(detected, "remix", "Found Remix dependency.");
+        if (deps["nuxt"])
+            pushFramework(detected, "nuxt", 'Found dependency "nuxt".');
+        if (deps["astro"])
+            pushFramework(detected, "astro", 'Found dependency "astro".');
+        if (deps["svelte"] || deps["@sveltejs/kit"])
+            pushFramework(detected, "svelte", "Found Svelte dependency.");
+        // Detect dev command
+        const pm = detected.packageManager ?? "npm";
+        const run = pm === "npm" ? "npm run" : pm;
+        const scripts = pkg.scripts;
+        if (scripts?.dev) {
+            detected.devCommand = `${run} dev`;
+            detected.reasons.push(`Using dev command "${detected.devCommand}" from package.json scripts.`);
+        }
+        else if (scripts?.start) {
+            detected.devCommand = `${run} start`;
+            detected.reasons.push(`Using start command "${detected.devCommand}" from package.json scripts.`);
+        }
+    }
+    // Python
+    if (fileExists(dir, "pyproject.toml") || fileExists(dir, "requirements.txt")) {
+        detected.language = detected.language ?? "python";
+        detected.reasons.push('Detected Python from "pyproject.toml" or "requirements.txt".');
+        try {
+            const pyproject = readFileSync(resolve(dir, "pyproject.toml"), "utf-8");
+            if (pyproject.includes("fastapi"))
+                pushFramework(detected, "fastapi", 'Found "fastapi" in pyproject.toml.');
+            else if (pyproject.includes("django"))
+                pushFramework(detected, "django", 'Found "django" in pyproject.toml.');
+            else if (pyproject.includes("flask"))
+                pushFramework(detected, "flask", 'Found "flask" in pyproject.toml.');
+        }
+        catch {
+            // Ignore missing or unreadable pyproject metadata.
+        }
+    }
+    // Rust
+    if (fileExists(dir, "Cargo.toml")) {
+        detected.language = detected.language ?? "rust";
+        detected.reasons.push('Detected Rust from "Cargo.toml".');
+        pushFramework(detected, "cargo", 'Using Cargo workflow from "Cargo.toml".');
+    }
+    // Go
+    if (fileExists(dir, "go.mod")) {
+        detected.language = detected.language ?? "go";
+        detected.reasons.push('Detected Go from "go.mod".');
+        pushFramework(detected, "go", 'Using Go workflow from "go.mod".');
+    }
+    // Docker
+    if (fileExists(dir, "docker-compose.yml") || fileExists(dir, "docker-compose.yaml")) {
+        pushFramework(detected, "docker", 'Detected Docker from "docker-compose.yml" or "docker-compose.yaml".');
+    }
+    if (detected.reasons.length === 0) {
+        detected.reasons.push("No framework-specific signals found; using the generic layout.");
+    }
+    return detected;
+}
+export function suggestConfig(dir, detected) {
+    const name = basename(dir);
+    const pm = detected.packageManager ?? "npm";
+    const run = pm === "npm" ? "npm run" : pm;
+    // Default: 2 claude panes + shell
+    const config = {
+        name,
+        rows: [
+            {
+                size: "70%",
+                panes: [
+                    { title: "Claude 1", command: "claude" },
+                    { title: "Claude 2", command: "claude" },
+                ],
+            },
+            {
+                panes: [],
+            },
+        ],
+    };
+    const bottom = config.rows[1].panes;
+    const frameworks = detected.frameworks;
+    // Add 3rd claude pane for complex stacks
+    if (frameworks.length >= 2) {
+        config.rows[0].panes.push({ title: "Claude 3", command: "claude" });
+    }
+    // Add dev servers
+    if (frameworks.includes("next")) {
+        bottom.push({ title: "Next.js", command: `${run} dev` });
+    }
+    else if (frameworks.includes("vite")) {
+        bottom.push({ title: "Vite", command: `${run} dev` });
+    }
+    else if (frameworks.includes("nuxt")) {
+        bottom.push({ title: "Nuxt", command: `${run} dev` });
+    }
+    else if (frameworks.includes("remix")) {
+        bottom.push({ title: "Remix", command: `${run} dev` });
+    }
+    else if (frameworks.includes("astro")) {
+        bottom.push({ title: "Astro", command: `${run} dev` });
+    }
+    else if (frameworks.includes("svelte")) {
+        bottom.push({ title: "SvelteKit", command: `${run} dev` });
+    }
+    else if (frameworks.includes("fastapi")) {
+        bottom.push({ title: "FastAPI", command: "uvicorn main:app --reload" });
+    }
+    else if (frameworks.includes("django")) {
+        bottom.push({ title: "Django", command: "python manage.py runserver" });
+    }
+    else if (frameworks.includes("flask")) {
+        bottom.push({ title: "Flask", command: "flask run --reload" });
+    }
+    else if (frameworks.includes("cargo")) {
+        bottom.push({ title: "Cargo", command: "cargo watch -x run" });
+    }
+    else if (frameworks.includes("go")) {
+        bottom.push({ title: "Go", command: "go run ." });
+    }
+    else if (detected.devCommand) {
+        bottom.push({ title: "Dev Server", command: detected.devCommand });
+    }
+    if (frameworks.includes("convex")) {
+        bottom.push({ title: "Convex", command: "npx convex dev" });
+    }
+    // Always add shell
+    bottom.push({ title: "Shell" });
+    return config;
+}
+export async function detect(targetDir, { json, write } = {}) {
+    const dir = resolve(targetDir ?? ".");
+    const detected = detectStack(dir);
+    const suggested = suggestConfig(dir, detected);
+    if (write) {
+        writeConfig(dir, suggested);
+        if (json) {
+            console.log(JSON.stringify({ detected, suggestedConfig: suggested, written: true }, null, 2));
+        }
+        else {
+            const desc = detected.frameworks.length > 0
+                ? detected.frameworks.join(" + ")
+                : (detected.language ?? "generic project");
+            console.log(`Detected ${desc}. Created ide.yml.`);
+            console.log("\nWhy this layout:");
+            for (const reason of detected.reasons) {
+                console.log(`  - ${reason}`);
+            }
+        }
+        return;
+    }
+    if (json) {
+        console.log(JSON.stringify({ detected, suggestedConfig: suggested }, null, 2));
+        return;
+    }
+    console.log("Detected stack:");
+    if (detected.packageManager)
+        console.log(`  Package manager: ${detected.packageManager}`);
+    if (detected.language)
+        console.log(`  Language: ${detected.language}`);
+    if (detected.frameworks.length)
+        console.log(`  Frameworks: ${detected.frameworks.join(", ")}`);
+    if (detected.devCommand)
+        console.log(`  Dev command: ${detected.devCommand}`);
+    console.log("\nReasoning:");
+    for (const reason of detected.reasons) {
+        console.log(`  - ${reason}`);
+    }
+    console.log("\nRun with --write to create ide.yml, or --json to see the suggested config.");
+}
+function pushFramework(detected, framework, reason) {
+    if (!detected.frameworks.includes(framework)) {
+        detected.frameworks.push(framework);
+    }
+    detected.reasons.push(reason);
+}

package/dist/doctor.d.ts

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

package/dist/doctor.js

@@ -0,0 +1,66 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+function check(label, fn, { optional = false } = {}) {
+    try {
+        const result = fn();
+        return { label, pass: true, detail: result, optional };
+    }
+    catch (e) {
+        return { label, pass: false, detail: e.message, optional };
+    }
+}
+export async function doctor({ json } = {}) {
+    const checks = [];
+    checks.push(check("tmux installed", () => {
+        execSync("which tmux", { stdio: "ignore" });
+        return "found";
+    }));
+    checks.push(check("tmux version ≥ 3.0", () => {
+        const version = execSync("tmux -V", { encoding: "utf-8" }).trim();
+        const num = parseFloat(version.replace(/[^0-9.]/g, ""));
+        if (num < 3.0)
+            throw new Error(`${version} (need ≥ 3.0)`);
+        return version;
+    }));
+    checks.push(check("Node.js ≥ 18", () => {
+        const major = parseInt(process.versions.node.split(".")[0]);
+        if (major < 18)
+            throw new Error(`Node ${process.versions.node} (need ≥ 18)`);
+        return `v${process.versions.node}`;
+    }));
+    checks.push(check("256-color terminal", () => {
+        const term = process.env.TERM ?? "";
+        if (!term.includes("256color") &&
+            !term.includes("ghostty") &&
+            !term.includes("kitty") &&
+            term !== "tmux-256color") {
+            throw new Error(`$TERM is "${term}"`);
+        }
+        return term;
+    }));
+    checks.push(check("ide.yml exists", () => {
+        const path = resolve(".", "ide.yml");
+        if (!existsSync(path))
+            throw new Error("not found in current directory");
+        return "found";
+    }));
+    checks.push(check("Claude Code agent teams", () => {
+        if (process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS !== "1") {
+            throw new Error("not set (enable with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1)");
+        }
+        return "enabled";
+    }, { optional: true }));
+    const allPass = checks.every((c) => c.pass || c.optional);
+    if (json) {
+        console.log(JSON.stringify({ ok: allPass, checks }, null, 2));
+        return;
+    }
+    for (const c of checks) {
+        const icon = c.pass ? "✓" : c.optional ? "○" : "✗";
+        const color = c.pass ? "\x1b[32m" : c.optional ? "\x1b[33m" : "\x1b[31m";
+        console.log(`${color}${icon}\x1b[0m ${c.label} — ${c.detail}`);
+    }
+    if (!allPass)
+        process.exitCode = 1;
+}

package/dist/init.d.ts

@@ -0,0 +1,4 @@
+export declare function init({ template, json, }?: {
+    template?: string;
+    json?: boolean;
+}): Promise<void>;