@getdial/cli 0.13.2 → 0.15.0

package/dist/lib/ops/events.js

@@ -0,0 +1,63 @@
+import { paths } from "../paths.js";
+import { supervisorStatus } from "../supervisor/index.js";
+import { parseFieldArg, parseRegexArg } from "../event-filter.js";
+import { currentSize, findLatestMatch, tailUntilMatch } from "../log-tail.js";
+import { apiPost } from "../api.js";
+import { requireAuth } from "./auth.js";
+import { DialError } from "./errors.js";
+const PER_POLL_SECONDS = 30;
+/**
+ * Wait for a matching account event. Tails the local listen log when the daemon is
+ * running, otherwise long-polls the REST API. Console-free: returns what to print and
+ * whether it timed out; throws DialError for auth/API failures.
+ */
+export async function waitForEvent(opts) {
+    const spec = {
+        eventType: opts.eventType,
+        fields: opts.fields.map(parseFieldArg),
+        regexes: opts.regexes.map(parseRegexArg),
+    };
+    const status = supervisorStatus();
+    if (status.installed && status.running)
+        return waitFromLog(spec, opts);
+    return waitFromApi(spec, opts);
+}
+async function waitFromLog(spec, opts) {
+    const file = paths().listenLog;
+    const startOffset = currentSize(file);
+    const hit = await tailUntilMatch(file, spec, startOffset, opts.timeoutSeconds * 1000);
+    if (hit)
+        return { source: "log", timedOut: false, event: hit.obj, line: hit.line };
+    const fallback = findLatestMatch(file, spec);
+    if (fallback)
+        return { source: "log", timedOut: true, event: fallback.obj, line: fallback.line };
+    return { source: null, timedOut: true, event: null, line: null };
+}
+async function waitFromApi(spec, opts) {
+    const auth = requireAuth();
+    const filters = {};
+    for (const f of spec.fields)
+        filters[f.name] = f.value;
+    const regexFilters = {};
+    for (const r of spec.regexes)
+        regexFilters[r.name] = { pattern: r.regex.source, flags: r.regex.flags };
+    const deadline = Date.now() + opts.timeoutSeconds * 1000;
+    while (Date.now() < deadline) {
+        const remainingSec = Math.max(1, Math.ceil((deadline - Date.now()) / 1000));
+        const timeout = Math.min(PER_POLL_SECONDS, remainingSec);
+        const res = await apiPost("/api/v1/events/wait", {
+            eventType: spec.eventType,
+            filters: Object.keys(filters).length > 0 ? filters : undefined,
+            regexFilters: Object.keys(regexFilters).length > 0 ? regexFilters : undefined,
+            timeout,
+        }, auth.apiKey);
+        if (res.ok && res.data?.event) {
+            return { source: "api", timedOut: false, event: res.data.event, line: JSON.stringify(res.data.event) };
+        }
+        if (res.ok === false && res.status === 408)
+            continue;
+        if (res.ok === false)
+            throw new DialError("api_fallback_failed", res.error, res.status);
+    }
+    return { source: "api", timedOut: true, event: null, line: null };
+}

package/dist/lib/ops/listen.js

@@ -0,0 +1,51 @@
+import { readFileSync } from "node:fs";
+import { installSupervised, uninstallSupervised, supervisorStatus, supervisorAvailability, lastEventAtFromLog, } from "../supervisor/index.js";
+import { paths } from "../paths.js";
+import { requireAuth } from "./auth.js";
+import { DialError } from "./errors.js";
+function resolveDialPath() {
+    return process.env.DIAL_BIN_OVERRIDE ?? process.argv[1] ?? "dial";
+}
+export function listenInstall() {
+    requireAuth();
+    const supervisor = supervisorAvailability();
+    if (!supervisor.available) {
+        throw new DialError("supervisor_unavailable", supervisor.reason);
+    }
+    try {
+        return installSupervised(resolveDialPath());
+    }
+    catch (err) {
+        throw new DialError("install_failed", err instanceof Error ? err.message : String(err));
+    }
+}
+export function listenUninstall() {
+    try {
+        uninstallSupervised();
+        return { ok: true };
+    }
+    catch (err) {
+        throw new DialError("uninstall_failed", err instanceof Error ? err.message : String(err));
+    }
+}
+export function listenStatus() {
+    const s = supervisorStatus();
+    const lastEventAt = lastEventAtFromLog(paths().listenLog);
+    let lastEvents = [];
+    try {
+        const raw = readFileSync(paths().listenLog, "utf8");
+        const lines = raw.trim().split("\n").filter(Boolean);
+        lastEvents = lines.slice(-5).map((l) => {
+            try {
+                return JSON.parse(l);
+            }
+            catch {
+                return l;
+            }
+        });
+    }
+    catch {
+        // no log yet — leave empty
+    }
+    return { installed: s.installed, running: s.running, pid: s.pid, unitPath: s.unitPath, lastEventAt, lastEvents };
+}

