@nexalink/carecompass-sdk 0.1.0-beta.8 → 0.2.0-beta.11

package/dist/cli.js

@@ -1,26 +1,36 @@
 #!/usr/bin/env node
+import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync, } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createDefaultCareCompassConfig, validateCareCompassConfig, } from "./schema.js";
-import { resolveApiKey, resolveCredentialsPath, writeStoredApiKey, } from "./credentials.js";
+import { normalizeApiKey, resolveApiKey, resolveCredentialsPath, writeStoredApiKey, } from "./credentials.js";
 import { generateCareCompassIframeSnippet, generateCareCompassSnippet, } from "./snippet.js";
+import { CARECOMPASS_TELEMETRY_ERROR_CODES, CARECOMPASS_TELEMETRY_EVENTS, createCareCompassCliTelemetry, } from "./telemetry.js";
 const DEFAULT_OUTPUT_DIR = "carecompass";
 const DEFAULT_CONFIG_PATH = join(DEFAULT_OUTPUT_DIR, "carecompass.config.json");
 const DEFAULT_SNIPPET_PATH = join(DEFAULT_OUTPUT_DIR, "carecompass-embed.html");
-const DEFAULT_IFRAME_PATH = join(DEFAULT_OUTPUT_DIR, "carecompass-iframe.html");
-const DEFAULT_SETUP_GUIDE_PATH = join(DEFAULT_OUTPUT_DIR, "README.md");
 const DEFAULT_PROMPT_PATH = "system-prompt.md";
-const DEFAULT_SIGNUP_URL = "https://nexalink.care/signup?group=payer";
+const DEFAULT_DEVELOPER_SIGNUP_URL = "https://www.nexalink.care/developer/signup";
 const DEFAULT_API_BASE_URL = "https://www.nexalink.care";
 const DEFAULT_SNIPPET_MODE = "bundler";
-const DEFAULT_SYSTEM_PROMPT = `You are CareCompass, a payer-approved care navigation assistant.
+const LEGACY_BAA_INIT_FLAGS = [
+    "baa-action",
+    "baa-output",
+    "baa-template-output",
+    "legal-entity-name",
+    "signer-name",
+    "signer-email",
+    "signer-title",
+    "baa-confirmation",
+];
+const DEFAULT_SYSTEM_PROMPT = `You are CareCompass, a customer-approved healthcare navigation assistant.
 
 Help members understand benefits, coverage navigation, in-network care options,
 support resources, and appropriate next steps. Stay out of diagnosis, treatment
 planning, emergency triage, legal advice, and coverage guarantees. When a member
