open-multi-agent-kit 0.78.0

package/dist/util/json-envelope.d.ts

@@ -0,0 +1,15 @@
+import type { OmkCommandStatus, OmkError, OmkJsonEnvelope, OmkWarning } from "../contracts/index.js";
+export type CreateOmkJsonEnvelopeOptions<TData> = {
+    command: string;
+    status: OmkCommandStatus;
+    data: TData;
+    ok?: boolean;
+    commit?: string;
+    runId?: string;
+    traceId?: string;
+    warnings?: OmkWarning[];
+    errors?: OmkError[];
+    provider?: string;
+    durationMs: number;
+};
+export declare function createOmkJsonEnvelope<TData>(options: CreateOmkJsonEnvelopeOptions<TData>): OmkJsonEnvelope<TData>;

package/dist/util/json-envelope.js

@@ -0,0 +1,28 @@
+import { randomUUID } from "node:crypto";
+import { OMK_CONTRACT_VERSION, OMK_RUNTIME_VERSION, } from "../version.js";
+import { getOmkVersionSync } from "./version.js";
+export function createOmkJsonEnvelope(options) {
+    const ok = options.ok ?? options.status === "passed";
+    return {
+        ok,
+        schemaVersion: OMK_CONTRACT_VERSION,
+        command: options.command,
+        omkVersion: getOmkVersionSync(),
+        runtimeVersion: OMK_RUNTIME_VERSION,
+        ...(options.commit ? { commit: options.commit } : {}),
+        ...(options.runId ? { runId: options.runId } : {}),
+        traceId: options.traceId ?? randomUUID(),
+        status: options.status,
+        data: options.data,
+        warnings: options.warnings ?? [],
+        errors: options.errors ?? [],
+        metadata: {
+            cwd: process.cwd(),
+            platform: process.platform,
+            nodeVersion: process.version,
+            ...(options.provider ? { provider: options.provider } : {}),
+            durationMs: options.durationMs,
+            timestamp: new Date().toISOString(),
+        },
+    };
+}

package/dist/util/mcp-preflight.d.ts

@@ -0,0 +1,26 @@
+export type RuntimeMcpPreflightMode = "warn-skip" | "strict" | "off";
+export type RuntimeMcpPreflightFailureReason = "timeout" | "exit" | "missing-env" | "http-fail" | "stdio-fail";
+export type RuntimeMcpPreflightEntryStatus = "ok" | "failed" | "skipped";
+export interface RuntimeMcpPreflightOptions {
+    timeoutMs: number;
+    concurrency: number;
+}
+export interface RuntimeMcpPreflightEntry {
+    name: string;
+    status: RuntimeMcpPreflightEntryStatus;
+    reason?: RuntimeMcpPreflightFailureReason | "not-npm-family" | "no-package-spec";
+    detail?: string;
+    packageSpec?: string;
+}
+export interface RuntimeMcpPreflightResult {
+    failed: Set<string>;
+    details: Map<string, {
+        reason: RuntimeMcpPreflightFailureReason;
+        detail: string;
+    }>;
+    entries: RuntimeMcpPreflightEntry[];
+}
+export declare function resolveRuntimeMcpPreflightMode(env?: Record<string, string | undefined>): RuntimeMcpPreflightMode;
+export declare function resolveRuntimeMcpPreflightOptions(env?: Record<string, string | undefined>): RuntimeMcpPreflightOptions & {
+    mode: RuntimeMcpPreflightMode;
+};

package/dist/util/mcp-preflight.js

@@ -0,0 +1,29 @@
+export function resolveRuntimeMcpPreflightMode(env = process.env) {
+    const raw = env.OMK_MCP_PREFLIGHT?.trim();
+    if (!raw)
+        return "warn-skip";
+    if (raw === "strict" || raw === "warn-skip")
+        return raw;
+    return "off";
+}
+function resolvePreflightTimeout(env = process.env) {
+    const raw = env.OMK_MCP_PREFLIGHT_TIMEOUT_MS;
+    if (!raw)
+        return 5000;
+    const n = Number.parseInt(raw, 10);
+    return Number.isFinite(n) && n > 0 ? n : 5000;
+}
+function resolvePreflightConcurrency(env = process.env) {
+    const raw = env.OMK_MCP_PREFLIGHT_CONCURRENCY;
+    if (!raw)
+        return 3;
+    const n = Number.parseInt(raw, 10);
+    return Number.isFinite(n) && n > 0 ? n : 3;
+}
+export function resolveRuntimeMcpPreflightOptions(env = process.env) {
+    return {
+        mode: resolveRuntimeMcpPreflightMode(env),
+        timeoutMs: resolvePreflightTimeout(env),
+        concurrency: resolvePreflightConcurrency(env),
+    };
+}

