@getdial/cli 0.6.0 → 0.8.0

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

@@ -1,29 +1,28 @@
 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.");
         return 1;
     }
-    const res = await apiGet("/api/v1/numbers", auth.api_key);
+    const res = await apiGet("/api/v1/numbers", auth.apiKey);
     if (!res.ok) {
         fail(opts.json, "list_failed", res.error, { status: res.status });
         return 2;
     }
     const numbers = res.data.numbers ?? [];
     if (opts.json) {
-        console.log(JSON.stringify({ ok: true, numbers, default_number_id: auth.phone_number_id ?? null }));
+        console.log(JSON.stringify({ ok: true, numbers, defaultNumberId: auth.phoneNumberId ?? null }));
         return 0;
     }
     if (numbers.length === 0) {
-        console.log("no phone numbers. provision one with `dial numbers provision`.");
+        console.log("no phone numbers. provision one with `dial number purchase`.");
         return 0;
     }
     for (const n of numbers) {
-        const tag = n.id === auth.phone_number_id ? "  (default)" : "";
-        const agent = n.agent ? `  agent=${n.agent.name}` : "";
-        console.log(`${n.number}  id=${n.id}  ${n.country}${agent}${tag}`);
+        const tag = n.id === auth.phoneNumberId ? "  (default)" : "";
+        console.log(`${n.number}  id=${n.id}  ${n.country}${tag}`);
     }
     return 0;
 }

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.");
@@ -10,12 +10,10 @@ export async function runNumbersProvision(opts) {
     if (opts.country)
         body.country = opts.country;
     if (opts.areaCode)
-        body.area_code = opts.areaCode;
-    if (opts.agentId)
-        body.agent_id = opts.agentId;
-    const res = await apiPost("/api/v1/numbers", body, auth.api_key);
+        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;
@@ -23,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,7 @@
 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";
 function maskApiKey(key) {
     return key.length >= 4 ? `sk_live_***${key.slice(-4)}` : "sk_live_***";
 }
@@ -22,10 +23,10 @@ export async function runOnboard(opts) {
                 console.error("No pending signup. Run `dial signup <email>` first, or pass --verification-id.");
             return 1;
         }
-        verificationId = pending.verification_id;
+        verificationId = pending.verificationId;
         email = pending.email;
     }
-    const res = await apiPost("/api/v1/auth/verify", { verification_id: verificationId, code: opts.code });
+    const res = await apiPost("/api/v1/auth/verify", { verificationId, code: opts.code });
     if (!res.ok) {
         if (opts.json)
             console.log(JSON.stringify({ ok: false, code: "verify_failed", status: res.status, error: res.error }));
@@ -33,52 +34,80 @@ export async function runOnboard(opts) {
             console.error(`onboard failed: ${res.error}`);
         return res.status === 401 ? 1 : 2;
     }
-    const apiKey = res.data.api_key ?? null;
-    if (!apiKey || !res.data.account_id) {
+    const apiKey = res.data.apiKey ?? null;
+    if (!apiKey || !res.data.accountId) {
         if (opts.json)
-            console.log(JSON.stringify({ ok: false, code: "missing_api_key", error: "backend returned no api_key" }));
+            console.log(JSON.stringify({ ok: false, code: "missing_api_key", error: "backend returned no apiKey" }));
         else
-            console.error("onboard failed: backend returned no api_key");
+            console.error("onboard failed: backend returned no apiKey");
         return 2;
     }
     writeAuth({
-        api_key: apiKey,
-        account_id: res.data.account_id,
+        apiKey,
+        accountId: res.data.accountId,
         email: email ?? "",
-        phone_number: res.data.phone_number ?? null,
-        phone_number_id: res.data.phone_number_id ?? null,
+        phoneNumber: res.data.phoneNumber ?? null,
+        phoneNumberId: res.data.phoneNumberId ?? null,
     });
     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) });
