@getdial/cli 0.13.2 → 0.15.0

package/dist/mcp/tools/onboard.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { onboard } from "../../lib/ops/account.js";
+const inputSchema = {
+    code: z.string().min(1).describe("6-digit OTP from the sign-up email"),
+    verificationId: z.string().optional().describe("Explicit verification id (defaults to the local pending signup)"),
+    inboundInstruction: z.string().optional().describe("System prompt for inbound calls to a newly provisioned number (new accounts)"),
+    agents: z.array(z.string()).optional().describe("Agent names to install the Dial skill into (e.g. claude-code, cursor)"),
+};
+export const onboardTool = {
+    name: "onboard",
+    config: {
+        title: "Onboard",
+        description: "Verify the sign-up OTP and finish onboarding: saves the API key locally and optionally installs " +
+            "the Dial skill into named agents. Returns the account summary (the raw API key is never returned).",
+        inputSchema,
+        outputSchema: {
+            apiKeyFingerprint: z.string().describe("Last 4 chars of the saved API key"),
+            apiKeyPath: z.string().describe("Where the key was saved"),
+            accountId: z.string(),
+            phoneNumber: z.string().nullable(),
+            phoneNumberId: z.string().nullable(),
+            skills: z.array(z.object({}).passthrough()).describe("Per-agent skill install results"),
+            supervisor: z.object({}).passthrough().describe("Listen daemon availability on this machine"),
+            listenAvailable: z.boolean(),
+        },
+        annotations: { openWorldHint: true },
+    },
+    run: async (args) => {
+        const r = await onboard({
+            code: args.code,
+            verificationId: args.verificationId,
+            inboundInstruction: args.inboundInstruction,
+            agents: args.agents,
+        });
+        // Never surface the raw API key to the model; it's saved to disk for the CLI to read.
+        const { apiKey: _omit, ...safe } = r;
+        void _omit;
+        return jsonResult({
+            ...safe,
+            listenAvailable: r.supervisor.available,
+        });
+    },
+};

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

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { placeCall } from "../../lib/ops/calls.js";
+import { callSchema } from "../schemas.js";
+const inputSchema = {
+    to: z.string().min(7).describe("Destination phone number, E.164 (e.g. +14155550123)"),
+    outboundInstruction: z.string().min(1).describe("System prompt for the AI voice agent on this call"),
+    language: z.string().default("en-US").describe("BCP-47 language tag for the call"),
+    fromNumberId: z.string().optional().describe("Number id to call from; defaults to your primary number"),
+};
+export const placeCallTool = {
+    name: "place_call",
+    config: {
+        title: "Place AI Voice Call",
+        description: "Place an outbound voice call handled by an AI agent. The call runs asynchronously — " +
+            "use wait_for_event to block until it ends, then get_call for the transcript.",
+        inputSchema,
+        outputSchema: { call: callSchema, hint: z.string().describe("Next-step guidance for tracking the call") },
+        annotations: { openWorldHint: true },
+    },
+    run: async (args) => {
+        const call = await placeCall({
+            to: args.to,
+            outboundInstruction: args.outboundInstruction,
+            language: args.language ?? "en-US",
+            fromNumberId: args.fromNumberId,
+        });
+        return jsonResult({
+            call,
+            hint: `The call is now in progress. To be notified when it ends, call wait_for_event with ` +
+                `eventType "call.ended" and field "callId=${call.id}". Then call get_call with callId ` +
+                `"${call.id}" for the final status, duration, and transcript.`,
+        });
+    },
+};

package/dist/mcp/tools/purchase-number.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { purchaseNumber } from "../../lib/ops/numbers.js";
+import { phoneNumberSchema } from "../schemas.js";
+const inputSchema = {
+    inboundInstruction: z.string().min(1).describe("System prompt for inbound calls to this number"),
+    country: z.string().optional().describe("ISO-3166-1 alpha-2 country code (defaults to US server-side)"),
+    areaCode: z.string().optional().describe("Preferred area code (US/CA)"),
+};
+export const purchaseNumberTool = {
+    name: "purchase_number",
+    config: {
+        title: "Purchase Phone Number",
+        description: "Purchase an additional phone number. This spends money on the account.",
+        inputSchema,
+        outputSchema: { number: phoneNumberSchema },
+        annotations: { destructiveHint: true, openWorldHint: true },
+    },
+    run: async (args) => jsonResult({
+        number: await purchaseNumber({
+            inboundInstruction: args.inboundInstruction,
+            country: args.country,
+            areaCode: args.areaCode,
+        }),
+    }),
+};