package/dist/util/mode-preset.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Mode-preset system for open-multi-agent-kit.
+ *
+ * Three tabs/modes:
+ *   - agent   : interactive orchestrator (execution choice → plan → execute/review)
+ *   - plan    : plan-only mode — generates enriched prompt & plan, waits for user approval
+ *   - chat    : chat-only mode — GPT-like conversation without code modification
+ */
+export type OmkMode = "agent" | "plan" | "chat" | "debugging" | "review";
+export interface ModePreset {
+    name: OmkMode;
+    label: string;
+    description: string;
+    icon: string;
+    behavior: {
+        autoExecute: boolean;
+        planOnly: boolean;
+        chatOnly: boolean;
+        requireApproval: boolean;
+        useDag: boolean;
+    };
+    /** Default CLI command launched when this mode is selected from the TTY selector. */
+    launchCommand: "chat" | "parallel" | "menu" | "review" | "doctor";
+}
+export declare function getModePresets(): ModePreset[];
+export declare function getModePreset(mode: OmkMode): ModePreset | undefined;
+export declare function isValidMode(mode: string): mode is OmkMode;
+export declare function getCurrentMode(): Promise<OmkMode>;
+export declare function setCurrentMode(mode: OmkMode): Promise<void>;

package/dist/util/mode-preset.js