package/dist/lib/ops/local-targets.js

@@ -0,0 +1,35 @@
+import { addTarget, removeTarget, listTargets, targetId, LocalTargetError, DEFAULT_SIGNATURE_HEADER, } from "../local-targets.js";
+import { DialError } from "./errors.js";
+function wrap(fn) {
+    try {
+        return fn();
+    }
+    catch (err) {
+        if (err instanceof LocalTargetError)
+            throw new DialError(err.code, err.message);
+        throw err;
+    }
+}
+export function addUrlTarget(opts) {
+    const { added } = wrap(() => addTarget({
+        kind: "url",
+        url: opts.url,
+        secret: opts.secret,
+        signatureHeader: opts.signatureHeader ?? (opts.secret ? DEFAULT_SIGNATURE_HEADER : undefined),
+        bearer: opts.bearer,
+        timeoutSeconds: opts.timeoutSeconds,
+    }));
+    return { added, url: opts.url };
+}
+export function addCommandTarget(opts) {
+    const args = opts.args ?? [];
+    const { added } = wrap(() => addTarget({ kind: "cmd", path: opts.path, args, timeoutSeconds: opts.timeoutSeconds }));
+    return { added, path: opts.path, args };
+}
+export function removeLocalTarget(id) {
+    const { removed } = removeTarget(id);
+    return { removed, id };
+}
+export function listLocalTargets() {
+    return listTargets().map((t) => ({ kind: t.kind, id: targetId(t), target: t }));
+}

package/dist/lib/ops/messages.js

@@ -0,0 +1,26 @@
+import { apiGet, apiPost } from "../api.js";
+import { requireAuth, requireFromNumberId } from "./auth.js";
+import { DialError } from "./errors.js";
+export async function sendMessage(opts) {
+    const auth = requireAuth();
+    const fromNumberId = requireFromNumberId(auth, opts.fromNumberId);
+    const res = await apiPost("/api/v1/messages", { to: opts.to, body: opts.body, channel: "sms", fromNumberId }, auth.apiKey);
+    if (!res.ok)
+        throw new DialError("send_failed", res.error, res.status);
+    return res.data.message;
+}
+export async function listMessages(opts) {
+    const auth = requireAuth();
+    const params = new URLSearchParams();
+    if (opts.numberId)
+        params.set("numberId", opts.numberId);
+    if (opts.direction)
+        params.set("direction", opts.direction);
+    if (opts.since)
+        params.set("since", opts.since);
+    const qs = params.toString();
+    const res = await apiGet(qs ? `/api/v1/messages?${qs}` : "/api/v1/messages", auth.apiKey);
+    if (!res.ok)
+        throw new DialError("list_failed", res.error, res.status);
+    return res.data.messages ?? [];
+}

package/dist/lib/ops/numbers.js