-needs clinical, emergency, or plan-specific help that requires a human, route
-them to the payer's approved support resources.`;
+needs clinical, emergency, plan-specific, or account-specific help that requires
+a human, route them to the customer's approved support resources.`;
 function parseArgs(argv) {
     const [command = "help", ...rest] = argv;
     const flags = {};
@@ -28,6 +38,12 @@ function parseArgs(argv) {
     for (let index = 0; index < rest.length; index += 1) {
         const token = rest[index];
         if (!token.startsWith("--")) {
+            const trimmedToken = token.trimStart();
+            if (trimmedToken.startsWith("-")) {
+                // This catches a common copy/paste failure where a continued shell line
+                // leaves whitespace before a flag and turns it into a positional arg.
+                throw new Error(`Unexpected argument "${trimmedToken}". Flags must not have leading whitespace. When splitting a command across lines, place \\ immediately before the newline.`);
+            }
             positionals.push(token);
             continue;
         }
@@ -65,14 +81,274 @@ function requireApiKey(flags, io) {
     const credentialsPath = resolveCredentialsPath(io.env);
     const credentials = resolveApiKey(flagString(flags, "api-key"), io.env, credentialsPath);
     if (!credentials.apiKey) {
-        throw new Error("Missing Nexalink API key. Run `npx @nexalink/carecompass-sdk login --api-key <key>` or set CARECOMPASS_API_KEY.");
+        throw new Error("Missing Nexalink API key. Run `npx @nexalink/carecompass-sdk init --api-key <key>` or set CARECOMPASS_API_KEY.");
     }
     return { ...credentials, apiKey: credentials.apiKey };
 }
+async function promptFor(io, question) {
+    if (io.prompt)
+        return (await io.prompt(question)).trim();
+    if (!io.stdin) {
+        throw new Error("Missing Nexalink API key. Re-run `npx @nexalink/carecompass-sdk init --api-key <key>` in a terminal or set CARECOMPASS_API_KEY.");
+    }
+    const { createInterface } = await import("node:readline/promises");
+    const readline = createInterface({
+        input: io.stdin,
+        output: io.stdout,
+    });
+    try {
+        return (await readline.question(question)).trim();
+    }
+    finally {
+        readline.close();
+    }
+}
+async function promptForSecret(io, question) {
+    if (io.prompt)
+        return (await io.prompt(question)).trim();
+    const stdin = io.stdin;
+    if (!stdin?.isTTY || typeof stdin.setRawMode !== "function") {
+        // Test harnesses and non-interactive shells use the regular prompt path;
+        // interactive terminals get raw-mode input so the secret is not echoed.
+        return promptFor(io, question);
+    }
+    return new Promise((resolveValue, reject) => {
+        let answer = "";
+        const cleanup = () => {
+            stdin.off("data", onData);
+            stdin.setRawMode?.(false);
+            io.stdout.write("\n");
+        };
+        const finish = () => {
+            cleanup();
+            resolveValue(answer.trim());
+        };
+        const cancel = () => {
+            cleanup();
+            reject(new Error("CareCompass init cancelled."));
+        };
+        const onData = (chunk) => {
+            const value = chunk.toString("utf8");
+            for (const character of value) {
+                if (character === "\u0003") {
+                    cancel();
+                    return;
+                }
+                if (character === "\r" || character === "\n") {
+                    finish();
+                    return;
+                }
+                if (character === "\u007f" || character === "\b") {
+                    answer = answer.slice(0, -1);
+                    continue;
+                }
+                if (character >= " ") {
+                    answer += character;
+                }
+            }
+        };
+        io.stdout.write(question);
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.on("data", onData);
+    });
+}
+const normalizeAccountType = (value) => {
+    const normalized = value?.trim().toLowerCase();
+    if (normalized === "enterprise")
+        return "enterprise";
+    if (normalized === "developer" || normalized === "1")
+        return "developer";
+    return null;
+};
+const isExitInput = (value) => ["exit", "cancel", "quit", "q", "2"].includes(value.trim().toLowerCase());
+const enterpriseUnavailableMessage = (developerSignupUrl) => `Enterprise signup is temporarily unavailable in the CLI. Use the developer flow for now:
+Developer: ${developerSignupUrl}`;
+async function selectAccountType(flags, io) {
+    const configuredType = flagString(flags, "account-type") ?? io.env.CARECOMPASS_ACCOUNT_TYPE;
+    if (configuredType) {
+        const accountType = normalizeAccountType(configuredType);
+        if (!accountType) {
+            throw new Error("--account-type must be developer.");
+        }
+        if (accountType === "enterprise") {
+            throw new Error(enterpriseUnavailableMessage(signupUrls(flags, io).developer));
+        }
+        return accountType;
+    }
+    while (true) {
+        const answer = await promptFor(io, `Select account type:
+  1. Developer
+  2. Exit
+
+Choice: `);
+        if (isExitInput(answer))
+            throw new Error("CareCompass init cancelled.");
+        const accountType = normalizeAccountType(answer);
+        if (accountType === "enterprise") {
+            throw new Error(enterpriseUnavailableMessage(signupUrls(flags, io).developer));
+        }
+        if (accountType)
+            return accountType;
+        io.stdout.write("Choose 1 for Developer or 2 to exit.\n");
+    }
+}
+async function promptForAccountExists(io, accountType) {
+    while (true) {
+        const answer = (await promptFor(io, `Do you already have a ${accountType} account? (y/n, or type exit): `)).toLowerCase();
+        if (isExitInput(answer))
+            throw new Error("CareCompass init cancelled.");
+        if (answer === "y" || answer === "yes")
+            return true;
+        if (answer === "n" || answer === "no")
+            return false;
+        io.stdout.write("Answer y, n, or exit.\n");
+    }
+}
+const signupUrls = (flags, io) => ({
+    developer: flagString(flags, "developer-signup-url") ??
+        io.env.CARECOMPASS_DEVELOPER_SIGNUP_URL ??
+        DEFAULT_DEVELOPER_SIGNUP_URL,
+});
+function rejectLegacyBaaInitFlags(flags, io) {
+    const legacyFlag = LEGACY_BAA_INIT_FLAGS.find((flag) => flag in flags);
+    if (!legacyFlag)
+        return;
+    const urls = signupUrls(flags, io);
+    throw new Error(`BAA execution now happens in the Nexalink web app before API key creation. Remove --${legacyFlag} and complete signup instead:
+Developer: ${urls.developer}`);
+}
+async function waitForSignupOrExit(io) {
+    const answer = await promptFor(io, "Press Enter after account creation to sign in, or type exit to cancel: ");
+    if (isExitInput(answer))
+        throw new Error("CareCompass init cancelled.");
+}
+function printSignupRoute(io, accountType, urls) {
+    if (accountType === "enterprise") {
+        io.stdout.write(`${enterpriseUnavailableMessage(urls.developer)}\n`);
+        return;
+    }
+    io.stdout.write(`Open ${urls.developer} to create a developer account.\n`);
+}
+function normalizeAuthSetup(value) {
+    // The auth service may return account defaults, but every field is narrowed
+    // before it is allowed to influence generated customer configuration.
+    if (!value || typeof value !== "object")
+        return undefined;
+    const source = value;
+    const setup = {};
+    if (typeof source.payerId === "string")
+        setup.payerId = source.payerId;
+    if (source.environment === "development" ||
+        source.environment === "staging" ||
+        source.environment === "production") {
+        setup.environment = source.environment;
+    }
+    if (typeof source.embedKey === "string")
+        setup.embedKey = source.embedKey;
+    if (Array.isArray(source.allowedOrigins) &&
+        source.allowedOrigins.every((origin) => typeof origin === "string")) {
+        setup.allowedOrigins = source.allowedOrigins;
+    }
+    return Object.keys(setup).length ? setup : undefined;
+}
+async function validateInitApiKey(apiBaseUrl, apiKey, accountType) {
+    const url = endpointUrl(apiBaseUrl, "/api/carecompass/auth/validate");
+    let response;
+    try {
+        response = await globalThis.fetch(url, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${apiKey}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({ accountType }),
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Network request failed";
+        throw new Error(`Could not reach CareCompass authentication API at ${url}. ${message}`);
+    }
+    const text = await response.text();
+    let payload = {};
+    try {
+        payload = text ? JSON.parse(text) : {};
+    }
+    catch {
+        payload = {};
+    }
+    if (!response.ok || payload.ok === false) {
+        return {
+            ok: false,
+            message: payload.error ?? "Invalid API key.",
+        };
+    }
+    const validatedType = typeof payload.accountType === "string"
+        ? normalizeAccountType(payload.accountType)
+        : null;
+    if (!validatedType) {
+        return {
+            ok: false,
+            message: "Credential validation succeeded but did not return a recognized account type. Contact support@nexalink.care.",
+        };
+    }
+    return {
+        ok: true,
+        accountType: validatedType,
+        setup: normalizeAuthSetup(payload.setup),
+    };
+}
+async function resolveInitApiKey(flags, io, apiBaseUrl) {
+    const credentialsPath = resolveCredentialsPath(io.env);
+    let credentials = resolveApiKey(flagString(flags, "api-key"), io.env, credentialsPath);
+    const urls = signupUrls(flags, io);
+    let useResolvedCredential = Boolean(credentials.apiKey);
+    while (true) {
+        const accountType = await selectAccountType(flags, io);
+        let hasAccount = useResolvedCredential
+            ? true
+            : await promptForAccountExists(io, accountType);
+        while (!hasAccount) {
+            printSignupRoute(io, accountType, urls);
+            await waitForSignupOrExit(io);
+            hasAccount = await promptForAccountExists(io, accountType);
+        }
+        const apiKey = useResolvedCredential
+            ? credentials.apiKey
+            : await promptForSecret(io, "Enter API key: ");
+        useResolvedCredential = false;
+        credentials = { apiKey: null, source: "missing" };
+        const normalizedApiKey = normalizeApiKey(apiKey);
+        if (!normalizedApiKey) {
+            io.stdout.write("Invalid or missing API key. Try again or type exit.\n");
+            continue;
+        }
+        io.stdout.write("Validating credentials...\n");
+        const validation = await validateInitApiKey(apiBaseUrl, normalizedApiKey, accountType);
+        if (!validation.ok) {
+            io.stdout.write(`${validation.message}\n`);
+            continue;
+        }
+        if (validation.accountType !== accountType) {
+            if (validation.accountType === "enterprise") {
+                io.stdout.write(`This API key belongs to an enterprise account. ${enterpriseUnavailableMessage(urls.developer)}\n`);
+                continue;
+            }
+            io.stdout.write(`This API key belongs to a ${validation.accountType} account. Select Developer to continue.\n`);
+            continue;
+        }
+        writeStoredApiKey(normalizedApiKey, credentialsPath);
+        io.stdout.write(`Stored CareCompass credentials at ${credentialsPath}\n`);
+        io.stdout.write("Sign-in successful.\n");
+        return { apiKey: normalizedApiKey, setup: validation.setup };
+    }
+}
 function resolvePromptFile(config, configPath) {
     const promptFile = config.prompt.systemInstructionFile;
     if (!promptFile)
         return config;
+    // Prompt files are resolved relative to the config file so generated kits work
+    // after the caller changes directories.
     const resolvedPath = resolve(dirname(configPath), promptFile);
     const systemInstruction = readFileSync(resolvedPath, "utf8").trim();
     const validation = validateCareCompassConfig({
@@ -92,6 +368,8 @@ function runtimeConfig(config) {
         return config;
     const prompt = { ...config.prompt };
     delete prompt.systemInstructionFile;
+    // Browser snippets receive the prompt text, not the local prompt file path,
+    // because deployed embeds cannot read files from the integrator's machine.
     return {
         ...config,
         prompt,
@@ -108,16 +386,23 @@ const configHeaders = (config, apiKey, origin) => ({
 const endpointUrl = (baseUrl, path) => `${baseUrl.replace(/\/+$/, "")}${path}`;
 const setupGuide = (params) => `# CareCompass SDK Setup
 
-This folder contains the payer-owned CareCompass embed setup. The generated iframe is the easiest way to place the CareCompass LLM experience on a payer website.
+This folder contains the CareCompass embed setup for your healthcare website or app. The generated iframe is the easiest way to place the CareCompass LLM experience where members or patients already seek help.
 
 ## Step 1: Confirm Credentials
 
-You need a Nexalink payer account and SDK API key before validation or runtime use. If you do not have a key, create or request payer SDK access at https://nexalink.care/signup?group=payer.
+You need a Nexalink account with SDK access before validation or runtime use. Live regulated deployments require BAA coverage where PHI may be involved. If you do not have a key, create one in the Nexalink web app, where BAA execution happens before API key creation.
 
 \`\`\`bash
-npx @nexalink/carecompass-sdk login --api-key <key>
+npx @nexalink/carecompass-sdk init --account-type developer --api-key <key>
 \`\`\`
 
+The \`init\` flow routes developers without accounts to the configured signup path, validates the API key with Nexalink, stores the key locally only after successful sign-in, and generates this setup kit.
+
+The API key and embed key serve different purposes:
+
+- API key: secret credential for trusted setup and server-side/CLI workflows. Keep it out of browser code, generated embed HTML, frontend config, and source control.
+- Embed key: public browser-facing identifier used by the CareCompass embed with the payer ID, environment, and allowed origins. It is safe to include in this generated config, but it is not a secret.
+
 ## Step 2: Review Config
 
 Open \`${params.configPath}\` and confirm:
@@ -126,13 +411,14 @@ Open \`${params.configPath}\` and confirm:
 - \`environment\`: ${params.config.environment}
 - \`apiBaseUrl\`: ${params.config.apiBaseUrl}
 - \`allowedOrigins\`: ${params.config.allowedOrigins.join(", ")}
-- \`embedKey\`: public embed key issued in the payer portal
+- \`embedKey\`: public embed key issued in the Nexalink portal
+- \`telemetry\`: enabled automatically with Nexalink-managed privacy-safe defaults
 
-The config file is safe to commit because it does not contain the secret API key.
+The config file is safe to commit because it does not contain the secret API key. Telemetry does not require customer configuration and never includes prompts, responses, chat history, user context, credentials, or raw errors.
 
 ## Step 3: Edit System Prompt
 
-Open \`${params.promptPath}\` and replace the starter text with payer-approved instructions. Use it for plan context, support boundaries, escalation rules, and member-navigation tone.
+Open \`${params.promptPath}\` and replace the starter text with customer-approved instructions. Use it for plan or program context, support boundaries, escalation rules, and member or patient navigation tone.
 
 Do not put secrets, raw PHI, diagnosis instructions, treatment instructions, or attempts to bypass Nexalink safety rules in this file.
 
@@ -142,11 +428,11 @@ Do not put secrets, raw PHI, diagnosis instructions, treatment instructions, or
 npx @nexalink/carecompass-sdk validate --config ${params.configPath}
 \`\`\`
 
-This checks local schema rules and verifies the config against Nexalink-hosted API routes.
+This checks local schema rules and verifies the config against Nexalink-hosted API routes. The hosted validation request uses the public embed identity from the config; it does not send the secret API key from the browser runtime.
 
 ## Step 5: Place The Iframe
 
-Copy the iframe from \`${params.iframePath}\` into the payer page where the CareCompass LLM should appear.
+Copy the iframe from \`${params.iframePath}\` into the page where the CareCompass LLM should appear.
 
 The iframe points at:
 
@@ -154,11 +440,13 @@ The iframe points at:
 ${params.iframeSrc}
 \`\`\`
 
-Make sure \`${params.embedPath}\` is served by the payer site at that URL. For many apps, that means copying the \`${params.outputDir}\` folder into the app's public/static assets folder before deployment.
+Make sure \`${params.embedPath}\` is served by your site at that URL. For many apps, that means copying the \`${params.outputDir}\` folder into the app's public/static assets folder before deployment.
 
 ## Step 6: Test
 
-Load the payer page from an allowed origin and send a non-PHI test message. If the embed cannot connect, run:
+Load the page from an allowed origin and send a non-PHI test message. If the embed cannot connect, run:
+
+Nexalink hosts the CareCompass LLM runtime behind Nexalink-managed API routes. Some MVP and development model endpoints use scale-to-zero capacity to control cost, so the first request after an idle period may take several minutes while the endpoint warms up. The request is queued through Nexalink-hosted APIs during warm-up; the browser embed does not receive SageMaker credentials or call the model endpoint directly.
 
 \`\`\`bash
 npx @nexalink/carecompass-sdk doctor --config ${params.configPath}
@@ -177,7 +465,7 @@ async function assertHostedConfig(config, apiKey) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : "Network request failed";
-        throw new Error(`Could not reach CareCompass API at ${url}. If apiBaseUrl is localhost, make sure the Nexalink Next.js app is running locally and the payer page is also local. Hosted sandboxes cannot reach your machine's localhost. ${message}`);
+        throw new Error(`Could not reach CareCompass API at ${url}. If apiBaseUrl is localhost, make sure the Nexalink Next.js app and integrating page are both running locally. Hosted sandboxes cannot reach your machine's localhost. ${message}`);
     }
     const text = await response.text();
     let payload = {};
@@ -203,19 +491,24 @@ function readConfig(path) {
     }
     return resolvePromptFile(validation.config, path);
 }
-function buildInitConfig(flags) {
+function buildInitConfig(flags, setup) {
     const origins = flags.origin;
+    // `--origin` is repeatable, but accepting comma-separated input keeps the CLI
+    // usable in package scripts and dashboards that only expose single text fields.
     const allowedOrigins = Array.isArray(origins)
         ? origins
         : typeof origins === "string"
             ? origins.split(",").map((origin) => origin.trim())
-            : ["https://example-payer.com"];
+            : (setup?.allowedOrigins ?? ["https://example-payer.com"]);
     return createDefaultCareCompassConfig({
-        payerId: flagString(flags, "payer-id") ?? "payer-demo",
+        payerId: flagString(flags, "payer-id") ?? setup?.payerId ?? "payer-demo",
         environment: flagString(flags, "environment") ??
+            setup?.environment ??
             "staging",
         apiBaseUrl: flagString(flags, "api-base-url") ?? DEFAULT_API_BASE_URL,
-        embedKey: flagString(flags, "embed-key") ?? "embed_demo_1234567890",
+        embedKey: flagString(flags, "embed-key") ??
+            setup?.embedKey ??
+            "embed_demo_1234567890",
         allowedOrigins,
         branding: {
             displayName: flagString(flags, "display-name") ?? "Example Health Plan",
@@ -242,50 +535,66 @@ function printHelp(io) {
     io.stdout.write(`CareCompass SDK CLI
 
 Run one-off commands with npx:
-  npx @nexalink/carecompass-sdk login --api-key <key>
-  npx @nexalink/carecompass-sdk init --payer-id <id> --origin <url>
+  npx @nexalink/carecompass-sdk init --account-type developer --api-key <key> --payer-id <id> --origin <url>
   npx @nexalink/carecompass-sdk validate --config carecompass/carecompass.config.json
   npx @nexalink/carecompass-sdk snippet --config carecompass.config.json
   npx @nexalink/carecompass-sdk doctor --config carecompass.config.json
 
 If installed globally or run from a package script:
-  carecompass login --api-key <key>
-  carecompass init [--payer-id <id>] [--origin <url>]
+  carecompass init [--account-type developer] [--api-key <key>] [--payer-id <id>] [--origin <url>]
 
 Commands:
-  login --api-key <key>
-  init [--payer-id <id>] [--origin <url>] [--output-dir carecompass]
+  init [--account-type developer] [--api-key <key>] [--payer-id <id>] [--origin <url>] [--output-dir carecompass]
   validate --config carecompass.config.json [--local-only]
   snippet --config carecompass.config.json [--output embed.html] [--snippet-mode bundler|cdn]
   doctor --config carecompass.config.json
+
+Init validates developer sign-in before setup. BAA execution happens in the Nexalink web app before API key creation. The developer signup URL can be configured with --developer-signup-url or CARECOMPASS_DEVELOPER_SIGNUP_URL.
 `);
 }
 export async function runCareCompassCli(argv = process.argv.slice(2), io = {
     stdout: process.stdout,
     stderr: process.stderr,
     env: process.env,
+    stdin: process.stdin,
 }) {
+    const cliSessionId = randomUUID();
+    // Start with anonymous CLI telemetry, then rebuild it with payer context after
+    // a config has been generated or read.
+    let cliTelemetry = createCareCompassCliTelemetry(cliSessionId);
+    let activeCommand = "unknown";
+    await cliTelemetry.captureAsync(CARECOMPASS_TELEMETRY_EVENTS.CLI_STARTED);
     try {
         const { command, flags, positionals } = parseArgs(argv);
+        activeCommand = command;
         if (command === "help" || command === "--help" || command === "-h") {
             printHelp(io);
             return 0;
         }
         if (command === "login") {
+            await cliTelemetry.captureAsync(CARECOMPASS_TELEMETRY_EVENTS.CLI_LOGIN_STARTED);
             const apiKey = flagString(flags, "api-key") ?? positionals[0];
             if (!apiKey) {
-                const signupUrl = flagString(flags, "signup-url") ?? DEFAULT_SIGNUP_URL;
-                io.stderr.write(`Missing --api-key. Create a Nexalink payer account or request SDK access at ${signupUrl}\n`);
+                const signupUrl = flagString(flags, "signup-url") ?? DEFAULT_DEVELOPER_SIGNUP_URL;
+                io.stderr.write(`Missing --api-key. Create a Nexalink account or request SDK access at ${signupUrl}\n`);
+                await cliTelemetry.captureAsync(CARECOMPASS_TELEMETRY_EVENTS.CLI_LOGIN_FAILED, {
+                    errorCode: CARECOMPASS_TELEMETRY_ERROR_CODES.AUTHENTICATION_FAILED,
+                    failureCategory: "authentication",
+                });
                 return 1;
             }
             const credentialsPath = resolveCredentialsPath(io.env);
             writeStoredApiKey(apiKey, credentialsPath);
             io.stdout.write(`Stored CareCompass credentials at ${credentialsPath}\n`);
+            await cliTelemetry.captureAsync(CARECOMPASS_TELEMETRY_EVENTS.CLI_LOGIN_SUCCEEDED);
             return 0;
         }
         if (command === "init") {
-            requireApiKey(flags, io);
+            await cliTelemetry.captureAsync(CARECOMPASS_TELEMETRY_EVENTS.CLI_INIT_STARTED);
+            rejectLegacyBaaInitFlags(flags, io);
             const outputDir = flagString(flags, "output-dir") ?? DEFAULT_OUTPUT_DIR;
+            const apiBaseUrl = flagString(flags, "api-base-url") ?? DEFAULT_API_BASE_URL;
+            const initAuth = await resolveInitApiKey(flags, io, apiBaseUrl);
             const output = flagString(flags, "output") ??
                 join(outputDir, "carecompass.config.json");
             const snippetOutput = flagString(flags, "snippet-output") ??
@@ -308,7 +617,8 @@ export async function runCareCompassCli(argv = process.argv.slice(2), io = {
                 }
             }
             mkdirSync(outputDir, { recursive: true });
-            const config = buildInitConfig(flags);
+            const config = buildInitConfig(flags, initAuth.setup);
+            cliTelemetry = createCareCompassCliTelemetry(cliSessionId, config);
             writeFileSync(output, `${JSON.stringify(config, null, 2)}\n`);
             writeFileSync(promptOutput, `${DEFAULT_SYSTEM_PROMPT}\n`);
             const resolvedConfig = readConfig(output);
@@ -332,7 +642,7 @@ export async function runCareCompassCli(argv = process.argv.slice(2), io = {
 Step 1: Review config
   ${output}
 
-Step 2: Edit the payer-approved system prompt
+Step 2: Edit the customer-approved system prompt
   ${promptOutput}
 
 Step 3: Serve the generated embed page from your site
@@ -347,20 +657,33 @@ Step 5: Follow the generated setup guide
 Next command:
   npx @nexalink/carecompass-sdk validate --config ${output}
 `);
+            await cliTelemetry.captureAsync(CARECOMPASS_TELEMETRY_EVENTS.CLI_SETUP_KIT_GENERATED);
             return 0;
         }
         if (command === "validate") {
-            const credentials = requireApiKey(flags, io);
-            const config = readConfig(flagString(flags, "config") ?? DEFAULT_CONFIG_PATH);
-            if (flags["local-only"] !== true) {
-                await assertHostedConfig(config, credentials.apiKey);
+            try {
+                const credentials = requireApiKey(flags, io);
+                const config = readConfig(flagString(flags, "config") ?? DEFAULT_CONFIG_PATH);
+                cliTelemetry = createCareCompassCliTelemetry(cliSessionId, config);
+                if (flags["local-only"] !== true) {
+                    await assertHostedConfig(config, credentials.apiKey);
+                }
+                io.stdout.write(`CareCompass config is valid for ${config.payerId}. Credentials loaded from ${credentials.source}.\n`);
+                await cliTelemetry.captureAsync(CARECOMPASS_TELEMETRY_EVENTS.CLI_VALIDATION_SUCCEEDED);
+                return 0;
+            }
+            catch (error) {
+                await cliTelemetry.captureAsync(CARECOMPASS_TELEMETRY_EVENTS.CLI_VALIDATION_FAILED, {
+                    errorCode: CARECOMPASS_TELEMETRY_ERROR_CODES.CLI_COMMAND_FAILED,
+                    failureCategory: "configuration",
+                });
+                throw error;
             }
-            io.stdout.write(`CareCompass config is valid for ${config.payerId}. Credentials loaded from ${credentials.source}.\n`);
-            return 0;
         }
         if (command === "snippet") {
             requireApiKey(flags, io);
             const config = readConfig(flagString(flags, "config") ?? DEFAULT_CONFIG_PATH);
+            cliTelemetry = createCareCompassCliTelemetry(cliSessionId, config);
             const snippet = generateCareCompassSnippet(runtimeConfig(config), {
                 mode: snippetMode(flags),
             });
@@ -373,11 +696,13 @@ Next command:
             else {
                 io.stdout.write(`${snippet}\n`);
             }
+            await cliTelemetry.captureAsync(CARECOMPASS_TELEMETRY_EVENTS.CLI_SNIPPET_GENERATED);
             return 0;
         }
         if (command === "doctor") {
             const credentials = requireApiKey(flags, io);
             const config = readConfig(flagString(flags, "config") ?? DEFAULT_CONFIG_PATH);
+            cliTelemetry = createCareCompassCliTelemetry(cliSessionId, config);
             let hostedStatus = "not checked";
             try {
                 await assertHostedConfig(config, credentials.apiKey);
@@ -392,15 +717,27 @@ Payer: ${config.payerId}
 Environment: ${config.environment}
 API base URL: ${config.apiBaseUrl}
 Allowed origins: ${config.allowedOrigins.join(", ")}
+Telemetry: enabled automatically with Nexalink-managed privacy-safe defaults
 Credentials: ${credentials.source}
 Hosted API: ${hostedStatus}
 Status: ready for staging verification
 `);
+            await cliTelemetry.captureAsync(CARECOMPASS_TELEMETRY_EVENTS.CLI_DOCTOR_COMPLETED);
             return 0;
         }
         throw new Error(`Unknown command: ${command}`);
     }
     catch (error) {
+        if (activeCommand === "init") {
+            await cliTelemetry.captureAsync(CARECOMPASS_TELEMETRY_EVENTS.CLI_INIT_FAILED, {
+                errorCode: CARECOMPASS_TELEMETRY_ERROR_CODES.CLI_COMMAND_FAILED,
+                failureCategory: "unknown",
+            });
+        }
+        await cliTelemetry.captureAsync(CARECOMPASS_TELEMETRY_EVENTS.CLI_COMMAND_FAILED, {
+            errorCode: CARECOMPASS_TELEMETRY_ERROR_CODES.CLI_COMMAND_FAILED,
+            failureCategory: "unknown",
+        });
         io.stderr.write(`${error.message}\n`);
         return 1;
     }
@@ -413,4 +750,3 @@ if (isMainModule()) {
         process.exitCode = code;
     });
 }
-//# sourceMappingURL=cli.js.map

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { CareCompassConfig } from "./schema.js";
+import { type CareCompassConfig } from "./schema.js";
 export type CareCompassAskRequest = {
     prompt: string;
     sessionId?: string;
@@ -12,13 +12,15 @@ export type CareCompassStatusResponse = {
     result?: string;
 };
 type Fetcher = typeof fetch;
-export declare function createCareCompassClient(config: CareCompassConfig, options?: {
+export declare function createCareCompassClient(inputConfig: CareCompassConfig, options?: {
     fetcher?: Fetcher;
+    now?: () => number;
 }): {
     validateConfig: () => Promise<{
         ok: true;
     }>;
     ask: (request: CareCompassAskRequest) => Promise<CareCompassAskResponse>;
     status: (jobId: string) => Promise<CareCompassStatusResponse>;
+    recordInferenceTimeout: (jobId: string, durationMs: number) => void;
 };
 export {};