@@ -0,0 +1,222 @@
+/**
+ * Mode-preset system for open-multi-agent-kit.
+ *
+ * Three tabs/modes:
+ *   - agent   : interactive orchestrator (execution choice → plan → execute/review)
+ *   - plan    : plan-only mode — generates enriched prompt & plan, waits for user approval
+ *   - chat    : chat-only mode — GPT-like conversation without code modification
+ */
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { getProjectRoot } from "./fs.js";
+const PRESETS = [
+    {
+        name: "agent",
+        label: "Agent Orchestrator",
+        description: "Interactive orchestrator: asks parallel vs one-by-one, then coordinates plan/run/review",
+        icon: "🤖",
+        behavior: {
+            autoExecute: true,
+            planOnly: false,
+            chatOnly: false,
+            requireApproval: false,
+            useDag: true,
+        },
+        launchCommand: "chat",
+    },
+    {
+        name: "plan",
+        label: "Plan",
+        description: "Plan-only mode: generates plan and enriched prompt, waits for your approval before executing",
+        icon: "📐",
+        behavior: {
+            autoExecute: false,
+            planOnly: true,
+            chatOnly: false,
+            requireApproval: true,
+            useDag: false,
+        },
+        launchCommand: "menu",
+    },
+    {
+        name: "chat",
+        label: "Chat",
+        description: "Chat-only mode: conversation about the project without code modification",
+        icon: "💬",
+        behavior: {
+            autoExecute: false,
+            planOnly: false,
+            chatOnly: true,
+            requireApproval: false,
+            useDag: false,
+        },
+        launchCommand: "chat",
+    },
+    {
+        name: "debugging",
+        label: "Debug",
+        description: "Debugging mode: focused on bug reproduction, root-cause analysis, and minimal fixes",
+        icon: "🐛",
+        behavior: {
+            autoExecute: true,
+            planOnly: false,
+            chatOnly: false,
+            requireApproval: false,
+            useDag: true,
+        },
+        launchCommand: "chat",
+    },
+    {
+        name: "review",
+        label: "Review",
+        description: "Review mode: focused on code audit, security scan, and quality assessment",
+        icon: "🔍",
+        behavior: {
+            autoExecute: true,
+            planOnly: false,
+            chatOnly: false,
+            requireApproval: false,
+            useDag: true,
+        },
+        launchCommand: "chat",
+    },
+];
+const MODE_CONFIG_KEY = "mode.preset";
+export function getModePresets() {
+    return PRESETS;
+}
+export function getModePreset(mode) {
+    return PRESETS.find((p) => p.name === mode);
+}
+export function isValidMode(mode) {
+    if (mode === "default")
+        return true; // backward compatibility
+    return PRESETS.some((p) => p.name === mode);
+}
+export async function getCurrentMode() {
+    const envMode = process.env.OMK_MODE;
+    if (envMode) {
+        if (envMode === "default")
+            return "agent"; // backward compatibility
+        if (isValidMode(envMode))
+            return envMode;
+    }
+    const config = await readSimpleToml(join(getProjectRoot(), ".omk", "config.toml"));
+    const cfg = config[MODE_CONFIG_KEY];
+    if (cfg) {
+        if (cfg === "default")
+            return "agent"; // backward compatibility
+        if (isValidMode(cfg))
+            return cfg;
+    }
+    return "agent";
+}
+export async function setCurrentMode(mode) {
+    const root = getProjectRoot();
+    const configPath = join(root, ".omk", "config.toml");
+    let content = "";
+    try {
+        content = await readFile(configPath, "utf-8");
+    }
+    catch {
+        // config.toml does not exist yet
+    }
+    const newContent = upsertConfigValue(content, "mode", "preset", mode);
+    await writeFile(configPath, newContent, "utf-8");
+}
+/** Read a simple TOML file into a flat record. */
+async function readSimpleToml(path) {
+    try {
+        const content = await readFile(path, "utf-8");
+        return parseSimpleToml(content);
+    }
+    catch {
+        return {};
+    }
+}
+function parseSimpleToml(content) {
+    const result = {};
+    let section = "";
+    for (const rawLine of content.split(/\r?\n/)) {
+        const line = stripComment(rawLine).trim();
+        if (!line)
+            continue;
+        const sectionMatch = line.match(/^\[([^\]]+)]$/);
+        if (sectionMatch) {
+            section = sectionMatch[1].trim();
+            continue;
+        }
+        const kv = line.match(/^([A-Za-z0-9_.-]+)\s*=\s*(.+)$/);
+        if (!kv)
+            continue;
+        const key = section ? `${section}.${kv[1].trim()}` : kv[1].trim();
+        result[key] = normalizeTomlValue(kv[2].trim());
+    }
+    return result;
+}
+function stripComment(line) {
+    // naive: remove everything after first unquoted #
+    let inString = false;
+    let quoteChar = "";
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (!inString && (ch === '"' || ch === "'")) {
+            inString = true;
+            quoteChar = ch;
+        }
+        else if (inString && ch === quoteChar && line[i - 1] !== "\\") {
+            inString = false;
+        }
+        else if (!inString && ch === "#") {
+            return line.slice(0, i);
+        }
+    }
+    return line;
+}
+function normalizeTomlValue(value) {
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function upsertConfigValue(content, section, key, value) {
+    const sectionHeader = `[${section}]`;
+    const lineToSet = `${key} = "${value}"`;
+    // If file is empty, just write the section
+    if (!content.trim()) {
+        return `${sectionHeader}\n${lineToSet}\n`;
+    }
+    const lines = content.split(/\r?\n/);
+    const sectionIdx = lines.findIndex((l) => l.trim() === sectionHeader);
+    if (sectionIdx === -1) {
+        // Section does not exist — append at the end
+        return content.trimEnd() + "\n\n" + sectionHeader + "\n" + lineToSet + "\n";
+    }
+    // Section exists — look for existing key
+    let keyIdx = -1;
+    for (let i = sectionIdx + 1; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith("["))
+            break; // next section
+        const kv = trimmed.match(new RegExp(`^${key}\\s*=`));
+        if (kv) {
+            keyIdx = i;
+            break;
+        }
+    }
+    if (keyIdx !== -1) {
+        lines[keyIdx] = lineToSet;
+    }
+    else {
+        // Insert at the end of the section (before next section or end)
+        let insertIdx = lines.length;
+        for (let i = sectionIdx + 1; i < lines.length; i++) {
+            if (lines[i].trim().startsWith("[")) {
+                insertIdx = i;
+                break;
+            }
+        }
+        lines.splice(insertIdx, 0, lineToSet);
+    }
+    return lines.join("\n") + "\n";
+}

