@myvoip/sdk 0.0.0-stage → 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,56 @@
+import { type FetchLike } from "./http.js";
+export type ClientOptions = {
+    apiToken: string;
+    baseUrl?: string;
+    fetch?: FetchLike;
+    timeoutMs?: number;
+};
+export declare class UponAI {
+    private readonly options;
+    constructor(options: ClientOptions);
+    private call;
+    me(): Promise<unknown>;
+    readonly credentials: {
+        list: () => Promise<unknown>;
+    };
+    readonly mappings: {
+        list: () => Promise<unknown>;
+        get: (mappingId: string) => Promise<unknown>;
+    };
+    readonly sourceDomains: {
+        list: (credentialId: string) => Promise<unknown>;
+    };
+    readonly preflight: {
+        start: (mappingId: string) => Promise<unknown>;
+        list: (mappingId?: string) => Promise<unknown>;
+        get: (runId: string) => Promise<unknown>;
+    };
+    readonly migrations: {
+        start: (preflightRunId: string, dryRun?: boolean) => Promise<unknown>;
+        list: (mappingId?: string) => Promise<unknown>;
+        get: (runId: string) => Promise<unknown>;
+        kill: (runId: string) => Promise<unknown>;
+        validate: (runId: string) => Promise<unknown>;
+    };
+    readonly probe: {
+        run: (mappingId: string) => Promise<unknown>;
+        latest: (mappingId: string) => Promise<unknown>;
+    };
+    readonly phones: {
+        dmStatus: (mappingId: string) => Promise<unknown>;
+        rpsAssign: (mappingId: string) => Promise<unknown>;
+        dmEnroll: (mappingId: string, dryRun?: boolean) => Promise<unknown>;
+        control: (mappingId: string, mac: string, action: "reboot" | "factory_reset", force?: boolean) => Promise<unknown>;
+        oneTimePass: (mappingId: string) => Promise<unknown>;
+    };
+    readonly autopilot: {
+        batches: () => Promise<unknown>;
+        batch: (batchId: string) => Promise<unknown>;
+        batchAction: (batchId: string, action: "pause" | "resume" | "cancel") => Promise<unknown>;
+        itemAction: (itemId: string, action: "continue" | "retry" | "skip") => Promise<unknown>;
+        setNote: (itemId: string, note: string) => Promise<unknown>;
+    };
+    readonly audit: {
+        list: (limit?: number) => Promise<unknown>;
+    };
+}

package/dist/client.js

@@ -0,0 +1,65 @@
+import { apiRequest } from "./http.js";
+const DEFAULT_BASE = "https://netsapiens.uponai.com";
+export class UponAI {
+    options;
+    constructor(options) {
+        this.options = {
+            baseUrl: options.baseUrl ?? DEFAULT_BASE,
+            token: options.apiToken,
+            fetch: options.fetch,
+            timeoutMs: options.timeoutMs,
+        };
+    }
+    call(method, path, query, body) {
+        return apiRequest(this.options, method, path, { query, body });
+    }
+    me() {
+        return this.call("GET", "/api/me");
+    }
+    credentials = {
+        list: () => this.call("GET", "/api/credentials"),
+    };
+    mappings = {
+        list: () => this.call("GET", "/api/mappings"),
+        get: (mappingId) => this.call("GET", `/api/mappings/${mappingId}`),
+    };
+    sourceDomains = {
+        list: (credentialId) => this.call("GET", "/api/source-domains", { credential_id: credentialId }),
+    };
+    preflight = {
+        start: (mappingId) => this.call("POST", "/api/preflight-runs", undefined, { mapping_id: mappingId }),
+        list: (mappingId) => this.call("GET", "/api/preflight-runs", { mapping_id: mappingId }),
+        get: (runId) => this.call("GET", `/api/preflight-runs/${runId}`),
+    };
+    migrations = {
+        start: (preflightRunId, dryRun = false) => this.call("POST", "/api/migration-runs", undefined, {
+            preflight_run_id: preflightRunId,
+            dry_run: dryRun,
+        }),
+        list: (mappingId) => this.call("GET", "/api/migration-runs", { mapping_id: mappingId }),
+        get: (runId) => this.call("GET", `/api/migration-runs/${runId}`),
+        kill: (runId) => this.call("POST", `/api/migration-runs/${runId}/kill`),
+        validate: (runId) => this.call("POST", `/api/migration-runs/${runId}/validate`),
+    };
+    probe = {
+        run: (mappingId) => this.call("POST", `/api/mappings/${mappingId}/probe`),
+        latest: (mappingId) => this.call("GET", `/api/mappings/${mappingId}/probe/latest`),
+    };
+    phones = {
+        dmStatus: (mappingId) => this.call("GET", `/api/mappings/${mappingId}/phones/dm-status`),
+        rpsAssign: (mappingId) => this.call("POST", `/api/mappings/${mappingId}/phones/rps-assign`),
+        dmEnroll: (mappingId, dryRun = true) => this.call("POST", `/api/mappings/${mappingId}/phones/dm-enroll`, { dry_run: dryRun }),
+        control: (mappingId, mac, action, force = false) => this.call("POST", `/api/mappings/${mappingId}/phones/dm-control`, undefined, { mac, action, force }),
+        oneTimePass: (mappingId) => this.call("POST", `/api/mappings/${mappingId}/phones/global-one-time-pass`),
+    };
+    autopilot = {
+        batches: () => this.call("GET", "/api/autopilot/batches"),
+        batch: (batchId) => this.call("GET", `/api/autopilot/batches/${batchId}`),
+        batchAction: (batchId, action) => this.call("POST", `/api/autopilot/batches/${batchId}/${action}`),
+        itemAction: (itemId, action) => this.call("POST", `/api/autopilot/items/${itemId}/${action}`),
+        setNote: (itemId, note) => this.call("PUT", `/api/autopilot/items/${itemId}/note`, undefined, { note }),
+    };
+    audit = {
+        list: (limit = 50) => this.call("GET", "/api/platform-audit-events", { limit }),
+    };
+}

