@getdial/cli 0.7.0 → 0.9.0

package/dist/cli.js

@@ -9,15 +9,23 @@ import { runListenInstall } from "./commands/listen/install.js";
 import { runListenUninstall } from "./commands/listen/uninstall.js";
 import { runListenStatus } from "./commands/listen/status.js";
 import { runWaitFor } from "./commands/wait-for.js";
-import { runNumbersList } from "./commands/numbers/list.js";
-import { runNumbersProvision } from "./commands/numbers/provision.js";
-import { runSend } from "./commands/send.js";
-import { runCall } from "./commands/call.js";
+import { runNumberList } from "./commands/number/list.js";
+import { runNumberPurchase } from "./commands/number/purchase.js";
+import { runMessageSend } from "./commands/message/send.js";
+import { runMessageList } from "./commands/message/list.js";
+import { runCallSend } from "./commands/call/send.js";
+import { runCallList } from "./commands/call/list.js";
+import { runCallGet } from "./commands/call/get.js";
+import { runLocalTargetAddUrl } from "./commands/local-target/add-url.js";
+import { runLocalTargetAddCmd } from "./commands/local-target/add-cmd.js";
+import { runLocalTargetRemove } from "./commands/local-target/remove.js";
+import { runLocalTargetList } from "./commands/local-target/list.js";
 const program = new Command();
 program
     .name("dial")
     .description("Dial CLI — set up your account and run the listen service.")
-    .version(VERSION);
+    .version(VERSION)
+    .enablePositionalOptions();
 program
     .command("doctor")
     .description("Report state and what to do next.")
@@ -34,8 +42,14 @@ program
     .description("Verify the OTP and finish onboarding.")
     .option("--verification-id <id>", "explicit verification id (falls back to local pending signup)")
     .requiredOption("--code <code>", "6-digit OTP from your email")
+    .option("--agent <name>", "install the Dial skill into the named agent's config dir. One of: claude-code, cursor, codex, opencode, pi, openclaw, nanoclaw, hermes. Repeatable.", (v, prev = []) => [...prev, v], [])
     .option("--json", "machine-readable output")
-    .action(async (opts) => process.exit(await runOnboard({ verificationId: opts.verificationId, code: opts.code, json: !!opts.json })));
+    .action(async (opts) => process.exit(await runOnboard({
+    verificationId: opts.verificationId,
+    code: opts.code,
+    agents: opts.agent,
+    json: !!opts.json,
+})));
 const listen = program
     .command("listen")
     .description("Run the listen worker (used by launchd/systemd).")
@@ -55,53 +69,142 @@ listen
     .description("Report listen daemon state and last events.")
     .option("--json", "machine-readable output")
     .action(async (opts) => process.exit(await runListenStatus({ json: !!opts.json })));
-const numbers = program
-    .command("numbers")
+const number = program
+    .command("number")
     .description("Manage your Dial phone numbers.");
-numbers
+number
     .command("list")
     .description("List the numbers on your account. GET /api/v1/numbers.")
     .option("--json", "machine-readable output")
-    .action(async (opts) => process.exit(await runNumbersList({ json: !!opts.json })));
-numbers
-    .command("provision")
-    .description("Provision an additional phone number. POST /api/v1/numbers.")
+    .action(async (opts) => process.exit(await runNumberList({ json: !!opts.json })));
+number
+    .command("purchase")
+    .description("Purchase an additional phone number. POST /api/v1/numbers.")
     .option("--country <iso2>", "ISO-3166-1 alpha-2 country code (defaults to US server-side)")
     .option("--area-code <code>", "preferred area code (US/CA)")
     .option("--json", "machine-readable output")