package/dist/util/mode-selector.d.ts

@@ -0,0 +1,6 @@
+/**
+ * TTY raw-mode mode selector.
+ * Shows a live-updating mode badge and cycles presets with Tab key.
+ */
+import { type OmkMode } from "./mode-preset.js";
+export declare function promptModeCycle(): Promise<OmkMode>;

package/dist/util/mode-selector.js

@@ -0,0 +1,74 @@
+/**
+ * TTY raw-mode mode selector.
+ * Shows a live-updating mode badge and cycles presets with Tab key.
+ */
+import { getCurrentMode, setCurrentMode, getModePresets } from "./mode-preset.js";
+import { style } from "./theme.js";
+import { enableRawTerminalInput, restoreTerminalInputState } from "./terminal-input.js";
+const MODES = ["agent", "plan", "chat", "debugging", "review"];
+export async function promptModeCycle() {
+    const current = await getCurrentMode();
+    let idx = MODES.indexOf(current);
+    if (idx === -1)
+        idx = 0;
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return current;
+    }
+    const preset = () => getModePresets().find((p) => p.name === MODES[idx]);
+    const renderBadge = () => {
+        const p = preset();
+        const badge = p ? `${p.icon} ${style.mintBold(p.label)}` : MODES[idx];
+        const hint = style.gray("[Tab] next  [Shift+Tab] prev  [Enter] start  [Ctrl+C] exit");
+        // Clear current line and rewrite
+        process.stdout.write(`\r\x1B[K  Mode: ${badge}  ${hint}  `);
+    };
+    process.stdout.write("\n");
+    renderBadge();
+    return new Promise((resolve, reject) => {
+        const stdin = process.stdin;
+        const terminalInputState = enableRawTerminalInput(stdin);
+        let cleaned = false;
+        let cleanup = () => undefined;
+        const onData = (data) => {
+            const key = typeof data === "string" ? data : data.toString("utf8");
+            if (key === "\t") {
+                idx = (idx + 1) % MODES.length;
+                renderBadge();
+                return;
+            }
+            // Shift+Tab (ESC [ Z) — reverse cycle
+            if (key === "\x1b[Z") {
+                idx = (idx - 1 + MODES.length) % MODES.length;
+                renderBadge();
+                return;
+            }
+            if (key === "\r" || key === "\n") {
+                cleanup();
+                process.stdout.write("\n");
+                const selected = MODES[idx];
+                if (selected !== current) {
+                    setCurrentMode(selected)
+                        .then(() => resolve(selected))
+                        .catch(reject);
+                }
+                else {
+                    resolve(selected);
+                }
+                return;
+            }
+            if (key === "\u0003" || key === "q" || key === "Q") {
+                cleanup();
+                process.stdout.write("\n");
+                process.exit(0);
+            }
+        };
+        cleanup = () => {
+            if (cleaned)
+                return;
+            cleaned = true;
+            stdin.off("data", onData);
+            restoreTerminalInputState(stdin, terminalInputState);
+        };
+        stdin.on("data", onData);
+    });
+}

package/dist/util/native-safety.d.ts

@@ -0,0 +1,28 @@
+export type NativeSafetySource = "env" | "bundled" | "target-release" | "target-debug" | "missing";
+export type NativeSafetyStatus = "ok" | "warn" | "info";
+export interface NativeSafetyResolution {
+    ok: boolean;
+    source: NativeSafetySource;
+    path: string | null;
+    platformArch: string;
+    builtFromSource: boolean;
+    message: string;
+}
+export interface NativeSafetySelfTest extends NativeSafetyResolution {
+    status: NativeSafetyStatus;
+    checks: number | null;
+}
+export interface NativeSafetyOptions {
+    root?: string;
+    packageRoot?: string;
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform | string;
+    arch?: string;
+    timeoutMs?: number;
+}
+export declare function getNativePlatformArchKey(platform?: NodeJS.Platform | string, arch?: string): string;
+export declare function getOmkSafetyBinaryName(platform?: NodeJS.Platform | string): string;
+export declare function getOmkPackageRoot(): string;
+export declare function getBundledOmkSafetyBinaryPath(packageRoot?: string, platform?: NodeJS.Platform | string, arch?: string): string;
+export declare function resolveOmkSafetyNative(options?: NativeSafetyOptions): Promise<NativeSafetyResolution>;
+export declare function runOmkSafetySelfTest(options?: NativeSafetyOptions): Promise<NativeSafetySelfTest>;

