@getdial/cli 0.13.2 → 0.15.0

package/dist/commands/number/set.js

@@ -1,44 +1,23 @@
-import { readAuth } from "../../lib/state.js";
-import { apiGet, apiPatch } from "../../lib/api.js";
+import { setNumberProperties } from "../../lib/ops/numbers.js";
+import { isDialError } from "../../lib/ops/errors.js";
+import { printDialError } from "../../lib/cli-error.js";
 export async function runNumberSet(opts) {
-    const auth = readAuth();
-    if (!auth) {
-        fail(opts.json, "not_signed_in", "Not signed in. Run `dial signup` and `dial onboard` first.");
-        return 1;
+    try {
+        const n = await setNumberProperties({ number: opts.number, inboundInstruction: opts.inboundInstruction });
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: true, number: n }));
+        }
+        else {
+            console.log(`updated.`);
+            console.log(`  number:               ${n.number}`);
+            console.log(`  id:                   ${n.id}`);
+            console.log(`  inbound instruction:  ${n.inboundInstruction ?? ""}`);
+        }
+        return 0;
     }
-    // The REST API keys numbers by id; the CLI 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) {
-        fail(opts.json, "list_failed", list.error, { status: list.status });
-        return 2;
+    catch (e) {
+        if (isDialError(e))
+            return printDialError(opts.json, e);
+        throw e;
     }
-    const match = list.data.numbers.find((n) => n.number === opts.number);
-    if (!match) {
-        const known = list.data.numbers.map((n) => n.number).join(", ") || "(none)";
-        fail(opts.json, "number_not_found", `No phone number ${opts.number} on your account. Yours: ${known}.`);
-        return 1;
-    }
-    const res = await apiPatch(`/api/v1/numbers/${match.id}`, { inboundInstruction: opts.inboundInstruction }, auth.apiKey);
-    if (!res.ok) {
-        fail(opts.json, "update_failed", res.error, { status: res.status });
-        return 2;
-    }
-    const n = res.data.number;
-    if (opts.json) {
-        console.log(JSON.stringify({ ok: true, number: n }));
-    }
-    else {
-        console.log(`updated.`);
-        console.log(`  number:               ${n.number}`);
-        console.log(`  id:                   ${n.id}`);
-        console.log(`  inbound instruction:  ${n.inboundInstruction ?? ""}`);
-    }
-    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/onboard.js

@@ -1,8 +1,5 @@
-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";
+import { onboard } from "../lib/ops/account.js";
+import { isDialError } from "../lib/ops/errors.js";
 function maskApiKey(key) {
     return key.length >= 4 ? `sk_live_***${key.slice(-4)}` : "sk_live_***";
 }