package/dist/mcp/tools/remove-local-target.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { removeLocalTarget } from "../../lib/ops/local-targets.js";
+const inputSchema = {
+    id: z.string().min(1).describe("Target id: the URL for url targets, the path for cmd targets"),
+};
+export const removeLocalTargetTool = {
+    name: "remove_local_target",
+    config: {
+        title: "Remove Fan-out Target",
+        description: "Unregister a local fan-out target by id. Returns removed:false if no such target.",
+        inputSchema,
+        outputSchema: {
+            removed: z.boolean().describe("False if no target matched the id"),
+            id: z.string(),
+        },
+        annotations: { destructiveHint: true },
+    },
+    run: async (args) => jsonResult(removeLocalTarget(args.id)),
+};

package/dist/mcp/tools/send-message.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { sendMessage } from "../../lib/ops/messages.js";
+import { messageSchema } from "../schemas.js";
+const inputSchema = {
+    to: z.string().min(7).describe("Destination phone number, E.164 (e.g. +14155550123)"),
+    body: z.string().min(1).describe("Message body"),
+    fromNumberId: z.string().optional().describe("Number id to send from; defaults to your primary number"),
+};
+export const sendMessageTool = {
+    name: "send_message",
+    config: {
+        title: "Send SMS",
+        description: "Send an SMS from one of your Dial numbers.",
+        inputSchema,
+        outputSchema: { message: messageSchema },
+        annotations: { openWorldHint: true },
+    },
+    run: async (args) => jsonResult({
+        message: await sendMessage({
+            to: args.to,
+            body: args.body,
+            fromNumberId: args.fromNumberId,
+        }),
+    }),
+};

package/dist/mcp/tools/set-number-properties.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { setNumberProperties } from "../../lib/ops/numbers.js";
+import { phoneNumberSchema } from "../schemas.js";
+const inputSchema = {
+    number: z.string().min(7).describe("The E.164 phone number to update (e.g. +14155550123)"),
+    inboundInstruction: z.string().min(1).describe("New system prompt for inbound calls to this number"),
+};
+export const setNumberPropertiesTool = {
+    name: "set_number_properties",
+    config: {
+        title: "Set Number Properties",
+        description: "Update a phone number's inbound instruction (the system prompt for inbound calls).",
+        inputSchema,
+        outputSchema: { number: phoneNumberSchema },
+        annotations: { openWorldHint: true },
+    },
+    run: async (args) => jsonResult({
+        number: await setNumberProperties({
+            number: args.number,
+            inboundInstruction: args.inboundInstruction,
+        }),
+    }),
+};

package/dist/mcp/tools/sign-up.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { signup } from "../../lib/ops/account.js";
+const inputSchema = {
+    email: z.string().email().describe("Email address to send the sign-up OTP to"),
+    force: z.boolean().optional().describe("Overwrite an existing fresh pending signup"),
+};
+export const signUpTool = {
+    name: "sign_up",
+    config: {
+        title: "Sign Up",
+        description: "Request an email OTP for a Dial account. The code is emailed; finish with the onboard tool. " +
+            "Stores the pending verification locally.",
+        inputSchema,
+        outputSchema: {
+            verificationId: z.string().describe("Pending verification id (also stored locally)"),
+            email: z.string(),
+        },
+        annotations: { openWorldHint: true },
+    },
+    run: async (args) => jsonResult(await signup({ email: args.email, force: args.force })),
+};

package/dist/mcp/tools/wait-for-event.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { jsonResult } from "../result.js";
+import { waitForEvent } from "../../lib/ops/events.js";
+import { eventSchema } from "../schemas.js";
+const inputSchema = {
+    eventType: z.string().min(1).describe('Event type to wait for (e.g. "call.ended", "message.received")'),
+    field: z.array(z.string()).optional().describe('Exact-match filters, each "name=value" (e.g. "callId=abc")'),
+    regex: z.array(z.string()).optional().describe('Regex filters, each "name=pattern" (/re/flags or a bare regex)'),
+    timeoutSeconds: z.number().default(30).describe("How long to wait before giving up"),
+};
+export const waitForEventTool = {
+    name: "wait_for_event",
+    config: {
+        title: "Wait For Event",
+        description: "Block until a matching account event arrives. Reads the local listen log when the daemon " +
+            "is running, otherwise long-polls the REST API. Returns the event, or a timeout result.",
+        inputSchema,
+        outputSchema: {
+            source: z.string().nullable().describe('"log", "api", or null when nothing matched'),
+            timedOut: z.boolean(),
+            event: eventSchema.nullable(),
+            line: z.string().nullable().describe("Raw matched event line, when available"),
+        },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    },
+    run: async (args) => jsonResult(await waitForEvent({
+        eventType: args.eventType,
+        fields: args.field ?? [],
+        regexes: args.regex ?? [],
+        timeoutSeconds: args.timeoutSeconds ?? 30,
+    })),
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getdial/cli",
-  "version": "0.13.2",
+  "version": "0.15.0",
   "description": "Dial CLI — install, sign up, and run the local listen service.",
   "license": "MIT",
   "repository": {
@@ -32,6 +32,7 @@
     "prepack": "npm run build && npm run build:skill"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "commander": "^14.0.3",
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",