npm - databody-cli - Versions diffs - 1.0.0 - Mend

databody-cli 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/index.js ADDED Viewed

@@ -0,0 +1,1252 @@
+#!/usr/bin/env node
+// src/index.ts
+import { Command } from "commander";
+// src/lib/token.ts
+import * as fs from "fs";
+// src/lib/config.ts
+import * as path from "path";
+import * as os from "os";
+var API_BASE_URL = process.env.DATABODY_API_URL || "http://localhost:3000";
+var CLIENT_ID = "databody-mcp";
+var CALLBACK_PORT = parseInt(
+  process.env.DATABODY_CALLBACK_PORT || "8787"
+);
+var TOKEN_FILE = path.join(os.homedir(), ".databody_token.json");
+// src/lib/token.ts
+function loadToken() {
+  try {
+    if (fs.existsSync(TOKEN_FILE)) {
+      const data = JSON.parse(fs.readFileSync(TOKEN_FILE, "utf-8"));
+      if (data.expires_at && Date.now() > data.expires_at) {
+        return data.refresh_token ? data : null;
+      }
+      return data;
+    }
+  } catch {
+  }
+  return null;
+}
+function saveToken(token) {
+  fs.writeFileSync(TOKEN_FILE, JSON.stringify(token, null, 2), {
+    mode: 384
+  });
+}
+function clearToken() {
+  try {
+    fs.unlinkSync(TOKEN_FILE);
+  } catch {
+  }
+}
+// src/lib/auth.ts
+import * as http from "http";
+import * as crypto from "crypto";
+function generateCodeVerifier() {
+  return crypto.randomBytes(32).toString("base64url");
+}
+function generateCodeChallenge(verifier) {
+  return crypto.createHash("sha256").update(verifier).digest("base64url");
+}
+async function refreshAccessToken(refreshToken) {
+  try {
+    const response = await fetch(`${API_BASE_URL}/oauth/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: refreshToken,
+        client_id: CLIENT_ID
+      })
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    const token = {
+      access_token: data.access_token,
+      refresh_token: data.refresh_token,
+      expires_at: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0
+    };
+    saveToken(token);
+    return token;
+  } catch {
+    return null;
+  }
+}
+async function startOAuthFlow() {
+  const codeVerifier = generateCodeVerifier();
+  const codeChallenge = generateCodeChallenge(codeVerifier);
+  const state = crypto.randomBytes(16).toString("hex");
+  return new Promise((resolve2, reject) => {
+    const server = http.createServer(async (req, res) => {
+      const url = new URL(
+        req.url || "",
+        `http://localhost:${CALLBACK_PORT}`
+      );
+      if (url.pathname === "/callback") {
+        const code = url.searchParams.get("code");
+        const returnedState = url.searchParams.get("state");
+        const error = url.searchParams.get("error");
+        if (error) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(
+            `<html><body><h1>Authorization Failed</h1><p>${error}</p></body></html>`
+          );
+          server.close();
+          reject(new Error(`OAuth error: ${error}`));
+          return;
+        }
+        if (returnedState !== state) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end("<html><body><h1>Invalid State</h1></body></html>");
+          server.close();
+          reject(new Error("Invalid OAuth state"));
+          return;
+        }
+        if (!code) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(
+            "<html><body><h1>No Code Received</h1></body></html>"
+          );
+          server.close();
+          reject(new Error("No authorization code received"));
+          return;
+        }
+        try {
+          const tokenResponse = await fetch(
+            `${API_BASE_URL}/oauth/token`,
+            {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/x-www-form-urlencoded"
+              },
+              body: new URLSearchParams({
+                grant_type: "authorization_code",
+                code,
+                redirect_uri: `http://localhost:${CALLBACK_PORT}/callback`,
+                client_id: CLIENT_ID,
+                code_verifier: codeVerifier
+              })
+            }
+          );
+          if (!tokenResponse.ok) {
+            const errorText = await tokenResponse.text();
+            throw new Error(`Token exchange failed: ${errorText}`);
+          }
+          const tokenData = await tokenResponse.json();
+          const token = {
+            access_token: tokenData.access_token,
+            refresh_token: tokenData.refresh_token,
+            expires_at: tokenData.expires_in ? Date.now() + tokenData.expires_in * 1e3 : void 0
+          };
+          saveToken(token);
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+            <html>
+              <body style="font-family: system-ui; text-align: center; padding: 50px;">
+                <h1>Authentication Successful!</h1>
+                <p>You can close this window and return to your terminal.</p>
+              </body>
+            </html>
+          `);
+          server.close();
+          resolve2(token);
+        } catch (err) {
+          res.writeHead(500, { "Content-Type": "text/html" });
+          res.end(
+            `<html><body><h1>Token Exchange Failed</h1><p>${err}</p></body></html>`
+          );
+          server.close();
+          reject(err);
+        }
+      } else {
+        res.writeHead(404);
+        res.end("Not Found");
+      }
+    });
+    server.listen(CALLBACK_PORT, () => {
+      const authUrl = new URL(`${API_BASE_URL}/oauth/authorize`);
+      authUrl.searchParams.set("client_id", CLIENT_ID);
+      authUrl.searchParams.set(
+        "redirect_uri",
+        `http://localhost:${CALLBACK_PORT}/callback`
+      );
+      authUrl.searchParams.set("response_type", "code");
+      authUrl.searchParams.set("scope", "read write");
+      authUrl.searchParams.set("state", state);
+      authUrl.searchParams.set("code_challenge", codeChallenge);
+      authUrl.searchParams.set("code_challenge_method", "S256");
+      const url = authUrl.toString();
+      console.error(`
+Open this URL in your browser to authenticate:
+${url}
+`);
+      console.error("Waiting for authentication...");
+      import("child_process").then(({ exec }) => {
+        const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        exec(`${cmd} "${url}"`);
+      });
+    });
+    server.on("error", (err) => {
+      reject(new Error(`Failed to start callback server: ${err.message}`));
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Authentication timeout - please try again"));
+    }, 5 * 60 * 1e3);
+  });
+}
+async function authenticateWithPassword(email, password) {
+  const response = await fetch(`${API_BASE_URL}/oauth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "password",
+      username: email,
+      password,
+      client_id: CLIENT_ID,
+      scope: "read write"
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Authentication failed: ${error}`);
+  }
+  const data = await response.json();
+  const token = {
+    access_token: data.access_token,
+    refresh_token: data.refresh_token,
+    expires_at: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0
+  };
+  saveToken(token);
+  return token;
+}
+// src/lib/api.ts
+var AuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AuthError";
+  }
+};
+async function getAccessToken() {
+  const token = loadToken();
+  if (!token) return null;
+  if (token.expires_at && Date.now() > token.expires_at) {
+    if (token.refresh_token) {
+      const refreshed = await refreshAccessToken(token.refresh_token);
+      return refreshed?.access_token || null;
+    }
+    return null;
+  }
+  return token.access_token;
+}
+async function apiCall(endpoint, method = "GET", body) {
+  const accessToken = await getAccessToken();
+  if (!accessToken) {
+    throw new AuthError("Not authenticated. Run 'databody auth login' first.");
+  }
+  const url = `${API_BASE_URL}/api/v1${endpoint}`;
+  const headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    Authorization: `Bearer ${accessToken}`
+  };
+  const response = await fetch(url, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : void 0
+  });
+  if (response.status === 401) {
+    const token = loadToken();
+    if (token?.refresh_token) {
+      const refreshed = await refreshAccessToken(token.refresh_token);
+      if (refreshed) {
+        headers.Authorization = `Bearer ${refreshed.access_token}`;
+        const retryResponse = await fetch(url, {
+          method,
+          headers,
+          body: body ? JSON.stringify(body) : void 0
+        });
+        if (retryResponse.ok) {
+          if (retryResponse.status === 204) return { success: true };
+          return retryResponse.json();
+        }
+      }
+    }
+    clearToken();
+    throw new AuthError(
+      "Session expired. Run 'databody auth login' to login again."
+    );
+  }
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`API error (${response.status}): ${error}`);
+  }
+  if (response.status === 204) {
+    return { success: true };
+  }
+  return response.json();
+}
+// src/lib/output.ts
+function output(data, pretty) {
+  const json = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+  console.log(json);
+}
+function errorOutput(message) {
+  console.error(JSON.stringify({ error: message }));
+}
+function withErrorHandler(fn) {
+  return (async (...args) => {
+    try {
+      await fn(...args);
+    } catch (err) {
+      errorOutput(err instanceof Error ? err.message : String(err));
+      process.exit(err instanceof AuthError ? 2 : 1);
+    }
+  });
+}
+// src/commands/auth.ts
+function registerAuthCommands(program2) {
+  const auth = program2.command("auth").description("Authentication");
+  auth.command("login").description("Authenticate with DataBody").option("--password", "Use email/password instead of browser OAuth").option("-e, --email <email>", "Email address (for password login)").option("-p, --pass <password>", "Password (for password login)").option(
+    "--token <access_token>",
+    "Directly set an access token (for cross-machine auth)"
+  ).option(
+    "--refresh-token <refresh_token>",
+    "Refresh token (used with --token)"
+  ).action(
+    withErrorHandler(async (opts) => {
+      const pretty = program2.opts().pretty;
+      if (opts.token) {
+        const token = {
+          access_token: opts.token,
+          refresh_token: opts.refreshToken
+        };
+        saveToken(token);
+        try {
+          const user2 = await apiCall("/users/me");
+          output(
+            { authenticated: true, message: "Token saved and verified", user: user2 },
+            pretty
+          );
+        } catch {
+          clearToken();
+          output(
+            { authenticated: false, error: "Token is invalid or expired" },
+            pretty
+          );
+          process.exit(1);
+        }
+        return;
+      }
+      if (opts.password) {
+        if (!opts.email || !opts.pass) {
+          output(
+            {
+              error: "Email and password required. Use: databody auth login --password -e EMAIL -p PASS"
+            },
+            pretty
+          );
+          process.exit(1);
+        }
+        await authenticateWithPassword(opts.email, opts.pass);
+        const user2 = await apiCall("/users/me");
+        output({ authenticated: true, message: "Logged in", user: user2 }, pretty);
+        return;
+      }
+      await startOAuthFlow();
+      const user = await apiCall("/users/me");
+      output({ authenticated: true, message: "Logged in", user }, pretty);
+    })
+  );
+  auth.command("logout").description("Clear stored authentication").action(
+    withErrorHandler(async () => {
+      clearToken();
+      output(
+        { authenticated: false, message: "Logged out" },
+        program2.opts().pretty
+      );
+    })
+  );
+  auth.command("status").description("Check authentication status").action(
+    withErrorHandler(async () => {
+      const pretty = program2.opts().pretty;
+      const token = loadToken();
+      if (!token) {
+        output({ authenticated: false }, pretty);
+        return;
+      }
+      try {
+        const user = await apiCall("/users/me");
+        output({ authenticated: true, user }, pretty);
+      } catch {
+        output({ authenticated: false, expired: true }, pretty);
+      }
+    })
+  );
+  auth.command("export-token").description("Export auth token for use on another machine").option("--compact", "Output as a single base64 string").action(
+    withErrorHandler(async (opts) => {
+      const pretty = program2.opts().pretty;
+      const token = loadToken();
+      if (!token) {
+        output({ error: "Not authenticated" }, pretty);
+        process.exit(2);
+      }
+      if (opts.compact) {
+        const encoded = Buffer.from(JSON.stringify(token)).toString(
+          "base64"
+        );
+        console.log(encoded);
+      } else {
+        output(token, pretty);
+      }
+    })
+  );
+  auth.command("import-token").description("Import auth token from another machine").argument("[token_data]", "Base64-encoded or JSON token data").option("--stdin", "Read token data from stdin").action(
+    withErrorHandler(async (tokenData, opts) => {
+      const pretty = program2.opts().pretty;
+      let raw;
+      if (opts.stdin) {
+        raw = await readStdin();
+      } else if (tokenData) {
+        raw = tokenData;
+      } else {
+        output(
+          {
+            error: "Provide token data as argument or use --stdin. Export with: databody auth export-token --compact"
+          },
+          pretty
+        );
+        process.exit(1);
+        return;
+      }
+      let token;
+      try {
+        token = JSON.parse(raw);
+      } catch {
+        try {
+          token = JSON.parse(Buffer.from(raw.trim(), "base64").toString("utf-8"));
+        } catch {
+          output({ error: "Invalid token data. Expected JSON or base64-encoded JSON." }, pretty);
+          process.exit(1);
+          return;
+        }
+      }
+      if (!token.access_token) {
+        output({ error: "Token data missing access_token field" }, pretty);
+        process.exit(1);
+        return;
+      }
+      saveToken(token);
+      try {
+        const user = await apiCall("/users/me");
+        output(
+          { authenticated: true, message: "Token imported and verified", user },
+          pretty
+        );
+      } catch {
+        clearToken();
+        output(
+          { authenticated: false, error: "Imported token is invalid or expired" },
+          pretty
+        );
+        process.exit(1);
+      }
+    })
+  );
+}
+function readStdin() {
+  return new Promise((resolve2) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => data += chunk);
+    process.stdin.on("end", () => resolve2(data));
+    process.stdin.resume();
+  });
+}
+// src/commands/user.ts
+function registerUserCommands(program2) {
+  const user = program2.command("user").description("User profile");
+  user.command("profile").description("Get current user profile").action(
+    withErrorHandler(async () => {
+      const result = await apiCall("/users/me");
+      output(result, program2.opts().pretty);
+    })
+  );
+  user.command("update").description("Update profile settings").option("--name <name>", "Display name").option("--height <cm>", "Height in cm").option("--sex <sex>", "Sex (male/female)").option("--birth-date <date>", "Birth date (YYYY-MM-DD)").option(
+    "--activity-level <level>",
+    "Activity level (sedentary/lightly_active/moderately_active/very_active/extra_active)"
+  ).option("--timezone <tz>", "Timezone (e.g. America/New_York)").option("--weight-unit <unit>", "Weight unit (lbs/kg)").option("--height-unit <unit>", "Height unit (in/cm)").action(
+    withErrorHandler(async (opts) => {
+      const body = {};
+      if (opts.name) body.name = opts.name;
+      if (opts.height) body.height_cm = parseFloat(opts.height);
+      if (opts.sex) body.sex = opts.sex;
+      if (opts.birthDate) body.birth_date = opts.birthDate;
+      if (opts.activityLevel) body.activity_level = opts.activityLevel;
+      if (opts.timezone) body.timezone = opts.timezone;
+      if (opts.weightUnit) body.weight_unit = opts.weightUnit;
+      if (opts.heightUnit) body.height_unit = opts.heightUnit;
+      const result = await apiCall("/users/me", "PATCH", body);
+      output(result, program2.opts().pretty);
+    })
+  );
+  user.command("change-password").description("Change password").requiredOption("--current <password>", "Current password").requiredOption("--new <password>", "New password").action(
+    withErrorHandler(
+      async (opts) => {
+        const result = await apiCall("/users/me/change_password", "POST", {
+          current_password: opts.current,
+          new_password: opts.new,
+          new_password_confirmation: opts.new
+        });
+        output(result, program2.opts().pretty);
+      }
+    )
+  );
+  user.command("change-email").description("Change email address").requiredOption("--password <password>", "Current password").requiredOption("--email <email>", "New email address").action(
+    withErrorHandler(
+      async (opts) => {
+        const result = await apiCall("/users/me/change_email", "POST", {
+          password: opts.password,
+          new_email_address: opts.email
+        });
+        output(result, program2.opts().pretty);
+      }
+    )
+  );
+}
+// src/commands/health.ts
+function registerHealthCommands(program2) {
+  const health = program2.command("health").description("Health data & summary");
+  health.command("summary").description(
+    "Today's health summary with macros, goals, workouts, and trends"
+  ).action(
+    withErrorHandler(async () => {
+      const result = await apiCall("/health/summary");
+      output(result, program2.opts().pretty);
+    })
+  );
+  health.command("history").description("Historical health stats with trend analysis").option("--days <n>", "Number of days (1-365, default 30)", "30").action(
+    withErrorHandler(async (opts) => {
+      const result = await apiCall(`/health/history?days=${opts.days}`);
+      output(result, program2.opts().pretty);
+    })
+  );
+}
+// src/commands/nutrition.ts
+function registerNutritionCommands(program2) {
+  const nutrition = program2.command("nutrition").description("Nutrition logging");
+  nutrition.command("today").description("Today's nutrition logs with totals and remaining macros").action(
+    withErrorHandler(async () => {
+      const result = await apiCall("/nutrition/today");
+      output(result, program2.opts().pretty);
+    })
+  );
+  nutrition.command("history").description("Nutrition history for date range").option("--start <date>", "Start date (YYYY-MM-DD)").option("--end <date>", "End date (YYYY-MM-DD)").action(
+    withErrorHandler(async (opts) => {
+      const params = new URLSearchParams();
+      if (opts.start) params.set("start_date", opts.start);
+      if (opts.end) params.set("end_date", opts.end);
+      const qs = params.toString();
+      const result = await apiCall(`/nutrition/history${qs ? `?${qs}` : ""}`);
+      output(result, program2.opts().pretty);
+    })
+  );
+  nutrition.command("get").description("Get a specific nutrition log").argument("<log_id>", "Nutrition log ID").action(
+    withErrorHandler(async (logId) => {
+      const result = await apiCall(`/nutrition/${logId}`);
+      output(result, program2.opts().pretty);
+    })
+  );
+  nutrition.command("log").description("Log food items").requiredOption(
+    "--meal <type>",
+    "Meal type (breakfast/lunch/dinner/snack)"
+  ).option("--items <json>", "JSON array of food items").option("--logged-at <iso>", "Timestamp (ISO format)").option("--notes <text>", "Notes").option("--stdin", "Read items JSON from stdin").action(
+    withErrorHandler(
+      async (opts) => {
+        let items;
+        if (opts.stdin) {
+          const raw = await readStdin2();
+          items = JSON.parse(raw);
+        } else if (opts.items) {
+          items = JSON.parse(opts.items);
+        } else {
+          output(
+            { error: "Provide --items JSON or use --stdin" },
+            program2.opts().pretty
+          );
+          process.exit(1);
+          return;
+        }
+        const body = {
+          meal_type: opts.meal,
+          nutrition_items_attributes: items
+        };
+        if (opts.loggedAt) body.logged_at = opts.loggedAt;
+        if (opts.notes) body.notes = opts.notes;
+        const result = await apiCall("/nutrition", "POST", body);
+        output(result, program2.opts().pretty);
+      }
+    )
+  );
+  nutrition.command("update").description("Update a nutrition log").argument("<log_id>", "Nutrition log ID").option("--meal <type>", "Meal type").option("--logged-at <iso>", "Timestamp").option("--notes <text>", "Notes").action(
+    withErrorHandler(
+      async (logId, opts) => {
+        const body = {};
+        if (opts.meal) body.meal_type = opts.meal;
+        if (opts.loggedAt) body.logged_at = opts.loggedAt;
+        if (opts.notes) body.notes = opts.notes;
+        const result = await apiCall(`/nutrition/${logId}`, "PATCH", body);
+        output(result, program2.opts().pretty);
+      }
+    )
+  );
+  nutrition.command("delete").description("Delete a nutrition log").argument("<log_id>", "Nutrition log ID").action(
+    withErrorHandler(async (logId) => {
+      const result = await apiCall(`/nutrition/${logId}`, "DELETE");
+      output(result, program2.opts().pretty);
+    })
+  );
+  nutrition.command("add-item").description("Add a food item to an existing log").argument("<log_id>", "Nutrition log ID").requiredOption("--name <name>", "Food name").option("--brand <brand>", "Brand").option("--serving-size <size>", "Serving size (e.g. 150g)").option("--serving-quantity <qty>", "Serving quantity").option("--calories <n>", "Calories").option("--protein <n>", "Protein grams").option("--carbs <n>", "Carbs grams").option("--fat <n>", "Fat grams").option("--fiber <n>", "Fiber grams").action(
+    withErrorHandler(
+      async (logId, opts) => {
+        const body = { name: opts.name };
+        if (opts.brand) body.brand = opts.brand;
+        if (opts.servingSize) body.serving_size = opts.servingSize;
+        if (opts.servingQuantity)
+          body.serving_quantity = parseFloat(opts.servingQuantity);
+        if (opts.calories) body.calories = parseFloat(opts.calories);
+        if (opts.protein) body.protein_grams = parseFloat(opts.protein);
+        if (opts.carbs) body.carbs_grams = parseFloat(opts.carbs);
+        if (opts.fat) body.fat_grams = parseFloat(opts.fat);
+        if (opts.fiber) body.fiber_grams = parseFloat(opts.fiber);
+        const result = await apiCall(
+          `/nutrition/${logId}/items`,
+          "POST",
+          body
+        );
+        output(result, program2.opts().pretty);
+      }
+    )
+  );
+  nutrition.command("delete-item").description("Delete a food item from a log").argument("<log_id>", "Nutrition log ID").argument("<item_id>", "Nutrition item ID").action(
+    withErrorHandler(async (logId, itemId) => {
+      const result = await apiCall(
+        `/nutrition/${logId}/items/${itemId}`,
+        "DELETE"
+      );
+      output(result, program2.opts().pretty);
+    })
+  );
+}
+function readStdin2() {
+  return new Promise((resolve2) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => data += chunk);
+    process.stdin.on("end", () => resolve2(data));
+    process.stdin.resume();
+  });
+}
+// src/commands/food.ts
+function registerFoodCommands(program2) {
+  const food = program2.command("food").description("Food search & favorites");
+  food.command("search").description("Search food databases").argument("<query>", "Search query").option(
+    "--source <source>",
+    "Database (fatsecret/usda/openfoodfacts/all)",
+    "all"
+  ).option("--page <n>", "Page number", "1").action(
+    withErrorHandler(
+      async (query, opts) => {
+        const params = new URLSearchParams({
+          query,
+          source: opts.source,
+          page: opts.page
+        });
+        const result = await apiCall(`/foods/search?${params}`);
+        output(result, program2.opts().pretty);
+      }
+    )
+  );
+  food.command("details").description("Get detailed nutrition for a food").argument("<food_id>", "Food ID (e.g. fatsecret_12345)").action(
+    withErrorHandler(async (foodId) => {
+      const result = await apiCall(`/foods/details/${foodId}`);
+      output(result, program2.opts().pretty);
+    })
+  );
+  food.command("barcode").description("Look up food by barcode").argument("<barcode>", "UPC/EAN barcode").action(
+    withErrorHandler(async (barcode) => {
+      const result = await apiCall(`/foods/barcode/${barcode}`);
+      output(result, program2.opts().pretty);
+    })
+  );
+  food.command("favorites").description("List saved food favorites").action(
+    withErrorHandler(async () => {
+      const result = await apiCall("/foods/favorites");
+      output(result, program2.opts().pretty);
+    })
+  );
+  food.command("add-favorite").description("Save a food to favorites").requiredOption("--name <name>", "Food name").option("--brand <brand>", "Brand").option("--serving-size <size>", "Serving size").option("--calories <n>", "Calories").option("--protein <n>", "Protein grams").option("--carbs <n>", "Carbs grams").option("--fat <n>", "Fat grams").option("--fiber <n>", "Fiber grams").option("--barcode <code>", "Barcode").action(
+    withErrorHandler(async (opts) => {
+      const body = { name: opts.name };
+      if (opts.brand) body.brand = opts.brand;
+      if (opts.servingSize) body.serving_size = opts.servingSize;
+      if (opts.calories) body.calories = parseFloat(opts.calories);
+      if (opts.protein) body.protein_grams = parseFloat(opts.protein);
+      if (opts.carbs) body.carbs_grams = parseFloat(opts.carbs);
+      if (opts.fat) body.fat_grams = parseFloat(opts.fat);
+      if (opts.fiber) body.fiber_grams = parseFloat(opts.fiber);
+      if (opts.barcode) body.barcode = opts.barcode;
+      const result = await apiCall("/foods/favorites", "POST", body);
+      output(result, program2.opts().pretty);
+    })
+  );
+  food.command("remove-favorite").description("Remove a food from favorites").argument("<id>", "Favorite ID").action(
+    withErrorHandler(async (id) => {
+      const result = await apiCall(`/foods/favorites/${id}`, "DELETE");
+      output(result, program2.opts().pretty);
+    })
+  );
+  food.command("recents").description("Get recently logged foods").action(
+    withErrorHandler(async () => {
+      const result = await apiCall("/foods/recents");
+      output(result, program2.opts().pretty);
+    })
+  );
+}
+// src/commands/goals.ts
+function registerGoalsCommands(program2) {
+  const goals = program2.command("goals").description("Fitness goals");
+  goals.command("current").description("Get active goal with macro targets").action(
+    withErrorHandler(async () => {
+      const result = await apiCall("/goals/current");
+      output(result, program2.opts().pretty);
+    })
+  );
+  goals.command("list").description("List all goals").action(
+    withErrorHandler(async () => {
+      const result = await apiCall("/goals");
+      output(result, program2.opts().pretty);
+    })
+  );
+  goals.command("get").description("Get a specific goal").argument("<id>", "Goal ID").action(
+    withErrorHandler(async (id) => {
+      const result = await apiCall(`/goals/${id}`);
+      output(result, program2.opts().pretty);
+    })
+  );
+  goals.command("create").description("Create a new goal").option("--calories <n>", "Daily calorie target").option("--protein <n>", "Daily protein grams").option("--carbs <n>", "Daily carbs grams").option("--fat <n>", "Daily fat grams").option("--strategy <s>", "Strategy (cut/maintain/bulk)").option("--target-bf <n>", "Target body fat percentage").option("--target-date <date>", "Target date (YYYY-MM-DD)").option("--active", "Set as active goal").action(
+    withErrorHandler(async (opts) => {
+      const body = {};
+      if (opts.calories) body.daily_calorie_target = parseFloat(opts.calories);
+      if (opts.protein) body.daily_protein_grams = parseFloat(opts.protein);
+      if (opts.carbs) body.daily_carbs_grams = parseFloat(opts.carbs);
+      if (opts.fat) body.daily_fat_grams = parseFloat(opts.fat);
+      if (opts.strategy) body.strategy = opts.strategy;
+      if (opts.targetBf)
+        body.target_body_fat_percentage = parseFloat(opts.targetBf);
+      if (opts.targetDate) body.target_date = opts.targetDate;
+      if (opts.active) body.active = true;
+      const result = await apiCall("/goals", "POST", body);
+      output(result, program2.opts().pretty);
+    })
+  );
+  goals.command("update").description("Update a goal").argument("<id>", "Goal ID").option("--calories <n>", "Daily calorie target").option("--protein <n>", "Daily protein grams").option("--carbs <n>", "Daily carbs grams").option("--fat <n>", "Daily fat grams").option("--strategy <s>", "Strategy (cut/maintain/bulk)").option("--target-bf <n>", "Target body fat percentage").option("--target-date <date>", "Target date (YYYY-MM-DD)").option("--active <bool>", "Active status (true/false)").option("--protein-per-lb <n>", "Protein per lb lean body mass").option("--fat-per-lb <n>", "Fat per lb body weight").option("--weekly-loss <n>", "Weekly weight loss percentage").option("--flex-weekends", "Enable flexible weekends").option("--no-flex-weekends", "Disable flexible weekends").option("--flex-weekends-pct <n>", "Flexible weekends percentage").action(
+    withErrorHandler(async (id, opts) => {
+      const body = {};
+      if (opts.calories) body.daily_calorie_target = parseFloat(opts.calories);
+      if (opts.protein) body.daily_protein_grams = parseFloat(opts.protein);
+      if (opts.carbs) body.daily_carbs_grams = parseFloat(opts.carbs);
+      if (opts.fat) body.daily_fat_grams = parseFloat(opts.fat);
+      if (opts.strategy) body.strategy = opts.strategy;
+      if (opts.targetBf)
+        body.target_body_fat_percentage = parseFloat(opts.targetBf);
+      if (opts.targetDate) body.target_date = opts.targetDate;
+      if (opts.active !== void 0) body.active = opts.active === "true";
+      if (opts.proteinPerLb)
+        body.protein_per_lb_lbm = parseFloat(opts.proteinPerLb);
+      if (opts.fatPerLb) body.fat_per_lb = parseFloat(opts.fatPerLb);
+      if (opts.weeklyLoss)
+        body.weekly_weight_loss_percentage = parseFloat(opts.weeklyLoss);
+      if (opts.flexWeekends === true) body.flexible_weekends_enabled = true;
+      if (opts.flexWeekends === false) body.flexible_weekends_enabled = false;
+      if (opts.flexWeekendsPct)
+        body.flexible_weekends_percentage = parseFloat(
+          opts.flexWeekendsPct
+        );
+      const result = await apiCall(`/goals/${id}`, "PATCH", body);
+      output(result, program2.opts().pretty);
+    })
+  );
+  goals.command("delete").description("Delete a goal").argument("<id>", "Goal ID").action(
+    withErrorHandler(async (id) => {
+      const result = await apiCall(`/goals/${id}`, "DELETE");
+      output(result, program2.opts().pretty);
+    })
+  );
+  goals.command("calculate").description("Recalculate macros based on current health data").argument("<id>", "Goal ID").action(
+    withErrorHandler(async (id) => {
+      const result = await apiCall(`/goals/${id}/calculate`, "POST");
+      output(result, program2.opts().pretty);
+    })
+  );
+}
+// src/commands/workouts.ts
+function registerWorkoutsCommands(program2) {
+  const workouts = program2.command("workouts").description("Workout tracking");
+  workouts.command("recent").description("Recent workouts (last 7 days)").option("--limit <n>", "Number of workouts", "10").action(
+    withErrorHandler(async (opts) => {
+      const result = await apiCall(`/workouts/recent?limit=${opts.limit}`);
+      output(result, program2.opts().pretty);
+    })
+  );
+  workouts.command("list").description("List workouts with filters").option("--start <date>", "Start date (YYYY-MM-DD)").option("--end <date>", "End date (YYYY-MM-DD)").option("--type <type>", "Workout type").option("--limit <n>", "Maximum results", "50").action(
+    withErrorHandler(
+      async (opts) => {
+        const params = new URLSearchParams({ limit: opts.limit });
+        if (opts.start) params.set("start_date", opts.start);
+        if (opts.end) params.set("end_date", opts.end);
+        if (opts.type) params.set("type", opts.type);
+        const result = await apiCall(`/workouts?${params}`);
+        output(result, program2.opts().pretty);
+      }
+    )
+  );
+  workouts.command("get").description("Get a specific workout").argument("<id>", "Workout ID").action(
+    withErrorHandler(async (id) => {
+      const result = await apiCall(`/workouts/${id}`);
+      output(result, program2.opts().pretty);
+    })
+  );
+  workouts.command("create").description("Log a new workout").requiredOption("--type <type>", "Workout type (running, cycling, etc.)").requiredOption("--started-at <iso>", "Start time (ISO format)").option("--duration <min>", "Duration in minutes").option("--ended-at <iso>", "End time (ISO format)").option("--calories <n>", "Calories burned").option("--heart-rate <n>", "Average heart rate").option("--distance <m>", "Distance in meters").action(
+    withErrorHandler(async (opts) => {
+      const body = {
+        workout_type: opts.type,
+        started_at: opts.startedAt
+      };
+      if (opts.duration)
+        body.duration_minutes = parseFloat(opts.duration);
+      if (opts.endedAt) body.ended_at = opts.endedAt;
+      if (opts.calories)
+        body.calories_burned = parseFloat(opts.calories);
+      if (opts.heartRate)
+        body.average_heart_rate = parseFloat(opts.heartRate);
+      if (opts.distance)
+        body.distance_meters = parseFloat(opts.distance);
+      const result = await apiCall("/workouts", "POST", body);
+      output(result, program2.opts().pretty);
+    })
+  );
+  workouts.command("update").description("Update a workout").argument("<id>", "Workout ID").option("--type <type>", "Workout type").option("--started-at <iso>", "Start time").option("--duration <min>", "Duration in minutes").option("--ended-at <iso>", "End time").option("--calories <n>", "Calories burned").option("--heart-rate <n>", "Average heart rate").option("--distance <m>", "Distance in meters").action(
+    withErrorHandler(async (id, opts) => {
+      const body = {};
+      if (opts.type) body.workout_type = opts.type;
+      if (opts.startedAt) body.started_at = opts.startedAt;
+      if (opts.duration)
+        body.duration_minutes = parseFloat(opts.duration);
+      if (opts.endedAt) body.ended_at = opts.endedAt;
+      if (opts.calories)
+        body.calories_burned = parseFloat(opts.calories);
+      if (opts.heartRate)
+        body.average_heart_rate = parseFloat(opts.heartRate);
+      if (opts.distance)
+        body.distance_meters = parseFloat(opts.distance);
+      const result = await apiCall(`/workouts/${id}`, "PATCH", body);
+      output(result, program2.opts().pretty);
+    })
+  );
+  workouts.command("delete").description("Delete a workout").argument("<id>", "Workout ID").action(
+    withErrorHandler(async (id) => {
+      const result = await apiCall(`/workouts/${id}`, "DELETE");
+      output(result, program2.opts().pretty);
+    })
+  );
+}
+// src/commands/ai.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+function registerAiCommands(program2) {
+  const ai = program2.command("ai").description("AI features & coaching");
+  ai.command("chat").description("Chat with the AI nutrition coach").argument("<message>", "Your message").option("--thread <id>", "Thread ID for conversation context").option("--household <id>", "Household ID for family context").action(
+    withErrorHandler(
+      async (message, opts) => {
+        const body = { message };
+        if (opts.thread) body.thread_id = parseInt(opts.thread);
+        if (opts.household) body.household_id = parseInt(opts.household);
+        const result = await apiCall("/ai/chat", "POST", body);
+        output(result, program2.opts().pretty);
+      }
+    )
+  );
+  ai.command("suggestions").description("Get AI meal suggestions based on remaining macros").option("--preferences <text>", "Meal preferences").option("--household <id>", "Household ID").action(
+    withErrorHandler(
+      async (opts) => {
+        const params = new URLSearchParams();
+        if (opts.preferences) params.set("preferences", opts.preferences);
+        if (opts.household) params.set("household_id", opts.household);
+        const qs = params.toString();
+        const result = await apiCall(
+          `/ai/suggestions${qs ? `?${qs}` : ""}`
+        );
+        output(result, program2.opts().pretty);
+      }
+    )
+  );
+  ai.command("analyze-photo").description("Analyze a meal photo for nutrition estimation").option("--file <path>", "Path to image file").option("--base64 <data>", "Base64-encoded image data").option("--mime <type>", "MIME type (default: auto-detect from file)").action(
+    withErrorHandler(
+      async (opts) => {
+        let imageData;
+        let mimeType;
+        if (opts.file) {
+          const filePath = path2.resolve(opts.file);
+          const buffer = fs2.readFileSync(filePath);
+          imageData = buffer.toString("base64");
+          mimeType = opts.mime || detectMimeType(filePath) || "image/jpeg";
+          const sizeMB = buffer.length / (1024 * 1024);
+          if (sizeMB > 20) {
+            output(
+              { error: `File too large (${sizeMB.toFixed(1)}MB). Max 20MB.` },
+              program2.opts().pretty
+            );
+            process.exit(1);
+          }
+        } else if (opts.base64) {
+          imageData = opts.base64;
+          mimeType = opts.mime || "image/jpeg";
+        } else {
+          output(
+            { error: "Provide --file or --base64" },
+            program2.opts().pretty
+          );
+          process.exit(1);
+          return;
+        }
+        const result = await apiCall("/ai/analyze_photo", "POST", {
+          image: imageData,
+          mime_type: mimeType
+        });
+        output(result, program2.opts().pretty);
+      }
+    )
+  );
+  ai.command("parse").description("Parse a food description into structured nutrition data").argument("<description>", "Food description text").action(
+    withErrorHandler(async (description) => {
+      const result = await apiCall("/ai/parse_description", "POST", {
+        description
+      });
+      output(result, program2.opts().pretty);
+    })
+  );
+  ai.command("expand").description("Expand a meal into individual ingredients with macros").requiredOption("--meal <name>", "Meal name").requiredOption("--ingredients <list>", "Comma-separated ingredients").option("--calories <n>", "Total calories").option("--protein <n>", "Total protein").option("--carbs <n>", "Total carbs").option("--fat <n>", "Total fat").action(
+    withErrorHandler(
+      async (opts) => {
+        const body = {
+          meal_name: opts.meal,
+          ingredients: opts.ingredients
+        };
+        if (opts.calories || opts.protein || opts.carbs || opts.fat) {
+          body.total_macros = {
+            calories: opts.calories ? parseFloat(opts.calories) : void 0,
+            protein: opts.protein ? parseFloat(opts.protein) : void 0,
+            carbs: opts.carbs ? parseFloat(opts.carbs) : void 0,
+            fat: opts.fat ? parseFloat(opts.fat) : void 0
+          };
+        }
+        const result = await apiCall(
+          "/ai/expand_meal_ingredients",
+          "POST",
+          body
+        );
+        output(result, program2.opts().pretty);
+      }
+    )
+  );
+  ai.command("greeting").description("Get a personalized daily greeting").action(
+    withErrorHandler(async () => {
+      const result = await apiCall("/ai/daily_greeting");
+      output(result, program2.opts().pretty);
+    })
+  );
+  ai.command("token-usage").description("Get AI token usage statistics").action(
+    withErrorHandler(async () => {
+      const result = await apiCall("/ai/token_usage");
+      output(result, program2.opts().pretty);
+    })
+  );
+  ai.command("chat-history").description("Get chat message history").option("--thread <id>", "Thread ID").action(
+    withErrorHandler(async (opts) => {
+      const params = new URLSearchParams();
+      if (opts.thread) params.set("thread_id", opts.thread);
+      const qs = params.toString();
+      const result = await apiCall(
+        `/ai/chat_history${qs ? `?${qs}` : ""}`
+      );
+      output(result, program2.opts().pretty);
+    })
+  );
+}
+function detectMimeType(filePath) {
+  const ext = path2.extname(filePath).toLowerCase();
+  const mimeTypes = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".heic": "image/heic",
+    ".heif": "image/heif"
+  };
+  return mimeTypes[ext] || null;
+}
+// src/commands/threads.ts
+function registerThreadsCommands(program2) {
+  const threads = program2.command("threads").description("Chat threads");
+  threads.command("list").description("List chat threads with previews").action(
+    withErrorHandler(async () => {
+      const result = await apiCall("/chat_threads");
+      output(result, program2.opts().pretty);
+    })
+  );
+  threads.command("get").description("Get a thread with all messages").argument("<id>", "Thread ID").action(
+    withErrorHandler(async (id) => {
+      const result = await apiCall(`/chat_threads/${id}`);
+      output(result, program2.opts().pretty);
+    })
+  );
+  threads.command("create").description("Create a new chat thread").option("--title <title>", "Thread title").action(
+    withErrorHandler(async (opts) => {
+      const body = {};
+      if (opts.title) body.title = opts.title;
+      const result = await apiCall("/chat_threads", "POST", body);
+      output(result, program2.opts().pretty);
+    })
+  );
+  threads.command("delete").description("Delete a chat thread").argument("<id>", "Thread ID").action(
+    withErrorHandler(async (id) => {
+      const result = await apiCall(`/chat_threads/${id}`, "DELETE");
+      output(result, program2.opts().pretty);
+    })
+  );
+  threads.command("generate-title").description("AI-generate a title from thread messages").argument("<id>", "Thread ID").action(
+    withErrorHandler(async (id) => {
+      const result = await apiCall(
+        `/chat_threads/${id}/generate_title`,
+        "POST"
+      );
+      output(result, program2.opts().pretty);
+    })
+  );
+}
+// src/commands/notes.ts
+function registerNotesCommands(program2) {
+  const notes = program2.command("notes").description("Personal notes for AI context");
+  notes.command("list").description("List all notes").action(
+    withErrorHandler(async () => {
+      const result = await apiCall("/notes");
+      output(result, program2.opts().pretty);
+    })
+  );
+  notes.command("create").description("Create a note").argument("<content>", "Note content").action(
+    withErrorHandler(async (content) => {
+      const result = await apiCall("/notes", "POST", {
+        content,
+        created_via: "cli"
+      });
+      output(result, program2.opts().pretty);
+    })
+  );
+  notes.command("update").description("Update a note").argument("<id>", "Note ID").argument("<content>", "New content").action(
+    withErrorHandler(async (id, content) => {
+      const result = await apiCall(`/notes/${id}`, "PATCH", { content });
+      output(result, program2.opts().pretty);
+    })
+  );
+  notes.command("delete").description("Delete a note").argument("<id>", "Note ID").action(
+    withErrorHandler(async (id) => {
+      const result = await apiCall(`/notes/${id}`, "DELETE");
+      output(result, program2.opts().pretty);
+    })
+  );
+}
+// src/commands/households.ts
+function registerHouseholdsCommands(program2) {
+  const households = program2.command("households").description("Household management");
+  households.command("list").description("List households").action(
+    withErrorHandler(async () => {
+      const result = await apiCall("/households");
+      output(result, program2.opts().pretty);
+    })
+  );
+  households.command("summary").description("Get household details with member health data").argument("<id>", "Household ID").option("--days <n>", "Days of nutrition history (1-30)", "1").action(
+    withErrorHandler(async (id, opts) => {
+      const result = await apiCall(
+        `/households/${id}?include_health=true&days=${opts.days}`
+      );
+      output(result, program2.opts().pretty);
+    })
+  );
+  households.command("create").description("Create a household").argument("<name>", "Household name").action(
+    withErrorHandler(async (name) => {
+      const result = await apiCall("/households", "POST", { name });
+      output(result, program2.opts().pretty);
+    })
+  );
+  households.command("update").description("Update a household").argument("<id>", "Household ID").requiredOption("--name <name>", "New name").action(
+    withErrorHandler(async (id, opts) => {
+      const result = await apiCall(`/households/${id}`, "PATCH", {
+        name: opts.name
+      });
+      output(result, program2.opts().pretty);
+    })
+  );
+  households.command("delete").description("Delete a household (owner only)").argument("<id>", "Household ID").action(
+    withErrorHandler(async (id) => {
+      const result = await apiCall(`/households/${id}`, "DELETE");
+      output(result, program2.opts().pretty);
+    })
+  );
+  households.command("leave").description("Leave a household").argument("<id>", "Household ID").action(
+    withErrorHandler(async (id) => {
+      const result = await apiCall(`/households/${id}/leave`, "DELETE");
+      output(result, program2.opts().pretty);
+    })
+  );
+  households.command("members").description("List household members").argument("<id>", "Household ID").action(
+    withErrorHandler(async (id) => {
+      const result = await apiCall(`/households/${id}/members`);
+      output(result, program2.opts().pretty);
+    })
+  );
+  households.command("remove-member").description("Remove a member from household (owner only)").argument("<id>", "Household ID").argument("<member_id>", "Member ID").action(
+    withErrorHandler(async (id, memberId) => {
+      const result = await apiCall(
+        `/households/${id}/members/${memberId}`,
+        "DELETE"
+      );
+      output(result, program2.opts().pretty);
+    })
+  );
+}
+// src/commands/invites.ts
+function registerInvitesCommands(program2) {
+  const invites = program2.command("invites").description("Household invitations");
+  invites.command("list").description("List pending invites for a household (owner view)").argument("<household_id>", "Household ID").action(
+    withErrorHandler(async (householdId) => {
+      const result = await apiCall(
+        `/households/${householdId}/invites`
+      );
+      output(result, program2.opts().pretty);
+    })
+  );
+  invites.command("pending").description("List invites sent to you").action(
+    withErrorHandler(async () => {
+      const result = await apiCall("/household_invites");
+      output(result, program2.opts().pretty);
+    })
+  );
+  invites.command("create").description("Invite someone to a household").argument("<household_id>", "Household ID").requiredOption("--email <email>", "Email address to invite").action(
+    withErrorHandler(
+      async (householdId, opts) => {
+        const result = await apiCall(
+          `/households/${householdId}/invites`,
+          "POST",
+          { email_address: opts.email }
+        );
+        output(result, program2.opts().pretty);
+      }
+    )
+  );
+  invites.command("cancel").description("Cancel a pending invite (owner only)").argument("<household_id>", "Household ID").argument("<invite_id>", "Invite ID").action(
+    withErrorHandler(async (householdId, inviteId) => {
+      const result = await apiCall(
+        `/households/${householdId}/invites/${inviteId}`,
+        "DELETE"
+      );
+      output(result, program2.opts().pretty);
+    })
+  );
+  invites.command("accept").description("Accept an invite").argument("<id>", "Invite ID").action(
+    withErrorHandler(async (id) => {
+      const result = await apiCall(
+        `/household_invites/${id}/accept`,
+        "POST"
+      );
+      output(result, program2.opts().pretty);
+    })
+  );
+  invites.command("decline").description("Decline an invite").argument("<id>", "Invite ID").action(
+    withErrorHandler(async (id) => {
+      const result = await apiCall(
+        `/household_invites/${id}/reject`,
+        "POST"
+      );
+      output(result, program2.opts().pretty);
+    })
+  );
+}
+// src/index.ts
+var program = new Command();
+program.name("databody").description("DataBody CLI - Health & Fitness Tracking").version("1.0.0").option("--pretty", "Pretty-print JSON output");
+registerAuthCommands(program);
+registerUserCommands(program);
+registerHealthCommands(program);
+registerNutritionCommands(program);
+registerFoodCommands(program);
+registerGoalsCommands(program);
+registerWorkoutsCommands(program);
+registerAiCommands(program);
+registerThreadsCommands(program);
+registerNotesCommands(program);
+registerHouseholdsCommands(program);
+registerInvitesCommands(program);
+program.command("summary").description("Today's health summary (shortcut for: health summary)").action(
+  withErrorHandler(async () => {
+    const result = await apiCall("/health/summary");
+    output(result, program.opts().pretty);
+  })
+);
+program.command("today").description("Today's nutrition (shortcut for: nutrition today)").action(
+  withErrorHandler(async () => {
+    const result = await apiCall("/nutrition/today");
+    output(result, program.opts().pretty);
+  })
+);
+program.command("chat").description("Chat with AI coach (shortcut for: ai chat)").argument("<message>", "Your message").option("--thread <id>", "Thread ID").option("--household <id>", "Household ID").action(
+  withErrorHandler(
+    async (message, opts) => {
+      const body = { message };
+      if (opts.thread) body.thread_id = parseInt(opts.thread);
+      if (opts.household) body.household_id = parseInt(opts.household);
+      const result = await apiCall("/ai/chat", "POST", body);
+      output(result, program.opts().pretty);
+    }
+  )
+);
+program.command("log").description("Log food (shortcut for: nutrition log)").argument("<meal>", "Meal type (breakfast/lunch/dinner/snack)").argument("<items>", "JSON array of food items").action(
+  withErrorHandler(async (meal, items) => {
+    const parsed = JSON.parse(items);
+    const result = await apiCall("/nutrition", "POST", {
+      meal_type: meal,
+      nutrition_items_attributes: parsed
+    });
+    output(result, program.opts().pretty);
+  })
+);
+program.parse();