+        }
+    }
     if (opts.json) {
         console.log(JSON.stringify({
             ok: true,
-            api_key_fingerprint: apiKey.slice(-4),
-            api_key_masked: masked,
-            api_key_path: authFile,
-            account_id: res.data.account_id,
-            phone_number: res.data.phone_number ?? null,
-            phone_number_id: res.data.phone_number_id ?? null,
-            listen: { installed: false, auto_installed: false },
-            agent_hint: {
+            apiKeyFingerprint: apiKey.slice(-4),
+            apiKeyMasked: masked,
+            apiKeyPath: authFile,
+            accountId: res.data.accountId,
+            phoneNumber: res.data.phoneNumber ?? null,
+            phoneNumberId: res.data.phoneNumberId ?? null,
+            listen: { installed: false, autoInstalled: false },
+            skills: skillResults,
+            agentHint: {
                 action: "ask_user",
                 kind: "onboarding_finalization",
                 question: LISTEN_QUESTION,
                 rationale: LISTEN_RATIONALE,
                 presentation: PRESENTATION_HINT,
-                finalization_note: FINALIZATION_HINT,
-                use_structured_tool_if_available: true,
-                on_yes: "dial listen install",
-                on_no: null,
+                finalizationNote: FINALIZATION_HINT,
+                useStructuredToolIfAvailable: true,
+                onYes: "dial listen install",
+                onNo: null,
             },
         }));
     }
     else {
         console.log("onboarded.");
         console.log(`  api key:      ${masked}   (saved to ${authFile})`);
-        if (res.data.phone_number)
-            console.log(`  phone number: ${res.data.phone_number}`);
+        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(``);
         console.log(`Onboarding finalization (required):`);
         console.log(``);

package/dist/commands/signup.js

@@ -4,11 +4,11 @@ const PENDING_FRESH_MS = 10 * 60 * 1000;
 export async function runSignup(email, opts) {
     const existing = readPendingSignup();
     if (existing && !opts.force) {
-        const age = Date.now() - Date.parse(existing.created_at);
+        const age = Date.now() - Date.parse(existing.createdAt);
         if (Number.isFinite(age) && age < PENDING_FRESH_MS) {
             const ageS = Math.round(age / 1000);
             if (opts.json) {
-                console.log(JSON.stringify({ ok: false, code: "pending_exists", verification_id: existing.verification_id, email: existing.email, age_seconds: ageS }));
+                console.log(JSON.stringify({ ok: false, code: "pending_exists", verificationId: existing.verificationId, email: existing.email, ageSeconds: ageS }));
             }
             else {
                 console.error(`A pending OTP for ${existing.email} is still fresh (${ageS}s old). Use \`dial onboard --code <code>\` or re-run with --force to start a new one.`);
@@ -24,13 +24,13 @@ export async function runSignup(email, opts) {
             console.error(`signup failed: ${res.error}`);
         return 2;
     }
-    writePendingSignup({ verification_id: res.data.verification_id, email, created_at: new Date().toISOString() });
+    writePendingSignup({ verificationId: res.data.verificationId, email, createdAt: new Date().toISOString() });
     if (opts.json) {
-        console.log(JSON.stringify({ ok: true, verification_id: res.data.verification_id, email }));
+        console.log(JSON.stringify({ ok: true, verificationId: res.data.verificationId, email }));
     }
     else {
         console.log(`OTP sent to ${email}.`);
-        console.log(`Run \`dial onboard --code <code>\` once you have it (verification_id is stored locally).`);
+        console.log(`Run \`dial onboard --code <code>\` once you have it (verificationId is stored locally).`);
     }
     return 0;
 }

package/dist/commands/wait-for.js

@@ -61,11 +61,11 @@ async function waitFromApi(spec, opts) {
         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", {
-            event_type: spec.eventType,
+            eventType: spec.eventType,
             filters: Object.keys(filters).length > 0 ? filters : undefined,
-            regex_filters: Object.keys(regexFilters).length > 0 ? regexFilters : undefined,
+            regexFilters: Object.keys(regexFilters).length > 0 ? regexFilters : undefined,
             timeout,
-        }, auth.api_key);
+        }, auth.apiKey);
         if (res.ok && res.data?.event) {
             process.stdout.write(JSON.stringify(res.data.event) + "\n");
             return 0;

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;
@@ -45,7 +46,7 @@ export function startWorker(apiKey, accountId) {
         }
     }
     function scheduleRefresh(creds) {
-        const ms = Math.max(60, Math.floor(creds.ttl_seconds / 2)) * 1000;
+        const ms = Math.max(60, Math.floor(creds.ttlSeconds / 2)) * 1000;
         refreshTimer = setTimeout(() => refresh(creds), ms);
     }
     async function stop() {
@@ -81,7 +82,7 @@ export function startWorker(apiKey, accountId) {
             return;
         }
         pn = new PubNub({
-            subscribeKey: creds.subscribe_key,
+            subscribeKey: creds.subscribeKey,
             userId: `dial-cli-${accountId}`,
             ssl: true,
             authKey: creds.token,
@@ -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/state.js

@@ -4,16 +4,16 @@ import { z } from "zod";
 import { paths } from "./paths.js";
 import { logger } from "./log.js";
 export const AuthSchema = z.object({
-    api_key: z.string(),
-    account_id: z.string(),
+    apiKey: z.string(),
+    accountId: z.string(),
     email: z.string(),
-    phone_number: z.string().nullable(),
-    phone_number_id: z.string().nullable(),
+    phoneNumber: z.string().nullable(),
+    phoneNumberId: z.string().nullable(),
 });
 export const PendingSignupSchema = z.object({
-    verification_id: z.string(),
+    verificationId: z.string(),
     email: z.string(),
-    created_at: z.string(),
+    createdAt: z.string(),
 });
 const CHMOD_UNSUPPORTED_CODES = new Set(["ENOTSUP", "EOPNOTSUPP", "EPERM"]);
 function ensureDir(path) {