package/dist/http.d.ts

@@ -0,0 +1,20 @@
+export declare class ApiError extends Error {
+    readonly status: number;
+    readonly body: string;
+    constructor(status: number, message: string, body: string);
+}
+export declare class AuthenticationError extends ApiError {
+    constructor(message: string, body: string);
+}
+export declare function scrub(value: unknown): unknown;
+export type FetchLike = typeof fetch;
+export type RequestOptions = {
+    baseUrl: string;
+    token: string;
+    fetch?: FetchLike;
+    timeoutMs?: number;
+};
+export declare function apiRequest(options: RequestOptions, method: string, path: string, init?: {
+    query?: Record<string, string | number | boolean | undefined>;
+    body?: unknown;
+}): Promise<unknown>;

package/dist/http.js

@@ -0,0 +1,84 @@
+export class ApiError extends Error {
+    status;
+    body;
+    constructor(status, message, body) {
+        super(message);
+        this.name = "ApiError";
+        this.status = status;
+        this.body = body;
+    }
+}
+export class AuthenticationError extends ApiError {
+    constructor(message, body) {
+        super(401, message, body);
+        this.name = "AuthenticationError";
+    }
+}
+const SECRET_PARTS = [
+    "password",
+    "passwd",
+    "secret",
+    "token",
+    "api_key",
+    "api-key",
+    "auth_tag",
+    "auth-tag",
+    "device_key",
+    "device-key",
+];
+export function scrub(value) {
+    if (Array.isArray(value))
+        return value.map(scrub);
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [key, item] of Object.entries(value)) {
+            const lowered = key.toLowerCase();
+            out[key] = SECRET_PARTS.some((part) => lowered.includes(part)) ? "***" : scrub(item);
+        }
+        return out;
+    }
+    return value;
+}
+export async function apiRequest(options, method, path, init = {}) {
+    if (!options.token) {
+        throw new AuthenticationError("missing API token", "");
+    }
+    const url = new URL(path.replace(/^\//, ""), options.baseUrl.replace(/\/$/, "") + "/");
+    for (const [key, value] of Object.entries(init.query ?? {})) {
+        if (value !== undefined)
+            url.searchParams.set(key, String(value));
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? 60_000);
+    let response;
+    try {
+        response = await (options.fetch ?? fetch)(url, {
+            method,
+            signal: controller.signal,
+            headers: {
+                Accept: "application/json",
+                Authorization: `Bearer ${options.token}`,
+                ...(init.body === undefined ? {} : { "Content-Type": "application/json" }),
+            },
+            body: init.body === undefined ? undefined : JSON.stringify(init.body),
+        });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    const text = await response.text();
+    if (response.status === 401) {
+        throw new AuthenticationError(`${method} ${path} returned 401`, text.slice(0, 2000));
+    }
+    if (!response.ok) {
+        throw new ApiError(response.status, `${method} ${path} returned ${response.status}`, text.slice(0, 2000));
+    }
+    if (response.status === 204 || text.length === 0)
+        return { ok: true };
+    try {
+        return scrub(JSON.parse(text));
+    }
+    catch {
+        return { text: text.slice(0, 4000) };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { UponAI, type ClientOptions } from "./client.js";
+export { Netsapiens, type NetsapiensOptions } from "./netsapiens.js";
+export { ApiError, AuthenticationError } from "./http.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { UponAI } from "./client.js";
+export { Netsapiens } from "./netsapiens.js";
+export { ApiError, AuthenticationError } from "./http.js";

package/dist/netsapiens.d.ts

@@ -0,0 +1,25 @@
+import { type FetchLike } from "./http.js";
+export type NetsapiensOptions = {
+    apiToken: string;
+    baseUrl: string;
+    fetch?: FetchLike;
+    timeoutMs?: number;
+};
+export declare class Netsapiens {
+    private readonly options;
+    constructor(options: NetsapiensOptions);
+    private call;
+    private domainPath;
+    domain(domain: string): Promise<unknown>;
+    connections(domain: string): Promise<unknown>;
+    /** Header Manipulation on Edit SIP Trunk. Request and To are the trunk name, not the .myvoip domain. */
+    setTrunkHeaders(domain: string, origMatch: string, headers: {
+        requestHost?: string;
+        toHost?: string;
+        fromHost?: string;
+    }): Promise<unknown>;
+    phoneNumbers(domain: string): Promise<unknown>;
+    dialRules(domain: string, dialPlan?: string): Promise<unknown>;
+    cdrs(domain: string, start: string, end: string, limit?: number): Promise<unknown>;
+    users(domain: string): Promise<unknown>;
+}

package/dist/netsapiens.js

@@ -0,0 +1,58 @@
+import { apiRequest } from "./http.js";
+export class Netsapiens {
+    options;
+    constructor(options) {
+        this.options = {
+            baseUrl: options.baseUrl,
+            token: options.apiToken,
+            fetch: options.fetch,
+            timeoutMs: options.timeoutMs,
+        };
+    }
+    call(method, path, query, body) {
+        return apiRequest(this.options, method, path, { query, body });
+    }
+    domainPath(domain, suffix = "") {
+        return `/ns-api/v2/domains/${encodeURIComponent(domain)}${suffix}`;
+    }
+    domain(domain) {
+        return this.call("GET", this.domainPath(domain));
+    }
+    connections(domain) {
+        return this.call("GET", this.domainPath(domain, "/connections"));
+    }
+    /** Header Manipulation on Edit SIP Trunk. Request and To are the trunk name, not the .myvoip domain. */
+    setTrunkHeaders(domain, origMatch, headers) {
+        const body = {};
+        if (headers.requestHost !== undefined)
+            body["connection-translation-request-host"] = headers.requestHost;
+        if (headers.toHost !== undefined)
+            body["connection-translation-destination-host"] = headers.toHost;
+        if (headers.fromHost !== undefined)
+            body["connection-translation-source-host"] = headers.fromHost;
+        return this.call("PUT", this.domainPath(domain, `/connections/${encodeURIComponent(origMatch)}`), undefined, body);
+    }
+    phoneNumbers(domain) {
+        return this.call("GET", this.domainPath(domain, "/phonenumbers"));
+    }
+    async dialRules(domain, dialPlan) {
+        let plan = dialPlan;
+        if (!plan) {
+            const row = await this.domain(domain);
+            plan = typeof row === "object" && row && "dial-plan" in row ? String(row["dial-plan"] ?? "") : "";
+            if (!plan)
+                throw new Error(`domain ${domain} has no dial-plan; pass one`);
+        }
+        return this.call("GET", this.domainPath(domain, `/dialplans/${encodeURIComponent(plan)}/dialrules`));
+    }
+    cdrs(domain, start, end, limit = 25) {
+        return this.call("GET", this.domainPath(domain, "/cdrs"), {
+            "datetime-start": start,
+            "datetime-end": end,
+            limit: Math.max(1, Math.min(limit, 100)),
+        });
+    }
+    users(domain) {
+        return this.call("GET", this.domainPath(domain, "/users"));
+    }
+}

package/package.json

@@ -1,6 +1,22 @@
 {
   "name": "@myvoip/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "TypeScript SDK for the UponAI migration tool and the NetSapiens portal",
+  "license": "MIT",
+  "type": "module",
+  "engines": { "node": ">=22" },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "node --experimental-strip-types --test src/http.test.ts"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.