@@ -0,0 +1,39 @@
+import { apiGet, apiPost, apiPatch } from "../api.js";
+import { requireAuth } from "./auth.js";
+import { DialError } from "./errors.js";
+export async function listNumbers() {
+    const auth = requireAuth();
+    const res = await apiGet("/api/v1/numbers", auth.apiKey);
+    if (!res.ok)
+        throw new DialError("list_failed", res.error, res.status);
+    return { numbers: res.data.numbers ?? [], defaultNumberId: auth.phoneNumberId ?? null };
+}
+export async function purchaseNumber(opts) {
+    const auth = requireAuth();
+    const body = { inboundInstruction: opts.inboundInstruction };
+    if (opts.country)
+        body.country = opts.country;
+    if (opts.areaCode)
+        body.areaCode = opts.areaCode;
+    const res = await apiPost("/api/v1/numbers", body, auth.apiKey);
+    if (!res.ok)
+        throw new DialError("purchase_failed", res.error, res.status);
+    return res.data.number;
+}
+export async function setNumberProperties(opts) {
+    const auth = requireAuth();
+    // The REST API keys numbers by id; the CLI/tool takes the E.164 number for ergonomics,
+    // so resolve it to its id first.
+    const list = await apiGet("/api/v1/numbers", auth.apiKey);
+    if (!list.ok)
+        throw new DialError("list_failed", list.error, list.status);
+    const match = list.data.numbers.find((n) => n.number === opts.number);
+    if (!match) {
+        const known = list.data.numbers.map((n) => n.number).join(", ") || "(none)";
+        throw new DialError("number_not_found", `No phone number ${opts.number} on your account. Yours: ${known}.`);
+    }
+    const res = await apiPatch(`/api/v1/numbers/${match.id}`, { inboundInstruction: opts.inboundInstruction }, auth.apiKey);
+    if (!res.ok)
+        throw new DialError("update_failed", res.error, res.status);
+    return res.data.number;
+}

package/dist/mcp/register.js

@@ -0,0 +1,27 @@
+import { ZodError } from "zod";
+import { tools } from "./tools/index.js";
+import { errorResult } from "./result.js";
+import { isDialError } from "../lib/ops/errors.js";
+import { logger } from "../lib/log.js";
+/**
+ * Register every tool onto the MCP server. DialError/ZodError surface their message to
+ * the model as a tool error; unexpected errors are logged (to stderr — safe for stdio)
+ * and surfaced generically.
+ */
+export function registerTools(server) {
+    for (const tool of tools) {
+        server.registerTool(tool.name, tool.config, async (args) => {
+            try {
+                return await tool.run(args ?? {});
+            }
+            catch (err) {
+                if (isDialError(err))
+                    return errorResult(err.message);
+                if (err instanceof ZodError)
+                    return errorResult(`Invalid input: ${err.message}`);
+                logger.error({ err, tool: tool.name }, "mcp tool error");
+                return errorResult("Internal error running tool.");
+            }
+        });
+    }
+}

package/dist/mcp/result.js

@@ -0,0 +1,16 @@
+/**
+ * JSON tool response. Rendered as text, and mirrored into `structuredContent` (the
+ * JSON-coerced form) for clients that validate against the tool's `outputSchema`.
+ */
+export function jsonResult(data) {
+    const text = JSON.stringify(data, null, 2);
+    const structured = JSON.parse(text);
+    const result = { content: [{ type: "text", text }] };
+    if (structured !== null && typeof structured === "object" && !Array.isArray(structured)) {
+        result.structuredContent = structured;
+    }
+    return result;
+}
+export function errorResult(message) {
+    return { content: [{ type: "text", text: message }], isError: true };
+}

package/dist/mcp/schemas.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+/**
+ * Reusable Zod output schemas for tool results. Inner entity objects are
+ * `.passthrough()` so extra fields aren't stripped from `structuredContent`.
+ * Mirrors the remote server's schemas so the two surfaces stay aligned.
+ */
+export const phoneNumberSchema = z
+    .object({
+    id: z.string().describe("Phone number id (pn_…)"),
+    number: z.string().describe("E.164 phone number"),
+    country: z.string().optional(),
+    inboundInstruction: z.string().nullable().optional(),
+})
+    .passthrough();
+export const messageSchema = z
+    .object({
+    id: z.string(),
+    from: z.string(),
+    to: z.string(),
+    body: z.string(),
+    channel: z.string().optional(),
+    direction: z.string().optional(),
+    status: z.string(),
+    createdAt: z.string().optional(),
+})
+    .passthrough();
+export const callSchema = z
+    .object({
+    id: z.string(),
+    from: z.string(),
+    to: z.string(),
+    direction: z.string().optional(),
+    status: z.string(),
+    duration: z.number().optional(),
+    transcript: z.string().nullable().optional(),
+    instruction: z.string().nullable().optional(),
+    createdAt: z.string().optional(),
+})
+    .passthrough();
+export const eventSchema = z
+    .object({})
+    .passthrough()
+    .describe("The matched account event; shape varies by event type");
+export const localTargetSchema = z
+    .object({
+    kind: z.string().describe('"url" or "cmd"'),
+    id: z.string().describe("Target id (URL for url targets, path for cmd targets)"),
+    target: z.object({}).passthrough(),
+})
+    .passthrough();

