dblx 0.1.46 → 0.1.48

package/README.md

@@ -0,0 +1,79 @@
+# dblx
+
+CLI for [dblebox](https://app.dblebox.com) — thread-first communication.
+
+## Usage
+
+```
+bunx dblx <command>
+```
+
+## Authentication
+
+Generate an API key from **Settings > API Keys** in the dblebox web app, then:
+
+```
+dblx auth login
+```
+
+You'll be prompted for your key (starts with `dblx_`). Credentials are saved to `~/.config/dblx.json`.
+
+```
+dblx auth whoami     # show current user
+dblx auth logout     # remove saved credentials
+```
+
+You can also set `DBLEBOX_API_KEY` and `DBLEBOX_API_URL` environment variables instead of using `auth login`.
+
+## Threads
+
+```
+dblx threads list                          # list your threads
+dblx threads list --archived               # include archived
+dblx threads list --snoozed                # include snoozed
+dblx threads create --title "New thread"   # create a thread
+dblx threads create --title "..." --comment "First message"
+dblx threads update <id> --title "New title"
+dblx threads archive <id>
+dblx threads unarchive <id>
+dblx threads snooze <id> --until 2026-03-01T09:00:00
+dblx threads unsnooze <id>
+dblx threads set-parent <id> --parent <parent-id>
+dblx threads set-today <id>               # assign to today
+dblx threads set-today <id> --date 2026-03-01
+dblx threads unset-today <id>
+```
+
+## Comments
+
+```
+dblx comments list --thread <id>
+dblx comments add --thread <id> --body "Hello"
+dblx comments edit <comment-id> --body "Updated text"
+```
+
+## Members
+
+```
+dblx members list <thread-id>
+dblx members invite <thread-id> --user alice@example.com
+```
+
+## Today
+
+```
+dblx today                        # show today's threads and note
+dblx today --date 2026-03-01      # show a specific date
+dblx today note                   # read today's daily note
+dblx today note --set "My note"   # update today's daily note
+dblx today note --date 2026-03-01
+```
+
+## JSON output
+
+All read commands support `--json` for machine-readable output:
+
+```
+dblx threads list --json
+dblx today --json
+```

package/dist/index.js

@@ -2079,9 +2079,13 @@ import {
   unlinkSync,
   existsSync
 } from "fs";
-var CONFIG_DIR = join(homedir(), ".config");
-var CONFIG_PATH = join(CONFIG_DIR, "dblx.json");
 var DEFAULT_API_URL = "https://app.dblebox.com";
+var DEFAULT_CONFIG_DIR = join(homedir(), ".config");
+var DEFAULT_CONFIG_PATH = join(DEFAULT_CONFIG_DIR, "dblx.json");
+var configPath = DEFAULT_CONFIG_PATH;
+function getConfigPath() {
+  return configPath;
+}
 function loadConfig() {
   const envKey = process.env.DBLEBOX_API_KEY;
   if (envKey) {
@@ -2090,50 +2094,358 @@ function loadConfig() {
       api_url: process.env.DBLEBOX_API_URL || DEFAULT_API_URL
     };
   }
-  if (!existsSync(CONFIG_PATH)) {
+  if (!existsSync(configPath)) {
     return null;
   }
   try {
-    const raw = readFileSync(CONFIG_PATH, "utf-8");
+    const raw = readFileSync(configPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
   }
 }
 function saveConfig(config) {
-  mkdirSync(CONFIG_DIR, { recursive: true });
-  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + `
+  const dir = join(configPath, "..");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + `
 `, "utf-8");
 }
 function deleteConfig() {
-  if (existsSync(CONFIG_PATH)) {
-    unlinkSync(CONFIG_PATH);
+  if (existsSync(configPath)) {
+    unlinkSync(configPath);
   }
 }
-function getConfigPath() {
-  return CONFIG_PATH;
+
+// ../node_modules/@elysiajs/eden/dist/chunk-QSLHAOSM.mjs
+var s = class extends Error {
+  constructor(e, n) {
+    super(n + "");
+    this.status = e;
+    this.value = n;
+  }
+};
+var i = /(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))/;
+var o = /(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat)\s(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s\d{2}\s\d{4}\s\d{2}:\d{2}:\d{2}\sGMT(?:\+|-)\d{4}\s\([^)]+\)/;
+var c = /^(?:(?:(?:(?:0?[1-9]|[12][0-9]|3[01])[/\s-](?:0?[1-9]|1[0-2])[/\s-](?:19|20)\d{2})|(?:(?:19|20)\d{2}[/\s-](?:0?[1-9]|1[0-2])[/\s-](?:0?[1-9]|[12][0-9]|3[01]))))(?:\s(?:1[012]|0?[1-9]):[0-5][0-9](?::[0-5][0-9])?(?:\s[AP]M)?)?$/;
+var u = (t) => t.trim().length !== 0 && !Number.isNaN(Number(t));
+var d = (t) => {
+  if (typeof t != "string")
+    return null;
+  let r = t.replace(/"/g, "");
+  if (i.test(r) || o.test(r) || c.test(r)) {
+    let e = new Date(r);
+    if (!Number.isNaN(e.getTime()))
+      return e;
+  }
+  return null;
+};
+var a = (t) => {
+  let r = t.charCodeAt(0), e = t.charCodeAt(t.length - 1);
+  return r === 123 && e === 125 || r === 91 && e === 93;
+};
+var p = (t) => JSON.parse(t, (r, e) => {
+  let n = d(e);
+  return n || e;
+});
+var g = (t) => {
+  if (!t)
+    return t;
+  if (u(t))
+    return +t;
+  if (t === "true")
+    return true;
+  if (t === "false")
+    return false;
+  let r = d(t);
+  if (r)
+    return r;
+  if (a(t))
+    try {
+      return p(t);
+    } catch {}
+  return t;
+};
+var S = (t) => {
+  let r = t.data.toString();
+  return r === "null" ? null : g(r);
+};
+
+// ../node_modules/@elysiajs/eden/dist/chunk-LJDYVDXQ.mjs
+var F = class {
+  constructor(t) {
+    this.url = t;
+    this.ws = new WebSocket(t);
+  }
+  ws;
+  send(t) {
+    return Array.isArray(t) ? (t.forEach((n) => this.send(n)), this) : (this.ws.send(typeof t == "object" ? JSON.stringify(t) : t.toString()), this);
+  }
+  on(t, n, s2) {
+    return this.addEventListener(t, n, s2);
+  }
+  off(t, n, s2) {
+    return this.ws.removeEventListener(t, n, s2), this;
+  }
+  subscribe(t, n) {
+    return this.addEventListener("message", t, n);
+  }
+  addEventListener(t, n, s2) {
+    return this.ws.addEventListener(t, (f) => {
+      if (t === "message") {
+        let o2 = S(f);
+        n({ ...f, data: o2 });
+      } else
+        n(f);
+    }, s2), this;
+  }
+  removeEventListener(t, n, s2) {
+    return this.off(t, n, s2), this;
+  }
+  close() {
+    return this.ws.close(), this;
+  }
+};
+var J = ["get", "post", "put", "delete", "patch", "options", "head", "connect", "subscribe"];
+var D = ["localhost", "127.0.0.1", "0.0.0.0"];
+var K = typeof FileList > "u";
+var I = (e) => K ? e instanceof Blob : e instanceof FileList || e instanceof File;
+var P = (e) => {
+  if (!e)
+    return false;
+  for (let t in e)
+    if (I(e[t]) || Array.isArray(e[t]) && e[t].find(I))
+      return true;
+  return false;
+};
+var C = (e) => K ? e : new Promise((t) => {
+  let n = new FileReader;
+  n.onload = () => {
+    let s2 = new File([n.result], e.name, { lastModified: e.lastModified, type: e.type });
+    t(s2);
+  }, n.readAsArrayBuffer(e);
+});
+var b = (e, t, n = {}, s2 = {}) => {
+  if (Array.isArray(e)) {
+    for (let f of e)
+      if (!Array.isArray(f))
+        s2 = b(f, t, n, s2);
+      else {
+        let o2 = f[0];
+        if (typeof o2 == "string")
+          s2[o2.toLowerCase()] = f[1];
+        else
+          for (let [i2, h] of o2)
+            s2[i2.toLowerCase()] = h;
+      }
+    return s2;
+  }
+  if (!e)
+    return s2;
+  switch (typeof e) {
+    case "function":
+      if (e instanceof Headers)
+        return b(e, t, n, s2);
+      let f = e(t, n);
+      return f ? b(f, t, n, s2) : s2;
+    case "object":
+      if (e instanceof Headers)
+        return e.forEach((o2, i2) => {
+          s2[i2.toLowerCase()] = o2;
+        }), s2;
+      for (let [o2, i2] of Object.entries(e))
+        s2[o2.toLowerCase()] = i2;
+      return s2;
+    default:
+      return s2;
+  }
+};
+async function* U(e) {
+  let t = e.body;
+  if (!t)
+    return;
+  let n = t.getReader(), s2 = new TextDecoder;
+  try {
+    for (;; ) {
+      let { done: f, value: o2 } = await n.read();
+      if (f)
+        break;
+      let i2 = typeof o2 == "string" ? o2 : s2.decode(o2);
+      i2.includes(`
+
+`) ? yield* _(i2) : yield g(i2);
+    }
+  } finally {
+    n.releaseLock();
+  }
 }
+function* _(e) {
+  let t = e.split(`
+
+`);
+  for (let n of t) {
+    if (n.indexOf(":") <= 0) {
+      n && (yield g(n));
+      continue;
+    }
+    let s2 = n.split(`
+`), f = {};
+    for (let o2 of s2) {
+      let i2 = o2.indexOf(":");
+      if (i2 > 0) {
+        let h = o2.slice(0, i2).trim(), L = o2.slice(i2 + 1).trim();
+        f[h] = g(L);
+      }
+    }
+    yield f;
+  }
+}
+var x = (e, t, n = [], s2) => new Proxy(() => {}, { get(f, o2) {
+  return x(e, t, o2 === "index" ? n : [...n, o2], s2);
+}, apply(f, o2, [i2, h]) {
+  if (!i2 || h || typeof i2 == "object" && Object.keys(i2).length !== 1 || J.includes(n.at(-1))) {
+    let L = [...n], k = L.pop(), v = "/" + L.join("/"), { fetcher: N = fetch, headers: R, onRequest: g2, onResponse: E, fetch: H } = t, m = k === "get" || k === "head" || k === "subscribe";
+    R = b(R, v, h);
+    let T = m ? i2?.query : h?.query, O = "";
+    if (T) {
+      let r = (w, u2) => {
+        O += (O ? "&" : "?") + `${encodeURIComponent(w)}=${encodeURIComponent(u2)}`;
+      };
+      for (let [w, u2] of Object.entries(T)) {
+        if (Array.isArray(u2)) {
+          for (let y of u2)
+            r(w, y);
+          continue;
+        }
+        if (u2 != null) {
+          if (typeof u2 == "object") {
+            r(w, JSON.stringify(u2));
+            continue;
+          }
+          r(w, `${u2}`);
+        }
+      }
+    }
+    if (k === "subscribe") {
+      let r = e.replace(/^([^]+):\/\//, e.startsWith("https://") ? "wss://" : e.startsWith("http://") || D.find((w) => e.includes(w)) ? "ws://" : "wss://") + v + O;
+      return new F(r);
+    }
+    return (async () => {
+      let r = { method: k?.toUpperCase(), body: i2, ...H, headers: R };
+      r.headers = { ...R, ...b(m ? i2?.headers : h?.headers, v, r) };
+      let w = m && typeof i2 == "object" ? i2.fetch : h?.fetch;
+      if (r = { ...r, ...w }, m && delete r.body, g2) {
+        Array.isArray(g2) || (g2 = [g2]);
+        for (let l of g2) {
+          let a2 = await l(v, r);
+          typeof a2 == "object" && (r = { ...r, ...a2, headers: { ...r.headers, ...b(a2.headers, v, r) } });
+        }
+      }
+      if (m && delete r.body, P(i2)) {
+        let l = new FormData;
+        for (let [a2, c2] of Object.entries(r.body)) {
+          if (Array.isArray(c2)) {
+            for (let d2 = 0;d2 < c2.length; d2++) {
+              let j = c2[d2];
+              l.append(a2, j instanceof File ? await C(j) : j);
+            }
+            continue;
+          }
+          if (K) {
+            if (Array.isArray(c2))
+              for (let d2 of c2)
+                l.append(a2, d2);
+            else
+              l.append(a2, c2);
+            continue;
+          }
+          if (c2 instanceof File) {
+            l.append(a2, await C(c2));
+            continue;
+          }
+          if (c2 instanceof FileList) {
+            for (let d2 = 0;d2 < c2.length; d2++)
+              l.append(a2, await C(c2[d2]));
+            continue;
+          }
+          l.append(a2, c2);
+        }
+        r.body = l;
+      } else
+        typeof i2 == "object" ? (r.headers["content-type"] = "application/json", r.body = JSON.stringify(i2)) : i2 != null && (r.headers["content-type"] = "text/plain");
+      if (m && delete r.body, g2) {
+        Array.isArray(g2) || (g2 = [g2]);
+        for (let l of g2) {
+          let a2 = await l(v, r);
+          typeof a2 == "object" && (r = { ...r, ...a2, headers: { ...r.headers, ...b(a2.headers, v, r) } });
+        }
+      }
+      h?.headers?.["content-type"] && (r.headers["content-type"] = h?.headers["content-type"]);
+      let u2 = e + v + O, y = await (s2?.handle(new Request(u2, r)) ?? N(u2, r)), p2 = null, S2 = null;
+      if (E) {
+        Array.isArray(E) || (E = [E]);
+        for (let l of E)
+          try {
+            let a2 = await l(y.clone());
+            if (a2 != null) {
+              p2 = a2;
+              break;
+            }
+          } catch (a2) {
+            a2 instanceof s ? S2 = a2 : S2 = new s(422, a2);
+            break;
+          }
+      }
+      if (p2 !== null)
+        return { data: p2, error: S2, response: y, status: y.status, headers: y.headers };
+      switch (y.headers.get("Content-Type")?.split(";")[0]) {
+        case "text/event-stream":
+          p2 = U(y);
+          break;
+        case "application/json":
+          p2 = JSON.parse(await y.text(), (a2, c2) => {
+            if (typeof c2 != "string")
+              return c2;
+            let d2 = d(c2);
+            return d2 || c2;
+          });
+          break;
+        case "application/octet-stream":
+          p2 = await y.arrayBuffer();
+          break;
+        case "multipart/form-data":
+          let l = await y.formData();
+          p2 = {}, l.forEach((a2, c2) => {
+            p2[c2] = a2;
+          });
+          break;
+        default:
+          p2 = await y.text().then(g);
+      }
+      return (y.status >= 300 || y.status < 200) && (S2 = new s(y.status, p2), p2 = null), { data: p2, error: S2, response: y, status: y.status, headers: y.headers };
+    })();
+  }
+  return typeof i2 == "object" ? x(e, t, [...n, Object.values(i2)[0]], s2) : x(e, t, n);
+} });
+var Q = (e, t = {}) => typeof e == "string" ? (t.keepDomain || (e.includes("://") || (e = (D.find((n) => e.includes(n)) ? "http://" : "https://") + e), e.endsWith("/") && (e = e.slice(0, -1))), x(e, t)) : (typeof window < "u" && console.warn("Elysia instance server found on client side, this is not recommended for security reason. Use generic type instead."), x("http://e.ly", t, [], e));
 
 // src/api.ts
-async function apiRequest(path, options = {}) {
+function getApi() {
   const config = loadConfig();
   if (!config) {
     throw new Error("Not logged in. Run: dblx auth login");
   }
-  const url = `${config.api_url}${path}`;
-  const res = await fetch(url, {
-    ...options,
+  return Q(config.api_url, {
     headers: {
-      Authorization: `Bearer ${config.api_key}`,
-      "Content-Type": "application/json",
-      ...options.headers
+      Authorization: `Bearer ${config.api_key}`
+    }
+  });
+}
+function getApiWith(apiKey, apiUrl) {
+  return Q(apiUrl, {
+    headers: {
+      Authorization: `Bearer ${apiKey}`
     }
   });
-  if (!res.ok) {
-    const body = await res.json().catch(() => ({}));
-    throw new Error(`API error (${res.status}): ${body.error || res.statusText}`);
-  }
-  return res.json();
 }
 
 // src/output.ts
@@ -2162,11 +2474,11 @@ function output(data, opts) {
 function printTable(rows) {
   const keys = Object.keys(rows[0]);
   const widths = keys.map((k) => Math.max(k.length, ...rows.map((r) => String(r[k] ?? "").length)));
-  const header = keys.map((k, i) => k.padEnd(widths[i])).join("  ");
+  const header = keys.map((k, i2) => k.padEnd(widths[i2])).join("  ");
   console.log(header);
   console.log(widths.map((w) => "-".repeat(w)).join("  "));
   for (const row of rows) {
-    const line = keys.map((k, i) => String(row[k] ?? "").padEnd(widths[i])).join("  ");
+    const line = keys.map((k, i2) => String(row[k] ?? "").padEnd(widths[i2])).join("  ");
     console.log(line);
   }
 }
@@ -2195,25 +2507,26 @@ var authCommand = new Command("auth").description("Manage authentication").addCo
     console.error('Invalid API key format. Keys should start with "dblx_".');
     process.exit(1);
   }
-  const config = { api_key: apiKey, api_url: opts.apiUrl };
-  saveConfig(config);
-  try {
-    const me = await apiRequest("/api/cli/v1/me");
-    console.log(`Logged in as ${me.username} (${me.email})`);
-    console.log(`Config saved to ${getConfigPath()}`);
-  } catch {
-    deleteConfig();
+  const api = getApiWith(apiKey, opts.apiUrl);
+  const { data, error } = await api.api.cli.v1.me.get();
+  if (error) {
     console.error("Login failed. The API key may be invalid.");
     process.exit(1);
   }
+  saveConfig({ api_key: apiKey, api_url: opts.apiUrl });
+  console.log(`Logged in as ${data.username} (${data.email})`);
+  console.log(`Config saved to ${getConfigPath()}`);
 })).addCommand(new Command("whoami").description("Show the current authenticated user").option("--json", "Output as JSON").action(async (opts) => {
   const config = loadConfig();
   if (!config) {
     console.error("Not logged in. Run: dblx auth login");
     process.exit(1);
   }
-  const me = await apiRequest("/api/cli/v1/me");
-  output(me, { json: opts.json });
+  const api = getApi();
+  const { data, error } = await api.api.cli.v1.me.get();
+  if (error)
+    throw error;
+  output(data, { json: opts.json });
 })).addCommand(new Command("logout").description("Remove saved credentials").action(() => {
   deleteConfig();
   console.log("Logged out. Config removed.");
@@ -2221,13 +2534,15 @@ var authCommand = new Command("auth").description("Manage authentication").addCo
 
 // src/commands/threads.ts
 var threadsCommand = new Command("threads").description("Manage threads").addCommand(new Command("list").description("List your threads").option("--json", "Output as JSON").option("--archived", "Include archived threads").option("--snoozed", "Include snoozed threads").action(async (opts) => {
-  const params = new URLSearchParams;
-  if (opts.archived)
-    params.set("archived", "true");
-  if (opts.snoozed)
-    params.set("snoozed", "true");
-  const qs = params.toString();
-  const data = await apiRequest(`/api/cli/v1/threads${qs ? `?${qs}` : ""}`);
+  const api = getApi();
+  const { data, error } = await api.api.cli.v1.threads.get({
+    query: {
+      archived: opts.archived ? "true" : undefined,
+      snoozed: opts.snoozed ? "true" : undefined
+    }
+  });
+  if (error)
+    throw error;
   if (opts.json) {
     output(data.threads, { json: true });
     return;
@@ -2240,11 +2555,228 @@ var threadsCommand = new Command("threads").description("Manage threads").addCom
     snoozed: t.snoozed ? "snoozed" : ""
   }));
   output(rows, { json: false });
+})).addCommand(new Command("create").description("Create a new thread").requiredOption("--title <title>", "Thread title").option("--comment <text>", "Optional first comment").option("--json", "Output as JSON").action(async (opts) => {
+  const api = getApi();
+  const { data, error } = await api.api.cli.v1.threads.post({
+    body: opts.title,
+    comment: opts.comment
+  });
+  if (error)
+    throw error;
+  if (opts.json) {
+    output(data.thread, { json: true });
+    return;
+  }
+  console.log(`Created thread ${data.thread.id.slice(0, 8)}: ${data.thread.body}`);
+})).addCommand(new Command("update").description("Update a thread title").argument("<id>", "Thread ID").requiredOption("--title <title>", "New title").option("--json", "Output as JSON").action(async (id, opts) => {
+  const api = getApi();
+  const { data, error } = await api.api.cli.v1.threads({ id }).put({
+    body: opts.title
+  });
+  if (error)
+    throw error;
+  if (opts.json) {
+    output(data.thread, { json: true });
+    return;
+  }
+  console.log(`Updated thread ${data.thread.id.slice(0, 8)}: ${data.thread.body}`);
+})).addCommand(new Command("archive").description("Archive a thread").argument("<id>", "Thread ID").action(async (id) => {
+  const api = getApi();
+  const { error } = await api.api.cli.v1.threads({ id }).archive.put({
+    archived: true
+  });
+  if (error)
+    throw error;
+  console.log("Archived.");
+})).addCommand(new Command("unarchive").description("Unarchive a thread").argument("<id>", "Thread ID").action(async (id) => {
+  const api = getApi();
+  const { error } = await api.api.cli.v1.threads({ id }).archive.put({
+    archived: false
+  });
+  if (error)
+    throw error;
+  console.log("Unarchived.");
+})).addCommand(new Command("snooze").description("Snooze a thread").argument("<id>", "Thread ID").requiredOption("--until <datetime>", "Snooze until (ISO datetime)").action(async (id, opts) => {
+  const api = getApi();
+  const { error } = await api.api.cli.v1.threads({ id }).snooze.put({
+    until: opts.until
+  });
+  if (error)
+    throw error;
+  console.log(`Snoozed until ${opts.until}.`);
+})).addCommand(new Command("unsnooze").description("Remove snooze from a thread").argument("<id>", "Thread ID").action(async (id) => {
+  const api = getApi();
+  const { error } = await api.api.cli.v1.threads({ id }).snooze.put({
+    until: null
+  });
+  if (error)
+    throw error;
+  console.log("Unsnoozed.");
+})).addCommand(new Command("set-parent").description("Set a parent thread").argument("<id>", "Thread ID").requiredOption("--parent <parent-id>", "Parent thread ID").action(async (id, opts) => {
+  const api = getApi();
+  const { error } = await api.api.cli.v1.threads({ id }).parent.put({
+    parent_id: opts.parent
+  });
+  if (error)
+    throw error;
+  console.log(`Parent set to ${opts.parent.slice(0, 8)}.`);
+})).addCommand(new Command("set-today").description("Assign thread to a date").argument("<id>", "Thread ID").option("--date <date>", "Date (YYYY-MM-DD)", new Date().toISOString().slice(0, 10)).action(async (id, opts) => {
+  const api = getApi();
+  const { error } = await api.api.cli.v1.threads({ id }).today.put({
+    date: opts.date
+  });
+  if (error)
+    throw error;
+  console.log(`Assigned to ${opts.date}.`);
+})).addCommand(new Command("unset-today").description("Remove thread from a date").argument("<id>", "Thread ID").option("--date <date>", "Date (YYYY-MM-DD)", new Date().toISOString().slice(0, 10)).action(async (id, opts) => {
+  const api = getApi();
+  const { error } = await api.api.cli.v1.threads({ id }).today.delete({
+    date: opts.date
+  });
+  if (error)
+    throw error;
+  console.log(`Removed from ${opts.date}.`);
+}));
+
+// src/commands/comments.ts
+var commentsCommand = new Command("comments").description("Manage comments").addCommand(new Command("list").description("List comments in a thread").requiredOption("--thread <id>", "Thread ID").option("--json", "Output as JSON").action(async (opts) => {
+  const api = getApi();
+  const { data, error } = await api.api.cli.v1.threads({ id: opts.thread }).comments.get();
+  if (error)
+    throw error;
+  if (opts.json) {
+    output(data.comments, { json: true });
+    return;
+  }
+  const rows = data.comments.map((c2) => ({
+    id: c2.id.slice(0, 8),
+    user: c2.creator_username,
+    body: c2.body.length > 60 ? c2.body.slice(0, 57) + "..." : c2.body,
+    created_at: c2.created_at
+  }));
+  output(rows, { json: false });
+})).addCommand(new Command("add").description("Add a comment to a thread").requiredOption("--thread <id>", "Thread ID").requiredOption("--body <text>", "Comment text").option("--json", "Output as JSON").action(async (opts) => {
+  const api = getApi();
+  const { data, error } = await api.api.cli.v1.threads({ id: opts.thread }).comments.post({ body: opts.body });
+  if (error)
+    throw error;
+  if (opts.json) {
+    output(data.comment, { json: true });
+    return;
+  }
+  console.log(`Comment added (${data.comment.id.slice(0, 8)}).`);
+})).addCommand(new Command("edit").description("Edit a comment").argument("<id>", "Comment ID").requiredOption("--body <text>", "New comment text").option("--json", "Output as JSON").action(async (id, opts) => {
+  const api = getApi();
+  const { data, error } = await api.api.cli.v1.comments({ id }).put({ body: opts.body });
+  if (error)
+    throw error;
+  if (opts.json) {
+    output(data.comment, { json: true });
+    return;
+  }
+  console.log(`Comment updated (${data.comment.id.slice(0, 8)}).`);
+}));
+
+// src/commands/members.ts
+var membersCommand = new Command("members").description("Manage thread members").addCommand(new Command("list").description("List members of a thread").argument("<thread-id>", "Thread ID").option("--json", "Output as JSON").action(async (threadId, opts) => {
+  const api = getApi();
+  const { data, error } = await api.api.cli.v1.threads({ id: threadId }).members.get();
+  if (error)
+    throw error;
+  if (opts.json) {
+    output(data.members, { json: true });
+    return;
+  }
+  const rows = data.members.filter((m) => !m.revoked_at).map((m) => ({
+    username: m.username,
+    email: m.email
+  }));
+  output(rows, { json: false });
+})).addCommand(new Command("invite").description("Invite a user to a thread").argument("<thread-id>", "Thread ID").requiredOption("--user <email-or-username>", "User email or username").action(async (threadId, opts) => {
+  const api = getApi();
+  const { data, error } = await api.api.cli.v1.threads({ id: threadId }).members.post({ user: opts.user });
+  if (error)
+    throw error;
+  if (data.invited) {
+    console.log(`Invited ${data.user?.username || opts.user}.`);
+  } else {
+    console.log(data.reason || "Could not invite user.");
+  }
+}));
+
+// src/commands/today.ts
+function localDate(dateArg) {
+  if (dateArg)
+    return dateArg;
+  const now = new Date;
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, "0");
+  const d2 = String(now.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d2}`;
+}
+var todayCommand = new Command("today").description("Today view — threads and daily note").option("--date <date>", "Date (YYYY-MM-DD)").option("--json", "Output as JSON").action(async (opts) => {
+  const date = localDate(opts.date);
+  const api = getApi();
+  const { data, error } = await api.api.cli.v1.today.get({
+    query: { date }
+  });
+  if (error)
+    throw error;
+  if (opts.json) {
+    output(data, { json: true });
+    return;
+  }
+  console.log(`Date: ${data.date}
+`);
+  if (data.threads.length > 0) {
+    console.log("Threads:");
+    for (const t of data.threads) {
+      console.log(`  ${t.id.slice(0, 8)}  ${t.body}`);
+    }
+    console.log();
+  } else {
+    console.log(`No threads for this date.
+`);
+  }
+  if (data.note) {
+    console.log("Note:");
+    console.log(data.note.content || "(empty)");
+  } else {
+    console.log("No daily note.");
+  }
+}).addCommand(new Command("note").description("Read or update the daily note").option("--date <date>", "Date (YYYY-MM-DD)").option("--set <content>", "Set note content").option("--json", "Output as JSON").action(async (opts) => {
+  const date = localDate(opts.date);
+  const api = getApi();
+  if (opts.set !== undefined) {
+    const { data: data2, error: error2 } = await api.api.cli.v1.today.note.put({ content: opts.set }, { query: { date } });
+    if (error2)
+      throw error2;
+    if (opts.json) {
+      output(data2, { json: true });
+      return;
+    }
+    console.log("Note updated.");
+    return;
+  }
+  const { data, error } = await api.api.cli.v1.today.note.get({
+    query: { date }
+  });
+  if (error)
+    throw error;
+  if (opts.json) {
+    output(data, { json: true });
+    return;
+  }
+  if (!data.note) {
+    console.log("No daily note.");
+    return;
+  }
+  console.log(data.note.content || "(empty)");
 }));
 // package.json
 var package_default = {
   name: "dblx",
-  version: "0.1.46",
+  version: "0.1.48",
   description: "CLI for dblebox — thread-first communication",
   type: "module",
   bin: {
@@ -2272,6 +2804,9 @@ var package_default = {
 var program2 = new Command().name("dblx").description("CLI for dblebox — thread-first communication").version(package_default.version);
 program2.addCommand(authCommand);
 program2.addCommand(threadsCommand);
+program2.addCommand(commentsCommand);
+program2.addCommand(membersCommand);
+program2.addCommand(todayCommand);
 program2.parseAsync().catch((err) => {
   console.error(err.message);
   process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dblx",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "description": "CLI for dblebox — thread-first communication",
   "type": "module",
   "bin": {