@otto-code/cli 0.5.0

package/dist/commands/daemon/status.js

@@ -0,0 +1,338 @@
+import { createRequire } from "node:module";
+import { getOrCreateServerId, findExecutable, execCommand } from "@otto-code/server";
+import { connectToDaemon } from "../../utils/client.js";
+import { resolveLocalDaemonState, resolveTcpHostFromListen } from "./local-daemon.js";
+import { resolveNodePathFromPid } from "./runtime-toolchain.js";
+const DAEMON_STATUS_PROBE_TIMEOUT_MS = 1500;
+const require = createRequire(import.meta.url);
+function normalizeError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function shortenMessage(message, max = 120) {
+    const normalized = message.replace(/\s+/g, " ").trim();
+    if (normalized.length <= max) {
+        return normalized;
+    }
+    return `${normalized.slice(0, max - 3)}...`;
+}
+function appendNote(current, next) {
+    if (!next)
+        return current;
+    if (!current)
+        return next;
+    return `${current}; ${next}`;
+}
+function resolveCliVersion() {
+    try {
+        const packageJson = require("../../../package.json");
+        if (typeof packageJson.version === "string" && packageJson.version.trim().length > 0) {
+            return packageJson.version.trim();
+        }
+    }
+    catch {
+        // Fall through.
+    }
+    return "unknown";
+}
+function createStatusSchema(status) {
+    return {
+        idField: "key",
+        columns: [
+            { header: "KEY", field: "key" },
+            {
+                header: "VALUE",
+                field: "value",
+                color: (_, item) => {
+                    if (item.key === "Local Daemon") {
+                        if (item.value === "running")
+                            return "green";
+                        if (item.value === "unresponsive")
+                            return "yellow";
+                        return "red";
+                    }
+                    if (item.key === "Connected Daemon") {
+                        if (item.value === "reachable")
+                            return "green";
+                        if (item.value === "not_probed" || item.value === "auth_required")
+                            return "yellow";
+                        return "red";
+                    }
+                    if (item.key.startsWith("  ")) {
+                        if (item.value === "not found" || item.value === "not found (daemon)")
+                            return "red";
+                        if (item.value.endsWith("(--version failed)"))
+                            return "yellow";
+                        return "green";
+                    }
+                    return undefined;
+                },
+            },
+        ],
+        serialize: () => status,
+    };
+}
+function toStatusRows(status) {
+    const rows = [
+        { key: "Server ID", value: status.serverId ?? "-" },
+        { key: "Local Daemon", value: status.localDaemon },
+        { key: "Connected Daemon", value: status.connectedDaemon },
+        { key: "Home", value: status.home },
+        { key: "Listen", value: status.listen },
+        { key: "Relay", value: status.relay },
+        { key: "Hostname", value: status.hostname ?? "-" },
+        { key: "PID", value: status.pid === null ? "-" : String(status.pid) },
+        { key: "Started", value: status.startedAt ?? "-" },
+        { key: "Owner", value: status.owner ?? "-" },
+        { key: "Logs", value: status.logPath },
+        { key: "Daemon Node", value: status.daemonNode },
+        { key: "CLI Node", value: status.cliNode },
+        { key: "CLI", value: status.cliVersion },
+        { key: "Daemon Version", value: status.daemonVersion ?? "-" },
+    ];
+    if (status.note) {
+        rows.push({ key: "Note", value: status.note });
+    }
+    rows.push({ key: "", value: "" });
+    rows.push({ key: "Providers", value: "" });
+    for (const provider of status.providers) {
+        if (provider.source === "daemon") {
+            if (!provider.path) {
+                rows.push({ key: `  ${provider.label}`, value: "not found (daemon)" });
+            }
+            else {
+                rows.push({ key: `  ${provider.label}`, value: `${provider.path} (daemon)` });
+            }
+        }
+        else if (!provider.path) {
+            rows.push({ key: `  ${provider.label}`, value: "not found" });
+        }
+        else if (!provider.version) {
+            rows.push({ key: `  ${provider.label}`, value: `${provider.path} (--version failed)` });
+        }
+        else {
+            rows.push({ key: `  ${provider.label}`, value: `${provider.path} (${provider.version})` });
+        }
+    }
+    return rows;
+}
+const PROVIDER_BINARIES = [
+    { label: "Claude", binary: "claude" },
+    { label: "Codex", binary: "codex" },
+    { label: "OpenCode", binary: "opencode" },
+];
+async function checkProviderBinary(binary) {
+    const binaryPath = await findExecutable(binary);
+    if (!binaryPath) {
+        return { path: null, version: null };
+    }
+    try {
+        const { stdout } = await execCommand(binaryPath, ["--version"], {
+            timeout: 5000,
+        });
+        return { path: binaryPath, version: stdout.trim() || null };
+    }
+    catch {
+        return { path: binaryPath, version: null };
+    }
+}
+async function checkProviderBinaries() {
+    const results = await Promise.all(PROVIDER_BINARIES.map(async ({ label, binary }) => {
+        const result = await checkProviderBinary(binary);
+        return Object.assign({ label }, result);
+    }));
+    return results;
+}
+function resolveOwnerLabel(uid, hostname) {
+    if (uid === undefined && !hostname) {
+        return null;
+    }
+    const uidPart = uid === undefined ? "?" : String(uid);
+    const hostPart = hostname ?? "unknown-host";
+    return `${uidPart}@${hostPart}`;
+}
+function classifyDaemonAuthProbeFailure(error) {
+    if (!(error instanceof Error))
+        return null;
+    if (error.message === "Password required")
+        return "auth_required";
+    if (error.message === "Incorrect password")
+        return "auth_failed";
+    return null;
+}
+function describeDaemonAuthProbeFailure(host, failure) {
+    if (failure === "auth_required") {
+        return `Daemon is reachable at ${host} but requires a password. Set OTTO_PASSWORD and retry.`;
+    }
+    return `Daemon is reachable at ${host} but the supplied password was rejected. Check OTTO_PASSWORD and retry.`;
+}
+async function probeDaemonOverWebsocket(args) {
+    const { host, state } = args;
+    let client;
+    try {
+        client = await connectToDaemon({ host, timeout: 1500 });
+    }
+    catch (error) {
+        const authFailure = classifyDaemonAuthProbeFailure(error);
+        if (authFailure) {
+            return {
+                connectedDaemon: authFailure,
+                note: describeDaemonAuthProbeFailure(host, authFailure),
+            };
+        }
+        if (state.running) {
+            return {
+                connectedDaemon: "unreachable",
+                localDaemonOverride: "unresponsive",
+                note: `Local daemon PID is running but websocket at ${host} is not reachable`,
+            };
+        }
+        return { connectedDaemon: "unreachable" };
+    }
+    const daemonVersion = client.getLastServerInfoMessage()?.version ?? null;
+    try {
+        const statusPayload = await client.getDaemonStatus({
+            timeout: DAEMON_STATUS_PROBE_TIMEOUT_MS,
+        });
+        const labelMap = new Map(PROVIDER_BINARIES.map((p) => [p.binary, p.label]));
+        const daemonProviders = statusPayload.providers.map((p) => ({
+            label: labelMap.get(p.provider) ?? p.provider,
+            path: p.available ? "available" : null,
+            version: p.available ? null : (p.error ?? null),
+            source: "daemon",
+        }));
+        if (!state.running) {
+            return {
+                connectedDaemon: "reachable",
+                daemonVersion: statusPayload.version ?? daemonVersion,
+                daemonNodeOverride: statusPayload.nodePath,
+                daemonProviders,
+                note: state.pidInfo
+                    ? `Connected daemon is reachable at ${host} even though local daemon PID ${state.pidInfo.pid} is stale`
+                    : `Connected daemon is reachable at ${host} but no local daemon PID file was found`,
+            };
+        }
+        return {
+            connectedDaemon: "reachable",
+            daemonVersion: statusPayload.version ?? daemonVersion,
+            daemonNodeOverride: statusPayload.nodePath,
+            daemonProviders,
+        };
+    }
+    catch {
+        return {
+            connectedDaemon: "reachable",
+            daemonVersion,
+            note: state.running
+                ? `Local daemon PID is running but daemon detail request to ${host} failed`
+                : `Connected daemon websocket is reachable at ${host} but daemon status request failed`,
+        };
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+function applyProbeToStatus(input) {
+    const { probe } = input;
+    return {
+        connectedDaemon: probe.connectedDaemon,
+        localDaemon: probe.localDaemonOverride ?? input.localDaemon,
+        daemonNode: probe.daemonNodeOverride ?? input.daemonNode,
+        daemonVersion: probe.daemonVersion !== undefined ? probe.daemonVersion : input.daemonVersion,
+        daemonProviders: probe.daemonProviders ?? input.daemonProviders,
+        note: probe.note ? appendNote(input.note, probe.note) : input.note,
+    };
+}
+function resolveServerIdSafely(home) {
+    try {
+        return { serverId: getOrCreateServerId(home), error: null };
+    }
+    catch (error) {
+        return {
+            serverId: null,
+            error: `serverId unavailable: ${shortenMessage(normalizeError(error))}`,
+        };
+    }
+}
+async function resolveDaemonNodeLabel(state) {
+    if (!state.running)
+        return "-";
+    if (!state.pidInfo?.pid)
+        return "unknown (no PID available)";
+    const fromPid = await resolveNodePathFromPid(state.pidInfo.pid);
+    return fromPid.nodePath ?? `unknown (${fromPid.error ?? "could not resolve from PID"})`;
+}
+function formatRelayStatus(state) {
+    if (!state.relayEnabled)
+        return "disabled";
+    const scheme = state.relayPublicUseTls ? "wss" : "ws";
+    return `${scheme}://${state.relayEndpoint}`;
+}
+export async function runStatusCommand(options, _command) {
+    const home = typeof options.home === "string" ? options.home : undefined;
+    const state = resolveLocalDaemonState({ home });
+    const host = resolveTcpHostFromListen(state.listen);
+    const owner = resolveOwnerLabel(state.pidInfo?.uid, state.pidInfo?.hostname);
+    let daemonNode = await resolveDaemonNodeLabel(state);
+    const cliNode = process.execPath;
+    let localDaemon = state.running ? "running" : "stopped";
+    let connectedDaemon = "not_probed";
+    let daemonVersion = null;
+    let daemonProviders;
+    let note;
+    if (!state.running && state.stalePidFile && state.pidInfo) {
+        localDaemon = "stale_pid";
+        note = `Stale PID file found for PID ${state.pidInfo.pid}`;
+    }
+    if (host) {
+        const probe = await probeDaemonOverWebsocket({ host, state });
+        ({ connectedDaemon, localDaemon, daemonNode, daemonVersion, daemonProviders, note } =
+            applyProbeToStatus({
+                probe,
+                connectedDaemon,
+                localDaemon,
+                daemonNode,
+                daemonVersion,
+                daemonProviders,
+                note,
+            }));
+    }
+    else {
+        note = appendNote(note, "Daemon is configured for unix socket listen; API probe skipped");
+    }
+    const cliVersion = resolveCliVersion();
+    const serverIdResult = resolveServerIdSafely(state.home);
+    const serverId = serverIdResult.serverId;
+    if (serverIdResult.error) {
+        note = appendNote(note, serverIdResult.error);
+    }
+    const providers = daemonProviders ?? (await checkProviderBinaries());
+    const daemonStatus = {
+        serverId,
+        localDaemon,
+        connectedDaemon,
+        home: state.home,
+        listen: state.listen,
+        relay: formatRelayStatus(state),
+        hostname: state.pidInfo?.hostname ?? null,
+        pid: state.pidInfo?.pid ?? null,
+        startedAt: state.pidInfo?.startedAt ?? null,
+        owner,
+        logPath: state.logPath,
+        daemonNode,
+        cliNode,
+        cliVersion,
+        daemonVersion,
+        desktopManaged: state.pidInfo?.desktopManaged === true,
+        providers,
+        note,
+    };
+    return {
+        type: "list",
+        data: toStatusRows(daemonStatus),
+        schema: createStatusSchema(daemonStatus),
+    };
+}
+//# sourceMappingURL=status.js.map

package/dist/commands/daemon/stop.d.ts

@@ -0,0 +1,15 @@
+import type { Command } from "commander";
+import type { CommandOptions, SingleResult } from "../../output/index.js";
+interface StopResult {
+    action: "stopped" | "not_running";
+    home: string;
+    pid: string;
+    forced: boolean;
+    usedLifecycleRpc: boolean;
+    reason: "not_running" | "lifecycle_shutdown_rpc" | "owner_pid_signal" | "owner_pid_sigkill";
+    message: string;
+}
+export type StopCommandResult = SingleResult<StopResult>;
+export declare function runStopCommand(options: CommandOptions, _command: Command): Promise<StopCommandResult>;
+export {};
+//# sourceMappingURL=stop.d.ts.map

package/dist/commands/daemon/stop.js

@@ -0,0 +1,60 @@
+import { stopLocalDaemon, DEFAULT_STOP_TIMEOUT_MS, DEFAULT_KILL_TIMEOUT_MS, } from "./local-daemon.js";
+const stopResultSchema = {
+    idField: "action",
+    columns: [
+        {
+            header: "STATUS",
+            field: "action",
+            color: (value) => (value === "stopped" ? "green" : "yellow"),
+        },
+        { header: "HOME", field: "home" },
+        { header: "PID", field: "pid" },
+        { header: "MESSAGE", field: "message" },
+    ],
+};
+function parseSecondsOption(raw, fallbackMs, label) {
+    if (typeof raw !== "string" || raw.trim().length === 0) {
+        return fallbackMs;
+    }
+    const seconds = Number(raw);
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        const error = {
+            code: "INVALID_TIMEOUT",
+            message: `Invalid ${label} value: ${raw}`,
+            details: `${label} must be a positive number of seconds`,
+        };
+        throw error;
+    }
+    return Math.ceil(seconds * 1000);
+}
+export async function runStopCommand(options, _command) {
+    const home = typeof options.home === "string" ? options.home : undefined;
+    const force = options.force === true;
+    const timeoutMs = parseSecondsOption(options.timeout, DEFAULT_STOP_TIMEOUT_MS, "timeout");
+    const killTimeoutMs = parseSecondsOption(options.killTimeout, DEFAULT_KILL_TIMEOUT_MS, "kill-timeout");
+    try {
+        const result = await stopLocalDaemon({ home, force, timeoutMs, killTimeoutMs });
+        return {
+            type: "single",
+            data: {
+                action: result.action,
+                home: result.home,
+                pid: result.pid === null ? "-" : String(result.pid),
+                forced: result.forced,
+                usedLifecycleRpc: result.usedLifecycleRpc,
+                reason: result.reason,
+                message: result.message,
+            },
+            schema: stopResultSchema,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "STOP_FAILED",
+            message: `Failed to stop local daemon: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=stop.js.map

package/dist/commands/hooks.d.ts

@@ -0,0 +1,19 @@
+import { Command } from "commander";
+interface HookEnvironment {
+    OTTO_TERMINAL_ID?: string;
+    OTTO_ACTIVITY_TOKEN?: string;
+    OTTO_TERMINAL_ACTIVITY_URL?: string;
+}
+interface HookInput {
+    [Symbol.asyncIterator](): AsyncIterator<string | Buffer>;
+    isTTY?: boolean;
+}
+interface HooksRuntime {
+    env: HookEnvironment;
+    input: HookInput;
+    fetch: typeof fetch;
+}
+export declare function createHooksCommand(): Command;
+export declare function runHooksCommand(agent: string, event: string, runtime?: HooksRuntime): Promise<void>;
+export {};
+//# sourceMappingURL=hooks.d.ts.map

package/dist/commands/hooks.js

@@ -0,0 +1,89 @@
+import { Command } from "commander";
+import { resolveHookActivity } from "@otto-code/server/agent-hooks";
+export function createHooksCommand() {
+    return new Command("hooks")
+        .description("Record agent hook activity")
+        .argument("<agent>", "Agent hook source")
+        .argument("<event>", "Agent hook event")
+        .action((agent, event) => runHooksCommand(agent, event));
+}
+export async function runHooksCommand(agent, event, runtime = {
+    env: process.env,
+    input: process.stdin,
+    fetch,
+}) {
+    const target = resolveTarget(runtime.env);
+    if (!target)
+        return;
+    const state = await resolveHookActivity({
+        provider: agent,
+        event,
+        input: {
+            isTTY: runtime.input.isTTY,
+            read: () => readInput(runtime.input),
+        },
+    });
+    if (!state)
+        return;
+    await postActivity(target, state, runtime.fetch);
+}
+function resolveTarget(env) {
+    const terminalId = env.OTTO_TERMINAL_ID;
+    const token = env.OTTO_ACTIVITY_TOKEN;
+    const url = env.OTTO_TERMINAL_ACTIVITY_URL;
+    if (!terminalId || !token || !url)
+        return null;
+    return { terminalId, token, url };
+}
+async function readInput(input) {
+    const iterator = input[Symbol.asyncIterator]();
+    const chunks = [];
+    while (true) {
+        const next = await withTimeout(iterator.next(), 100);
+        if (!next) {
+            await iterator.return?.();
+            return null;
+        }
+        if (next.done)
+            return chunks.join("");
+        chunks.push(String(next.value));
+    }
+}
+async function withTimeout(promise, ms) {
+    let timeout;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((resolve) => {
+                timeout = setTimeout(() => resolve(null), ms);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+async function postActivity(target, state, send) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 500);
+    try {
+        await send(target.url, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                terminalId: target.terminalId,
+                token: target.token,
+                state,
+            }),
+            signal: controller.signal,
+        });
+    }
+    catch {
+        return;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+//# sourceMappingURL=hooks.js.map

package/dist/commands/loop/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createLoopCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/loop/index.js

@@ -0,0 +1,18 @@
+import { Command } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions, addDaemonHostOption } from "../../utils/command-options.js";
+import { addLoopRunOptions, runLoopRunCommand } from "./run.js";
+import { addLoopLsOptions, runLoopLsCommand } from "./ls.js";
+import { addLoopInspectOptions, runLoopInspectCommand } from "./inspect.js";
+import { addLoopLogsOptions, runLoopLogsCommand } from "./logs.js";
+import { addLoopStopOptions, runLoopStopCommand } from "./stop.js";
+export function createLoopCommand() {
+    const loop = new Command("loop").description("Run iterative worker loops");
+    addJsonAndDaemonHostOptions(addLoopRunOptions(loop.command("run"))).action(withOutput(runLoopRunCommand));
+    addJsonAndDaemonHostOptions(addLoopLsOptions(loop.command("ls"))).action(withOutput(runLoopLsCommand));
+    addJsonAndDaemonHostOptions(addLoopInspectOptions(loop.command("inspect"))).action(withOutput(runLoopInspectCommand));
+    addDaemonHostOption(addLoopLogsOptions(loop.command("logs"))).action(runLoopLogsCommand);
+    addJsonAndDaemonHostOptions(addLoopStopOptions(loop.command("stop"))).action(withOutput(runLoopStopCommand));
+    return loop;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/loop/inspect.d.ts

@@ -0,0 +1,13 @@
+import { Command } from "commander";
+import type { CommandOptions, ListResult } from "../../output/index.js";
+interface InspectRow {
+    key: string;
+    value: string;
+}
+export interface LoopInspectOptions extends CommandOptions {
+}
+export declare function addLoopInspectOptions(command: Command): Command;
+export type LoopInspectResult = ListResult<InspectRow>;
+export declare function runLoopInspectCommand(id: string, options: LoopInspectOptions, _command: Command): Promise<LoopInspectResult>;
+export {};
+//# sourceMappingURL=inspect.d.ts.map

package/dist/commands/loop/inspect.js

@@ -0,0 +1,100 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+export function addLoopInspectOptions(command) {
+    return command.description("Show loop details and iteration history").argument("<id>", "Loop ID");
+}
+function createInspectSchema(loop) {
+    return {
+        idField: "key",
+        columns: [
+            { header: "KEY", field: "key", width: 18 },
+            { header: "VALUE", field: "value", width: 80 },
+        ],
+        serialize: () => loop,
+    };
+}
+function toRows(loop) {
+    return [
+        { key: "Id", value: loop.id },
+        { key: "Name", value: loop.name ?? "null" },
+        { key: "Status", value: loop.status },
+        { key: "Cwd", value: loop.cwd },
+        { key: "Provider", value: loop.provider },
+        { key: "Model", value: loop.model ?? "null" },
+        { key: "WorkerProvider", value: loop.workerProvider ?? "null" },
+        { key: "WorkerModel", value: loop.workerModel ?? "null" },
+        { key: "VerifierProvider", value: loop.verifierProvider ?? "null" },
+        { key: "VerifierModel", value: loop.verifierModel ?? "null" },
+        { key: "Prompt", value: loop.prompt },
+        { key: "VerifyPrompt", value: loop.verifyPrompt ?? "null" },
+        {
+            key: "VerifyChecks",
+            value: loop.verifyChecks.length > 0 ? loop.verifyChecks.join(" | ") : "[]",
+        },
+        { key: "Archive", value: String(loop.archive) },
+        { key: "SleepMs", value: String(loop.sleepMs) },
+        {
+            key: "MaxIterations",
+            value: loop.maxIterations === null ? "null" : String(loop.maxIterations),
+        },
+        { key: "MaxTimeMs", value: loop.maxTimeMs === null ? "null" : String(loop.maxTimeMs) },
+        { key: "CreatedAt", value: loop.createdAt },
+        { key: "UpdatedAt", value: loop.updatedAt },
+        { key: "CompletedAt", value: loop.completedAt ?? "null" },
+        {
+            key: "Iterations",
+            value: loop.iterations.length === 0
+                ? "[]"
+                : loop.iterations
+                    .map((iteration) => {
+                    const summary = [
+                        `#${iteration.index}`,
+                        iteration.status,
+                        iteration.workerAgentId ? `worker=${iteration.workerAgentId}` : null,
+                        iteration.verifierAgentId ? `verifier=${iteration.verifierAgentId}` : null,
+                        iteration.failureReason ? `reason=${iteration.failureReason}` : null,
+                    ]
+                        .filter(Boolean)
+                        .join(" ");
+                    return summary;
+                })
+                    .join(" | "),
+        },
+    ];
+}
+export async function runLoopInspectCommand(id, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    let client;
+    try {
+        client = (await connectToDaemon({
+            host: options.host,
+        }));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+    }
+    try {
+        const payload = await client.loopInspect(id);
+        await client.close();
+        if (payload.error || !payload.loop) {
+            throw new Error(payload.error ?? `Loop not found: ${id}`);
+        }
+        return {
+            type: "list",
+            data: toRows(payload.loop),
+            schema: createInspectSchema(payload.loop),
+        };
+    }
+    catch (error) {
+        await client.close().catch(() => { });
+        throw {
+            code: "LOOP_INSPECT_FAILED",
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+//# sourceMappingURL=inspect.js.map

package/dist/commands/loop/logs.d.ts

@@ -0,0 +1,8 @@
+import { Command } from "commander";
+import type { CommandOptions } from "../../output/index.js";
+export interface LoopLogsOptions extends CommandOptions {
+    pollInterval?: string;
+}
+export declare function addLoopLogsOptions(command: Command): Command;
+export declare function runLoopLogsCommand(id: string, options: LoopLogsOptions, _command: Command): Promise<void>;
+//# sourceMappingURL=logs.d.ts.map