-    .action(async (opts) => process.exit(await runNumbersProvision({
+    .action(async (opts) => process.exit(await runNumberPurchase({
     country: opts.country,
     areaCode: opts.areaCode,
     json: !!opts.json,
 })));
-program
-    .command("send")
+const message = program
+    .command("message")
     .description("Send an SMS. POST /api/v1/messages.")
-    .requiredOption("--to <e164>", "destination phone number, E.164 (e.g. +14155551234)")
-    .requiredOption("--body <text>", "message body")
+    .option("--to <e164>", "destination phone number, E.164 (e.g. +14155551234)")
+    .option("--body <text>", "message body")
     .option("--from-number-id <id>", "phoneNumberId to send from (defaults to onboard's number)")
     .option("--json", "machine-readable output")
-    .action(async (opts) => process.exit(await runSend({
-    to: opts.to,
-    body: opts.body,
-    fromNumberId: opts.fromNumberId,
+    .action(async (opts) => {
+    if (!opts.to || !opts.body) {
+        console.error("error: --to and --body are required to send a message. Use `dial message list` to list, or `dial message --help` for usage.");
+        process.exit(2);
+    }
+    process.exit(await runMessageSend({
+        to: opts.to,
+        body: opts.body,
+        fromNumberId: opts.fromNumberId,
+        json: !!opts.json,
+    }));
+});
+message
+    .command("list")
+    .description("List recent messages on your account. GET /api/v1/messages.")
+    .option("--number-id <id>", "filter to a single phone number")
+    .option("--direction <dir>", "inbound or outbound")
+    .option("--since <iso8601>", "only messages created after this timestamp")
+    .option("--json", "machine-readable output")
+    .action(async (opts) => process.exit(await runMessageList({
+    numberId: opts.numberId,
+    direction: opts.direction,
+    since: opts.since,
     json: !!opts.json,
 })));
-program
+const call = program
     .command("call")
     .description("Place an outbound voice call. POST /api/v1/calls.")
-    .requiredOption("--to <e164>", "destination phone number, E.164 (e.g. +14155551234)")
-    .requiredOption("--system-prompt <text>", "system prompt for the agent that will speak")
+    .option("--to <e164>", "destination phone number, E.164 (e.g. +14155551234)")
+    .option("--system-prompt <text>", "system prompt for the agent that will speak")
     .option("--language <bcp47>", "BCP-47 language tag for the call", "en-US")
     .option("--from-number-id <id>", "phoneNumberId to call from (defaults to onboard's number)")
     .option("--json", "machine-readable output")
-    .action(async (opts) => process.exit(await runCall({
-    to: opts.to,
-    systemPrompt: opts.systemPrompt,
-    language: opts.language,
-    fromNumberId: opts.fromNumberId,
+    .action(async (opts) => {
+    if (!opts.to || !opts.systemPrompt) {
+        console.error("error: --to and --system-prompt are required to place a call. Use `dial call list` to list, `dial call get <id>` to fetch one, or `dial call --help` for usage.");
+        process.exit(2);
+    }
+    process.exit(await runCallSend({
+        to: opts.to,
+        systemPrompt: opts.systemPrompt,
+        language: opts.language,
+        fromNumberId: opts.fromNumberId,
+        json: !!opts.json,
+    }));
+});
+call
+    .command("list")
+    .description("List recent calls on your account. GET /api/v1/calls.")
+    .option("--number-id <id>", "filter to a single phone number")
+    .option("--direction <dir>", "inbound or outbound")
+    .option("--since <iso8601>", "only calls created after this timestamp")
+    .option("--json", "machine-readable output")
+    .action(async (opts) => process.exit(await runCallList({
+    numberId: opts.numberId,
+    direction: opts.direction,
+    since: opts.since,
+    json: !!opts.json,
+})));
+call
+    .command("get <call-id>")
+    .description("Fetch a single call by id. GET /api/v1/calls/<id>.")
+    .option("--json", "machine-readable output")
+    .action(async (callId, opts) => process.exit(await runCallGet({ callId, json: !!opts.json })));
+const localTarget = program
+    .command("local-target")
+    .description("Register local fan-out targets the listen daemon delivers events to.")
+    .enablePositionalOptions();
+const localTargetAdd = localTarget
+    .command("add")
+    .description("Register a new local fan-out target (url or cmd).")
+    .enablePositionalOptions();
+localTargetAdd
+    .command("url <url>")
+    .description("Register a loopback HTTP endpoint. The daemon POSTs each event JSON to <url>.")
+    .option("--secret <value>", "HMAC-SHA256 key. The daemon signs each request body and sends the hex digest.")
+    .option("--signature-header <name>", "HTTP header for the HMAC signature (defaults to X-Dial-Signature; only used with --secret)")
+    .option("--bearer <token>", "static bearer token, sent as `Authorization: Bearer <token>`")
+    .option("--timeout <seconds>", "per-attempt timeout (default 5)", (v) => parseInt(v, 10))
+    .option("--json", "machine-readable output")
+    .action(async (url, opts) => process.exit(await runLocalTargetAddUrl({
+    url,
+    secret: opts.secret,
+    signatureHeader: opts.signatureHeader,
+    bearer: opts.bearer,
+    timeoutSeconds: opts.timeout,
     json: !!opts.json,
 })));
+localTargetAdd
+    .command("cmd <path> [args...]")
+    .description("Register an executable. The daemon spawns it per event with the event JSON as the final positional argument.")
+    .option("--timeout <seconds>", "per-attempt timeout (default 5)", (v) => parseInt(v, 10))
+    .option("--json", "machine-readable output")
+    .passThroughOptions(true)
+    .action(async (path, args, opts) => process.exit(await runLocalTargetAddCmd({
+    path,
+    args: args ?? [],
+    timeoutSeconds: opts.timeout,
+    json: !!opts.json,
+})));
+localTarget
+    .command("remove <id>")
+    .description("Unregister a target by id (URL for url targets, path for cmd targets).")
+    .option("--json", "machine-readable output")
+    .action(async (id, opts) => process.exit(await runLocalTargetRemove({ id, json: !!opts.json })));
+localTarget
+    .command("list")
+    .description("List the local targets currently registered for fan-out.")
+    .option("--json", "machine-readable output")
+    .action(async (opts) => process.exit(await runLocalTargetList({ json: !!opts.json })));
 program
     .command("wait-for <event-type>")
     .description("Wait for the next matching event in the listen log (e.g. call.ended, message.received).")

package/dist/commands/call/get.js

@@ -0,0 +1,37 @@
+import { readAuth } from "../../lib/state.js";
+import { apiGet } from "../../lib/api.js";
+export async function runCallGet(opts) {
+    const auth = readAuth();
+    if (!auth) {
+        fail(opts.json, "not_signed_in", "Not signed in. Run `dial signup` and `dial onboard` first.");
+        return 1;
+    }
+    const res = await apiGet(`/api/v1/calls/${encodeURIComponent(opts.callId)}`, auth.apiKey);
+    if (!res.ok) {
+        fail(opts.json, res.status === 404 ? "not_found" : "get_failed", res.error, { status: res.status });
+        return res.status === 404 ? 1 : 2;
+    }
+    const c = res.data.call;
+    if (opts.json) {
+        console.log(JSON.stringify({ ok: true, call: c }));
+        return 0;
+    }
+    console.log(`id:         ${c.id}`);
+    console.log(`direction:  ${c.direction}`);
+    console.log(`from:       ${c.from}`);
+    console.log(`to:         ${c.to}`);
+    console.log(`status:     ${c.status}`);
+    console.log(`duration:   ${c.duration}s`);
+    console.log(`created:    ${c.createdAt}`);
+    if (c.transcript) {
+        console.log(`transcript:`);
+        console.log(c.transcript);
+    }
+    return 0;
+}
+function fail(json, code, message, extra) {
+    if (json)
+        console.log(JSON.stringify({ ok: false, code, message, ...extra }));
+    else
+        console.error(message);
+}

package/dist/commands/call/list.js

@@ -0,0 +1,42 @@
+import { readAuth } from "../../lib/state.js";
+import { apiGet } from "../../lib/api.js";
+export async function runCallList(opts) {
+    const auth = readAuth();
+    if (!auth) {
+        fail(opts.json, "not_signed_in", "Not signed in. Run `dial signup` and `dial onboard` first.");
+        return 1;
+    }
+    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 path = qs ? `/api/v1/calls?${qs}` : "/api/v1/calls";
+    const res = await apiGet(path, auth.apiKey);
+    if (!res.ok) {
+        fail(opts.json, "list_failed", res.error, { status: res.status });
+        return 2;
+    }
+    const calls = res.data.calls ?? [];
+    if (opts.json) {
+        console.log(JSON.stringify({ ok: true, calls }));
+        return 0;
+    }
+    if (calls.length === 0) {
+        console.log("no calls.");
+        return 0;
+    }
+    for (const c of calls) {
+        console.log(`${c.createdAt}  ${c.direction.padEnd(8)}  ${c.from} -> ${c.to}  ${c.status}  ${c.duration}s  id=${c.id}`);
+    }
+    return 0;
+}
+function fail(json, code, message, extra) {
+    if (json)
+        console.log(JSON.stringify({ ok: false, code, message, ...extra }));
+    else
+        console.error(message);
+}

package/dist/commands/{call.js → call/send.js}

@@ -1,6 +1,6 @@
-import { readAuth } from "../lib/state.js";
-import { apiPost } from "../lib/api.js";
-export async function runCall(opts) {
+import { readAuth } from "../../lib/state.js";
+import { apiPost } from "../../lib/api.js";
+export async function runCallSend(opts) {
     const auth = readAuth();
     if (!auth) {
         fail(opts.json, "not_signed_in", "Not signed in. Run `dial signup` and `dial onboard` first.");

package/dist/commands/listen/install.js

@@ -1,5 +1,5 @@
 import { readAuth } from "../../lib/state.js";
-import { installSupervised } from "../../lib/supervisor/index.js";
+import { installSupervised, supervisorAvailability } from "../../lib/supervisor/index.js";
 function resolveDialPath() {
     return process.env.DIAL_BIN_OVERRIDE ?? process.argv[1] ?? "dial";
 }
@@ -12,6 +12,14 @@ export async function runListenInstall(opts) {
             console.error("Not signed in. Run `dial signup` and `dial onboard` first.");
         return 1;
     }
+    const supervisor = supervisorAvailability();
+    if (!supervisor.available) {
+        if (opts.json)
+            console.log(JSON.stringify({ ok: false, code: "supervisor_unavailable", error: supervisor.reason }));
+        else
+            console.error(`listen install unavailable: ${supervisor.reason}. This machine has no user-level service supervisor (sandbox/container/CI). Inbound events still work via \`dial wait-for\`; only the always-on background listener and \`dial local-target\` fan-out are unavailable here.`);
+        return 2;
+    }
     try {
         const result = installSupervised(resolveDialPath());
         if (opts.json)

package/dist/commands/local-target/add-cmd.js

@@ -0,0 +1,27 @@
+import { addTarget, LocalTargetError } from "../../lib/local-targets.js";
+export async function runLocalTargetAddCmd(opts) {
+    try {
+        const { added } = addTarget({
+            kind: "cmd",
+            path: opts.path,
+            args: opts.args,
+            timeoutSeconds: opts.timeoutSeconds,
+        });
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: true, added, path: opts.path, args: opts.args }));
+        }
+        else {
+            console.log(added ? `added cmd target: ${opts.path}` : `cmd target already registered: ${opts.path}`);
+        }
+        return 0;
+    }
+    catch (err) {
+        const code = err instanceof LocalTargetError ? err.code : "add_failed";
+        const message = err instanceof Error ? err.message : String(err);
+        if (opts.json)
+            console.log(JSON.stringify({ ok: false, code, message }));
+        else
+            console.error(`add cmd failed: ${message}`);
+        return 2;
+    }
+}

package/dist/commands/local-target/add-url.js

@@ -0,0 +1,29 @@
+import { addTarget, LocalTargetError, DEFAULT_SIGNATURE_HEADER } from "../../lib/local-targets.js";
+export async function runLocalTargetAddUrl(opts) {
+    try {
+        const { added } = addTarget({
+            kind: "url",
+            url: opts.url,
+            secret: opts.secret,
+            signatureHeader: opts.signatureHeader ?? (opts.secret ? DEFAULT_SIGNATURE_HEADER : undefined),
+            bearer: opts.bearer,
+            timeoutSeconds: opts.timeoutSeconds,
+        });
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: true, added, url: opts.url }));
+        }
+        else {
+            console.log(added ? `added url target: ${opts.url}` : `url target already registered: ${opts.url}`);
+        }
+        return 0;
+    }
+    catch (err) {
+        const code = err instanceof LocalTargetError ? err.code : "add_failed";
+        const message = err instanceof Error ? err.message : String(err);
+        if (opts.json)
+            console.log(JSON.stringify({ ok: false, code, message }));
+        else
+            console.error(`add url failed: ${message}`);
+        return 2;
+    }
+}

package/dist/commands/local-target/list.js

@@ -0,0 +1,16 @@
+import { listTargets, targetId } from "../../lib/local-targets.js";
+export async function runLocalTargetList(opts) {
+    const targets = listTargets();
+    if (opts.json) {
+        console.log(JSON.stringify({ ok: true, targets }));
+        return 0;
+    }
+    if (targets.length === 0) {
+        console.log("no local targets registered. add one with `dial local-target add url <url>` or `dial local-target add cmd <path>`.");
+        return 0;
+    }
+    for (const t of targets) {
+        console.log(`${t.kind.padEnd(4)}  ${targetId(t)}`);
+    }
+    return 0;
+}

package/dist/commands/local-target/remove.js

@@ -0,0 +1,14 @@
+import { removeTarget } from "../../lib/local-targets.js";
+export async function runLocalTargetRemove(opts) {
+    const { removed } = removeTarget(opts.id);
+    if (opts.json) {
+        console.log(JSON.stringify({ ok: removed, removed, id: opts.id }));
+    }
+    else if (removed) {
+        console.log(`removed: ${opts.id}`);
+    }
+    else {
+        console.error(`not found: ${opts.id}`);
+    }
+    return removed ? 0 : 1;
+}

package/dist/commands/message/list.js

@@ -0,0 +1,42 @@
+import { readAuth } from "../../lib/state.js";
+import { apiGet } from "../../lib/api.js";
+export async function runMessageList(opts) {
+    const auth = readAuth();
+    if (!auth) {
+        fail(opts.json, "not_signed_in", "Not signed in. Run `dial signup` and `dial onboard` first.");
+        return 1;
+    }
+    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 path = qs ? `/api/v1/messages?${qs}` : "/api/v1/messages";
+    const res = await apiGet(path, auth.apiKey);
+    if (!res.ok) {
+        fail(opts.json, "list_failed", res.error, { status: res.status });
+        return 2;
+    }
+    const messages = res.data.messages ?? [];
+    if (opts.json) {
+        console.log(JSON.stringify({ ok: true, messages }));
+        return 0;
+    }
+    if (messages.length === 0) {
+        console.log("no messages.");
+        return 0;
+    }
+    for (const m of messages) {
+        console.log(`${m.createdAt}  ${m.direction.padEnd(8)}  ${m.from} -> ${m.to}  ${m.body}`);
+    }
+    return 0;
+}
+function fail(json, code, message, extra) {
+    if (json)
+        console.log(JSON.stringify({ ok: false, code, message, ...extra }));
+    else
+        console.error(message);
+}

package/dist/commands/{send.js → message/send.js}

@@ -1,6 +1,6 @@
-import { readAuth } from "../lib/state.js";
-import { apiPost } from "../lib/api.js";
-export async function runSend(opts) {
+import { readAuth } from "../../lib/state.js";
+import { apiPost } from "../../lib/api.js";
+export async function runMessageSend(opts) {
     const auth = readAuth();
     if (!auth) {
         fail(opts.json, "not_signed_in", "Not signed in. Run `dial signup` and `dial onboard` first.");

package/dist/commands/{numbers → number}/list.js

@@ -1,6 +1,6 @@
 import { readAuth } from "../../lib/state.js";
 import { apiGet } from "../../lib/api.js";
-export async function runNumbersList(opts) {
+export async function runNumberList(opts) {
     const auth = readAuth();
     if (!auth) {
         fail(opts.json, "not_signed_in", "Not signed in. Run `dial signup` and `dial onboard` first.");

package/dist/commands/{numbers/provision.js → number/purchase.js}

@@ -1,6 +1,6 @@
 import { readAuth } from "../../lib/state.js";
 import { apiPost } from "../../lib/api.js";
-export async function runNumbersProvision(opts) {
+export async function runNumberPurchase(opts) {
     const auth = readAuth();
     if (!auth) {
         fail(opts.json, "not_signed_in", "Not signed in. Run `dial signup` and `dial onboard` first.");
@@ -13,7 +13,7 @@ export async function runNumbersProvision(opts) {
         body.areaCode = opts.areaCode;
     const res = await apiPost("/api/v1/numbers", body, auth.apiKey);
     if (!res.ok) {
-        fail(opts.json, "provision_failed", res.error, { status: res.status });
+        fail(opts.json, "purchase_failed", res.error, { status: res.status });
         return 2;
     }
     const n = res.data.number;
@@ -21,7 +21,7 @@ export async function runNumbersProvision(opts) {
         console.log(JSON.stringify({ ok: true, number: n }));
     }
     else {
-        console.log(`provisioned.`);
+        console.log(`purchased.`);
         console.log(`  number:   ${n.number}`);
         console.log(`  id:       ${n.id}`);
         console.log(`  country:  ${n.country}`);

package/dist/commands/onboard.js

@@ -1,6 +1,8 @@
 import { readPendingSignup, clearPendingSignup, writeAuth } from "../lib/state.js";
 import { apiPost } from "../lib/api.js";
 import { paths } from "../lib/paths.js";
+import { installSkill, isSupportedAgent, SUPPORTED_AGENTS } from "../lib/skill-install.js";
+import { supervisorAvailability } from "../lib/supervisor/index.js";
 function maskApiKey(key) {
     return key.length >= 4 ? `sk_live_***${key.slice(-4)}` : "sk_live_***";
 }
@@ -51,6 +53,23 @@ export async function runOnboard(opts) {
     clearPendingSignup();
     const authFile = paths().authFile;
     const masked = maskApiKey(apiKey);
+    const skillResults = [];
+    for (const requested of opts.agents ?? []) {
+        if (!isSupportedAgent(requested)) {
+            skillResults.push({
+                agent: requested,
+                error: `unknown agent "${requested}". Supported: ${SUPPORTED_AGENTS.join(", ")}.`,
+            });
+            continue;
+        }
+        try {
+            skillResults.push(installSkill(requested));
+        }
+        catch (err) {
+            skillResults.push({ agent: requested, error: err instanceof Error ? err.message : String(err) });
+        }
+    }
+    const supervisor = supervisorAvailability();
     if (opts.json) {
         console.log(JSON.stringify({
             ok: true,
@@ -60,18 +79,31 @@ export async function runOnboard(opts) {
             accountId: res.data.accountId,
             phoneNumber: res.data.phoneNumber ?? null,
             phoneNumberId: res.data.phoneNumberId ?? null,
-            listen: { installed: false, autoInstalled: false },
-            agentHint: {
-                action: "ask_user",
-                kind: "onboarding_finalization",
-                question: LISTEN_QUESTION,
-                rationale: LISTEN_RATIONALE,
-                presentation: PRESENTATION_HINT,
-                finalizationNote: FINALIZATION_HINT,
-                useStructuredToolIfAvailable: true,
-                onYes: "dial listen install",
-                onNo: null,
+            listen: {
+                installed: false,
+                autoInstalled: false,
+                canInstall: supervisor.available,
+                unavailableReason: supervisor.available ? null : supervisor.reason,
             },
+            skills: skillResults,
+            agentHint: supervisor.available
+                ? {
+                    action: "ask_user",
+                    kind: "onboarding_finalization",
+                    question: LISTEN_QUESTION,
+                    rationale: LISTEN_RATIONALE,
+                    presentation: PRESENTATION_HINT,
+                    finalizationNote: FINALIZATION_HINT,
+                    useStructuredToolIfAvailable: true,
+                    onYes: "dial listen install",
+                    onNo: null,
+                }
+                : {
+                    action: "skip",
+                    kind: "listen_install_unavailable",
+                    reason: supervisor.reason,
+                    note: "No user-level service supervisor on this machine (sandbox/container/CI). Skip the install offer and continue with the original task. Inbound events are still reachable via `dial wait-for` (long-poll); only the always-on background listener and `dial local-target` fan-out are unavailable here.",
+                },
         }));
     }
     else {
@@ -79,7 +111,24 @@ export async function runOnboard(opts) {
         console.log(`  api key:      ${masked}   (saved to ${authFile})`);
         if (res.data.phoneNumber)
             console.log(`  phone number: ${res.data.phoneNumber}`);
+        for (const r of skillResults) {
+            if ("error" in r) {
+                console.log(`  skill (${r.agent}):  failed — ${r.error}`);
+            }
+            else if (r.written) {
+                console.log(`  skill (${r.agent}):  installed → ${r.path}`);
+            }
+            else if (r.unchanged) {
+                console.log(`  skill (${r.agent}):  already up to date → ${r.path}`);
+            }
+        }
         console.log(``);
+        if (!supervisor.available) {
+            console.log(`listen service: not available on this machine (${supervisor.reason}).`);
+            console.log(`Skipping the install offer. Inbound events still work via \`dial wait-for\` (long-poll);`);
+            console.log(`only the always-on background listener and \`dial local-target\` fan-out are unavailable here.`);
+            return 0;
+        }
         console.log(`Onboarding finalization (required):`);
         console.log(``);
         console.log(FINALIZATION_HINT);

package/dist/lib/fanout.js

@@ -0,0 +1,131 @@
+import { spawn } from "node:child_process";
+import { createHmac } from "node:crypto";
+import { request } from "undici";
+import { DEFAULT_SIGNATURE_HEADER, listTargets, targetId, timeoutMs, } from "./local-targets.js";
+const MAX_CAPTURE_BYTES = 4 * 1024;
+function clipCapture(buf) {
+    const s = typeof buf === "string" ? buf : buf.toString("utf8");
+    if (s.length <= MAX_CAPTURE_BYTES)
+        return s;
+    return s.slice(0, MAX_CAPTURE_BYTES) + `…[truncated, total ${s.length} chars]`;
+}
+async function attemptUrl(target, body) {
+    const headers = { "Content-Type": "application/json" };
+    if (target.bearer)
+        headers["Authorization"] = `Bearer ${target.bearer}`;
+    if (target.secret) {
+        const sig = createHmac("sha256", target.secret).update(body).digest("hex");
+        headers[target.signatureHeader ?? DEFAULT_SIGNATURE_HEADER] = sig;
+    }
+    const controller = new AbortController();
+    const t = setTimeout(() => controller.abort(), timeoutMs(target));
+    try {
+        const res = await request(target.url, {
+            method: "POST",
+            headers,
+            body,
+            signal: controller.signal,
+        });
+        const ok = res.statusCode >= 200 && res.statusCode < 300;
+        return { ok, status: res.statusCode };
+    }
+    catch (err) {
+        if (err.name === "AbortError") {
+            return { ok: false, timedOut: true, error: "timeout" };
+        }
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+    finally {
+        clearTimeout(t);
+    }
+}
+async function attemptCmd(target, eventJson) {
+    return new Promise((resolve) => {
+        const argv = [...(target.args ?? []), eventJson];
+        const child = spawn(target.path, argv, {
+            env: {
+                PATH: process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin",
+                HOME: process.env.HOME ?? "",
+            },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString("utf8");
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString("utf8");
+        });
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            try {
+                child.kill("SIGKILL");
+            }
+            catch { /* already exited */ }
+            resolve({
+                ok: false,
+                timedOut: true,
+                error: "timeout",
+                stdout: clipCapture(stdout),
+                stderr: clipCapture(stderr),
+            });
+        }, timeoutMs(target));
+        child.on("error", (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({
+                ok: false,
+                error: err.message,
+                stdout: clipCapture(stdout),
+                stderr: clipCapture(stderr),
+            });
+        });
+        child.on("close", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({
+                ok: code === 0,
+                exitCode: code,
+                stdout: clipCapture(stdout),
+                stderr: clipCapture(stderr),
+            });
+        });
+    });
+}
+async function dispatchOne(target, body, eventJson) {
+    const attempts = [];
+    for (let i = 0; i < 2; i += 1) {
+        const attempt = target.kind === "url" ? await attemptUrl(target, body) : await attemptCmd(target, eventJson);
+        attempts.push(attempt);
+        if (attempt.ok)
+            return { target, attempts, delivered: true };
+    }
+    return { target, attempts, delivered: false };
+}
+export async function fanout(event, log) {
+    const targets = listTargets();
+    if (targets.length === 0)
+        return [];
+    const eventJson = JSON.stringify(event);
+    const results = await Promise.all(targets.map(async (target) => {
+        const result = await dispatchOne(target, eventJson, eventJson);
+        log({
+            ts: new Date().toISOString(),
+            lifecycle: "local_target_dispatch",
+            kind: target.kind,
+            id: targetId(target),
+            delivered: result.delivered,
+            attempts: result.attempts,
+        });
+        return result;
+    }));
+    return results;
+}

package/dist/lib/local-targets.js

@@ -0,0 +1,122 @@
+import { mkdirSync, readFileSync, writeFileSync, chmodSync } from "node:fs";
+import { dirname, isAbsolute } from "node:path";
+import { z } from "zod";
+import { paths } from "./paths.js";
+const LOOPBACK_HOSTS = new Set(["127.0.0.1", "0.0.0.0", "localhost", "::1", "[::1]"]);
+export const DEFAULT_TIMEOUT_SECONDS = 5;
+export const DEFAULT_SIGNATURE_HEADER = "X-Dial-Signature";
+export const UrlTargetSchema = z.object({
+    kind: z.literal("url"),
+    url: z.string(),
+    secret: z.string().optional(),
+    signatureHeader: z.string().optional(),
+    bearer: z.string().optional(),
+    timeoutSeconds: z.number().int().positive().optional(),
+});
+export const CmdTargetSchema = z.object({
+    kind: z.literal("cmd"),
+    path: z.string(),
+    args: z.array(z.string()).default([]),
+    timeoutSeconds: z.number().int().positive().optional(),
+});
+export const LocalTargetSchema = z.discriminatedUnion("kind", [UrlTargetSchema, CmdTargetSchema]);
+const RegistrySchema = z.object({
+    targets: z.array(LocalTargetSchema).default([]),
+});
+export class LocalTargetError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+export function assertLoopbackUrl(raw) {
+    let parsed;
+    try {
+        parsed = new URL(raw);
+    }
+    catch {
+        throw new LocalTargetError("invalid_url", `not a valid URL: ${raw}`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new LocalTargetError("invalid_scheme", `URL must be http(s): ${raw}`);
+    }
+    const host = parsed.hostname;
+    if (!LOOPBACK_HOSTS.has(host)) {
+        throw new LocalTargetError("non_loopback", `URL host must be a loopback (${[...LOOPBACK_HOSTS].join(", ")}); got "${host}".`);
+    }
+}
+export function targetId(t) {
+    return t.kind === "url" ? t.url : t.path;
+}
+function ensureDir(file) {
+    mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
+}
+function readRegistry() {
+    const file = paths().localTargetsFile;
+    let raw;
+    try {
+        raw = readFileSync(file, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return { targets: [] };
+        throw err;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return { targets: [] };
+    }
+    const result = RegistrySchema.safeParse(parsed);
+    if (!result.success)
+        return { targets: [] };
+    return result.data;
+}
+function writeRegistry(reg) {
+    const file = paths().localTargetsFile;
+    ensureDir(file);
+    writeFileSync(file, JSON.stringify(reg, null, 2), { mode: 0o600 });
+    try {
+        chmodSync(file, 0o600);
+    }
+    catch {
+        // chmod can fail on some filesystems; the create-mode is the important guarantee
+    }
+}
+export function listTargets() {
+    return readRegistry().targets;
+}
+export function addTarget(t) {
+    if (t.kind === "url") {
+        assertLoopbackUrl(t.url);
+    }
+    else {
+        if (!t.path)
+            throw new LocalTargetError("invalid_path", "executable path is required");
+    }
+    const reg = readRegistry();
+    const id = targetId(t);
+    if (reg.targets.some((existing) => targetId(existing) === id && existing.kind === t.kind)) {
+        return { added: false };
+    }
+    reg.targets.push(t);
+    writeRegistry(reg);
+    return { added: true };
+}
+export function removeTarget(id) {
+    const reg = readRegistry();
+    const next = reg.targets.filter((t) => targetId(t) !== id);
+    if (next.length === reg.targets.length)
+        return { removed: false };
+    writeRegistry({ targets: next });
+    return { removed: true };
+}
+export function timeoutMs(t) {
+    return (t.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS) * 1000;
+}
+export function isAbsolutePath(p) {
+    return isAbsolute(p);
+}

package/dist/lib/paths.js

@@ -15,6 +15,7 @@ export function paths() {
         configFile: join(configDir, "config.json"),
         authFile: join(dataDir, "auth.json"),
         pendingSignupFile: join(dataDir, "pending-signup.json"),
+        localTargetsFile: join(configDir, "local-targets.json"),
         listenLog: join(stateDir, "listen.log"),
         listenOutLog: join(stateDir, "listen.out.log"),
         listenErrLog: join(stateDir, "listen.err.log"),

package/dist/lib/pubnub.js

@@ -2,6 +2,7 @@ import PubNub from "pubnub";
 import { apiPost } from "./api.js";
 import { appendJsonl, rotateIfLarge } from "./log.js";
 import { paths } from "./paths.js";
+import { fanout } from "./fanout.js";
 const MAX_LOG_BYTES = 10 * 1024 * 1024;
 const SUBSCRIBE_PATH = "/api/v1/listen/subscribe";
 const REFRESH_FAILURES_BEFORE_EXIT = 3;
@@ -90,6 +91,9 @@ export function startWorker(apiKey, accountId) {
         pn.addListener({
             message: (ev) => {
                 logLine({ ts: new Date().toISOString(), ...ev.message });
+                void fanout(ev.message, logLine).catch((err) => {
+                    logLine({ ts: new Date().toISOString(), lifecycle: "fanout_error", error: err instanceof Error ? err.message : String(err) });
+                });
             },
             status: (s) => {
                 logLine({ ts: new Date().toISOString(), lifecycle: "status", category: s.category, operation: s.operation ?? null });

package/dist/lib/skill-install.js

@@ -0,0 +1,100 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export const SUPPORTED_AGENTS = [
+    "claude-code",
+    "cursor",
+    "codex",
+    "opencode",
+    "pi",
+    "openclaw",
+    "nanoclaw",
+    "hermes",
+];
+export function isSupportedAgent(name) {
+    return SUPPORTED_AGENTS.includes(name);
+}
+/**
+ * Where SKILL.md lands for each supported agent. Paths follow each tool's
+ * documented skill location, verified against the upstream docs:
+ *
+ *   - claude-code: ~/.claude/skills/<name>/SKILL.md           (docs.claude.com)
+ *   - cursor:      ~/.cursor/skills/<name>/SKILL.md           (cursor.com/docs/skills)
+ *   - codex:       ~/.agents/skills/<name>/SKILL.md           (developers.openai.com/codex/skills)
+ *   - opencode:    ~/.config/opencode/skills/<name>/SKILL.md  (opencode.ai/docs/skills)
+ *   - pi:          ~/.pi/agent/skills/<name>/SKILL.md         (pi.dev/docs/latest/skills)
+ *   - openclaw:    ~/.openclaw/skills/<name>/SKILL.md         (docs.openclaw.ai/tools/skills-config)
+ *   - hermes:      ~/.hermes/skills/<name>/SKILL.md           (hermes-agent.nousresearch.com)
+ *   - nanoclaw:    <cwd>/.claude/skills/<name>/SKILL.md       (docs.nanoclaw.dev — project-scoped)
+ */
+function targetPath(agent, home, cwd) {
+    switch (agent) {
+        case "claude-code":
+            return join(home, ".claude", "skills", "dial", "SKILL.md");
+        case "cursor":
+            return join(home, ".cursor", "skills", "dial", "SKILL.md");
+        case "codex":
+            return join(home, ".agents", "skills", "dial", "SKILL.md");
+        case "opencode":
+            return join(home, ".config", "opencode", "skills", "dial", "SKILL.md");
+        case "pi":
+            return join(home, ".pi", "agent", "skills", "dial", "SKILL.md");
+        case "openclaw":
+            return join(home, ".openclaw", "skills", "dial", "SKILL.md");
+        case "hermes":
+            return join(home, ".hermes", "skills", "dial", "SKILL.md");
+        case "nanoclaw":
+            return join(cwd, ".claude", "skills", "dial", "SKILL.md");
+    }
+}
+function packageRoot() {
+    // This file resolves to dist/lib/skill-install.js at runtime. The package
+    // root is two levels up. During `tsx` (tests / dev), src/lib/... → also two
+    // levels up still lands inside cli/.
+    const here = fileURLToPath(import.meta.url);
+    return resolve(dirname(here), "..", "..");
+}
+export function tarballPath() {
+    return join(packageRoot(), "skill.tar.gz");
+}
+export function readSkillMarkdown(tarball = tarballPath()) {
+    if (!existsSync(tarball)) {
+        throw new Error(`Dial skill tarball not found at ${tarball}. ` +
+            `Re-run \`npm install -g @getdial/cli\` (or, from a checkout, \`npm run build:skill\`).`);
+    }
+    const tmp = mkdtempSync(join(tmpdir(), "dial-skill-"));
+    try {
+        execFileSync("tar", ["-xzf", tarball, "-C", tmp], { stdio: "pipe" });
+        const skillFile = join(tmp, "skill", "SKILL.md");
+        if (!existsSync(skillFile)) {
+            throw new Error(`skill.tar.gz does not contain skill/SKILL.md (looked in ${tmp})`);
+        }
+        return readFileSync(skillFile, "utf8");
+    }
+    finally {
+        rmSync(tmp, { recursive: true, force: true });
+    }
+}
+export function installSkill(agent, opts = {}) {
+    const home = opts.home ?? process.env.HOME ?? homedir();
+    const cwd = opts.cwd ?? process.cwd();
+    const body = readSkillMarkdown();
+    const path = targetPath(agent, home, cwd);
+    mkdirSync(dirname(path), { recursive: true });
+    if (existsSync(path)) {
+        try {
+            const existing = readFileSync(path, "utf8");
+            if (existing === body) {
+                return { agent, path, written: false, unchanged: true };
+            }
+        }
+        catch {
+            // unreadable existing file — overwrite below
+        }
+    }
+    writeFileSync(path, body, { mode: 0o644 });
+    statSync(path);
+    return { agent, path, written: true };
+}

package/dist/lib/supervisor/index.js

@@ -11,6 +11,28 @@ export function currentPlatform() {
         return "linux";
     throw new Error(`Unsupported platform: ${process.platform} (macOS and Linux only)`);
 }
+/**
+ * Detects whether a user-level service supervisor (launchd on macOS,
+ * systemd --user on Linux) is reachable on this machine. Returns
+ * unavailable for sandboxes / containers / CI runners where the user
+ * bus is missing — `dial listen install` would fail there with errors
+ * like "Failed to connect to bus: No medium found".
+ */
+export function supervisorAvailability() {
+    if (process.platform === "darwin")
+        return { available: true };
+    if (process.platform !== "linux") {
+        return { available: false, reason: `unsupported platform: ${process.platform}` };
+    }
+    const runtimeDir = process.env.XDG_RUNTIME_DIR;
+    if (!runtimeDir) {
+        return { available: false, reason: "XDG_RUNTIME_DIR is not set (no systemd user session)" };
+    }
+    if (!existsSync(`${runtimeDir}/systemd/private`)) {
+        return { available: false, reason: "systemd user bus socket not found (sandbox or container without systemd --user)" };
+    }
+    return { available: true };
+}
 export function installSupervised(programPath) {
     const platform = currentPlatform();
     const p = paths();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getdial/cli",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "Dial CLI — install, sign up, and run the local listen service.",
   "license": "MIT",
   "bin": {
@@ -13,12 +13,15 @@
   },
   "files": [
     "dist",
+    "skill.tar.gz",
     "README.md"
   ],
   "scripts": {
     "build": "tsc -p .",
     "test": "node --import tsx --test",
-    "clean": "rm -rf dist"
+    "clean": "rm -rf dist skill.tar.gz",
+    "build:skill": "tar -czf skill.tar.gz skill",
+    "prepack": "npm run build && npm run build:skill"
   },
   "dependencies": {
     "commander": "^14.0.3",
@@ -32,5 +35,8 @@
     "@types/node": "^22.10.0",
     "tsx": "^4.22.3",
     "typescript": "^5.6.0"
+  },
+  "overrides": {
+    "react-native-url-polyfill": "npm:empty-npm-package@1.0.0"
   }
 }