3meel 0.1.0

package/dist/index.js

@@ -0,0 +1,726 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import * as readline from "readline";
+import { stdin as input, stdout as output } from "process";
+import fs2 from "fs";
+import path2 from "path";
+
+// src/config.ts
+import fs from "fs";
+
+// src/paths.ts
+import { homedir } from "os";
+import path from "path";
+function configDir() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg) return path.join(xdg, "3meel");
+  return path.join(homedir(), ".config", "3meel");
+}
+function configFilePath() {
+  return path.join(configDir(), "config.json");
+}
+
+// src/config.ts
+var DEFAULT_ENVIRONMENTS = {
+  local: {
+    apiBase: "http://localhost:3000",
+    mcpBase: "http://localhost:3002"
+  },
+  staging: {
+    apiBase: "https://staging.3meel.ai",
+    mcpBase: "https://mcp.staging.3meel.ai"
+  },
+  prod: {
+    apiBase: "https://3meel.ai",
+    mcpBase: "https://mcp.3meel.ai"
+  }
+};
+function mergeWithDefaults(data) {
+  return {
+    defaultEnv: data?.defaultEnv ?? "prod",
+    environments: { ...DEFAULT_ENVIRONMENTS, ...data?.environments ?? {} },
+    bearerTokens: { ...data?.bearerTokens ?? {} }
+  };
+}
+function loadConfig() {
+  try {
+    const raw = fs.readFileSync(configFilePath(), "utf8");
+    const parsed = JSON.parse(raw);
+    return mergeWithDefaults(parsed);
+  } catch {
+    return mergeWithDefaults(null);
+  }
+}
+function saveConfig(cfg) {
+  fs.mkdirSync(configDir(), { recursive: true });
+  fs.writeFileSync(configFilePath(), JSON.stringify(cfg, null, 2), "utf8");
+}
+function getActiveProfile(cfg, envName2) {
+  const name = envName2 ?? cfg.defaultEnv;
+  const profile = cfg.environments[name];
+  if (!profile) {
+    throw new Error(
+      `Unknown environment "${name}". Define it in ${configFilePath()} or use --env local|staging|prod`
+    );
+  }
+  return { name, profile };
+}
+function getBearerToken(cfg, envName2) {
+  return cfg.bearerTokens?.[envName2];
+}
+function setBearerToken(cfg, envName2, token) {
+  const next = { ...cfg, bearerTokens: { ...cfg.bearerTokens ?? {} } };
+  if (token === void 0) {
+    delete next.bearerTokens[envName2];
+  } else {
+    next.bearerTokens[envName2] = token;
+  }
+  return next;
+}
+
+// src/client.ts
+var ApiError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "ApiError";
+  }
+};
+function apiUrl(profile, path3) {
+  const base = profile.apiBase.replace(/\/$/, "");
+  const p = path3.startsWith("/") ? path3 : `/${path3}`;
+  return `${base}${p}`;
+}
+async function apiFetch(opts, path3, init = {}) {
+  const headers = new Headers(init.headers);
+  headers.set("Accept", "application/json");
+  headers.set("Origin", opts.profile.apiBase);
+  if (opts.bearerToken) {
+    headers.set("Authorization", `Bearer ${opts.bearerToken}`);
+  }
+  if (init.body && typeof init.body === "string" && !headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/json");
+  }
+  const url = apiUrl(opts.profile, path3);
+  const res = await fetch(url, { ...init, headers });
+  const text = await res.text();
+  let parsed = null;
+  if (text) {
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      parsed = text;
+    }
+  }
+  if (!res.ok) {
+    const msg = typeof parsed === "object" && parsed !== null && "error" in parsed && typeof parsed.error?.message === "string" ? parsed.error.message : `HTTP ${res.status} ${res.statusText}`;
+    throw new ApiError(msg, res.status, parsed);
+  }
+  return parsed;
+}
+async function signInEmail(profile, email, password) {
+  const url = apiUrl(profile, "/api/auth/sign-in/email");
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Accept: "application/json", Origin: profile.apiBase },
+    body: JSON.stringify({ email, password })
+  });
+  const text = await res.text();
+  let body = null;
+  if (text) {
+    try {
+      body = JSON.parse(text);
+    } catch {
+      body = text;
+    }
+  }
+  if (!res.ok) {
+    const msg = typeof body === "object" && body !== null && "message" in body && typeof body.message === "string" ? body.message : `Sign-in failed (${res.status})`;
+    throw new ApiError(msg, res.status, body);
+  }
+  const token = res.headers.get("set-auth-token") ?? res.headers.get("Set-Auth-Token") ?? null;
+  return { token, raw: body };
+}
+
+// src/output.ts
+var Out = class {
+  constructor(mode2, isInteractive) {
+    this.mode = mode2;
+    this.isInteractive = isInteractive;
+  }
+  /** Agent-safe: no color, no decorative noise */
+  get useColor() {
+    return this.mode === "human" && this.isInteractive && !process.env.NO_COLOR;
+  }
+  json(obj) {
+    console.log(JSON.stringify(obj, null, this.mode === "human" ? 2 : void 0));
+  }
+  lineNdjson(obj) {
+    console.log(JSON.stringify(obj));
+  }
+  log(msg) {
+    if (this.mode !== "human") return;
+    console.log(msg);
+  }
+  err(msg) {
+    console.error(msg);
+  }
+  table(rows, columns) {
+    if (this.mode !== "human") {
+      this.json({ rows });
+      return;
+    }
+    if (rows.length === 0) {
+      console.log("(empty)");
+      return;
+    }
+    const widths = columns.map(
+      (c) => Math.max(c.length, ...rows.map((r) => String(r[c] ?? "").length))
+    );
+    const sep = columns.map((c, i) => "-".repeat(widths[i])).join("-+-");
+    console.log(
+      columns.map((c, i) => c.padEnd(widths[i])).join(" | ")
+    );
+    console.log(sep);
+    for (const r of rows) {
+      console.log(
+        columns.map((c, i) => String(r[c] ?? "").padEnd(widths[i])).join(" | ")
+      );
+    }
+  }
+};
+function stdoutIsTTY() {
+  return Boolean(process.stdout.isTTY);
+}
+
+// src/index.ts
+var EXIT = { ok: 0, error: 1, usage: 2, auth: 3 };
+function globalOpts(cmd) {
+  return cmd.optsWithGlobals();
+}
+function mode(g, tty) {
+  if (g.ndjson) return "ndjson";
+  if (g.json) return "json";
+  return "human";
+}
+function envName(cfg, g) {
+  return g.env ?? cfg.defaultEnv;
+}
+async function readPassword() {
+  return new Promise((resolve, reject) => {
+    const stdin = input;
+    const chunks = [];
+    if (stdin.setRawMode) stdin.setRawMode(true);
+    const onData = (b) => {
+      const s = b.toString("utf8");
+      const code = s.charCodeAt(0);
+      if (code === 3) {
+        reject(new Error("interrupted"));
+      }
+      if (s === "\n" || s === "\r") {
+        if (stdin.setRawMode) stdin.setRawMode(false);
+        stdin.removeListener("data", onData);
+        output.write("\n");
+        resolve(Buffer.concat(chunks).toString("utf8"));
+        return;
+      }
+      if (code === 127 || code === 8) {
+        chunks.pop();
+        return;
+      }
+      chunks.push(b);
+    };
+    stdin.on("data", onData);
+  });
+}
+function requireAuth(cfg, en, out) {
+  const { profile, name } = getActiveProfile(cfg, en);
+  const token = getBearerToken(cfg, name);
+  if (!token) {
+    if (out.mode === "human") {
+      output.write("Not authenticated. Run `3meel auth login`.\n");
+    } else {
+      console.log(
+        JSON.stringify({
+          error: {
+            code: "unauthorized",
+            hint: "3meel auth login"
+          }
+        })
+      );
+    }
+    process.exit(EXIT.auth);
+  }
+  return { profile, bearerToken: token };
+}
+var TERMINAL_DOC = /* @__PURE__ */ new Set(["complete", "failed"]);
+async function main() {
+  const tty = stdoutIsTTY() && Boolean(input.isTTY);
+  const program = new Command();
+  program.name("3meel");
+  program.description(
+    "3meel CLI \u2014 terminal interface to the same APIs as the web app. Use --json or --ndjson for agents."
+  );
+  program.configureHelp({ sortSubcommands: true });
+  program.option("--env <name>", "Environment: local | staging | prod (or a custom name from config)").option("--json", "Structured JSON output").option("--ndjson", "NDJSON events (for watch)");
+  const authCmd = program.command("auth").description("Authenticate and inspect session");
+  authCmd.command("login").description("Sign in with email/password; stores Bearer token").option("--email <email>").option("--password <password>").action(async function(opts, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const { name, profile } = getActiveProfile(cfg, envName(cfg, g));
+    const email = opts.email?.trim() || process.env.THREE_MEEL_EMAIL?.trim() || (tty && out.mode === "human" ? await new Promise((resolve) => {
+      const rl = readline.createInterface({ input, output });
+      rl.question("Email: ", (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    }) : "");
+    if (!email) {
+      out.err("Email required: --email or THREE_MEEL_EMAIL");
+      process.exit(EXIT.usage);
+    }
+    let password = opts.password || process.env.THREE_MEEL_PASSWORD || "";
+    if (!password && tty && out.mode === "human") {
+      output.write("Password: ");
+      password = await readPassword();
+    }
+    if (!password) {
+      out.err("Password: --password, THREE_MEEL_PASSWORD, or interactive");
+      process.exit(EXIT.usage);
+    }
+    try {
+      const { token, raw } = await signInEmail(profile, email, password);
+      if (!token) {
+        if (out.mode === "human") {
+          out.err(
+            "No Set-Auth-Token header. Ensure Better Auth bearer plugin is enabled on the server."
+          );
+        } else {
+          out.json({ error: { code: "no_token", raw } });
+        }
+        process.exit(EXIT.error);
+      }
+      let next = setBearerToken(cfg, name, token);
+      next = { ...next, defaultEnv: name };
+      saveConfig(next);
+      if (out.mode === "human") out.log(`Logged in (${name}) as ${email}`);
+      else
+        out.json({
+          ok: true,
+          environment: name,
+          user: raw?.user
+        });
+    } catch (e) {
+      if (e instanceof ApiError) {
+        if (out.mode === "human") out.err(e.message);
+        else out.json({ error: { message: e.message, body: e.body } });
+        process.exit(EXIT.auth);
+      }
+      throw e;
+    }
+  });
+  authCmd.command("logout").action(async function(_, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const { name } = getActiveProfile(cfg, envName(cfg, g));
+    saveConfig(setBearerToken(cfg, name, void 0));
+    if (out.mode === "human") out.log(`Logged out (${name})`);
+    else out.json({ ok: true, environment: name });
+  });
+  authCmd.command("whoami").action(async function(_, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const en = envName(cfg, g);
+    const c = requireAuth(cfg, en, out);
+    try {
+      const data = await apiFetch(
+        c,
+        "/api/cli/v1/whoami"
+      );
+      if (out.mode === "human") {
+        out.log(JSON.stringify(data.user, null, 2));
+        out.log(`Environment: ${getActiveProfile(cfg, en).name}`);
+      } else out.json({ ...data, environment: getActiveProfile(cfg, en).name });
+    } catch (e) {
+      if (e instanceof ApiError && e.status === 401) process.exit(EXIT.auth);
+      throw e;
+    }
+  });
+  authCmd.command("environment").alias("env").description("Show resolved API and MCP base URLs").action(async function(_, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const { name, profile } = getActiveProfile(cfg, envName(cfg, g));
+    if (out.mode === "human") {
+      out.log(`${name}
+  API  ${profile.apiBase}
+  MCP  ${profile.mcpBase}`);
+    } else {
+      out.json({
+        environment: name,
+        apiBase: profile.apiBase,
+        mcpBase: profile.mcpBase
+      });
+    }
+  });
+  const kb = program.command("kb").description("Knowledge bases");
+  kb.command("list").action(async function(_, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const c = requireAuth(cfg, envName(cfg, g), out);
+    const { knowledgeBases } = await apiFetch(c, "/api/cli/v1/kbs");
+    if (out.mode === "human") {
+      out.table(
+        knowledgeBases.map((k) => ({
+          id: k.id,
+          name: k.name,
+          documents: k.documentCount,
+          createdAt: k.createdAt
+        })),
+        ["id", "name", "documents", "createdAt"]
+      );
+    } else out.json({ knowledgeBases });
+  });
+  kb.command("create").argument("<name>", "Knowledge base name").action(async function(name, _opts, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const c = requireAuth(cfg, envName(cfg, g), out);
+    const { knowledgeBase } = await apiFetch(
+      c,
+      "/api/cli/v1/kbs",
+      { method: "POST", body: JSON.stringify({ name }) }
+    );
+    if (out.mode === "human") out.log(JSON.stringify(knowledgeBase, null, 2));
+    else out.json({ knowledgeBase });
+  });
+  kb.command("get").argument("<kbId>", "Knowledge base UUID").action(async function(kbId, _opts, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const c = requireAuth(cfg, envName(cfg, g), out);
+    const { knowledgeBase } = await apiFetch(
+      c,
+      `/api/cli/v1/kbs/${kbId}`
+    );
+    if (out.mode === "human") out.log(JSON.stringify(knowledgeBase, null, 2));
+    else out.json({ knowledgeBase });
+  });
+  kb.command("delete").argument("<kbId>", "Knowledge base UUID").action(async function(kbId, _opts, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const c = requireAuth(cfg, envName(cfg, g), out);
+    await apiFetch(c, `/api/cli/v1/kbs/${kbId}`, { method: "DELETE" });
+    if (out.mode === "human") out.log("Deleted.");
+    else out.json({ deleted: true, kbId });
+  });
+  const docs = program.command("docs").description("Documents (PDF)");
+  docs.command("list").requiredOption("--kb <uuid>", "Knowledge base id").action(async function(opts, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const c = requireAuth(cfg, envName(cfg, g), out);
+    const { documents } = await apiFetch(c, `/api/cli/v1/kbs/${opts.kb}/documents`);
+    if (out.mode === "human") {
+      out.table(
+        documents.map((d) => ({
+          id: d.id,
+          name: d.name,
+          status: d.status,
+          error: d.errorMessage ?? "",
+          createdAt: d.createdAt
+        })),
+        ["id", "name", "status", "error", "createdAt"]
+      );
+    } else out.json({ documents });
+  });
+  docs.command("upload").argument("<file>", "Path to PDF").requiredOption("--kb <uuid>", "Knowledge base id").action(async function(file, opts, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const c = requireAuth(cfg, envName(cfg, g), out);
+    const abs = path2.resolve(file);
+    if (!abs.toLowerCase().endsWith(".pdf")) {
+      out.err("Only .pdf files are supported.");
+      process.exit(EXIT.usage);
+    }
+    const st = fs2.statSync(abs);
+    const fileName = path2.basename(abs);
+    const presign = await apiFetch(c, "/api/cli/v1/upload/presign", {
+      method: "POST",
+      body: JSON.stringify({
+        knowledgeBaseId: opts.kb,
+        fileName,
+        fileSize: st.size
+      })
+    });
+    const buf = fs2.readFileSync(abs);
+    const put = await fetch(presign.presignedUrl, {
+      method: "PUT",
+      headers: { "Content-Type": "application/pdf" },
+      body: buf
+    });
+    if (!put.ok) {
+      const t = await put.text();
+      if (out.mode === "human") out.err(`Upload to storage failed: ${put.status} ${t}`);
+      else out.json({ error: { code: "upload_failed", status: put.status, body: t } });
+      process.exit(EXIT.error);
+    }
+    await apiFetch(c, "/api/cli/v1/upload/confirm", {
+      method: "POST",
+      body: JSON.stringify({ documentId: presign.documentId })
+    });
+    if (out.mode === "human") {
+      out.log(`Uploaded. documentId=${presign.documentId}`);
+      out.log(`Run: 3meel watch ${presign.documentId}`);
+    } else {
+      out.json({
+        documentId: presign.documentId,
+        status: "queued",
+        knowledgeBaseId: opts.kb
+      });
+    }
+  });
+  docs.command("get").argument("<documentId>", "Document UUID").action(async function(documentId, _opts, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const c = requireAuth(cfg, envName(cfg, g), out);
+    const { document } = await apiFetch(
+      c,
+      `/api/cli/v1/documents/${documentId}`
+    );
+    if (out.mode === "human") out.log(JSON.stringify(document, null, 2));
+    else out.json({ document });
+  });
+  docs.command("delete").argument("<documentId>", "Document UUID").action(async function(documentId, _opts, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const c = requireAuth(cfg, envName(cfg, g), out);
+    await apiFetch(c, `/api/cli/v1/documents/${documentId}`, { method: "DELETE" });
+    if (out.mode === "human") out.log("Deleted.");
+    else out.json({ deleted: true, documentId });
+  });
+  docs.command("retry").argument("<documentId>", "Document UUID (failed only)").action(async function(documentId, _opts, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const c = requireAuth(cfg, envName(cfg, g), out);
+    const r = await apiFetch(
+      c,
+      `/api/cli/v1/documents/${documentId}/retry`,
+      { method: "POST", body: "{}" }
+    );
+    if (out.mode === "human") out.log("Re-queued for processing.");
+    else out.json(r);
+  });
+  program.command("query").argument("<question>", "Question to ask").requiredOption("--kb <uuid>", "Knowledge base id").action(async function(question, opts, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const c = requireAuth(cfg, envName(cfg, g), out);
+    const data = await apiFetch(c, "/api/cli/v1/query", {
+      method: "POST",
+      body: JSON.stringify({
+        knowledgeBaseId: opts.kb,
+        question
+      })
+    });
+    if (out.mode === "human") {
+      out.log(data.answer);
+      out.log("\n--- Citations ---");
+      for (const cit of data.citations) {
+        out.log(JSON.stringify(cit));
+      }
+    } else {
+      out.json(data);
+    }
+  });
+  const mcp = program.command("mcp").description("MCP URLs and client snippets");
+  mcp.command("url").description("Print unified MCP URL (needs API key)").option("--api-key <key>", "Account API key (rak_...) or THREE_MEEL_API_KEY").action(async function(opts, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const { profile } = getActiveProfile(cfg, envName(cfg, g));
+    const key = opts.apiKey || process.env.THREE_MEEL_API_KEY;
+    if (!key) {
+      out.err("Set --api-key or THREE_MEEL_API_KEY (plaintext rak_ key).");
+      process.exit(EXIT.usage);
+    }
+    const u = `${profile.mcpBase.replace(/\/$/, "")}/mcp/unified/${key}`;
+    if (out.mode === "human") out.log(u);
+    else out.json({ url: u, kind: "unified" });
+  });
+  mcp.command("config").argument("<client>", "claude | cursor | generic").option("--api-key <key>", "or THREE_MEEL_API_KEY").action(async function(client, opts, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const { profile } = getActiveProfile(cfg, envName(cfg, g));
+    const key = opts.apiKey || process.env.THREE_MEEL_API_KEY;
+    if (!key) {
+      out.err("Set --api-key or THREE_MEEL_API_KEY");
+      process.exit(EXIT.usage);
+    }
+    const url = `${profile.mcpBase.replace(/\/$/, "")}/mcp/unified/${key}`;
+    let block;
+    if (client === "claude") {
+      block = JSON.stringify(
+        {
+          mcpServers: {
+            "3meel": { type: "streamable-http", url }
+          }
+        },
+        null,
+        2
+      );
+    } else if (client === "cursor") {
+      block = JSON.stringify(
+        { mcpServers: { "3meel": { url } } },
+        null,
+        2
+      );
+    } else {
+      block = JSON.stringify({ type: "streamable-http", url }, null, 2);
+    }
+    if (out.mode === "human") {
+      out.log(block);
+      out.log("\nMerge into your existing MCP config if needed.");
+    } else {
+      out.json({ client, configText: block, url });
+    }
+  });
+  mcp.command("test").action(async function(_, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const { profile } = getActiveProfile(cfg, envName(cfg, g));
+    const healthUrl = `${profile.mcpBase.replace(/\/$/, "")}/health`;
+    try {
+      const res = await fetch(healthUrl);
+      const text = await res.text();
+      const ok = res.ok;
+      if (out.mode === "human") {
+        out.log(`${ok ? "OK" : "FAIL"} ${healthUrl} \u2192 ${res.status} ${text.slice(0, 200)}`);
+      } else {
+        out.json({ ok, status: res.status, url: healthUrl, body: text });
+      }
+      if (!ok) process.exit(EXIT.error);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (out.mode === "human") out.err(`Request failed: ${msg}`);
+      else out.json({ ok: false, error: msg });
+      process.exit(EXIT.error);
+    }
+  });
+  program.command("watch").argument("<documentId>", "Document UUID").option("-i, --interval <ms>", "Poll interval", "2000").action(async function(documentId, opts, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const c = requireAuth(cfg, envName(cfg, g), out);
+    const ms = Math.max(500, Number(opts.interval) || 2e3);
+    let lastStatus = "";
+    for (; ; ) {
+      const { document } = await apiFetch(c, `/api/cli/v1/documents/${documentId}`);
+      const st = document.status;
+      if (st !== lastStatus) {
+        lastStatus = st;
+        if (out.mode === "ndjson") {
+          out.lineNdjson({
+            type: "document_status",
+            documentId,
+            status: st,
+            at: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        } else if (out.mode === "human") {
+          out.log(`[${documentId}] ${st}`);
+        }
+      }
+      if (TERMINAL_DOC.has(st)) {
+        if (out.mode === "ndjson") {
+          out.lineNdjson({
+            type: "document_done",
+            documentId,
+            status: st,
+            errorMessage: document.errorMessage ?? null
+          });
+        } else if (out.mode === "human") {
+          if (st === "failed") {
+            out.err(
+              document.errorMessage ? `Failed: ${document.errorMessage}
+Try: 3meel docs retry ${documentId}` : `Failed. Try: 3meel docs retry ${documentId}`
+            );
+            process.exit(EXIT.error);
+          }
+          out.log("Complete.");
+        } else {
+          out.json({
+            documentId,
+            status: st,
+            errorMessage: document.errorMessage ?? null
+          });
+        }
+        return;
+      }
+      await new Promise((r) => setTimeout(r, ms));
+    }
+  });
+  const conf = program.command("config").description("CLI config file and environment");
+  conf.command("path").action(async function(_, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const p = configFilePath();
+    if (out.mode === "human") out.log(p);
+    else out.json({ path: p });
+  });
+  conf.command("show").action(async function(_, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    const redacted = {
+      ...cfg,
+      bearerTokens: cfg.bearerTokens ? Object.fromEntries(
+        Object.keys(cfg.bearerTokens).map((k) => [k, "***"])
+      ) : {}
+    };
+    if (out.mode === "human") out.log(JSON.stringify(redacted, null, 2));
+    else out.json(redacted);
+  });
+  conf.command("set-default-env").argument("<name>").action(async function(name, _opts, cmd) {
+    const g = globalOpts(cmd);
+    const out = new Out(mode(g, tty), tty);
+    const cfg = loadConfig();
+    if (!cfg.environments[name]) {
+      out.err(`Unknown environment "${name}". Edit ${configFilePath()} to add it.`);
+      process.exit(EXIT.usage);
+    }
+    saveConfig({ ...cfg, defaultEnv: name });
+    if (out.mode === "human") out.log(`Default environment: ${name}`);
+    else out.json({ ok: true, defaultEnv: name });
+  });
+  program.showHelpAfterError("(add --help for usage)");
+  try {
+    await program.parseAsync(process.argv);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(msg);
+    process.exit(EXIT.usage);
+  }
+}
+main().catch((e) => {
+  if (e instanceof ApiError) {
+    console.error(e.message);
+    if (e.status === 401) process.exit(EXIT.auth);
+    process.exit(EXIT.error);
+  }
+  console.error(e);
+  process.exit(EXIT.error);
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "3meel",
+  "version": "0.1.0",
+  "description": "CLI for 3meel.ai — manage knowledge bases, upload documents, and query via MCP",
+  "type": "module",
+  "bin": {
+    "3meel": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "start": "node dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "rag",
+    "knowledge-base",
+    "ai",
+    "claude",
+    "pdf",
+    "3meel"
+  ],
+  "author": "Ali Almadhoob",
+  "license": "MIT",
+  "homepage": "https://3meel.ai",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AliProgrammin/rag-as-service-mcp"
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.3",
+    "tsup": "^8.5.1",
+    "typescript": "5.9.3"
+  },
+  "dependencies": {
+    "commander": "^13.1.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "files": [
+    "dist"
+  ]
+}