package/dist/util/native-safety.js

@@ -0,0 +1,118 @@
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import { dirname, isAbsolute, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { runShell } from "./shell.js";
+const SUPPORTED_PLATFORMS = new Set(["linux", "darwin", "win32"]);
+const SUPPORTED_ARCHES = new Set(["x64", "arm64"]);
+export function getNativePlatformArchKey(platform = process.platform, arch = process.arch) {
+    return `${platform}-${arch}`;
+}
+export function getOmkSafetyBinaryName(platform = process.platform) {
+    return platform === "win32" ? "omk-safety.exe" : "omk-safety";
+}
+export function getOmkPackageRoot() {
+    return join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+}
+export function getBundledOmkSafetyBinaryPath(packageRoot = getOmkPackageRoot(), platform = process.platform, arch = process.arch) {
+    return join(packageRoot, "dist", "native", getNativePlatformArchKey(platform, arch), getOmkSafetyBinaryName(platform));
+}
+function isSupportedPlatformArch(platform, arch) {
+    return SUPPORTED_PLATFORMS.has(platform) && SUPPORTED_ARCHES.has(arch);
+}
+function normalizeEnvPath(rawPath) {
+    return isAbsolute(rawPath) ? rawPath : join(process.cwd(), rawPath);
+}
+function getNativeSafetyCandidates(options = {}) {
+    const env = options.env ?? process.env;
+    const packageRoot = options.packageRoot ?? getOmkPackageRoot();
+    const root = options.root ?? packageRoot;
+    const platform = options.platform ?? process.platform;
+    const arch = options.arch ?? process.arch;
+    const binaryName = getOmkSafetyBinaryName(platform);
+    const candidates = [];
+    if (env.OMK_SAFETY_BIN) {
+        candidates.push({ source: "env", path: normalizeEnvPath(env.OMK_SAFETY_BIN), builtFromSource: false });
+    }
+    if (isSupportedPlatformArch(platform, arch)) {
+        candidates.push({ source: "bundled", path: getBundledOmkSafetyBinaryPath(packageRoot, platform, arch), builtFromSource: false });
+    }
+    candidates.push({ source: "target-release", path: join(root, "target", "release", binaryName), builtFromSource: true });
+    candidates.push({ source: "target-debug", path: join(root, "target", "debug", binaryName), builtFromSource: true });
+    return candidates;
+}
+async function fileExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveOmkSafetyNative(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const arch = options.arch ?? process.arch;
+    const platformArch = getNativePlatformArchKey(platform, arch);
+    for (const candidate of getNativeSafetyCandidates(options)) {
+        if (await fileExists(candidate.path)) {
+            return {
+                ok: true,
+                source: candidate.source,
+                path: candidate.path,
+                platformArch,
+                builtFromSource: candidate.builtFromSource,
+                message: `native omk-safety resolved via ${candidate.source}: ${candidate.path}`,
+            };
+        }
+    }
+    return {
+        ok: false,
+        source: "missing",
+        path: null,
+        platformArch,
+        builtFromSource: false,
+        message: `native omk-safety binary not bundled for ${platformArch} — run npm run native:build or use TS fallback`,
+    };
+}
+export async function runOmkSafetySelfTest(options = {}) {
+    const resolution = await resolveOmkSafetyNative(options);
+    if (!resolution.path) {
+        return { ...resolution, status: "info", checks: null };
+    }
+    const result = await runShell(resolution.path, ["self-test"], {
+        cwd: options.root ?? options.packageRoot ?? getOmkPackageRoot(),
+        timeout: options.timeoutMs ?? 5000,
+    });
+    if (result.failed) {
+        return {
+            ...resolution,
+            ok: false,
+            status: "warn",
+            checks: null,
+            message: `self-test failed for ${resolution.path}`,
+        };
+    }
+    try {
+        const parsed = JSON.parse(result.stdout);
+        if (parsed.ok === true && typeof parsed.checks === "number") {
+            const prefix = resolution.builtFromSource ? "self-test passed from source build" : "self-test passed";
+            return {
+                ...resolution,
+                status: "ok",
+                checks: parsed.checks,
+                message: `${prefix} (${parsed.checks} checks): ${resolution.path}`,
+            };
+        }
+    }
+    catch {
+        // fall through to warning below
+    }
+    return {
+        ...resolution,
+        ok: false,
+        status: "warn",
+        checks: null,
+        message: `self-test returned unexpected output for ${resolution.path}`,
+    };
+}

package/dist/util/output-buffer.d.ts

@@ -0,0 +1,12 @@
+export declare class CappedOutputBuffer {
+    private readonly maxBytes;
+    private readonly label;
+    private chunks;
+    private bytes;
+    private omittedBytes;
+    private truncated;
+    constructor(maxBytes: number, label?: string);
+    append(value: unknown): void;
+    toString(): string;
+}
+export declare function formatBytes(bytes: number): string;

package/dist/util/output-buffer.js

@@ -0,0 +1,59 @@
+export class CappedOutputBuffer {
+    maxBytes;
+    label;
+    chunks = [];
+    bytes = 0;
+    omittedBytes = 0;
+    truncated = false;
+    constructor(maxBytes, label = "output") {
+        this.maxBytes = maxBytes;
+        this.label = label;
+    }
+    append(value) {
+        const text = String(value ?? "");
+        if (!text)
+            return;
+        const input = Buffer.from(text, "utf8");
+        if (this.maxBytes <= 0) {
+            this.truncated = true;
+            this.omittedBytes += input.byteLength;
+            return;
+        }
+        const remaining = this.maxBytes - this.bytes;
+        if (remaining <= 0) {
+            this.truncated = true;
+            this.omittedBytes += input.byteLength;
+            return;
+        }
+        if (input.byteLength <= remaining) {
+            this.chunks.push(text);
+            this.bytes += input.byteLength;
+            return;
+        }
+        this.chunks.push(input.subarray(0, remaining).toString("utf8"));
+        this.bytes = this.maxBytes;
+        this.omittedBytes += input.byteLength - remaining;
+        this.truncated = true;
+    }
+    toString() {
+        const output = this.chunks.join("");
+        if (!this.truncated)
+            return output;
+        const marker = `\n[omk: ${this.label} truncated at ${formatBytes(this.maxBytes)}; omitted at least ${formatBytes(this.omittedBytes)}]\n`;
+        return `${output}${marker}`;
+    }
+}
+export function formatBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes < 0)
+        return "unknown";
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const kib = bytes / 1024;
+    if (kib < 1024)
+        return `${kib.toFixed(1)} KiB`;
+    const mib = kib / 1024;
+    if (mib < 1024)
+        return `${mib.toFixed(1)} MiB`;
+    const gib = mib / 1024;
+    return `${gib.toFixed(1)} GiB`;
+}

package/dist/util/process-tree.d.ts

@@ -0,0 +1,18 @@
+export interface ProcessTreeTarget {
+    pid?: number;
+    exitCode?: number | null;
+    signalCode?: NodeJS.Signals | null;
+    kill(signal?: NodeJS.Signals | number): boolean;
+    once(event: "exit" | "close" | "error", listener: (...args: unknown[]) => void): unknown;
+}
+export interface TerminateProcessTreeOptions {
+    graceMs?: number;
+    waitMs?: number;
+    signal?: NodeJS.Signals;
+    forceSignal?: NodeJS.Signals;
+}
+export declare function shouldUseProcessGroup(): boolean;
+export declare function managedChildProcessOptions(): {
+    detached: boolean;
+};
+export declare function terminateProcessTree(target: ProcessTreeTarget, options?: TerminateProcessTreeOptions): Promise<void>;