@athletelog/cli 0.1.0-beta.1

package/dist/index.js

@@ -0,0 +1,450 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { parseArgs } from "util";
+
+// src/config.ts
+import { existsSync, readFileSync, writeFileSync, chmodSync, mkdirSync, rmSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var ENV_BASE_URLS = {
+  prod: "https://api.athletelog.ai",
+  staging: "https://api-staging.athletelog.ai",
+  dev: ""
+  // dev has no fixed host; it comes from a literal --url / ATHLETELOG_API_URL / legacy convexUrl
+};
+var CONFIG_DIR = join(homedir(), ".athletelog");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function readStored() {
+  if (!existsSync(CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function toRequestBase(raw) {
+  return raw.includes(".convex.cloud") ? raw.replace(".convex.cloud", ".convex.site") : raw;
+}
+function resolveBaseUrl(o, stored) {
+  const literal = o.url ?? process.env.ATHLETELOG_API_URL ?? stored.url ?? stored.convexUrl;
+  if (literal) {
+    const env = literal.includes(".convex.") ? "dev" : "unknown";
+    return { baseUrl: toRequestBase(literal), env };
+  }
+  const named = o.env ?? process.env.ATHLETELOG_ENV ?? stored.env ?? "prod";
+  const base = ENV_BASE_URLS[named] ?? ENV_BASE_URLS.prod;
+  return { baseUrl: toRequestBase(base), env: named };
+}
+function loadConfig(overrides = {}) {
+  const stored = readStored();
+  const apiKey = overrides.apiKey ?? process.env.ATHLETELOG_API_KEY ?? stored.apiKey;
+  if (!apiKey) {
+    throw new Error(
+      `No API key. Run "athletelog login", or pass --key / set ATHLETELOG_API_KEY.`
+    );
+  }
+  const { baseUrl, env } = resolveBaseUrl(overrides, stored);
+  if (!baseUrl) {
+    throw new Error(
+      `No URL resolved for dev. Pass --url <https://\u2026convex.site> or set ATHLETELOG_API_URL.`
+    );
+  }
+  warnOnPrefixMismatch(apiKey, env);
+  return { apiKey, baseUrl, env };
+}
+function parseKeyEnv(key) {
+  const m = /^alog_(dev|staging|prod)_/.exec(key);
+  return m?.[1] ?? "unknown";
+}
+function warnOnPrefixMismatch(key, env) {
+  const keyEnv = parseKeyEnv(key);
+  if (keyEnv === "unknown") {
+    process.stderr.write(
+      `Warning: API key prefix is not a recognized alog_<env>_ form; cannot verify it matches "${env}".
+`
+    );
+    return;
+  }
+  if (env !== "unknown" && keyEnv !== env) {
+    process.stderr.write(
+      `Warning: API key is for "${keyEnv}" but the target is "${env}". This will likely fail to authenticate.
+`
+    );
+  }
+}
+function writeConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", { mode: 384 });
+  chmodSync(CONFIG_PATH, 384);
+}
+function clearConfig() {
+  if (existsSync(CONFIG_PATH)) rmSync(CONFIG_PATH);
+}
+
+// src/version.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join as join2 } from "path";
+var cached;
+function getVersion() {
+  if (cached) return cached;
+  const here = dirname(fileURLToPath(import.meta.url));
+  const pkgPath = join2(here, "..", "package.json");
+  try {
+    cached = JSON.parse(readFileSync2(pkgPath, "utf8")).version ?? "0.0.0";
+  } catch {
+    cached = "0.0.0";
+  }
+  return cached;
+}
+
+// src/auth-client.ts
+var REFRESH_MARGIN_MS = 5 * 60 * 1e3;
+async function exchangeKeyForToken(config) {
+  const res = await fetch(`${config.baseUrl}/athletelog/auth/token`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${config.apiKey}`,
+      // never logged
+      "User-Agent": `athletelog-cli/${getVersion()}`
+    }
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    let detail = body;
+    try {
+      const parsed = JSON.parse(body);
+      detail = parsed?.error?.message ?? parsed?.error?.code ?? body;
+    } catch {
+    }
+    throw new Error(`Token exchange failed (${res.status}): ${detail}`);
+  }
+  return await res.json();
+}
+async function createAuthSession(config) {
+  let { token, expiresAt } = await exchangeKeyForToken(config);
+  async function ensureFresh() {
+    if (Date.now() < expiresAt - REFRESH_MARGIN_MS) return;
+    const next = await exchangeKeyForToken(config);
+    token = next.token;
+    expiresAt = next.expiresAt;
+  }
+  return { getToken: () => token, ensureFresh };
+}
+
+// src/http-client.ts
+var ApiError = class extends Error {
+  status;
+  code;
+  constructor(message, opts = {}) {
+    super(message);
+    this.name = "ApiError";
+    this.status = opts.status;
+    this.code = opts.code;
+  }
+};
+async function apiRequest(baseUrl, path, opts) {
+  if (typeof fetch === "undefined") {
+    throw new ApiError("global fetch is unavailable. Use Node >=18.18 without --no-experimental-fetch.", { code: "NO_FETCH" });
+  }
+  const headers = {
+    "User-Agent": `athletelog-cli/${getVersion()}`,
+    // sent on EVERY request (success criterion)
+    Authorization: `Bearer ${opts.token}`,
+    // never logged
+    Accept: "application/json"
+  };
+  if (opts.body !== void 0) headers["Content-Type"] = "application/json";
+  let res;
+  try {
+    res = await fetch(new URL(path, baseUrl), {
+      method: opts.method ?? "GET",
+      headers,
+      body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0
+    });
+  } catch (err) {
+    const e = err;
+    const cause = e.cause?.code ? ` (${e.cause.code})` : "";
+    throw new ApiError(`Network error: ${e.message ?? String(err)}${cause}`, { code: "NETWORK" });
+  }
+  const sunset = res.headers.get("Sunset");
+  if (res.headers.get("Deprecation") || sunset) {
+    let msg = "Warning: this CLI uses a deprecated API endpoint.";
+    if (sunset) msg += ` It will stop working after ${sunset}.`;
+    process.stderr.write(msg + " Upgrade: npm i -g @athletelog/cli\n");
+  }
+  if (res.status === 410) {
+    throw new ApiError("This API endpoint was removed (410 Gone). Upgrade: npm i -g @athletelog/cli", { status: 410, code: "GONE" });
+  }
+  if (!res.ok) {
+    const text = await res.text();
+    let code;
+    let message = text;
+    try {
+      const parsed = JSON.parse(text);
+      message = parsed?.error?.message ?? parsed?.error?.code ?? text;
+      code = parsed?.error?.code;
+    } catch {
+    }
+    throw new ApiError(`Request failed (${res.status}): ${message}`, { status: res.status, code });
+  }
+  if (res.status === 204) return void 0;
+  return await res.json();
+}
+
+// src/commands/athletes-list.ts
+async function runAthletesList(args) {
+  const config = loadConfig();
+  const session = await createAuthSession(config);
+  const athletes = await apiRequest(config.baseUrl, "/athletelog/v1/athletes", { token: session.getToken() });
+  if (args.json) {
+    process.stdout.write(JSON.stringify(athletes, null, 2) + "\n");
+    return;
+  }
+  if (athletes.length === 0) {
+    process.stderr.write("No active athletes.\n");
+    return;
+  }
+  for (const a of athletes) {
+    process.stdout.write(`${a._id}	${a.name}	${a.email ?? ""}
+`);
+  }
+}
+
+// src/commands/checkin-import.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+
+// src/skinfold-sites.ts
+var SKINFOLD_SITES = [
+  "chin",
+  "cheek",
+  "pectoral",
+  "bicep",
+  "midAxilla",
+  "supraIliac",
+  "umbilical",
+  "triceps",
+  "subScapular",
+  "lowerback",
+  "knee",
+  "calf",
+  "quad",
+  "hamstring"
+];
+
+// src/commands/checkin-import.ts
+function toNumber(value) {
+  if (typeof value !== "number" || Number.isNaN(value)) return void 0;
+  return value;
+}
+async function runCheckinImport(args) {
+  const config = loadConfig();
+  const session = await createAuthSession(config);
+  const targetUserId = args.athlete;
+  if (!existsSync2(args.file)) throw new Error(`File not found: ${args.file}`);
+  const records = JSON.parse(readFileSync3(args.file, "utf8"));
+  if (!Array.isArray(records)) throw new Error("--file must contain a JSON array of records");
+  let created = 0, updated = 0, failed = 0;
+  for (let i = 0; i < records.length; i++) {
+    const rec = records[i];
+    try {
+      await session.ensureFresh();
+      const sites = {};
+      for (const site of SKINFOLD_SITES) {
+        const n = toNumber(rec[site]);
+        if (n !== void 0) sites[site] = n;
+      }
+      const checkInDate = typeof rec.checkInDate === "string" ? rec.checkInDate : void 0;
+      if (checkInDate === void 0) throw new Error("record missing checkInDate");
+      const checkInTime = typeof rec.checkInTime === "string" ? rec.checkInTime : void 0;
+      const bodyWeightKg = toNumber(rec.bodyWeightKg);
+      const result = await apiRequest(config.baseUrl, "/athletelog/v1/checkins/import", {
+        method: "POST",
+        token: session.getToken(),
+        body: {
+          targetUserId,
+          checkInDate,
+          ...checkInTime ? { checkInTime } : {},
+          ...bodyWeightKg !== void 0 ? { bodyWeightKg } : {},
+          ...sites
+        }
+      });
+      if (result.created) created++;
+      else updated++;
+    } catch (err) {
+      failed++;
+      const message = err instanceof ApiError ? err.message : err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Record ${i} failed: ${message}
+`);
+    }
+  }
+  const summary = { created, updated, failed };
+  if (args.json) {
+    process.stdout.write(JSON.stringify(summary, null, 2) + "\n");
+    return;
+  }
+  process.stdout.write(`Import complete: ${created} created, ${updated} updated, ${failed} failed
+`);
+}
+
+// src/prompt.ts
+import { createInterface } from "readline";
+function isInteractive() {
+  return process.stdin.isTTY === true;
+}
+function promptSecret(query) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+    let muted = false;
+    rl._writeToOutput = (chunk) => {
+      if (!muted) process.stdout.write(chunk);
+    };
+    rl.question(query, (answer) => {
+      process.stdout.write("\n");
+      rl.close();
+      resolve(answer.trim());
+    });
+    muted = true;
+  });
+}
+
+// src/commands/login.ts
+async function runLogin(args) {
+  const envKey = process.env.ATHLETELOG_API_KEY;
+  let key = args.key ?? envKey;
+  const fromEnvVar = key !== void 0 && args.key === void 0;
+  if (!key) {
+    if (!isInteractive()) {
+      throw new Error("No API key. In a non-interactive shell, pass --key or set ATHLETELOG_API_KEY.");
+    }
+    key = await promptSecret("Enter API key: ");
+  }
+  if (!key) throw new Error("No API key provided.");
+  const overrides = { apiKey: key, url: args.url, env: args.env };
+  const config = loadConfig(overrides);
+  const session = await createAuthSession(config);
+  const me = await apiRequest(config.baseUrl, "/athletelog/v1/me", { token: session.getToken() });
+  process.stdout.write(`\u2713 Logged in as Coach ${me.name} (${me.env})
+`);
+  if (!fromEnvVar) {
+    const storedEnv = args.env ?? (config.env === "unknown" ? void 0 : config.env);
+    writeConfig({
+      apiKey: key,
+      ...storedEnv ? { env: storedEnv } : {},
+      ...args.url ? { url: args.url } : {}
+    });
+  }
+}
+
+// src/commands/whoami.ts
+async function runWhoami(args) {
+  const config = loadConfig();
+  const session = await createAuthSession(config);
+  const me = await apiRequest(config.baseUrl, "/athletelog/v1/me", { token: session.getToken() });
+  if (args.json) {
+    process.stdout.write(JSON.stringify({ name: me.name, email: me.email, env: me.env, baseUrl: config.baseUrl }, null, 2) + "\n");
+    return;
+  }
+  process.stdout.write(`Coach ${me.name} (${me.env}) @ ${config.baseUrl}
+`);
+}
+
+// src/commands/logout.ts
+function runLogout() {
+  clearConfig();
+  process.stdout.write("Logged out.\n");
+}
+
+// src/index.ts
+var VALID_ENVS = ["dev", "staging", "prod"];
+var FULL_USAGE = `athletelog -- AthleteLog CLI
+Usage:
+  athletelog login [--key alog_\u2026] [--env dev|staging|prod] [--url <base>]
+  athletelog whoami [--json]
+  athletelog logout
+  athletelog athletes list [--json]
+  athletelog checkin import --athlete <id> --file <records.json> [--json]
+`;
+function usageFor(group, action) {
+  if (group === "checkin" && action === "import") {
+    return `athletelog checkin import --athlete <id> --file <records.json> [--json]
+  --athlete  target athlete userId (applied to every record; NOT read from the file)
+  --file     path to a JSON array of records
+`;
+  }
+  if (group === "athletes" && action === "list") return `athletelog athletes list [--json]
+`;
+  if (group === "login") return `athletelog login [--key alog_\u2026] [--env dev|staging|prod] [--url <base>]
+`;
+  return FULL_USAGE;
+}
+async function main() {
+  let parsed;
+  try {
+    parsed = parseArgs({
+      allowPositionals: true,
+      strict: true,
+      options: {
+        json: { type: "boolean", default: false },
+        help: { type: "boolean", default: false },
+        athlete: { type: "string" },
+        file: { type: "string" },
+        key: { type: "string" },
+        url: { type: "string" },
+        env: { type: "string" }
+      }
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`Argument error: ${message}
+${usageFor()}`);
+    process.exit(1);
+  }
+  const { values, positionals } = parsed;
+  const [group, action] = positionals;
+  const json = values.json === true;
+  if (values.help === true || group === "help") {
+    process.stdout.write(usageFor(group === "help" ? action : group, action));
+    process.exit(0);
+  }
+  let env;
+  if (typeof values.env === "string") {
+    if (!VALID_ENVS.includes(values.env)) {
+      throw new Error(`--env must be one of: ${VALID_ENVS.join(", ")}`);
+    }
+    env = values.env;
+  }
+  if (group === "login") {
+    await runLogin({ key: values.key, url: values.url, env });
+    return;
+  }
+  if (group === "whoami") {
+    await runWhoami({ json });
+    return;
+  }
+  if (group === "logout") {
+    runLogout();
+    return;
+  }
+  if (group === "athletes" && action === "list") {
+    await runAthletesList({ json });
+    return;
+  }
+  if (group === "checkin" && action === "import") {
+    if (!values.athlete || !values.file) {
+      throw new Error("checkin import requires --athlete and --file");
+    }
+    await runCheckinImport({ json, athlete: values.athlete, file: values.file });
+    return;
+  }
+  process.stderr.write(`Unknown command: ${group ?? ""} ${action ?? ""}
+`);
+  process.exit(1);
+}
+main().catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`Error: ${message}
+`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@athletelog/cli",
+  "version": "0.1.0-beta.1",
+  "type": "module",
+  "bin": {
+    "athletelog": "./dist/index.js"
+  },
+  "files": ["dist"],
+  "engines": {
+    "node": ">=18.18"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "beta"
+  },
+  "scripts": {
+    "build": "tsup",
+    "prepack": "tsup"
+  },
+  "devDependencies": {
+    "tsup": "8.5.0"
+  }
+}