@betterness/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1835 @@
+#!/usr/bin/env node
+
+// src/program.ts
+import { Command } from "commander";
+
+// src/commands/auth.ts
+import { createInterface } from "readline/promises";
+import { stdin, stdout } from "process";
+
+// src/auth/credentialStore.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var CONFIG_DIR = join(homedir(), ".betterness");
+var CREDENTIALS_FILE = join(CONFIG_DIR, "credentials.json");
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+}
+function loadCredentials() {
+  if (!existsSync(CREDENTIALS_FILE)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(CREDENTIALS_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(credentials) {
+  ensureConfigDir();
+  const data = {
+    ...credentials,
+    savedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync(CREDENTIALS_FILE, JSON.stringify(data, null, 2), { mode: 384 });
+}
+function deleteCredentials() {
+  if (!existsSync(CREDENTIALS_FILE)) {
+    return false;
+  }
+  unlinkSync(CREDENTIALS_FILE);
+  return true;
+}
+
+// src/types/errors.ts
+var CliError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "CliError";
+    this.code = code;
+  }
+  toJSON() {
+    return {
+      error: {
+        code: this.code,
+        message: this.message
+      }
+    };
+  }
+};
+
+// src/auth/resolve.ts
+function resolveCredentials(explicitApiKey) {
+  if (explicitApiKey) {
+    return { apiKey: explicitApiKey };
+  }
+  const envKey = process.env.BETTERNESS_API_KEY;
+  if (envKey) {
+    return { apiKey: envKey };
+  }
+  const stored = loadCredentials();
+  if (stored) {
+    return { apiKey: stored.apiKey };
+  }
+  throw new CliError(
+    "No credentials found. Use one of:\n  1. betterness auth login\n  2. --api-key <key>\n  3. BETTERNESS_API_KEY environment variable",
+    "AUTH_MISSING"
+  );
+}
+
+// src/client/apiClient.ts
+var MAX_RETRIES = 3;
+var RETRY_BASE_DELAY_MS = 500;
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+var ApiClient = class {
+  apiKey;
+  apiUrl;
+  constructor(options = {}) {
+    const credentials = resolveCredentials(options.apiKey);
+    this.apiKey = credentials.apiKey;
+    const apiUrl = process.env.BETTERNESS_API_URL || "";
+    if (!apiUrl) {
+      throw new CliError(
+        "No API URL configured. Set BETTERNESS_API_URL or rebuild with BETTERNESS_BUILD_API_URL.",
+        "CONFIG_MISSING"
+      );
+    }
+    this.apiUrl = apiUrl;
+  }
+  async request(path, options = {}) {
+    const { method = "GET", body, params, timeout = 3e4 } = options;
+    const url = new URL(path, this.apiUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      if (attempt > 0) {
+        const delay = RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 1);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      try {
+        const response = await fetch(url.toString(), {
+          method,
+          headers: {
+            "Authorization": `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+            "User-Agent": "betterness-cli/0.1.0",
+            "Accept": "application/json"
+          },
+          body: body ? JSON.stringify(body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          if (attempt < MAX_RETRIES && RETRYABLE_STATUS_CODES.has(response.status)) {
+            lastError = new CliError(`Request failed with status ${response.status}`, `HTTP_${response.status}`);
+            continue;
+          }
+          await this.handleErrorResponse(response);
+        }
+        const text = await response.text();
+        if (!text) return void 0;
+        return JSON.parse(text);
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof CliError) throw error;
+        if (error instanceof Error && error.name === "AbortError") {
+          lastError = new CliError(`Request timed out after ${timeout}ms: ${method} ${path}`, "TIMEOUT");
+          if (attempt < MAX_RETRIES) continue;
+          throw lastError;
+        }
+        lastError = new CliError(`Network error: ${error instanceof Error ? error.message : "Unknown error"}`, "NETWORK_ERROR");
+        if (attempt < MAX_RETRIES) continue;
+      }
+    }
+    throw lastError;
+  }
+  async get(path, params, schema) {
+    const raw = await this.request(path, { method: "GET", params });
+    return this.unwrap(raw, schema);
+  }
+  async post(path, body, params, schema) {
+    const raw = await this.request(path, { method: "POST", body, params });
+    return this.unwrap(raw, schema);
+  }
+  async put(path, body, schema) {
+    const raw = await this.request(path, { method: "PUT", body });
+    return this.unwrap(raw, schema);
+  }
+  async delete(path, schema) {
+    const raw = await this.request(path, { method: "DELETE" });
+    return this.unwrap(raw, schema);
+  }
+  async upload(path, filePath, fieldName = "file", schema) {
+    const { readFileSync: readFileSync2 } = await import("fs");
+    const { basename, extname } = await import("path");
+    const buffer = readFileSync2(filePath);
+    const fileName = basename(filePath);
+    const ext = extname(filePath).toLowerCase();
+    const mimeType = ext === ".pdf" ? "application/pdf" : "application/octet-stream";
+    const formData = new FormData();
+    formData.append(fieldName, new Blob([buffer], { type: mimeType }), fileName);
+    const url = new URL(path, this.apiUrl);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 6e4);
+    try {
+      const response = await fetch(url.toString(), {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`,
+          "User-Agent": "betterness-cli/0.1.0",
+          "Accept": "application/json"
+        },
+        body: formData,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
+      const text = await response.text();
+      if (!text) return void 0;
+      const raw = JSON.parse(text);
+      return this.unwrap(raw, schema);
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof CliError) throw error;
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new CliError("Upload timed out after 60s", "TIMEOUT");
+      }
+      throw new CliError(`Upload failed: ${error instanceof Error ? error.message : "Unknown error"}`, "NETWORK_ERROR");
+    }
+  }
+  unwrap(result, schema) {
+    if (!result.success) {
+      throw new CliError(result.message ?? "Request failed", result.errorCode ?? "API_ERROR");
+    }
+    if (schema) {
+      const parsed = schema.safeParse(result.content);
+      if (!parsed.success) {
+        throw new CliError(
+          `Unexpected response shape: ${parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")}`,
+          "VALIDATION_ERROR"
+        );
+      }
+      return parsed.data;
+    }
+    return result.content;
+  }
+  async handleErrorResponse(response) {
+    let errorBody;
+    try {
+      errorBody = await response.text();
+    } catch {
+      errorBody = "";
+    }
+    let message;
+    let code;
+    switch (response.status) {
+      case 401:
+        code = "AUTH_UNAUTHORIZED";
+        message = "Invalid or expired API key. Run 'betterness auth login' to re-authenticate.";
+        break;
+      case 403:
+        code = "AUTH_FORBIDDEN";
+        message = "Access denied. Your API key does not have permission for this operation.";
+        break;
+      case 404:
+        code = "NOT_FOUND";
+        message = "Resource not found.";
+        break;
+      case 429:
+        code = "RATE_LIMITED";
+        message = "Rate limit exceeded. Please wait before retrying.";
+        break;
+      default:
+        code = `HTTP_${response.status}`;
+        message = `Request failed with status ${response.status}`;
+        if (errorBody) {
+          try {
+            const parsed = JSON.parse(errorBody);
+            if (parsed.message) message = parsed.message;
+            if (parsed.error_description) message = parsed.error_description;
+          } catch {
+            if (errorBody.length < 200) message = errorBody;
+          }
+        }
+    }
+    throw new CliError(message, code);
+  }
+};
+
+// src/formatters/json.ts
+function formatJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+
+// src/formatters/table.ts
+function formatTable(rows, columns) {
+  if (rows.length === 0) {
+    return "No results.";
+  }
+  const cols = columns ?? inferColumns(rows);
+  const widths = calculateWidths(rows, cols);
+  const header = cols.map((col, i) => padCell(col.label, widths[i], col.align)).join("  ");
+  const separator = cols.map((_, i) => "-".repeat(widths[i])).join("  ");
+  const body = rows.map(
+    (row) => cols.map((col, i) => padCell(String(row[col.key] ?? ""), widths[i], col.align)).join("  ")
+  );
+  return [header, separator, ...body].join("\n");
+}
+function formatKeyValue(data) {
+  const entries = Object.entries(data).filter(([_, v]) => v !== null && v !== void 0);
+  const maxKeyLen = Math.max(...entries.map(([k]) => k.length));
+  return entries.map(([key, value]) => `${key.padEnd(maxKeyLen)}  ${String(value)}`).join("\n");
+}
+function inferColumns(rows) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      keys.add(key);
+    }
+  }
+  return Array.from(keys).map((key) => ({
+    key,
+    label: key.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase()).trim()
+  }));
+}
+function calculateWidths(rows, columns) {
+  return columns.map((col) => {
+    if (col.width) return col.width;
+    const headerLen = col.label.length;
+    const maxDataLen = rows.reduce((max, row) => {
+      const val = String(row[col.key] ?? "");
+      return Math.max(max, val.length);
+    }, 0);
+    return Math.min(Math.max(headerLen, maxDataLen), 60);
+  });
+}
+function padCell(value, width, align) {
+  const truncated = value.length > width ? value.slice(0, width - 1) + "\u2026" : value;
+  return align === "right" ? truncated.padStart(width) : truncated.padEnd(width);
+}
+
+// src/formatters/markdown.ts
+function formatMarkdownTable(rows, keys) {
+  if (rows.length === 0) {
+    return "*No results.*";
+  }
+  const columns = keys ?? Object.keys(rows[0]);
+  const header = "| " + columns.join(" | ") + " |";
+  const separator = "| " + columns.map(() => "---").join(" | ") + " |";
+  const body = rows.map(
+    (row) => "| " + columns.map((col) => String(row[col] ?? "")).join(" | ") + " |"
+  );
+  return [header, separator, ...body].join("\n");
+}
+function formatMarkdownKeyValue(data) {
+  return Object.entries(data).filter(([_, v]) => v !== null && v !== void 0).map(([key, value]) => `**${key}:** ${String(value)}`).join("\n\n");
+}
+
+// src/formatters/output.ts
+function isQuiet(cmd) {
+  return cmd.optsWithGlobals().quiet === true;
+}
+function getOutputFormat(cmd) {
+  const opts = cmd.optsWithGlobals();
+  if (opts.json) return "json";
+  if (opts.markdown) return "markdown";
+  const env = process.env.BETTERNESS_OUTPUT?.toLowerCase();
+  if (env === "json") return "json";
+  if (env === "markdown") return "markdown";
+  return "table";
+}
+function outputList(cmd, rows, columns) {
+  if (isQuiet(cmd)) return;
+  const format = getOutputFormat(cmd);
+  switch (format) {
+    case "json":
+      console.log(formatJson(rows));
+      break;
+    case "markdown":
+      console.log(formatMarkdownTable(rows, columns?.map((c) => c.key)));
+      break;
+    case "table":
+      console.log(formatTable(rows, columns));
+      break;
+  }
+}
+function outputRecord(cmd, data) {
+  if (isQuiet(cmd)) return;
+  const format = getOutputFormat(cmd);
+  switch (format) {
+    case "json":
+      console.log(formatJson(data));
+      break;
+    case "markdown":
+      console.log(formatMarkdownKeyValue(data));
+      break;
+    case "table":
+      console.log(formatKeyValue(data));
+      break;
+  }
+}
+function outputError(error) {
+  if (error instanceof CliError) {
+    console.error(JSON.stringify(error.toJSON(), null, 2));
+    process.exit(error.code === "AUTH_MISSING" || error.code === "AUTH_UNAUTHORIZED" ? 2 : 1);
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(JSON.stringify({ error: { code: "UNKNOWN", message } }, null, 2));
+  process.exit(1);
+}
+
+// src/types/api.ts
+import { z } from "zod";
+var simplePageSchema = (itemSchema) => z.object({
+  content: z.array(itemSchema),
+  number: z.number(),
+  last: z.boolean(),
+  totalResults: z.number()
+});
+var springPageSchema = (itemSchema) => z.object({
+  content: z.array(itemSchema),
+  totalPages: z.number(),
+  totalElements: z.number(),
+  number: z.number(),
+  size: z.number(),
+  numberOfElements: z.number(),
+  first: z.boolean(),
+  last: z.boolean(),
+  empty: z.boolean()
+});
+var homeAddressSchema = z.object({
+  fullAddress: z.string().nullable().optional(),
+  city: z.string().nullable().optional(),
+  state: z.string().nullable().optional(),
+  zipCode: z.string().nullable().optional(),
+  streetNumber: z.string().nullable().optional(),
+  streetName: z.string().nullable().optional(),
+  country: z.string().nullable().optional(),
+  latitude: z.number().nullable().optional(),
+  longitude: z.number().nullable().optional()
+});
+var vitalConnectionSchema = z.object({
+  externalId: z.string(),
+  provider: z.string(),
+  disabledAt: z.string().nullable().optional()
+});
+var betternessUserSchema = z.object({
+  externalId: z.string(),
+  firstName: z.string().nullable().optional(),
+  lastName: z.string().nullable().optional(),
+  birthDate: z.string().nullable().optional(),
+  location: z.string().nullable().optional(),
+  phone: z.string().nullable().optional(),
+  phoneDialCode: z.string().nullable().optional(),
+  email: z.string().nullable().optional(),
+  gender: z.string().nullable().optional(),
+  type: z.string().nullable().optional(),
+  fullName: z.string().nullable().optional(),
+  avatarUrl: z.string().nullable().optional(),
+  createdAtUnixSeconds: z.number().nullable().optional(),
+  onboardingStep: z.string().nullable().optional(),
+  vitalId: z.string().nullable().optional(),
+  vitalConnections: z.array(vitalConnectionSchema).nullable().optional(),
+  interests: z.array(z.string()).nullable().optional(),
+  phoneVerified: z.boolean().nullable().optional(),
+  homeAddressV2: homeAddressSchema.nullable().optional(),
+  heightCm: z.number().nullable().optional(),
+  weight: z.number().nullable().optional()
+}).passthrough();
+var loincSchema = z.object({
+  externalId: z.string().nullable().optional(),
+  slug: z.string().nullable().optional(),
+  code: z.string().nullable().optional(),
+  name: z.string().nullable().optional(),
+  description: z.string().nullable().optional(),
+  categories: z.array(z.string()).nullable().optional(),
+  syncedAt: z.string().nullable().optional()
+}).passthrough();
+var biomarkerSchema = z.object({
+  externalId: z.string(),
+  name: z.string(),
+  category: z.string().nullable().optional(),
+  type: z.string().nullable().optional(),
+  loinc: loincSchema.nullable().optional()
+}).passthrough();
+var biomarkerResultSchema = z.object({
+  externalId: z.string(),
+  biomarker: biomarkerSchema,
+  sourceCreationDate: z.string().nullable().optional(),
+  value: z.number().nullable().optional(),
+  unit: z.string().nullable().optional(),
+  range: z.string().nullable().optional(),
+  minRangeValue: z.number().nullable().optional(),
+  maxRangeValue: z.number().nullable().optional(),
+  metadataType: z.string().nullable().optional(),
+  metadataInterpretation: z.string().nullable().optional(),
+  metadataResult: z.string().nullable().optional(),
+  healthRecordExternalId: z.string().nullable().optional(),
+  dateCollected: z.string().nullable().optional()
+});
+var markerValueSchema = z.object({
+  loincCode: z.string().nullable().optional(),
+  label: z.string().nullable().optional(),
+  rawValue: z.number().nullable().optional(),
+  rawUnit: z.string().nullable().optional(),
+  standardizedValue: z.number().nullable().optional(),
+  standardizedUnit: z.string().nullable().optional(),
+  isOptimal: z.boolean().nullable().optional()
+});
+var biologicalAgeResultSchema = z.object({
+  externalId: z.string(),
+  calculatedAt: z.string().nullable().optional(),
+  measurementDate: z.string().nullable().optional(),
+  currentAge: z.number().nullable().optional(),
+  biologicalAge: z.number().nullable().optional(),
+  source: z.string().nullable().optional(),
+  markers: z.array(markerValueSchema).nullable().optional()
+});
+var labTestSchema = z.object({
+  externalId: z.string(),
+  objectKey: z.string().nullable().optional(),
+  integrationProductId: z.string().nullable().optional(),
+  name: z.string(),
+  description: z.string().nullable().optional(),
+  lab: z.string().nullable().optional(),
+  price: z.number().nullable().optional(),
+  imageUrl: z.string().nullable().optional(),
+  isPopular: z.boolean().nullable().optional()
+}).passthrough();
+var paymentMethodSchema = z.object({
+  externalId: z.string(),
+  brand: z.string().nullable().optional(),
+  last4: z.string().nullable().optional(),
+  expiresAt: z.string().nullable().optional(),
+  id: z.string().nullable().optional(),
+  active: z.boolean().nullable().optional()
+});
+var healthRecordSchema = z.object({
+  externalId: z.string(),
+  source: z.string().nullable().optional()
+}).passthrough();
+var connectionsResponseSchema = z.object({
+  connections: z.array(z.string()),
+  nativeConnections: z.array(z.object({
+    provider: z.string(),
+    deviceId: z.string().nullable().optional(),
+    syncEnabled: z.boolean().nullable().optional()
+  }).passthrough())
+}).passthrough();
+
+// src/commands/auth.ts
+function registerAuthCommands(program2) {
+  const auth = program2.command("auth").description("Manage authentication");
+  auth.command("login").description("Save API key for authentication").option("--key <apiKey>", "API key to save (if not provided, will prompt)").action(async (opts) => {
+    try {
+      let apiKey = opts.key;
+      if (!apiKey) {
+        const rl = createInterface({ input: stdin, output: stdout });
+        apiKey = await rl.question("Enter your Betterness API key: ");
+        rl.close();
+      }
+      if (!apiKey || !apiKey.trim()) {
+        console.error("API key cannot be empty.");
+        process.exit(1);
+      }
+      apiKey = apiKey.trim();
+      console.error("Verifying...");
+      const client = new ApiClient({ apiKey });
+      const user = await client.get("/api/betterness-user/detail", void 0, betternessUserSchema);
+      saveCredentials({
+        apiKey,
+        email: user.email ?? void 0,
+        name: user.firstName ?? void 0
+      });
+      console.log(`Logged in as: ${user.firstName ?? "Unknown"} (${user.email ?? "no email"})`);
+      console.log("Credentials saved to ~/.betterness/credentials.json");
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  auth.command("logout").description("Remove stored credentials").action(() => {
+    const deleted = deleteCredentials();
+    if (deleted) {
+      console.log("Credentials removed.");
+    } else {
+      console.log("No stored credentials found.");
+    }
+  });
+  auth.command("whoami").description("Show the currently authenticated user").action(async (_, cmd) => {
+    try {
+      const parentOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: parentOpts.apiKey });
+      const user = await client.get("/api/betterness-user/detail", void 0, betternessUserSchema);
+      outputRecord(cmd, {
+        name: user.fullName ?? user.firstName,
+        email: user.email,
+        id: user.externalId
+      });
+    } catch (error) {
+      outputError(error);
+    }
+  });
+}
+
+// src/commands/profile.ts
+function registerProfileCommands(program2) {
+  const profile = program2.command("profile").description("User profile information");
+  profile.command("get").description("Retrieve current user profile (name, email, phone, gender, DOB, address)").action(async (_, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const user = await client.get(
+        "/api/betterness-user/detail",
+        void 0,
+        betternessUserSchema
+      );
+      outputRecord(cmd, {
+        firstName: user.firstName,
+        lastName: user.lastName,
+        email: user.email,
+        phone: user.phone,
+        gender: user.gender,
+        birthDate: user.birthDate,
+        heightCm: user.heightCm,
+        weight: user.weight,
+        homeAddress: user.homeAddressV2?.fullAddress,
+        city: user.homeAddressV2?.city,
+        state: user.homeAddressV2?.state,
+        zipCode: user.homeAddressV2?.zipCode,
+        country: user.homeAddressV2?.country
+      });
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  profile.command("update").description("Update profile information (only provided fields are changed)").option("--first-name <name>", "First name").option("--last-name <name>", "Last name").option("--phone <number>", "Phone number without dial code").option("--phone-dial-code <code>", "Phone dial code (e.g. +1, +44)").option("--gender <value>", "Gender: MALE, FEMALE, OTHER, or PREF_NOT").option("--birth-date <YYYY-MM-DD>", "Date of birth").option("--address <street>", "Home street address").option("--city <city>", "City").option("--state <state>", "State or province").option("--zip-code <zip>", "ZIP or postal code").option("--country <code>", "Country (e.g. US, GB)").option("--dry-run", "Preview changes without applying").action(async (opts, cmd) => {
+    try {
+      const dto = {};
+      if (opts.firstName) dto.firstName = opts.firstName;
+      if (opts.lastName) dto.lastName = opts.lastName;
+      if (opts.phone) dto.phone = opts.phone;
+      if (opts.phoneDialCode) dto.phoneDialCode = opts.phoneDialCode;
+      if (opts.gender) dto.gender = opts.gender;
+      if (opts.birthDate) dto.birthDate = opts.birthDate;
+      const hasAddress = opts.address || opts.city || opts.state || opts.zipCode || opts.country;
+      if (hasAddress) {
+        const address = {};
+        if (opts.address) address.fullAddress = opts.address;
+        if (opts.city) address.city = opts.city;
+        if (opts.state) address.state = opts.state;
+        if (opts.zipCode) address.zipCode = opts.zipCode;
+        if (opts.country) address.country = opts.country;
+        dto.homeAddressV2 = address;
+      }
+      if (Object.keys(dto).length === 0) {
+        console.log("No fields provided to update. Use --help to see available options.");
+        return;
+      }
+      if (opts.dryRun) {
+        outputRecord(cmd, { action: "profile update", fields: dto, note: "Dry run \u2014 profile will not be updated." });
+        return;
+      }
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      await client.put(
+        "/api/betterness-user/personal-details",
+        dto
+      );
+      console.log("Profile updated successfully.");
+    } catch (error) {
+      outputError(error);
+    }
+  });
+}
+
+// src/commands/biomarkers.ts
+import { z as z2 } from "zod";
+var biomarkerColumns = [
+  { key: "name", label: "Name", width: 25 },
+  { key: "value", label: "Value", width: 10, align: "right" },
+  { key: "unit", label: "Unit", width: 10 },
+  { key: "range", label: "Range", width: 15 },
+  { key: "date", label: "Date", width: 12 }
+];
+function mapBiomarkerRows(results) {
+  return results.map((r) => ({
+    name: r.biomarker.name,
+    value: r.value,
+    unit: r.unit,
+    range: r.range,
+    date: r.dateCollected
+  }));
+}
+function registerBiomarkersCommands(program2) {
+  const biomarkers = program2.command("biomarkers").description("Biomarker lab results and LOINC codes");
+  biomarkers.command("search").description("Search and filter biomarker lab results").option("--name <text>", "Filter by biomarker name").option("--loinc-code <code>", "Filter by LOINC code").option("--start-date <YYYY-MM-DD>", "Start date (ISO-8601)").option("--end-date <YYYY-MM-DD>", "End date (ISO-8601)").option("--categories <list>", "Comma-separated category filter").option("--range <type>", "Range filter: OPTIMAL, AVERAGE, OUT_OF_RANGE, UNKNOWN").option("--limit <n>", "Maximum number of results", "20").action(async (opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const params = { size: opts.limit };
+      if (opts.name) params.name = opts.name;
+      if (opts.loincCode) params.loincCode = opts.loincCode;
+      if (opts.startDate) params.startDate = opts.startDate;
+      if (opts.endDate) params.endDate = opts.endDate;
+      if (opts.categories) params.categories = opts.categories;
+      if (opts.range) params.range = opts.range;
+      const results = await client.get(
+        "/api/biomarker-result/all",
+        params,
+        z2.array(biomarkerResultSchema)
+      );
+      outputList(cmd, mapBiomarkerRows(results), biomarkerColumns);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  biomarkers.command("loinc-codes").description("List all available LOINC codes for biomarker identification").action(async (_, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const loincs = await client.get(
+        "/api/health-record/active-loinc",
+        void 0,
+        z2.array(loincSchema)
+      );
+      outputList(cmd, loincs.map((l) => ({
+        code: l.code,
+        name: l.name,
+        categories: l.categories?.join(", ") ?? ""
+      })), [
+        { key: "code", label: "LOINC Code", width: 12 },
+        { key: "name", label: "Name", width: 35 },
+        { key: "categories", label: "Categories", width: 30 }
+      ]);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+}
+
+// src/commands/biological-age.ts
+import { z as z3 } from "zod";
+function registerBiologicalAgeCommands(program2) {
+  const bioAge = program2.command("biological-age").description("Biological age calculations and history");
+  bioAge.command("get").description("Get biological age history with biomarker values").option("--limit <n>", "Maximum number of results", "10").action(async (opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const results = await client.get("/api/biological-age", {
+        size: opts.limit,
+        sort: "date,desc"
+      }, z3.array(biologicalAgeResultSchema));
+      if (results.length === 0) {
+        console.log("No biological age data found.");
+        return;
+      }
+      outputList(cmd, results.map((r) => ({
+        currentAge: r.currentAge,
+        biologicalAge: r.biologicalAge,
+        source: r.source,
+        measurementDate: r.measurementDate,
+        calculatedAt: r.calculatedAt
+      })), [
+        { key: "currentAge", label: "Current Age", width: 12, align: "right" },
+        { key: "biologicalAge", label: "Bio Age", width: 10, align: "right" },
+        { key: "source", label: "Source", width: 15 },
+        { key: "measurementDate", label: "Date", width: 12 }
+      ]);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+}
+
+// src/commands/helpers/trends.ts
+function todayIso() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function defaultTimezone() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+function dateRange(from, to) {
+  const dates = [];
+  const current = /* @__PURE__ */ new Date(from + "T00:00:00");
+  const end = /* @__PURE__ */ new Date(to + "T00:00:00");
+  while (current <= end) {
+    dates.push(current.toISOString().slice(0, 10));
+    current.setDate(current.getDate() + 1);
+  }
+  return dates;
+}
+function flattenTrends(data, categoryFilter) {
+  const rows = [];
+  for (const [provider, categories] of Object.entries(data)) {
+    if (!categories || typeof categories !== "object") continue;
+    for (const [category, goalTypes] of Object.entries(categories)) {
+      if (categoryFilter && category !== categoryFilter) continue;
+      if (!goalTypes || typeof goalTypes !== "object") continue;
+      for (const [_goalType, goals] of Object.entries(goalTypes)) {
+        if (!goals || typeof goals !== "object") continue;
+        for (const [goalKey, trend] of Object.entries(goals)) {
+          if (!trend || typeof trend !== "object") continue;
+          rows.push({ provider, goalKey, ...trend });
+        }
+      }
+    }
+  }
+  return rows;
+}
+async function fetchTrendsForRange(client, from, to, zoneId, categoryFilter) {
+  const dates = dateRange(from, to);
+  const allRows = [];
+  for (const day of dates) {
+    const data = await client.get("/api/goal-entry/trends", {
+      day,
+      zoneId,
+      periodType: "DAILY"
+    });
+    const rows = flattenTrends(data, categoryFilter);
+    for (const row of rows) {
+      row.date = day;
+    }
+    allRows.push(...rows);
+  }
+  return allRows;
+}
+function printTrendRows(rows) {
+  for (const row of rows) {
+    console.log(`--- ${row.goalKey} (${row.provider}) ---`);
+    const display = { ...row };
+    delete display.provider;
+    delete display.goalKey;
+    const entries = Object.entries(display).filter(([_, v]) => v !== null && v !== void 0);
+    if (entries.length === 0) continue;
+    const maxKeyLen = Math.max(...entries.map(([k]) => k.length));
+    for (const [key, value] of entries) {
+      console.log(`  ${key.padEnd(maxKeyLen)}  ${String(value)}`);
+    }
+    console.log();
+  }
+}
+function registerHealthDataCommand(parent, name, description, categoryFilter) {
+  parent.command(name).description(description).option("--from <YYYY-MM-DD>", "Start date", todayIso()).option("--to <YYYY-MM-DD>", "End date").option("--timezone <tz>", "IANA timezone", defaultTimezone()).action(async (opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const to = opts.to ?? opts.from;
+      const rows = await fetchTrendsForRange(client, opts.from, to, opts.timezone, categoryFilter);
+      if (getOutputFormat(cmd) === "json") {
+        console.log(formatJson(rows));
+        return;
+      }
+      if (rows.length === 0) {
+        console.log(`No ${name} data found for ${opts.from}${to !== opts.from ? ` to ${to}` : ""}.`);
+        return;
+      }
+      printTrendRows(rows);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+}
+
+// src/commands/activity.ts
+function registerActivityCommands(program2) {
+  const activity = program2.command("activity").description("Activity and workout data from connected wearables");
+  registerHealthDataCommand(
+    activity,
+    "get",
+    "Retrieve activity and workout data (steps, distance, calories, VO2 max, workouts)",
+    "ACTIVITY"
+  );
+}
+
+// src/commands/sleep.ts
+import { z as z4 } from "zod";
+var sleepStageEntrySchema = z4.object({
+  stage: z4.string(),
+  start: z4.string(),
+  end: z4.string(),
+  durationSeconds: z4.number()
+}).passthrough();
+var sleepNightSchema = z4.object({
+  date: z4.string(),
+  stages: z4.array(sleepStageEntrySchema)
+}).passthrough();
+var sleepStagesResponseSchema = z4.object({
+  source: z4.string(),
+  nights: z4.array(sleepNightSchema)
+}).passthrough();
+function formatDuration(totalSeconds) {
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  if (hours > 0 && minutes > 0) return `${hours}h ${String(minutes).padStart(2, "0")}m`;
+  if (hours > 0) return `${hours}h 00m`;
+  return `${minutes}m`;
+}
+function registerSleepCommands(program2) {
+  const sleep = program2.command("sleep").description("Sleep data from connected wearables");
+  registerHealthDataCommand(
+    sleep,
+    "get",
+    "Retrieve nightly sleep data (time in bed, total sleep, sleep stage breakdown)",
+    "SLEEP"
+  );
+  sleep.command("stages").description("Retrieve minute-by-minute sleep stage transitions (Deep, Core, REM, Awake)").option("--from <YYYY-MM-DD>", "Start date", todayIso()).option("--to <YYYY-MM-DD>", "End date").option("--timezone <tz>", "IANA timezone", defaultTimezone()).action(async (opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const to = opts.to ?? opts.from;
+      const result = await client.get(
+        "/api/goal-entry/sleep-stages",
+        { from: opts.from, to, zoneId: opts.timezone },
+        sleepStagesResponseSchema
+      );
+      if (getOutputFormat(cmd) === "json") {
+        console.log(formatJson(result));
+        return;
+      }
+      if (result.nights.length === 0) {
+        console.log(`No sleep stage data found for ${opts.from}${to !== opts.from ? ` to ${to}` : ""}.`);
+        return;
+      }
+      console.log(`Source: ${result.source}
+`);
+      for (const night of result.nights) {
+        console.log(`--- ${night.date} ---`);
+        for (const stage of night.stages) {
+          console.log(`  ${stage.start} - ${stage.end}  ${stage.stage.padEnd(7)} ${formatDuration(stage.durationSeconds)}`);
+        }
+        console.log();
+      }
+    } catch (error) {
+      outputError(error);
+    }
+  });
+}
+
+// src/commands/vitals.ts
+function registerVitalsCommands(program2) {
+  const vitals = program2.command("vitals").description("Vital signs from connected wearables");
+  registerHealthDataCommand(
+    vitals,
+    "get",
+    "Retrieve vital signs (heart rate, HRV, blood pressure, SpO2, glucose, respiratory rate)",
+    "VITALS"
+  );
+}
+
+// src/commands/body-composition.ts
+function registerBodyCompositionCommands(program2) {
+  const bodyComp = program2.command("body-composition").description("Body composition data from connected wearables");
+  registerHealthDataCommand(
+    bodyComp,
+    "get",
+    "Retrieve body composition (weight, body fat %, muscle mass, BMI, waist circumference)",
+    "BODY"
+  );
+}
+
+// src/commands/connected-devices.ts
+import { z as z5 } from "zod";
+var availableIntegrationSchema = z5.object({
+  key: z5.string(),
+  name: z5.string(),
+  description: z5.string()
+}).passthrough();
+function registerConnectedDevicesCommands(program2) {
+  const devices = program2.command("connected-devices").description("Health device integrations and wearable connections");
+  devices.command("list").description("List all connected health devices and wearables").action(async (_, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const result = await client.get(
+        "/api/vital/user/connections",
+        void 0,
+        connectionsResponseSchema
+      );
+      const rows = [];
+      for (const native of result.nativeConnections) {
+        rows.push({
+          provider: native.provider,
+          type: "native",
+          syncEnabled: native.syncEnabled ?? false,
+          deviceId: native.deviceId ?? ""
+        });
+      }
+      for (const slug of result.connections) {
+        if (!rows.some((r) => r.provider === slug)) {
+          rows.push({
+            provider: slug,
+            type: "cloud",
+            syncEnabled: true,
+            deviceId: ""
+          });
+        }
+      }
+      if (rows.length === 0) {
+        console.log("No connected devices found.");
+        return;
+      }
+      outputList(cmd, rows, [
+        { key: "provider", label: "Provider", width: 20 },
+        { key: "type", label: "Type", width: 10 },
+        { key: "syncEnabled", label: "Sync", width: 8 },
+        { key: "deviceId", label: "Device ID", width: 25 }
+      ]);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  devices.command("available").description("List health device integrations the user can connect (not currently active)").action(async (_, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const available = await client.get(
+        "/api/vital/user/available-integrations",
+        void 0,
+        z5.array(availableIntegrationSchema)
+      );
+      if (available.length === 0) {
+        console.log("All available integrations are already connected.");
+        return;
+      }
+      outputList(cmd, available, [
+        { key: "key", label: "Integration Key", width: 22 },
+        { key: "name", label: "Name", width: 16 },
+        { key: "description", label: "Description", width: 60 }
+      ]);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  devices.command("link").description("Generate connection link for a web-based health device integration").requiredOption("--integration-key <key>", "Integration provider (GARMIN, OURA, WITHINGS, PELOTON, WAHOO, EIGHT_SLEEP)").action(async (opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const result = await client.post(
+        `/api/vital/user/link-token/${opts.integrationKey}`
+      );
+      outputRecord(cmd, result);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  devices.command("apple-health-code").description("Generate connection code for Apple HealthKit via Junction app").action(async (_, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const code = await client.post("/api/vital/user/ios-app-code");
+      outputRecord(cmd, { connectionCode: code });
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  devices.command("disconnect").description("Disconnect a health device integration").requiredOption("--integration-key <key>", "Integration provider to disconnect").option("--dry-run", "Preview the disconnection without executing").action(async (opts, cmd) => {
+    try {
+      if (opts.dryRun) {
+        outputRecord(cmd, { action: "connected-devices disconnect", integrationKey: opts.integrationKey, note: "Dry run \u2014 device will not be disconnected." });
+        return;
+      }
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      await client.delete(`/api/vital/user/connection/${opts.integrationKey}`);
+      console.log(`Disconnected ${opts.integrationKey} successfully.`);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+}
+
+// src/commands/lab-tests.ts
+import { z as z6 } from "zod";
+function registerLabTestsCommands(program2) {
+  const labTests = program2.command("lab-tests").description("Available lab tests for ordering");
+  labTests.command("list").description("List available lab tests with prices and included markers").option("--query <text>", "Search by name or description").option("--popular", "Only show popular tests").option("--loinc-slug <slug>", "Filter by LOINC slug").action(async (opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const params = {};
+      if (opts.query) params.slug = opts.query;
+      if (opts.popular) params.onlyPopular = true;
+      if (opts.loincSlug) params.loincSlug = opts.loincSlug;
+      const results = await client.get(
+        "/api/lab-test/all",
+        params,
+        z6.array(labTestSchema)
+      );
+      outputList(cmd, results.map((t) => ({
+        name: t.name,
+        lab: t.lab,
+        price: t.price,
+        isPopular: t.isPopular,
+        objectKey: t.objectKey
+      })), [
+        { key: "name", label: "Name", width: 35 },
+        { key: "lab", label: "Lab", width: 15 },
+        { key: "price", label: "Price", width: 10, align: "right" },
+        { key: "isPopular", label: "Popular", width: 8 },
+        { key: "objectKey", label: "Object Key", width: 20 }
+      ]);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+}
+
+// src/commands/lab-records.ts
+function registerLabRecordsCommands(program2) {
+  const labRecords = program2.command("lab-records").description("Lab records \u2014 uploaded results and purchased test orders");
+  labRecords.command("list").description("List lab records (both uploaded results and lab orders)").option("--limit <n>", "Results per page", "20").option("--page <n>", "Page number (zero-based)", "0").action(async (opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const page = await client.get(
+        "/api/health-record/all",
+        { page: opts.page, size: opts.limit },
+        springPageSchema(healthRecordSchema)
+      );
+      outputList(cmd, page.content.map((r) => {
+        const nested = r.result;
+        return {
+          externalId: nested?.externalId ?? r.externalId,
+          source: r.source
+        };
+      }), [
+        { key: "externalId", label: "ID", width: 30 },
+        { key: "source", label: "Source", width: 20 }
+      ]);
+      if (!page.last) {
+        console.error(`Page ${page.number + 1} of ${page.totalPages} (${page.totalElements} total records)`);
+      }
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  labRecords.command("detail").description("Get full detail of a lab record by external ID").requiredOption("--record-id <id>", "Lab record external ID").action(async (opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      let result;
+      try {
+        result = await client.get(
+          `/api/lab-result/${opts.recordId}`
+        );
+      } catch {
+        result = await client.get(
+          `/api/lab-order/${opts.recordId}`
+        );
+      }
+      outputRecord(cmd, result);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+}
+
+// src/commands/lab-orders.ts
+function registerLabOrdersCommands(program2) {
+  const labOrders = program2.command("lab-orders").description("Lab order management \u2014 scheduling, appointments, and service centers");
+  labOrders.command("initialize").description("Initialize a lab order for processing (order must be in Paid status)").requiredOption("--order-id <id>", "Lab order external ID").option("--dry-run", "Preview the action without executing").action(async (opts, cmd) => {
+    try {
+      if (opts.dryRun) {
+        outputRecord(cmd, { action: "lab-orders initialize", orderId: opts.orderId, note: "Dry run \u2014 order will not be initialized." });
+        return;
+      }
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const result = await client.post(
+        "/api/lab-test-order/initialize",
+        { order: opts.orderId }
+      );
+      outputRecord(cmd, result);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  labOrders.command("service-centers").description("Search lab service centers near a ZIP code").requiredOption("--zip-code <zip>", "ZIP code to search near").requiredOption("--order-id <id>", "Lab order external ID").option("--limit <n>", "Maximum results", "6").option("--offset <n>", "Pagination offset", "0").action(async (opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const results = await client.get(
+        "/api/lab-test-order/all-labs",
+        { zipCode: opts.zipCode, labOrderId: opts.orderId }
+      );
+      if (results.length === 0) {
+        console.log("No service centers found near this ZIP code.");
+        return;
+      }
+      outputList(cmd, results, [
+        { key: "name", label: "Name", width: 30 },
+        { key: "city", label: "City", width: 15 },
+        { key: "state", label: "State", width: 8 },
+        { key: "distance", label: "Distance", width: 10 },
+        { key: "siteCode", label: "Site Code", width: 12 }
+      ]);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  labOrders.command("slots").description("Get available appointment time slots at a service center").requiredOption("--site-code <code>", "Service center site code").requiredOption("--order-id <id>", "Lab order external ID").requiredOption("--timezone <tz>", "IANA timezone").option("--start-date <YYYY-MM-DD>", "Start date for slot search").option("--range-days <n>", "Number of days to search", "7").action(async (opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const params = {
+        siteCode: opts.siteCode,
+        labOrderId: opts.orderId,
+        timezone: opts.timezone
+      };
+      if (opts.startDate) params.startDate = opts.startDate;
+      if (opts.rangeDays) params.rangeDays = opts.rangeDays;
+      const results = await client.get(
+        "/api/lab-test-order/service-center-slots",
+        params
+      );
+      outputList(cmd, results, [
+        { key: "date", label: "Date", width: 12 },
+        { key: "slots", label: "Available Slots", width: 40 }
+      ]);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  labOrders.command("book").description("Book a blood draw appointment at a service center").requiredOption("--order-id <id>", "Lab order external ID").requiredOption("--booking-key <key>", "Booking key from slots command").requiredOption("--timezone <tz>", "IANA timezone").option("--dry-run", "Preview the booking without executing").action(async (opts, cmd) => {
+    try {
+      if (opts.dryRun) {
+        outputRecord(cmd, { action: "lab-orders book", orderId: opts.orderId, bookingKey: opts.bookingKey, timezone: opts.timezone, note: "Dry run \u2014 appointment will not be booked." });
+        return;
+      }
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const result = await client.post(
+        "/api/lab-test-order/book-appointment",
+        {
+          labOrderId: opts.orderId,
+          bookingKey: opts.bookingKey,
+          timeZone: opts.timezone,
+          toReschedule: false
+        }
+      );
+      outputRecord(cmd, result);
+      console.log("Appointment booked successfully.");
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  labOrders.command("reschedule").description("Reschedule an existing blood draw appointment").requiredOption("--order-id <id>", "Lab order external ID").requiredOption("--booking-key <key>", "New booking key from slots command").requiredOption("--timezone <tz>", "IANA timezone").option("--dry-run", "Preview the reschedule without executing").action(async (opts, cmd) => {
+    try {
+      if (opts.dryRun) {
+        outputRecord(cmd, { action: "lab-orders reschedule", orderId: opts.orderId, bookingKey: opts.bookingKey, timezone: opts.timezone, note: "Dry run \u2014 appointment will not be rescheduled." });
+        return;
+      }
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const result = await client.post(
+        "/api/lab-test-order/book-appointment",
+        {
+          labOrderId: opts.orderId,
+          bookingKey: opts.bookingKey,
+          timeZone: opts.timezone,
+          toReschedule: true
+        }
+      );
+      outputRecord(cmd, result);
+      console.log("Appointment rescheduled successfully.");
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  labOrders.command("cancel").description("Cancel a blood draw appointment (run without --reason-id to see available reasons)").requiredOption("--order-id <id>", "Lab order external ID").option("--reason-id <id>", "Cancellation reason ID").option("--dry-run", "Preview the cancellation without executing").action(async (opts, cmd) => {
+    try {
+      if (opts.dryRun) {
+        outputRecord(cmd, { action: "lab-orders cancel", orderId: opts.orderId, reasonId: opts.reasonId ?? null, note: "Dry run \u2014 appointment will not be cancelled." });
+        return;
+      }
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const result = await client.post(
+        "/api/appointment/cancel-appointment",
+        {
+          labOrderExternalId: opts.orderId,
+          reasonId: opts.reasonId
+        }
+      );
+      outputRecord(cmd, result);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+}
+
+// src/commands/lab-results.ts
+function registerLabResultsCommands(program2) {
+  const labResults = program2.command("lab-results").description("Lab result management \u2014 approve, update biomarkers, update metadata");
+  labResults.command("update-status").description("Update lab result status (APPROVE, ROLLBACK, or REPROCESS)").requiredOption("--result-id <id>", "Lab result external ID").requiredOption("--action <action>", "Action: APPROVE, ROLLBACK, or REPROCESS").action(async (opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const actionMap = {
+        APPROVE: "approve",
+        ROLLBACK: "rollback",
+        REPROCESS: "reprocess"
+      };
+      const action = actionMap[opts.action.toUpperCase()];
+      if (!action) {
+        console.error(`Invalid action: ${opts.action}. Valid: APPROVE, ROLLBACK, REPROCESS`);
+        process.exit(1);
+      }
+      await client.post(`/api/lab-result/${action}/${opts.resultId}`);
+      console.log(`Lab result ${opts.resultId} \u2014 ${opts.action.toUpperCase()} completed.`);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  labResults.command("update-biomarker").description("Update or delete a biomarker value within an uploaded lab result").requiredOption("--biomarker-id <id>", "Biomarker external ID").option("--action <action>", "Set to DELETE to remove the biomarker").option("--name <name>", "Biomarker name").option("--result <value>", "Biomarker value (e.g. '5.2', '120')").option("--unit <unit>", "Unit (e.g. 'mg/dL', 'ng/mL')").option("--min-range <n>", "Minimum range value").option("--max-range <n>", "Maximum range value").action(async (opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const body = {};
+      if (opts.name) body.name = opts.name;
+      if (opts.result) body.result = opts.result;
+      if (opts.unit) body.unit = opts.unit;
+      if (opts.minRange) body.minRangeValue = Number(opts.minRange);
+      if (opts.maxRange) body.maxRangeValue = Number(opts.maxRange);
+      const result = await client.put(
+        `/api/mocked-result/${opts.biomarkerId}`,
+        body
+      );
+      outputRecord(cmd, result);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  labResults.command("update-metadata").description("Update metadata of an uploaded lab result (patient info and test details)").requiredOption("--result-id <id>", "Lab result external ID").option("--patient-name <name>", "Patient name").option("--patient-sex <sex>", "Patient sex: MALE or FEMALE").option("--dob <date>", "Date of birth").option("--lab-name <name>", "Lab name").option("--ordering-physician <name>", "Ordering physician").option("--date-collected <date>", "Date collected (ISO-8601)").option("--fasting", "Mark as fasting test").action(async (opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const patientBody = {};
+      if (opts.patientName) patientBody.patientName = opts.patientName;
+      if (opts.patientSex) patientBody.patientSex = opts.patientSex;
+      if (opts.dob) patientBody.dob = opts.dob;
+      if (Object.keys(patientBody).length > 0) {
+        await client.put(`/api/lab-result/patient/${opts.resultId}`, patientBody);
+      }
+      const testBody = {};
+      if (opts.labName) testBody.labName = opts.labName;
+      if (opts.orderingPhysician) testBody.orderingPhysician = opts.orderingPhysician;
+      if (opts.dateCollected) testBody.dateCollected = opts.dateCollected;
+      if (opts.fasting !== void 0) testBody.fasting = opts.fasting;
+      if (Object.keys(testBody).length > 0) {
+        await client.put(`/api/lab-result/test-detail/${opts.resultId}`, testBody);
+      }
+      console.log(`Lab result ${opts.resultId} metadata updated.`);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  labResults.command("upload").description("Upload a lab result PDF for processing").requiredOption("--file <path>", "Path to the PDF file").action(async (opts, cmd) => {
+    try {
+      const { existsSync: existsSync2 } = await import("fs");
+      const { resolve } = await import("path");
+      const filePath = resolve(opts.file);
+      if (!existsSync2(filePath)) {
+        console.error(`File not found: ${filePath}`);
+        process.exit(1);
+      }
+      if (!filePath.toLowerCase().endsWith(".pdf")) {
+        console.error("Only PDF files are supported.");
+        process.exit(1);
+      }
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const result = await client.upload(
+        "/api/lab-result/agent-upload",
+        filePath
+      );
+      if (typeof result === "string") {
+        console.log(result);
+      } else {
+        outputRecord(cmd, result);
+      }
+    } catch (error) {
+      outputError(error);
+    }
+  });
+}
+
+// src/commands/purchases.ts
+import { z as z7 } from "zod";
+var checkoutResponseSchema = z7.object({
+  checkoutUrl: z7.string(),
+  testName: z7.string(),
+  originalPrice: z7.number().nullable().optional(),
+  finalPrice: z7.number().nullable().optional(),
+  discount: z7.string().nullable().optional(),
+  promotionCode: z7.string().nullable().optional()
+}).passthrough();
+function registerPurchasesCommands(program2) {
+  const purchases = program2.command("purchases").description("Lab test purchases and payment methods");
+  purchases.command("payment-methods").description("List saved payment methods (credit/debit cards)").action(async (_, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const results = await client.get(
+        "/api/payment-methods/all",
+        void 0,
+        z7.array(paymentMethodSchema)
+      );
+      if (results.length === 0) {
+        console.log("No saved payment methods found.");
+        return;
+      }
+      outputList(cmd, results.map((m) => ({
+        brand: m.brand,
+        last4: m.last4,
+        expiresAt: m.expiresAt,
+        active: m.active,
+        externalId: m.externalId
+      })), [
+        { key: "brand", label: "Brand", width: 15 },
+        { key: "last4", label: "Last 4", width: 8 },
+        { key: "expiresAt", label: "Expires", width: 12 },
+        { key: "active", label: "Active", width: 8 },
+        { key: "externalId", label: "ID", width: 20 }
+      ]);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  purchases.command("buy").description("Purchase a lab test using a saved payment method").requiredOption("--test-key <key>", "Lab test object key").requiredOption("--payment-method-id <id>", "Payment method external ID").option("--promo-code <code>", "Promotion code").option("--dry-run", "Preview what would be purchased without executing").action(async (opts, cmd) => {
+    try {
+      if (opts.dryRun) {
+        outputRecord(cmd, {
+          action: "purchases buy",
+          labTestObjectKey: opts.testKey,
+          paymentMethodExternalId: opts.paymentMethodId,
+          promotionCode: opts.promoCode ?? null,
+          note: "Dry run \u2014 no purchase will be made."
+        });
+        return;
+      }
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const result = await client.post(
+        "/api/purchase",
+        {
+          labTestObjectKey: opts.testKey,
+          paymentMethodExternalId: opts.paymentMethodId,
+          promotionCode: opts.promoCode
+        }
+      );
+      outputRecord(cmd, result);
+      console.log("Purchase completed successfully.");
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  purchases.command("checkout").description("Generate a Stripe Checkout payment link for a lab test (for users without saved cards)").requiredOption("--test-key <key>", "Lab test object key").requiredOption("--success-url <url>", "URL to redirect after successful payment").requiredOption("--cancel-url <url>", "URL to redirect if checkout is cancelled").option("--promo-code <code>", "Promotion code").option("--dry-run", "Preview the checkout request without executing").action(async (opts, cmd) => {
+    try {
+      if (opts.dryRun) {
+        outputRecord(cmd, {
+          action: "purchases checkout",
+          labTestObjectKey: opts.testKey,
+          successUrl: opts.successUrl,
+          cancelUrl: opts.cancelUrl,
+          promotionCode: opts.promoCode ?? null,
+          note: "Dry run \u2014 no checkout session will be created."
+        });
+        return;
+      }
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const result = await client.post(
+        "/api/purchase/checkout",
+        {
+          labTestObjectKey: opts.testKey,
+          successUrl: opts.successUrl,
+          cancelUrl: opts.cancelUrl,
+          promotionCode: opts.promoCode
+        },
+        void 0,
+        checkoutResponseSchema
+      );
+      outputRecord(cmd, result);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+}
+
+// src/commands/smart-listings.ts
+import { z as z8 } from "zod";
+var companySearchResultSchema = z8.object({
+  externalId: z8.string(),
+  name: z8.string().nullable().optional(),
+  description: z8.string().nullable().optional(),
+  city: z8.string().nullable().optional(),
+  state: z8.string().nullable().optional(),
+  avatarUrl: z8.string().nullable().optional(),
+  rating: z8.number().nullable().optional()
+}).passthrough();
+function registerSmartListingsCommands(program2) {
+  const smartListings = program2.command("smart-listings").description("Search and browse wellness providers (SmartListings)");
+  smartListings.command("search").description("Search SmartListings by name, description, tags, or location").option("--query <text>", "Text search query").option("--lat <n>", "Latitude for proximity search").option("--lng <n>", "Longitude for proximity search").option("--radius <km>", "Radius in km (1, 2, 5, 10, 20)").option("--following", "Only show followed providers").option("--limit <n>", "Results per page", "10").option("--page <n>", "Page number (zero-based)", "0").action(async (opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const body = {};
+      if (opts.query) body.search = opts.query;
+      if (opts.lat) body.latitude = Number(opts.lat);
+      if (opts.lng) body.longitude = Number(opts.lng);
+      if (opts.radius) body.radiusKm = Number(opts.radius);
+      if (opts.following) body.onlyFollowing = true;
+      const page = await client.post(
+        "/api/company/partners/filtered",
+        body,
+        { page: opts.page, size: opts.limit },
+        simplePageSchema(companySearchResultSchema)
+      );
+      outputList(cmd, page.content.map((c) => ({
+        name: c.name,
+        city: c.city,
+        state: c.state,
+        rating: c.rating,
+        externalId: c.externalId
+      })), [
+        { key: "name", label: "Name", width: 30 },
+        { key: "city", label: "City", width: 15 },
+        { key: "state", label: "State", width: 8 },
+        { key: "rating", label: "Rating", width: 8, align: "right" },
+        { key: "externalId", label: "ID", width: 20 }
+      ]);
+      if (!page.last) {
+        console.error(`Page ${page.number + 1} \u2014 ${page.totalResults} total results`);
+      }
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  smartListings.command("detail").description("Get full details of a SmartListing by ID").requiredOption("--id <externalId>", "SmartListing external ID").action(async (opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const result = await client.get(
+        `/api/company/detail/${opts.id}`
+      );
+      outputRecord(cmd, result);
+    } catch (error) {
+      outputError(error);
+    }
+  });
+}
+
+// src/commands/workflow.ts
+import { z as z9 } from "zod";
+function isOutOfRange(r) {
+  if (r.value == null) return false;
+  if (r.minRangeValue != null && r.value < r.minRangeValue) return true;
+  if (r.maxRangeValue != null && r.value > r.maxRangeValue) return true;
+  return false;
+}
+function rangeLabel(r) {
+  if (r.value == null) return "";
+  if (r.minRangeValue != null && r.value < r.minRangeValue) return "below range";
+  if (r.maxRangeValue != null && r.value > r.maxRangeValue) return "above range";
+  return "";
+}
+function deviceNames(devices) {
+  const names = devices.nativeConnections.map((c) => c.provider);
+  for (const slug of devices.connections) {
+    if (!names.includes(slug)) names.push(slug);
+  }
+  return names;
+}
+async function fetchDailyBrief(client, biomarkerLimit) {
+  const [profile, bioAgeList, biomarkers, devices] = await Promise.all([
+    client.get("/api/betterness-user/detail", void 0, betternessUserSchema),
+    client.get("/api/biological-age", { size: 1, sort: "date,desc" }, z9.array(biologicalAgeResultSchema)),
+    client.get("/api/biomarker-result/all", { size: biomarkerLimit }, z9.array(biomarkerResultSchema)),
+    client.get("/api/vital/user/connections", void 0, connectionsResponseSchema)
+  ]);
+  const outOfRange = biomarkers.filter(isOutOfRange);
+  const bioAge = bioAgeList.length > 0 ? bioAgeList[0] : null;
+  return {
+    user: {
+      firstName: profile.firstName ?? null,
+      lastName: profile.lastName ?? null,
+      email: profile.email ?? null
+    },
+    biologicalAge: bioAge ? {
+      currentAge: bioAge.currentAge ?? null,
+      biologicalAge: bioAge.biologicalAge ?? null,
+      source: bioAge.source ?? null,
+      measurementDate: bioAge.measurementDate ?? null
+    } : null,
+    biomarkersOutOfRange: outOfRange.map((r) => ({
+      name: r.biomarker.name,
+      value: r.value ?? null,
+      unit: r.unit ?? null,
+      minRange: r.minRangeValue ?? null,
+      maxRange: r.maxRangeValue ?? null,
+      dateCollected: r.dateCollected ?? null
+    })),
+    connectedDevices: deviceNames(devices),
+    recentBiomarkerCount: biomarkers.length
+  };
+}
+function printDailyBrief(brief) {
+  const date = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", { year: "numeric", month: "long", day: "numeric" });
+  console.log(`DAILY BRIEF \u2014 ${date}`);
+  console.log(`User: ${[brief.user.firstName, brief.user.lastName].filter(Boolean).join(" ") || "Unknown"}`);
+  console.log();
+  if (brief.biologicalAge) {
+    const ba = brief.biologicalAge;
+    if (ba.biologicalAge != null && ba.currentAge != null) {
+      console.log(`Biological Age: ${ba.biologicalAge} (chronological: ${ba.currentAge})`);
+    } else if (ba.biologicalAge != null) {
+      console.log(`Biological Age: ${ba.biologicalAge}`);
+    } else {
+      console.log("Biological Age: No data available");
+    }
+    if (ba.measurementDate) console.log(`  Measured: ${ba.measurementDate}`);
+    console.log();
+  }
+  if (brief.biomarkersOutOfRange.length > 0) {
+    console.log(`Biomarkers out of range (${brief.biomarkersOutOfRange.length}):`);
+    for (const b of brief.biomarkersOutOfRange) {
+      const val = b.value != null ? `${b.value}${b.unit ? " " + b.unit : ""}` : "N/A";
+      let label = "";
+      if (b.value != null && b.minRange != null && b.value < b.minRange) label = "below range";
+      if (b.value != null && b.maxRange != null && b.value > b.maxRange) label = "above range";
+      console.log(`  - ${b.name}: ${val}${label ? ` (${label})` : ""}`);
+    }
+  } else {
+    console.log("All biomarkers within range.");
+  }
+  console.log();
+  console.log(`Connected devices: ${brief.connectedDevices.length > 0 ? brief.connectedDevices.join(", ") : "None"}`);
+  console.log(`Recent biomarkers tracked: ${brief.recentBiomarkerCount}`);
+}
+async function fetchNextActions(client, biomarkerLimit) {
+  const [biomarkers, devices] = await Promise.all([
+    client.get("/api/biomarker-result/all", { size: biomarkerLimit }, z9.array(biomarkerResultSchema)),
+    client.get("/api/vital/user/connections", void 0, connectionsResponseSchema)
+  ]);
+  const actions = [];
+  const outOfRange = biomarkers.filter(isOutOfRange);
+  for (const r of outOfRange) {
+    const label = rangeLabel(r);
+    actions.push({
+      type: "biomarker",
+      priority: "high",
+      description: `${r.biomarker.name} is ${label}`,
+      detail: `Value: ${r.value}${r.unit ? " " + r.unit : ""} (range: ${r.minRangeValue ?? "?"}-${r.maxRangeValue ?? "?"})${r.dateCollected ? `, tested: ${r.dateCollected}` : ""}`
+    });
+  }
+  const now = Date.now();
+  const ninetyDaysMs = 90 * 24 * 60 * 60 * 1e3;
+  const latestByName = /* @__PURE__ */ new Map();
+  for (const r of biomarkers) {
+    const existing = latestByName.get(r.biomarker.name);
+    if (!existing || r.dateCollected && (!existing.dateCollected || r.dateCollected > existing.dateCollected)) {
+      latestByName.set(r.biomarker.name, r);
+    }
+  }
+  for (const [name, r] of latestByName) {
+    if (!r.dateCollected) continue;
+    const testDate = new Date(r.dateCollected).getTime();
+    if (now - testDate > ninetyDaysMs) {
+      const daysAgo = Math.floor((now - testDate) / (24 * 60 * 60 * 1e3));
+      actions.push({
+        type: "retest",
+        priority: "medium",
+        description: `${name} retest recommended`,
+        detail: `Last tested ${daysAgo} days ago (${r.dateCollected})`
+      });
+    }
+  }
+  const totalDevices = devices.connections.length + devices.nativeConnections.length;
+  if (totalDevices === 0) {
+    actions.push({
+      type: "device",
+      priority: "low",
+      description: "No health devices connected",
+      detail: "Connect a wearable to track activity, sleep, and vitals automatically."
+    });
+  }
+  const priorityOrder = { high: 0, medium: 1, low: 2 };
+  actions.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+  return {
+    actions,
+    summary: { biomarkersOutOfRange: outOfRange.length, totalBiomarkers: biomarkers.length }
+  };
+}
+function printNextActions(result) {
+  if (result.actions.length === 0) {
+    console.log("No recommended actions at this time. Everything looks good!");
+    return;
+  }
+  console.log(`RECOMMENDED ACTIONS (${result.actions.length})`);
+  console.log();
+  const grouped = { high: [], medium: [], low: [] };
+  for (const a of result.actions) grouped[a.priority].push(a);
+  const labels = { high: "HIGH PRIORITY", medium: "MEDIUM", low: "LOW" };
+  for (const [priority, actions] of Object.entries(grouped)) {
+    if (actions.length === 0) continue;
+    console.log(`${labels[priority]}:`);
+    for (const a of actions) {
+      console.log(`  - [${a.type}] ${a.description}`);
+      if (a.detail) console.log(`    ${a.detail}`);
+    }
+    console.log();
+  }
+  console.log(`Summary: ${result.summary.biomarkersOutOfRange} of ${result.summary.totalBiomarkers} biomarkers out of range.`);
+}
+function registerWorkflowCommands(program2) {
+  const workflow = program2.command("workflow").description("Composite commands that aggregate data from multiple endpoints");
+  workflow.command("daily-brief").description("Daily health summary \u2014 profile, biological age, biomarkers, devices").option("--biomarker-limit <n>", "Maximum biomarkers to fetch", "20").action(async (opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const brief = await fetchDailyBrief(client, opts.biomarkerLimit);
+      const format = getOutputFormat(cmd);
+      if (format === "json") {
+        console.log(formatJson(brief));
+      } else {
+        printDailyBrief(brief);
+      }
+    } catch (error) {
+      outputError(error);
+    }
+  });
+  workflow.command("next-actions").description("Recommended next actions based on biomarkers and health data").option("--biomarker-limit <n>", "Maximum biomarkers to analyze", "50").action(async (opts, cmd) => {
+    try {
+      const globalOpts = cmd.optsWithGlobals();
+      const client = new ApiClient({ apiKey: globalOpts.apiKey });
+      const result = await fetchNextActions(client, opts.biomarkerLimit);
+      const format = getOutputFormat(cmd);
+      if (format === "json") {
+        console.log(formatJson(result));
+      } else {
+        printNextActions(result);
+      }
+    } catch (error) {
+      outputError(error);
+    }
+  });
+}
+
+// src/commands/schema.ts
+function buildSchema(cmd) {
+  const schema = {
+    name: cmd.name(),
+    description: cmd.description()
+  };
+  const opts = cmd.options.filter((o) => !o.hidden);
+  if (opts.length > 0) {
+    schema.options = opts.map((o) => {
+      const entry = {
+        flags: o.flags,
+        description: o.description
+      };
+      if (o.defaultValue !== void 0) entry.default = o.defaultValue;
+      return entry;
+    });
+  }
+  const subs = cmd.commands;
+  if (subs.length > 0) {
+    schema.subcommands = subs.filter((s) => s.name() !== "help").map(buildSchema);
+  }
+  return schema;
+}
+function printSchemaTable(schema, prefix = "") {
+  const fullName = prefix ? `${prefix} ${schema.name}` : schema.name;
+  if (schema.subcommands && schema.subcommands.length > 0) {
+    for (const sub of schema.subcommands) {
+      printSchemaTable(sub, fullName);
+    }
+    return;
+  }
+  console.log(fullName);
+  console.log(`  ${schema.description}`);
+  if (schema.options && schema.options.length > 0) {
+    console.log("  Options:");
+    for (const opt of schema.options) {
+      const def = opt.default !== void 0 ? ` (default: ${opt.default})` : "";
+      console.log(`    ${opt.flags}  ${opt.description}${def}`);
+    }
+  }
+  console.log();
+}
+function registerSchemaCommand(program2) {
+  program2.command("schema").description("Discover available commands, options, and response formats").argument("[command-path]", "Command path (e.g. biomarkers, biomarkers.search)").action((commandPath, _, cmd) => {
+    const root = cmd.parent;
+    const format = getOutputFormat(cmd);
+    if (!commandPath) {
+      const allSchemas = root.commands.filter((c) => c.name() !== "schema" && c.name() !== "help").map(buildSchema);
+      if (format === "json") {
+        console.log(formatJson(allSchemas));
+      } else {
+        for (const s of allSchemas) {
+          printSchemaTable(s);
+        }
+      }
+      return;
+    }
+    const parts = commandPath.split(".");
+    let target = root;
+    for (const part of parts) {
+      target = target.commands.find((c) => c.name() === part);
+      if (!target) {
+        console.error(`Unknown command: ${commandPath}`);
+        process.exit(1);
+      }
+    }
+    const schema = buildSchema(target);
+    if (format === "json") {
+      console.log(formatJson(schema));
+    } else {
+      printSchemaTable(schema);
+    }
+  });
+}
+
+// src/program.ts
+function createProgram() {
+  const program2 = new Command();
+  program2.name("betterness").description("Betterness CLI - Agent-first terminal interface for the Betterness platform").version("0.1.0").option("--api-key <key>", "API key (overrides env and stored credentials)").option("--json", "Output as JSON").option("--markdown", "Output as Markdown").option("--quiet", "Suppress output (exit code only)");
+  registerAuthCommands(program2);
+  registerProfileCommands(program2);
+  registerBiomarkersCommands(program2);
+  registerBiologicalAgeCommands(program2);
+  registerActivityCommands(program2);
+  registerSleepCommands(program2);
+  registerVitalsCommands(program2);
+  registerBodyCompositionCommands(program2);
+  registerConnectedDevicesCommands(program2);
+  registerLabTestsCommands(program2);
+  registerLabRecordsCommands(program2);
+  registerLabOrdersCommands(program2);
+  registerLabResultsCommands(program2);
+  registerPurchasesCommands(program2);
+  registerSmartListingsCommands(program2);
+  registerWorkflowCommands(program2);
+  registerSchemaCommand(program2);
+  return program2;
+}
+
+// src/index.ts
+var program = createProgram();
+program.parse();