@@ -13,85 +10,57 @@ const LISTEN_RATIONALE = "The background notification listening service runs on
 const PRESENTATION_HINT = "When you ask the user, describe it as \"the background notification listening service.\" Don't expose technical details (launchd, plists, daemons, systemd units) — that's not how to talk about it to a non-technical user.";
 const FINALIZATION_HINT = "To finalize onboarding, ask the user this question before continuing with any other task. If the user's original request was something else (e.g. \"call X\", \"send Y\"), briefly pause that task, ask the question, get an answer, then resume.";
 export async function runOnboard(opts) {
-    let verificationId = opts.verificationId;
-    let email = null;
-    if (!verificationId) {
-        const pending = readPendingSignup();
-        if (!pending) {
+    let result;
+    try {
+        result = await onboard({
+            verificationId: opts.verificationId,
+            code: opts.code,
+            inboundInstruction: opts.inboundInstruction,
+            agents: opts.agents,
+        });
+    }
+    catch (e) {
+        if (!isDialError(e))
+            throw e;
+        if (e.code === "no_pending_signup") {
             if (opts.json)
                 console.log(JSON.stringify({ ok: false, code: "no_pending_signup" }));
             else
-                console.error("No pending signup. Run `dial signup <email>` first, or pass --verification-id.");
+                console.error(e.message);
             return 1;
         }
-        verificationId = pending.verificationId;
-        email = pending.email;
-    }
-    const res = await apiPost("/api/v1/auth/verify", {
-        verificationId,
-        code: opts.code,
-        // Sent only when provided; the server requires it when provisioning a first
-        // number (new account) and ignores it when signing in.
-        ...(opts.inboundInstruction ? { inboundInstruction: opts.inboundInstruction } : {}),
-    });
-    if (!res.ok) {
-        if (opts.json)
-            console.log(JSON.stringify({ ok: false, code: "verify_failed", status: res.status, error: res.error }));
-        else
-            console.error(`onboard failed: ${res.error}`);
-        return res.status === 401 ? 1 : 2;
-    }
-    const apiKey = res.data.apiKey ?? null;
-    if (!apiKey || !res.data.accountId) {
+        if (e.code === "verify_failed") {
+            if (opts.json)
+                console.log(JSON.stringify({ ok: false, code: "verify_failed", status: e.status, error: e.message }));
+            else
+                console.error(`onboard failed: ${e.message}`);
+            return e.status === 401 ? 1 : 2;
+        }
+        // missing_api_key
         if (opts.json)
-            console.log(JSON.stringify({ ok: false, code: "missing_api_key", error: "backend returned no apiKey" }));
+            console.log(JSON.stringify({ ok: false, code: "missing_api_key", error: e.message }));
         else
-            console.error("onboard failed: backend returned no apiKey");
+            console.error(`onboard failed: ${e.message}`);
         return 2;
     }
-    writeAuth({
-        apiKey,
-        accountId: res.data.accountId,
-        email: email ?? "",
-        phoneNumber: res.data.phoneNumber ?? null,
-        phoneNumberId: res.data.phoneNumberId ?? null,
-    });
-    clearPendingSignup();
-    const authFile = paths().authFile;
+    const { apiKey, accountId, phoneNumber, phoneNumberId, apiKeyPath, skills, supervisor } = result;
     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,
             apiKeyFingerprint: apiKey.slice(-4),
             apiKeyMasked: masked,
-            apiKeyPath: authFile,
-            accountId: res.data.accountId,
-            phoneNumber: res.data.phoneNumber ?? null,
-            phoneNumberId: res.data.phoneNumberId ?? null,
+            apiKeyPath,
+            accountId,
+            phoneNumber,
+            phoneNumberId,
             listen: {
                 installed: false,
                 autoInstalled: false,
                 canInstall: supervisor.available,
                 unavailableReason: supervisor.available ? null : supervisor.reason,
             },
-            skills: skillResults,
+            skills,
             agentHint: supervisor.available
                 ? {
                     action: "ask_user",
@@ -114,10 +83,10 @@ export async function runOnboard(opts) {
     }
     else {
         console.log("onboarded.");
-        console.log(`  api key:      ${masked}   (saved to ${authFile})`);
-        if (res.data.phoneNumber)
-            console.log(`  phone number: ${res.data.phoneNumber}`);
-        for (const r of skillResults) {
+        console.log(`  api key:      ${masked}   (saved to ${apiKeyPath})`);
+        if (phoneNumber)
+            console.log(`  phone number: ${phoneNumber}`);
+        for (const r of skills) {
             if ("error" in r) {
                 console.log(`  skill (${r.agent}):  failed — ${r.error}`);
             }

package/dist/commands/signup.js

@@ -1,36 +1,35 @@
-import { readPendingSignup, writePendingSignup } from "../lib/state.js";
-import { apiPost } from "../lib/api.js";
-const PENDING_FRESH_MS = 10 * 60 * 1000;
+import { signup } from "../lib/ops/account.js";
+import { isDialError } from "../lib/ops/errors.js";
 export async function runSignup(email, opts) {
-    const existing = readPendingSignup();
-    if (existing && !opts.force) {
-        const age = Date.now() - Date.parse(existing.createdAt);
-        if (Number.isFinite(age) && age < PENDING_FRESH_MS) {
-            const ageS = Math.round(age / 1000);
+    try {
+        const { verificationId } = await signup({ email, force: opts.force });
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: true, verificationId, email }));
+        }
+        else {
+            console.log(`OTP sent to ${email}.`);
+            console.log(`Run \`dial onboard --code <code>\` once you have it (verificationId is stored locally).`);
+        }
+        return 0;
+    }
+    catch (e) {
+        if (!isDialError(e))
+            throw e;
+        if (e.code === "pending_exists") {
+            const d = e.data ?? {};
             if (opts.json) {
-                console.log(JSON.stringify({ ok: false, code: "pending_exists", verificationId: existing.verificationId, email: existing.email, ageSeconds: ageS }));
+                console.log(JSON.stringify({ ok: false, code: "pending_exists", verificationId: d.verificationId, email: d.email, ageSeconds: d.ageSeconds }));
             }
             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.`);
+                console.error(e.message);
             }
             return 3;
         }
-    }
-    const res = await apiPost("/api/v1/auth/signup", { email });
-    if (!res.ok) {
+        // signup_failed
         if (opts.json)
-            console.log(JSON.stringify({ ok: false, code: "signup_failed", status: res.status, error: res.error }));
+            console.log(JSON.stringify({ ok: false, code: e.code, status: e.status, error: e.message }));
         else
-            console.error(`signup failed: ${res.error}`);
+            console.error(`signup failed: ${e.message}`);
         return 2;
     }
-    writePendingSignup({ verificationId: res.data.verificationId, email, createdAt: new Date().toISOString() });
-    if (opts.json) {
-        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 (verificationId is stored locally).`);
-    }
-    return 0;
 }

package/dist/commands/wait-for.js

@@ -1,83 +1,49 @@
-import { readAuth } from "../lib/state.js";
-import { paths } from "../lib/paths.js";
-import { supervisorStatus } from "../lib/supervisor/index.js";
-import { parseFieldArg, parseRegexArg } from "../lib/event-filter.js";
-import { currentSize, findLatestMatch, tailUntilMatch } from "../lib/log-tail.js";
-import { apiPost } from "../lib/api.js";
-const PER_POLL_SECONDS = 30;
+import { waitForEvent } from "../lib/ops/events.js";
+import { isDialError } from "../lib/ops/errors.js";
 export async function runWaitFor(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) {
-        process.stdout.write(hit.line + "\n");
+    let r;
+    try {
+        r = await waitForEvent({
+            eventType: opts.eventType,
+            fields: opts.fields,
+            regexes: opts.regexes,
+            timeoutSeconds: opts.timeoutSeconds,
+        });
+    }
+    catch (e) {
+        if (!isDialError(e))
+            throw e;
+        // not_signed_in (no auth on the API path) or api_fallback_failed
+        fail(opts.json, e.code, e.message, e.status ? { status: e.status } : undefined);
+        return e.code === "api_fallback_failed" ? 4 : 1;
+    }
+    // Hit: print the raw line and succeed.
+    if (!r.timedOut && r.line != null) {
+        process.stdout.write(r.line + "\n");
         return 0;
     }
-    const fallback = findLatestMatch(file, spec);
-    if (fallback) {
+    // Timed out tailing the log, but there was an earlier matching entry.
+    if (r.source === "log" && r.line != null) {
         if (opts.json) {
-            console.log(JSON.stringify({ ok: false, timeout: true, source: "log", event: fallback.obj }));
+            console.log(JSON.stringify({ ok: false, timeout: true, source: "log", event: r.event }));
         }
         else {
             console.error(`timed out after ${opts.timeoutSeconds}s; latest matching entry in log:`);
-            process.stdout.write(fallback.line + "\n");
+            process.stdout.write(r.line + "\n");
         }
         return 1;
     }
-    if (opts.json) {
-        console.log(JSON.stringify({ ok: false, timeout: true, source: null, event: null }));
-    }
-    else {
-        console.error(`timed out after ${opts.timeoutSeconds}s; no matching ${opts.eventType} entry in log.`);
-    }
-    return 2;
-}
-async function waitFromApi(spec, 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 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) {
-            process.stdout.write(JSON.stringify(res.data.event) + "\n");
-            return 0;
-        }
-        if (res.ok === false && res.status === 408) {
-            continue;
+    // Timed out tailing the log with no prior match at all.
+    if (r.source === "log") {
+        if (opts.json) {
+            console.log(JSON.stringify({ ok: false, timeout: true, source: null, event: null }));
         }
-        if (res.ok === false) {
-            fail(opts.json, "api_fallback_failed", res.error, { status: res.status });
-            return 4;
+        else {
+            console.error(`timed out after ${opts.timeoutSeconds}s; no matching ${opts.eventType} entry in log.`);
         }
+        return 2;
     }
+    // Timed out on the API fallback.
     if (opts.json) {
         console.log(JSON.stringify({ ok: false, timeout: true, source: "api", event: null }));
     }

package/dist/lib/cli-error.js

@@ -0,0 +1,24 @@
+// Codes that map to exit 1 (caller/precondition problems); everything else is 2
+// (operation failure). Matches the exit codes the commands used before the ops refactor.
+const EXIT_1_CODES = new Set([
+    "not_signed_in",
+    "no_from_number",
+    "number_not_found",
+    "not_found",
+    "no_pending_signup",
+]);
+/**
+ * Print a DialError the way the generic REST commands always have — `--json` emits
+ * `{ok:false, code, message, status?}`, human mode prints the message to stderr — and
+ * return the matching exit code. Commands with bespoke error JSON (signup, onboard,
+ * wait-for) handle their own printing instead.
+ */
+export function printDialError(json, e) {
+    if (json) {
+        console.log(JSON.stringify({ ok: false, code: e.code, message: e.message, ...(e.status ? { status: e.status } : {}) }));
+    }
+    else {
+        console.error(e.message);
+    }
+    return EXIT_1_CODES.has(e.code) ? 1 : 2;
+}

package/dist/lib/ops/account.js

@@ -0,0 +1,136 @@
+import { readAuth, readPendingSignup, writePendingSignup, clearPendingSignup, writeAuth } from "../state.js";
+import { apiGet, apiPost, baseUrl, pingBackend } from "../api.js";
+import { supervisorStatus, lastEventAtFromLog, supervisorAvailability } from "../supervisor/index.js";
+import { paths } from "../paths.js";
+import { VERSION } from "../version.js";
+import { installSkill, isSupportedAgent, SUPPORTED_AGENTS } from "../skill-install.js";
+import { DialError } from "./errors.js";
+const OTP_EXPIRY_MS = 10 * 60 * 1000;
+const PENDING_FRESH_MS = 10 * 60 * 1000;
+export async function accountStatus() {
+    const ping = await pingBackend();
+    const auth = readAuth();
+    const pending = readPendingSignup();
+    let keyValid = null;
+    if (auth?.apiKey) {
+        const res = await apiGet("/api/v1/account", auth.apiKey);
+        keyValid = res.ok;
+    }
+    const pendingAgeMs = pending ? Date.now() - Date.parse(pending.createdAt) : null;
+    const pendingExpired = pendingAgeMs == null ? null : pendingAgeMs > OTP_EXPIRY_MS;
+    let listenState = { installed: false, running: false, lastEventAt: null };
+    try {
+        const s = supervisorStatus();
+        listenState = { installed: s.installed, running: s.running, lastEventAt: lastEventAtFromLog(paths().listenLog) };
+    }
+    catch {
+        // unsupported platform — leave defaults
+    }
+    let nextStep;
+    if (!auth) {
+        if (pending && pendingExpired === false)
+            nextStep = "onboard";
+        else if (pending && pendingExpired)
+            nextStep = "resend_otp";
+        else
+            nextStep = "signup";
+    }
+    else if (keyValid === false) {
+        nextStep = "signup";
+    }
+    else if (!listenState.installed || !listenState.running) {
+        nextStep = "install_listen";
+    }
+    else {
+        nextStep = "ready";
+    }
+    return {
+        cli: { version: VERSION, node: process.versions.node },
+        backend: { url: baseUrl(), reachable: ping.reachable, latencyMs: ping.latencyMs },
+        auth: {
+            signedIn: Boolean(auth),
+            email: auth?.email ?? null,
+            accountId: auth?.accountId ?? null,
+            apiKeyPresent: Boolean(auth?.apiKey),
+            apiKeyFingerprint: auth?.apiKey ? auth.apiKey.slice(-4) : null,
+            keyValid,
+        },
+        pendingOtp: {
+            verificationId: pending?.verificationId ?? null,
+            ageSeconds: pendingAgeMs == null ? null : Math.round(pendingAgeMs / 1000),
+            expired: pendingExpired,
+        },
+        listen: listenState,
+        nextStep,
+    };
+}
+// ---- signup ----------------------------------------------------------------
+export async function signup(opts) {
+    const existing = readPendingSignup();
+    if (existing && !opts.force) {
+        const age = Date.now() - Date.parse(existing.createdAt);
+        if (Number.isFinite(age) && age < PENDING_FRESH_MS) {
+            const ageSeconds = Math.round(age / 1000);
+            throw new DialError("pending_exists", `A pending OTP for ${existing.email} is still fresh (${ageSeconds}s old). Use \`dial onboard --code <code>\` or re-run with --force to start a new one.`, undefined, { verificationId: existing.verificationId, email: existing.email, ageSeconds });
+        }
+    }
+    const res = await apiPost("/api/v1/auth/signup", { email: opts.email });
+    if (!res.ok)
+        throw new DialError("signup_failed", res.error, res.status);
+    writePendingSignup({ verificationId: res.data.verificationId, email: opts.email, createdAt: new Date().toISOString() });
+    return { verificationId: res.data.verificationId, email: opts.email };
+}
+export async function onboard(opts) {
+    let verificationId = opts.verificationId;
+    let email = null;
+    if (!verificationId) {
+        const pending = readPendingSignup();
+        if (!pending) {
+            throw new DialError("no_pending_signup", "No pending signup. Run `dial signup <email>` first, or pass --verification-id.");
+        }
+        verificationId = pending.verificationId;
+        email = pending.email;
+    }
+    const res = await apiPost("/api/v1/auth/verify", {
+        verificationId,
+        code: opts.code,
+        ...(opts.inboundInstruction ? { inboundInstruction: opts.inboundInstruction } : {}),
+    });
+    if (!res.ok)
+        throw new DialError("verify_failed", res.error, res.status);
+    const apiKey = res.data.apiKey ?? null;
+    if (!apiKey || !res.data.accountId) {
+        throw new DialError("missing_api_key", "backend returned no apiKey");
+    }
+    writeAuth({
+        apiKey,
+        accountId: res.data.accountId,
+        email: email ?? "",
+        phoneNumber: res.data.phoneNumber ?? null,
+        phoneNumberId: res.data.phoneNumberId ?? null,
+    });
+    clearPendingSignup();
+    const skills = [];
+    for (const requested of opts.agents ?? []) {
+        if (!isSupportedAgent(requested)) {
+            skills.push({ agent: requested, error: `unknown agent "${requested}". Supported: ${SUPPORTED_AGENTS.join(", ")}.` });
+            continue;
+        }
+        try {
+            skills.push(installSkill(requested));
+        }
+        catch (err) {
+            skills.push({ agent: requested, error: err instanceof Error ? err.message : String(err) });
+        }
+    }
+    return {
+        apiKey,
+        apiKeyFingerprint: apiKey.slice(-4),
+        apiKeyPath: paths().authFile,
+        accountId: res.data.accountId,
+        phoneNumber: res.data.phoneNumber ?? null,
+        phoneNumberId: res.data.phoneNumberId ?? null,
+        skills,
+        supervisor: supervisorAvailability(),
+    };
+}

package/dist/lib/ops/auth.js

@@ -0,0 +1,18 @@
+import { readAuth } from "../state.js";
+import { DialError } from "./errors.js";
+/** Resolve the saved auth or throw a `not_signed_in` DialError. */
+export function requireAuth() {
+    const auth = readAuth();
+    if (!auth) {
+        throw new DialError("not_signed_in", "Not signed in. Run `dial signup` and `dial onboard` first.");
+    }
+    return auth;
+}
+/** Resolve the from-number id: explicit override, else the account default, else throw. */
+export function requireFromNumberId(auth, override) {
+    const id = override ?? auth.phoneNumberId;
+    if (!id) {
+        throw new DialError("no_from_number", "No default phoneNumberId in auth. Pass --from-number-id <id>.");
+    }
+    return id;
+}

package/dist/lib/ops/calls.js

@@ -0,0 +1,33 @@
+import { apiGet, apiPost } from "../api.js";
+import { requireAuth, requireFromNumberId } from "./auth.js";
+import { DialError } from "./errors.js";
+export async function placeCall(opts) {
+    const auth = requireAuth();
+    const fromNumberId = requireFromNumberId(auth, opts.fromNumberId);
+    const res = await apiPost("/api/v1/calls", { to: opts.to, fromNumberId, outboundInstruction: opts.outboundInstruction, language: opts.language }, auth.apiKey);
+    if (!res.ok)
+        throw new DialError("call_failed", res.error, res.status);
+    return res.data.call;
+}
+export async function listCalls(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/calls?${qs}` : "/api/v1/calls", auth.apiKey);
+    if (!res.ok)
+        throw new DialError("list_failed", res.error, res.status);
+    return res.data.calls ?? [];
+}
+export async function getCall(callId) {
+    const auth = requireAuth();
+    const res = await apiGet(`/api/v1/calls/${encodeURIComponent(callId)}`, auth.apiKey);
+    if (!res.ok)
+        throw new DialError(res.status === 404 ? "not_found" : "get_failed", res.error, res.status);
+    return res.data.call;
+}

package/dist/lib/ops/errors.js

@@ -0,0 +1,23 @@
+/**
+ * Typed error thrown by ops. Carries a stable machine `code` (reused from the
+ * existing CLI command error codes), a human message, and an optional HTTP status.
+ * Commands map it to their `--json`/exit-code output; MCP tools map it to an error
+ * tool result. Mirrors the server-side `ServiceError`.
+ */
+export class DialError extends Error {
+    code;
+    status;
+    data;
+    constructor(code, message, status, 
+    /** Extra structured context for commands with bespoke error output (e.g. signup's pending_exists). */
+    data) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.data = data;
+        this.name = "DialError";
+    }
+}
+export function isDialError(e) {
+    return e instanceof DialError;
+}