package/dist/mcp/server.js

@@ -0,0 +1,20 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { VERSION } from "../lib/version.js";
+import { registerTools } from "./register.js";
+// Server identity shown by MCP clients. Mirrors the remote Dial MCP server: name/title +
+// the scalable Dial favicon (served same-origin, https). SVG with sizes:["any"] covers
+// every render size.
+const SERVER_INFO = {
+    name: "dial",
+    title: "Dial",
+    version: VERSION,
+    websiteUrl: "https://getdial.ai",
+    icons: [
+        { src: "https://getdial.ai/favicon.svg", mimeType: "image/svg+xml", sizes: ["any"] },
+    ],
+};
+export function buildServer() {
+    const server = new McpServer(SERVER_INFO);
+    registerTools(server);
+    return server;
+}

package/dist/mcp/tool.js

@@ -0,0 +1 @@
+export {};

package/dist/mcp/tools/add-command-target.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { addCommandTarget } from "../../lib/ops/local-targets.js";
+const inputSchema = {
+    path: z.string().min(1).describe("Absolute path to an executable the daemon spawns once per event"),
+    args: z.array(z.string()).optional().describe("Extra args; the event JSON is appended as the final positional arg"),
+    timeoutSeconds: z.number().int().positive().optional().describe("Per-attempt timeout (default 5)"),
+};
+export const addCommandTargetTool = {
+    name: "add_command_target",
+    config: {
+        title: "Add Command Fan-out Target",
+        description: "Register an executable the local listen daemon runs once per event (event JSON as the final arg).",
+        inputSchema,
+        outputSchema: {
+            added: z.boolean().describe("False if the target was already registered"),
+            path: z.string(),
+            args: z.array(z.string()),
+        },
+        annotations: { openWorldHint: false },
+    },
+    run: async (args) => jsonResult(addCommandTarget({
+        path: args.path,
+        args: args.args,
+        timeoutSeconds: args.timeoutSeconds,
+    })),
+};

package/dist/mcp/tools/add-url-target.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { addUrlTarget } from "../../lib/ops/local-targets.js";
+const inputSchema = {
+    url: z.string().min(1).describe("Loopback HTTP endpoint the listen daemon POSTs each event JSON to"),
+    secret: z.string().optional().describe("HMAC-SHA256 key; the daemon signs each request body and sends the hex digest"),
+    signatureHeader: z.string().optional().describe("Header for the HMAC signature (default X-Dial-Signature; only with secret)"),
+    bearer: z.string().optional().describe("Static bearer token, sent as Authorization: Bearer <token>"),
+    timeoutSeconds: z.number().int().positive().optional().describe("Per-attempt timeout (default 5)"),
+};
+export const addUrlTargetTool = {
+    name: "add_url_target",
+    config: {
+        title: "Add URL Fan-out Target",
+        description: "Register a loopback HTTP endpoint the local listen daemon delivers each event to.",
+        inputSchema,
+        outputSchema: {
+            added: z.boolean().describe("False if the target was already registered"),
+            url: z.string(),
+        },
+        annotations: { openWorldHint: false },
+    },
+    run: async (args) => jsonResult(addUrlTarget({
+        url: args.url,
+        secret: args.secret,
+        signatureHeader: args.signatureHeader,
+        bearer: args.bearer,
+        timeoutSeconds: args.timeoutSeconds,
+    })),
+};

