@otto-code/cli 0.5.0

package/dist/commands/onboard.js

@@ -0,0 +1,416 @@
+import { cancel, confirm, intro, isCancel, log, note, outro, spinner } from "@clack/prompts";
+import { Command, Option } from "commander";
+import { writeFileSync } from "node:fs";
+import path from "node:path";
+import { generateLocalPairingOffer, loadConfig, loadPersistedConfig, } from "@otto-code/server";
+import { resolveLocalOttoHome, resolveLocalDaemonState, resolveTcpHostFromListen, startLocalDaemonDetached, tailDaemonLog, } from "./daemon/local-daemon.js";
+import { tryConnectToDaemon } from "../utils/client.js";
+const DEFAULT_READY_TIMEOUT_MS = 10 * 60 * 1000;
+const READY_PROBE_TIMEOUT_MS = 1200;
+class OnboardCancelledError extends Error {
+}
+const plainNoteFormat = (line) => line;
+function renderNote(message, title) {
+    note(message, title, { format: plainNoteFormat });
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function parseTimeoutMs(raw) {
+    if (!raw || raw.trim().length === 0) {
+        return DEFAULT_READY_TIMEOUT_MS;
+    }
+    const seconds = Number(raw);
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        throw new Error(`Invalid timeout value: ${raw}`);
+    }
+    return Math.ceil(seconds * 1000);
+}
+function toCliOverrides(options) {
+    const cliOverrides = {};
+    if (options.listen) {
+        cliOverrides.listen = options.listen;
+    }
+    else if (options.port) {
+        cliOverrides.listen = `127.0.0.1:${options.port}`;
+    }
+    if (options.relay === false) {
+        cliOverrides.relayEnabled = false;
+    }
+    if (options.hostnames) {
+        const raw = options.hostnames.trim();
+        cliOverrides.hostnames =
+            raw.toLowerCase() === "true"
+                ? true
+                : raw
+                    .split(",")
+                    .map((host) => host.trim())
+                    .filter(Boolean);
+    }
+    if (options.mcp === false) {
+        cliOverrides.mcpEnabled = false;
+    }
+    return cliOverrides;
+}
+function savePersistedConfig(ottoHome, config) {
+    const configPath = path.join(ottoHome, "config.json");
+    writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+}
+function applyVoiceSelection(config, enabled) {
+    return {
+        ...config,
+        features: {
+            ...config.features,
+            dictation: {
+                ...config.features?.dictation,
+                enabled,
+            },
+            voiceMode: {
+                ...config.features?.voiceMode,
+                enabled,
+            },
+        },
+    };
+}
+function resolvePersistedVoiceSelection(config) {
+    const voiceModeEnabled = config.features?.voiceMode?.enabled;
+    if (typeof voiceModeEnabled === "boolean") {
+        return voiceModeEnabled;
+    }
+    const dictationEnabled = config.features?.dictation?.enabled;
+    if (typeof dictationEnabled === "boolean") {
+        return dictationEnabled;
+    }
+    return null;
+}
+async function resolveVoiceSelection(mode) {
+    if (mode === "enable") {
+        return true;
+    }
+    if (mode === "disable") {
+        return false;
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        log.message("Non-interactive terminal detected; voice setup defaults to disabled.");
+        return false;
+    }
+    const answer = await confirm({
+        message: "Enable voice features? (downloads local STT/TTS models in background)",
+        active: "Yes",
+        inactive: "No",
+        initialValue: false,
+    });
+    if (isCancel(answer)) {
+        throw new OnboardCancelledError("Onboarding cancelled by user.");
+    }
+    return answer;
+}
+function parseDownloadProgress(logTail) {
+    const lines = logTail.split("\n").filter(Boolean);
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const line = lines[index];
+        if (!line || !line.includes("Downloading model artifact")) {
+            continue;
+        }
+        const pctMatch = line.match(/"pct"\s*:\s*(\d{1,3})|\bpct[=:]\s*(\d{1,3})/);
+        const modelMatch = line.match(/"modelId"\s*:\s*"([^"]+)"|\bmodelId[=:]\s*"?([^\s",}]+)/);
+        return {
+            modelId: modelMatch?.[1] ?? modelMatch?.[2] ?? null,
+            pct: pctMatch ? Number(pctMatch[1] ?? pctMatch[2]) : null,
+        };
+    }
+    return null;
+}
+function renderProgressLine(progress) {
+    const modelSuffix = progress.modelId ? ` (${progress.modelId})` : "";
+    if (progress.pct === null) {
+        return `Downloading speech model${modelSuffix}...`;
+    }
+    return `Downloading speech model${modelSuffix}: ${progress.pct}%`;
+}
+async function probeDaemonReady(home, timeoutMs) {
+    const state = resolveLocalDaemonState({ home });
+    const host = resolveTcpHostFromListen(state.listen);
+    const deadline = Date.now() + timeoutMs;
+    const remainingTimeoutMs = () => Math.max(1, deadline - Date.now());
+    if (state.running && host) {
+        const client = await tryConnectToDaemon({
+            host,
+            timeout: Math.min(remainingTimeoutMs(), READY_PROBE_TIMEOUT_MS),
+        });
+        if (client) {
+            try {
+                await client.fetchAgents({
+                    timeout: Math.min(remainingTimeoutMs(), READY_PROBE_TIMEOUT_MS),
+                });
+                return { kind: "ready", listen: state.listen, host };
+            }
+            catch {
+                // Daemon process is alive but not API-ready yet.
+            }
+            finally {
+                await client.close().catch(() => { });
+            }
+        }
+    }
+    else if (state.running && !host) {
+        return { kind: "ready", listen: state.listen, host: null };
+    }
+    return { kind: "pending" };
+}
+function announceProgress(home, state, onStatus) {
+    const progress = parseDownloadProgress(tailDaemonLog(home, 120) ?? "");
+    const progressLine = progress ? renderProgressLine(progress) : null;
+    const statusMessage = progressLine ?? "Waiting for daemon to become ready...";
+    if (statusMessage !== state.lastStatus) {
+        onStatus?.(statusMessage);
+        return { lastStatus: statusMessage, lastPrintedAt: Date.now() };
+    }
+    if (!onStatus && Date.now() - state.lastPrintedAt >= 3000) {
+        console.log(statusMessage);
+        return { lastStatus: state.lastStatus, lastPrintedAt: Date.now() };
+    }
+    return state;
+}
+async function waitForDaemonReady(args) {
+    const deadline = Date.now() + args.timeoutMs;
+    const createTimeoutError = () => {
+        const recentLogs = tailDaemonLog(args.home, 60);
+        return new Error([
+            `Timed out after ${Math.ceil(args.timeoutMs / 1000)}s waiting for daemon readiness.`,
+            recentLogs ? `Recent daemon logs:\n${recentLogs}` : null,
+        ]
+            .filter(Boolean)
+            .join("\n\n"));
+    };
+    async function poll(state) {
+        if (Date.now() >= deadline) {
+            throw createTimeoutError();
+        }
+        const probe = await probeDaemonReady(args.home, Math.max(1, deadline - Date.now()));
+        if (probe.kind === "ready") {
+            return { listen: probe.listen, host: probe.host };
+        }
+        const nextState = announceProgress(args.home, state, args.onStatus);
+        if (Date.now() >= deadline) {
+            throw createTimeoutError();
+        }
+        await sleep(200);
+        return poll(nextState);
+    }
+    return poll({ lastStatus: "", lastPrintedAt: 0 });
+}
+function printNextSteps(pairingUrl, ottoHome, richUi) {
+    const daemonLogPath = path.join(ottoHome, "daemon.log");
+    const nextStepsLines = [
+        pairingUrl
+            ? "1. Open Otto and scan the QR code above, or paste the pairing link."
+            : "1. Open Otto and connect to your daemon.",
+        "2. Web app: https://app.otto-code.me",
+        "3. Desktop app: https://github.com/Draek2077/otto-code/releases/latest",
+        "4. Docs: https://otto-code.me/docs",
+        '5. Example: otto run --output-schema schema.json "extract fields"',
+    ];
+    const quickReferenceLines = [
+        "1. otto --help",
+        "2. otto ls",
+        '3. otto run "your prompt"',
+        "4. otto status",
+        `5. Daemon logs: ${daemonLogPath}`,
+    ];
+    if (!richUi) {
+        console.log("");
+        console.log("Next steps:");
+        for (const line of nextStepsLines) {
+            console.log(line);
+        }
+        console.log("");
+        console.log("CLI quick reference:");
+        for (const line of quickReferenceLines) {
+            console.log(line);
+        }
+        return;
+    }
+    renderNote(nextStepsLines.join("\n"), "Next steps");
+    renderNote(quickReferenceLines.join("\n"), "CLI quick reference");
+}
+export function onboardCommand() {
+    return new Command("onboard")
+        .description("Run first-time setup, start daemon, and print pairing instructions")
+        .option("--listen <listen>", "Listen target (host:port, port, or unix socket path)")
+        .option("--port <port>", "Port to listen on (default: 6868)")
+        .option("--home <path>", "Otto home directory (default: ~/.otto)")
+        .option("--no-relay", "Disable relay connection")
+        .option("--no-mcp", "Disable the Agent MCP HTTP endpoint")
+        .option("--hostnames <hosts>", 'Daemon hostnames (comma-separated, e.g. "myhost,.example.com" or "true" for any)')
+        .addOption(new Option("--allowed-hosts <hosts>").hideHelp())
+        .option("--timeout <seconds>", "Max time to wait for daemon readiness (default: 600)")
+        .option("--voice <mode>", "Voice setup mode: ask, enable, disable", "ask")
+        .action(async (options) => {
+        await runOnboard({
+            ...options,
+            hostnames: options.hostnames ?? options.allowedHosts,
+        });
+    });
+}
+async function resolveAndPersistVoice(ottoHome, options) {
+    let persisted = loadPersistedConfig(ottoHome);
+    const persistedVoiceSelection = resolvePersistedVoiceSelection(persisted);
+    const shouldPrompt = options.voice === "ask" || options.voice === undefined;
+    let voiceEnabled;
+    try {
+        voiceEnabled =
+            shouldPrompt && persistedVoiceSelection !== null
+                ? persistedVoiceSelection
+                : await resolveVoiceSelection(options.voice);
+    }
+    catch (error) {
+        if (error instanceof OnboardCancelledError) {
+            cancel("Onboarding cancelled.");
+            process.exit(0);
+        }
+        throw error;
+    }
+    if (shouldPrompt && persistedVoiceSelection !== null) {
+        log.message(`Using saved voice setup from config (${voiceEnabled ? "enabled" : "disabled"}).`);
+    }
+    persisted = applyVoiceSelection(persisted, voiceEnabled);
+    savePersistedConfig(ottoHome, persisted);
+    return voiceEnabled;
+}
+async function ensureDaemonStarted(options, richUi) {
+    const stateBeforeStart = resolveLocalDaemonState({ home: options.home });
+    if (stateBeforeStart.running) {
+        log.message(`Daemon already running (PID ${stateBeforeStart.pidInfo?.pid ?? "unknown"}).`);
+        return;
+    }
+    const startSpinner = richUi ? spinner() : null;
+    try {
+        if (startSpinner) {
+            startSpinner.start("Starting daemon...");
+        }
+        else {
+            log.message("Starting daemon...");
+        }
+        const startup = await startLocalDaemonDetached(options);
+        if (startSpinner) {
+            startSpinner.stop(`Daemon started (PID ${startup.pid ?? "unknown"})`);
+        }
+        else {
+            log.message(`Daemon started (PID ${startup.pid ?? "unknown"})`);
+        }
+        log.message(`Logs: ${startup.logPath}`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (startSpinner) {
+            startSpinner.error(message);
+        }
+        else {
+            log.error(message);
+        }
+        process.exit(1);
+    }
+}
+async function waitForDaemonReadyWithUi(args) {
+    const readySpinner = args.richUi ? spinner() : null;
+    try {
+        if (readySpinner) {
+            readySpinner.start("Waiting for daemon to become ready...");
+        }
+        else {
+            log.message("Waiting for daemon to become ready...");
+        }
+        const readyState = await waitForDaemonReady({
+            home: args.home,
+            timeoutMs: args.timeoutMs,
+            onStatus: readySpinner ? (message) => readySpinner.message(message) : undefined,
+        });
+        if (readySpinner) {
+            readySpinner.stop(`Daemon ready on ${readyState.listen}`);
+        }
+        else {
+            log.message(`Daemon ready on ${readyState.listen}`);
+        }
+        return readyState;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (readySpinner) {
+            readySpinner.error(message);
+        }
+        else {
+            log.error(message);
+        }
+        return process.exit(1);
+    }
+}
+export async function runOnboard(options) {
+    const richUi = process.stdin.isTTY && process.stdout.isTTY;
+    if (richUi) {
+        intro("Welcome to Otto");
+    }
+    if (options.listen && options.port) {
+        cancel("Cannot use --listen and --port together");
+        process.exit(1);
+    }
+    let timeoutMs = DEFAULT_READY_TIMEOUT_MS;
+    try {
+        timeoutMs = parseTimeoutMs(options.timeout);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        cancel(message);
+        process.exit(1);
+    }
+    const ottoHome = resolveLocalOttoHome(options.home);
+    if (richUi) {
+        renderNote(ottoHome, "Otto home");
+    }
+    const voiceEnabled = await resolveAndPersistVoice(ottoHome, options);
+    const config = loadConfig(ottoHome, { cli: toCliOverrides(options) });
+    log.message(voiceEnabled
+        ? "Voice features enabled. Local speech models will be downloaded automatically if missing."
+        : "Voice features disabled. Local speech models will not be downloaded.");
+    await ensureDaemonStarted(options, richUi);
+    await waitForDaemonReadyWithUi({
+        home: options.home ?? ottoHome,
+        timeoutMs,
+        richUi,
+    });
+    if (config.relayEnabled === false) {
+        log.warn("Relay is disabled; pairing offer is unavailable for this daemon.");
+        printNextSteps(null, ottoHome, richUi);
+        if (richUi) {
+            outro("Otto daemon is running.");
+        }
+        return;
+    }
+    const pairing = await generateLocalPairingOffer({
+        ottoHome,
+        relayEnabled: config.relayEnabled,
+        relayEndpoint: config.relayEndpoint,
+        relayPublicEndpoint: config.relayPublicEndpoint,
+        relayUseTls: config.relayUseTls,
+        relayPublicUseTls: config.relayPublicUseTls,
+        appBaseUrl: config.appBaseUrl,
+        includeQr: true,
+    });
+    if (!pairing.url) {
+        log.warn("Relay pairing URL is unavailable for this daemon configuration.");
+        printNextSteps(null, ottoHome, richUi);
+        if (richUi) {
+            outro("Otto daemon is running.");
+        }
+        return;
+    }
+    renderNote(pairing.qr ?? "QR is unavailable in this terminal. Use the pairing link below.", "Scan to pair");
+    renderNote(pairing.url, "Pairing link");
+    printNextSteps(pairing.url, ottoHome, richUi);
+    if (richUi) {
+        outro("Otto is ready!");
+    }
+}
+//# sourceMappingURL=onboard.js.map

package/dist/commands/open.d.ts

@@ -0,0 +1,2 @@
+export declare function openDesktopWithProject(projectPath: string): Promise<void>;
+//# sourceMappingURL=open.d.ts.map

package/dist/commands/open.js

@@ -0,0 +1,81 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { spawnProcess } from "@otto-code/server";
+function findDesktopApp() {
+    if (process.platform === "darwin") {
+        const candidates = ["/Applications/Otto.app", path.join(homedir(), "Applications", "Otto.app")];
+        for (const candidate of candidates) {
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        return null;
+    }
+    if (process.platform === "linux") {
+        const candidates = [
+            "/usr/bin/Otto",
+            "/opt/Otto/Otto",
+            path.join(homedir(), "Applications", "Otto.AppImage"),
+        ];
+        for (const candidate of candidates) {
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        return null;
+    }
+    if (process.platform === "win32") {
+        const localAppData = process.env.LOCALAPPDATA;
+        if (!localAppData) {
+            return null;
+        }
+        const candidate = path.join(localAppData, "Programs", "Otto", "Otto.exe");
+        return existsSync(candidate) ? candidate : null;
+    }
+    return null;
+}
+function cleanEnvForDesktopLaunch() {
+    const env = { ...process.env };
+    // The CLI runs via ELECTRON_RUN_AS_NODE=1. On Linux/Windows the spawned
+    // desktop process inherits the env directly, so we must strip it or the
+    // desktop app would start as a bare Node process instead of Electron.
+    delete env.ELECTRON_RUN_AS_NODE;
+    delete env.ELECTRON_NO_ATTACH_CONSOLE;
+    delete env.OTTO_NODE_ENV;
+    return env;
+}
+function spawnDetached(command, args) {
+    spawnProcess(command, args, {
+        detached: true,
+        stdio: "ignore",
+        env: cleanEnvForDesktopLaunch(),
+    }).unref();
+}
+export async function openDesktopWithProject(projectPath) {
+    try {
+        if (process.env.OTTO_DESKTOP_CLI === "1") {
+            throw new Error("Cannot open a desktop project while running in desktop CLI passthrough mode.");
+        }
+        const desktopApp = findDesktopApp();
+        if (!desktopApp) {
+            throw new Error("Otto desktop app not found. Install it from https://github.com/Draek2077/otto-code/releases");
+        }
+        if (process.platform === "darwin") {
+            // -n forces a new instance even if the app is already running.
+            // The new instance hits requestSingleInstanceLock(), fails, and relays
+            // the argv to the first instance via the second-instance event.
+            // -g keeps the terminal in the foreground (better CLI UX).
+            // Without -n, macOS just activates the existing window and drops --args.
+            spawnDetached("open", ["-n", "-g", "-a", desktopApp, "--args", projectPath]);
+            return;
+        }
+        spawnDetached(desktopApp, [projectPath]);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        process.exitCode = 1;
+    }
+}
+//# sourceMappingURL=open.js.map

package/dist/commands/permit/allow.d.ts

@@ -0,0 +1,20 @@
+import type { Command } from "commander";
+import type { CommandOptions, ListResult, OutputSchema } from "../../output/index.js";
+/** Permission response item for display */
+export interface PermissionResponseItem {
+    requestId: string;
+    agentId: string;
+    agentShortId: string;
+    name: string;
+    result: string;
+}
+/** Schema for permit allow/deny output */
+export declare const permitResponseSchema: OutputSchema<PermissionResponseItem>;
+export type PermitAllowResult = ListResult<PermissionResponseItem>;
+export interface PermitAllowOptions extends CommandOptions {
+    all?: boolean;
+    input?: string;
+    host?: string;
+}
+export declare function runAllowCommand(agentIdOrPrefix: string, reqId: string | undefined, options: PermitAllowOptions, _command: Command): Promise<PermitAllowResult>;
+//# sourceMappingURL=allow.d.ts.map

package/dist/commands/permit/allow.js

@@ -0,0 +1,133 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+/** Schema for permit allow/deny output */
+export const permitResponseSchema = {
+    idField: "requestId",
+    columns: [
+        { header: "REQUEST ID", field: "requestId", width: 12 },
+        { header: "AGENT", field: "agentShortId", width: 10 },
+        { header: "TOOL", field: "name", width: 20 },
+        {
+            header: "RESULT",
+            field: "result",
+            width: 10,
+            color: (value) => {
+                if (value === "allowed")
+                    return "green";
+                if (value === "denied")
+                    return "red";
+                return undefined;
+            },
+        },
+    ],
+};
+export async function runAllowCommand(agentIdOrPrefix, reqId, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    // No validation needed - if no reqId provided, allow all by default
+    // Parse input JSON if provided
+    let updatedInput;
+    if (options.input) {
+        try {
+            updatedInput = JSON.parse(options.input);
+        }
+        catch (err) {
+            const error = {
+                code: "INVALID_JSON",
+                message: `Invalid JSON for --input: ${err instanceof Error ? err.message : String(err)}`,
+                details: 'Provide valid JSON, e.g., --input \'{"key": "value"}\'',
+            };
+            throw error;
+        }
+    }
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+        throw error;
+    }
+    try {
+        const fetchResult = await client.fetchAgent({ agentId: agentIdOrPrefix });
+        if (!fetchResult) {
+            await client.close();
+            const error = {
+                code: "AGENT_NOT_FOUND",
+                message: `Agent not found: ${agentIdOrPrefix}`,
+                details: 'Use "otto ls" to list available agents',
+            };
+            throw error;
+        }
+        const agent = fetchResult.agent;
+        const resolvedAgentId = agent.id;
+        // Get pending permissions for this agent
+        const pendingPermissions = agent.pendingPermissions || [];
+        if (pendingPermissions.length === 0) {
+            await client.close();
+            const error = {
+                code: "NO_PENDING_PERMISSIONS",
+                message: `No pending permissions for agent ${agent.id.slice(0, 7)}`,
+            };
+            throw error;
+        }
+        // Determine which permissions to allow
+        let permissionsToAllow;
+        if (!reqId || options.all) {
+            // Default: allow all pending permissions if no req_id specified
+            // --all flag is kept as an explicit alias for clarity
+            permissionsToAllow = pendingPermissions;
+        }
+        else {
+            // Find permission by ID prefix
+            const permission = pendingPermissions.find((p) => p.id === reqId || p.id.startsWith(reqId));
+            if (!permission) {
+                await client.close();
+                const error = {
+                    code: "PERMISSION_NOT_FOUND",
+                    message: `Permission request not found: ${reqId}`,
+                    details: `Available requests: ${pendingPermissions.map((p) => p.id.slice(0, 8)).join(", ")}`,
+                };
+                throw error;
+            }
+            permissionsToAllow = [permission];
+        }
+        // Allow permissions
+        const results = await Promise.all(permissionsToAllow.map(async (permission) => {
+            await client.respondToPermission(resolvedAgentId, permission.id, {
+                behavior: "allow",
+                ...(updatedInput ? { updatedInput } : {}),
+            });
+            return {
+                requestId: permission.id.slice(0, 8),
+                agentId: resolvedAgentId,
+                agentShortId: resolvedAgentId.slice(0, 7),
+                name: permission.name,
+                result: "allowed",
+            };
+        }));
+        await client.close();
+        return {
+            type: "list",
+            data: results,
+            schema: permitResponseSchema,
+        };
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        // Re-throw CommandErrors
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "ALLOW_PERMISSION_FAILED",
+            message: `Failed to allow permission: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=allow.js.map

package/dist/commands/permit/deny.d.ts

@@ -0,0 +1,12 @@
+import type { Command } from "commander";
+import type { CommandOptions, ListResult } from "../../output/index.js";
+import { type PermissionResponseItem } from "./allow.js";
+export type PermitDenyResult = ListResult<PermissionResponseItem>;
+export interface PermitDenyOptions extends CommandOptions {
+    all?: boolean;
+    message?: string;
+    interrupt?: boolean;
+    host?: string;
+}
+export declare function runDenyCommand(agentIdOrPrefix: string, reqId: string | undefined, options: PermitDenyOptions, _command: Command): Promise<PermitDenyResult>;
+//# sourceMappingURL=deny.d.ts.map