package/dist/mcp/tools/get-account-status.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { accountStatus } from "../../lib/ops/account.js";
+export const getAccountStatusTool = {
+    name: "get_account_status",
+    config: {
+        title: "Get Account Status",
+        description: "Report local Dial setup state: CLI version, backend reachability, sign-in/key validity, " +
+            "any pending OTP, the listen daemon state, and the recommended next step.",
+        inputSchema: {},
+        outputSchema: {
+            cli: z.object({}).passthrough().describe("CLI and node versions"),
+            backend: z.object({}).passthrough().describe("Backend URL and reachability"),
+            auth: z.object({}).passthrough().describe("Sign-in and API-key state"),
+            pendingOtp: z.object({}).passthrough().describe("Any pending sign-up OTP"),
+            listen: z.object({}).passthrough().describe("Listen daemon state"),
+            nextStep: z.string().describe("Recommended next step (signup, onboard, install_listen, ready, …)"),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    },
+    run: async () => jsonResult(await accountStatus()),
+};

package/dist/mcp/tools/get-call.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { getCall } from "../../lib/ops/calls.js";
+import { callSchema } from "../schemas.js";
+const inputSchema = {
+    callId: z.string().min(1).describe("The call id to fetch"),
+};
+export const getCallTool = {
+    name: "get_call",
+    config: {
+        title: "Get Call",
+        description: "Fetch a single call by id — status, duration, and transcript when available.",
+        inputSchema,
+        outputSchema: { call: callSchema },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    },
+    run: async (args) => jsonResult({ call: await getCall(args.callId) }),
+};

package/dist/mcp/tools/index.js

@@ -0,0 +1,41 @@
+import { listNumbersTool } from "./list-numbers.js";
+import { purchaseNumberTool } from "./purchase-number.js";
+import { setNumberPropertiesTool } from "./set-number-properties.js";
+import { sendMessageTool } from "./send-message.js";
+import { listMessagesTool } from "./list-messages.js";
+import { placeCallTool } from "./place-call.js";
+import { listCallsTool } from "./list-calls.js";
+import { getCallTool } from "./get-call.js";
+import { getAccountStatusTool } from "./get-account-status.js";
+import { signUpTool } from "./sign-up.js";
+import { onboardTool } from "./onboard.js";
+import { waitForEventTool } from "./wait-for-event.js";
+import { addUrlTargetTool } from "./add-url-target.js";
+import { addCommandTargetTool } from "./add-command-target.js";
+import { removeLocalTargetTool } from "./remove-local-target.js";
+import { listLocalTargetsTool } from "./list-local-targets.js";
+import { listenInstallTool } from "./listen-install.js";
+import { listenUninstallTool } from "./listen-uninstall.js";
+import { listenStatusTool } from "./listen-status.js";
+/** Every tool registered on the local stdio MCP server. */
+export const tools = [
+    listNumbersTool,
+    purchaseNumberTool,
+    setNumberPropertiesTool,
+    sendMessageTool,
+    listMessagesTool,
+    placeCallTool,
+    listCallsTool,
+    getCallTool,
+    getAccountStatusTool,
+    signUpTool,
+    onboardTool,
+    waitForEventTool,
+    addUrlTargetTool,
+    addCommandTargetTool,
+    removeLocalTargetTool,
+    listLocalTargetsTool,
+    listenInstallTool,
+    listenUninstallTool,
+    listenStatusTool,
+];

package/dist/mcp/tools/list-calls.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { listCalls } from "../../lib/ops/calls.js";
+import { callSchema } from "../schemas.js";
+const inputSchema = {
+    numberId: z.string().optional().describe("Filter to a single phone number id"),
+    direction: z.enum(["inbound", "outbound"]).optional().describe("Filter by direction"),
+    since: z.string().optional().describe("Only calls created after this ISO-8601 timestamp"),
+};
+export const listCallsTool = {
+    name: "list_calls",
+    config: {
+        title: "List Calls",
+        description: "List recent calls on your account, newest first.",
+        inputSchema,
+        outputSchema: { calls: z.array(callSchema) },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    },
+    run: async (args) => jsonResult({
+        calls: await listCalls({
+            numberId: args.numberId,
+            direction: args.direction,
+            since: args.since,
+        }),
+    }),
+};

package/dist/mcp/tools/list-local-targets.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { listLocalTargets } from "../../lib/ops/local-targets.js";
+import { localTargetSchema } from "../schemas.js";
+export const listLocalTargetsTool = {
+    name: "list_local_targets",
+    config: {
+        title: "List Fan-out Targets",
+        description: "List the local fan-out targets the listen daemon currently delivers events to.",
+        inputSchema: {},
+        outputSchema: { targets: z.array(localTargetSchema) },
+        annotations: { readOnlyHint: true },
+    },
+    run: async () => jsonResult({ targets: listLocalTargets() }),
+};

package/dist/mcp/tools/list-messages.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { listMessages } from "../../lib/ops/messages.js";
+import { messageSchema } from "../schemas.js";
+const inputSchema = {
+    numberId: z.string().optional().describe("Filter to a single phone number id"),
+    direction: z.enum(["inbound", "outbound"]).optional().describe("Filter by direction"),
+    since: z.string().optional().describe("Only messages created after this ISO-8601 timestamp"),
+};
+export const listMessagesTool = {
+    name: "list_messages",
+    config: {
+        title: "List Messages",
+        description: "List recent messages on your account, newest first.",
+        inputSchema,
+        outputSchema: { messages: z.array(messageSchema) },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    },
+    run: async (args) => jsonResult({
+        messages: await listMessages({
+            numberId: args.numberId,
+            direction: args.direction,
+            since: args.since,
+        }),
+    }),
+};

package/dist/mcp/tools/list-numbers.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { listNumbers } from "../../lib/ops/numbers.js";
+import { phoneNumberSchema } from "../schemas.js";
+export const listNumbersTool = {
+    name: "list_numbers",
+    config: {
+        title: "List Phone Numbers",
+        description: "List the phone numbers on your Dial account, with the default number id.",
+        inputSchema: {},
+        outputSchema: {
+            numbers: z.array(phoneNumberSchema),
+            defaultNumberId: z.string().nullable().describe("Your primary number id, or null"),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    },
+    run: async () => jsonResult(await listNumbers()),
+};

package/dist/mcp/tools/listen-install.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { listenInstall } from "../../lib/ops/listen.js";
+export const listenInstallTool = {
+    name: "listen_install",
+    config: {
+        title: "Install Listen Daemon",
+        description: "Install the background event daemon (launchd on macOS, systemd --user on Linux) so inbound " +
+            "SMS and call-ended events are delivered to this machine in real time.",
+        inputSchema: {},
+        outputSchema: {
+            changed: z.boolean().describe("False if the daemon was already installed"),
+            warnings: z.array(z.string()),
+            unitPath: z.string().describe("Path to the installed launchd/systemd unit"),
+        },
+        annotations: {},
+    },
+    run: async () => jsonResult(listenInstall()),
+};

package/dist/mcp/tools/listen-status.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { listenStatus } from "../../lib/ops/listen.js";
+export const listenStatusTool = {
+    name: "listen_status",
+    config: {
+        title: "Listen Daemon Status",
+        description: "Report the background event daemon's state (installed/running/pid) and the last few events.",
+        inputSchema: {},
+        outputSchema: {
+            installed: z.boolean(),
+            running: z.boolean(),
+            pid: z.number().nullable(),
+            unitPath: z.string(),
+            lastEventAt: z.string().nullable(),
+            lastEvents: z.array(z.unknown()).describe("Up to the last 5 events from the local log"),
+        },
+        annotations: { readOnlyHint: true },
+    },
+    run: async () => jsonResult(listenStatus()),
+};

package/dist/mcp/tools/listen-uninstall.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { listenUninstall } from "../../lib/ops/listen.js";
+export const listenUninstallTool = {
+    name: "listen_uninstall",
+    config: {
+        title: "Uninstall Listen Daemon",
+        description: "Stop and remove the background event daemon from this machine.",
+        inputSchema: {},
+        outputSchema: { ok: z.boolean() },
+        annotations: { destructiveHint: true },
+    },
+    run: async () => jsonResult(listenUninstall()),
+};