@andrzejchm/notion-cli 0.1.2 → 0.3.0

package/dist/cli.js

@@ -1,109 +1,236 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { Command as Command14 } from "commander";
-import { fileURLToPath } from "url";
-import { dirname, join as join3 } from "path";
 import { readFileSync } from "fs";
+import { dirname, join as join3 } from "path";
+import { fileURLToPath } from "url";
+import { Command as Command19 } from "commander";
 
-// src/output/color.ts
-import { Chalk } from "chalk";
-var _colorForced = false;
-function setColorForced(forced) {
-  _colorForced = forced;
-}
-function isColorEnabled() {
-  if (process.env.NO_COLOR) return false;
-  if (_colorForced) return true;
-  return Boolean(process.stderr.isTTY);
-}
-function createChalk() {
-  const level = isColorEnabled() ? void 0 : 0;
-  return new Chalk({ level });
-}
-function success(msg) {
-  return createChalk().green(msg);
-}
-function dim(msg) {
-  return createChalk().dim(msg);
-}
-function bold(msg) {
-  return createChalk().bold(msg);
-}
+// src/commands/append.ts
+import { Command } from "commander";
 
-// src/output/format.ts
-var _mode = "auto";
-function setOutputMode(mode) {
-  _mode = mode;
-}
-function getOutputMode() {
-  return _mode;
-}
-function isatty() {
-  return Boolean(process.stdout.isTTY);
-}
-function isHumanMode() {
-  if (_mode === "json") return false;
-  if (_mode === "md") return false;
-  return true;
-}
-function formatJSON(data) {
-  return JSON.stringify(data, null, 2);
-}
-var COLUMN_CAPS = {
-  TITLE: 50,
-  ID: 36
-};
-var DEFAULT_MAX_COL_WIDTH = 40;
-function getColumnCap(header) {
-  return COLUMN_CAPS[header.toUpperCase()] ?? DEFAULT_MAX_COL_WIDTH;
-}
-function truncate(str, maxLen) {
-  if (str.length <= maxLen) return str;
-  return str.slice(0, maxLen - 1) + "\u2026";
+// src/blocks/md-to-blocks.ts
+var INLINE_RE = /(\*\*[^*]+\*\*|_[^_]+_|\*[^*]+\*|`[^`]+`|\[[^\]]+\]\([^)]+\)|[^*_`[]+)/g;
+function parseInlineMarkdown(text) {
+  const result = [];
+  let match;
+  INLINE_RE.lastIndex = 0;
+  while ((match = INLINE_RE.exec(text)) !== null) {
+    const segment = match[0];
+    if (segment.startsWith("**") && segment.endsWith("**")) {
+      const content = segment.slice(2, -2);
+      result.push({
+        type: "text",
+        text: { content, link: null },
+        annotations: {
+          bold: true,
+          italic: false,
+          strikethrough: false,
+          underline: false,
+          code: false,
+          color: "default"
+        }
+      });
+      continue;
+    }
+    if (segment.startsWith("_") && segment.endsWith("_") || segment.startsWith("*") && segment.endsWith("*")) {
+      const content = segment.slice(1, -1);
+      result.push({
+        type: "text",
+        text: { content, link: null },
+        annotations: {
+          bold: false,
+          italic: true,
+          strikethrough: false,
+          underline: false,
+          code: false,
+          color: "default"
+        }
+      });
+      continue;
+    }
+    if (segment.startsWith("`") && segment.endsWith("`")) {
+      const content = segment.slice(1, -1);
+      result.push({
+        type: "text",
+        text: { content, link: null },
+        annotations: {
+          bold: false,
+          italic: false,
+          strikethrough: false,
+          underline: false,
+          code: true,
+          color: "default"
+        }
+      });
+      continue;
+    }
+    const linkMatch = segment.match(/^\[([^\]]+)\]\(([^)]+)\)$/);
+    if (linkMatch) {
+      const [, label, url] = linkMatch;
+      result.push({
+        type: "text",
+        text: { content: label, link: { url } },
+        annotations: {
+          bold: false,
+          italic: false,
+          strikethrough: false,
+          underline: false,
+          code: false,
+          color: "default"
+        }
+      });
+      continue;
+    }
+    result.push({
+      type: "text",
+      text: { content: segment, link: null },
+      annotations: {
+        bold: false,
+        italic: false,
+        strikethrough: false,
+        underline: false,
+        code: false,
+        color: "default"
+      }
+    });
+  }
+  return result;
 }
-function formatTable(rows, headers) {
-  const colWidths = headers.map((header, colIdx) => {
-    const cap = getColumnCap(header);
-    const headerLen = header.length;
-    const maxRowLen = rows.reduce((max, row) => {
-      const cell = row[colIdx] ?? "";
-      return Math.max(max, cell.length);
-    }, 0);
-    return Math.min(Math.max(headerLen, maxRowLen), cap);
-  });
-  const sep = "\u2500";
-  const colSep = "  ";
-  const headerRow = headers.map((h, i) => h.padEnd(colWidths[i])).join(colSep);
-  const separatorRow = colWidths.map((w) => sep.repeat(w)).join(colSep);
-  const dataRows = rows.map(
-    (row) => headers.map((_, i) => {
-      const cell = row[i] ?? "";
-      return truncate(cell, colWidths[i]).padEnd(colWidths[i]);
-    }).join(colSep)
-  );
-  return [headerRow, separatorRow, ...dataRows].join("\n");
+function makeRichText(text) {
+  return parseInlineMarkdown(text);
 }
-function printOutput(data, tableHeaders, tableRows) {
-  const mode = getOutputMode();
-  if (mode === "json") {
-    process.stdout.write(formatJSON(data) + "\n");
-  } else if (isHumanMode() && tableHeaders && tableRows) {
-    printWithPager(formatTable(tableRows, tableHeaders) + "\n");
+function mdToBlocks(md) {
+  if (!md) return [];
+  const lines = md.split("\n");
+  const blocks = [];
+  let inFence = false;
+  let fenceLang = "";
+  const fenceLines = [];
+  for (const line of lines) {
+    if (!inFence && line.startsWith("```")) {
+      inFence = true;
+      fenceLang = line.slice(3).trim() || "plain text";
+      fenceLines.length = 0;
+      continue;
+    }
+    if (inFence) {
+      if (line.startsWith("```")) {
+        const content = fenceLines.join("\n");
+        blocks.push({
+          type: "code",
+          code: {
+            rich_text: [
+              {
+                type: "text",
+                text: { content, link: null },
+                annotations: {
+                  bold: false,
+                  italic: false,
+                  strikethrough: false,
+                  underline: false,
+                  code: false,
+                  color: "default"
+                }
+              }
+            ],
+            // biome-ignore lint/suspicious/noExplicitAny: Notion SDK language type is too narrow
+            language: fenceLang
+          }
+        });
+        inFence = false;
+        fenceLang = "";
+        fenceLines.length = 0;
+      } else {
+        fenceLines.push(line);
+      }
+      continue;
+    }
+    if (line.trim() === "") continue;
+    const h1 = line.match(/^# (.+)$/);
+    if (h1) {
+      blocks.push({
+        type: "heading_1",
+        heading_1: { rich_text: makeRichText(h1[1]) }
+      });
+      continue;
+    }
+    const h2 = line.match(/^## (.+)$/);
+    if (h2) {
+      blocks.push({
+        type: "heading_2",
+        heading_2: { rich_text: makeRichText(h2[1]) }
+      });
+      continue;
+    }
+    const h3 = line.match(/^### (.+)$/);
+    if (h3) {
+      blocks.push({
+        type: "heading_3",
+        heading_3: { rich_text: makeRichText(h3[1]) }
+      });
+      continue;
+    }
+    const bullet = line.match(/^[-*] (.+)$/);
+    if (bullet) {
+      blocks.push({
+        type: "bulleted_list_item",
+        bulleted_list_item: { rich_text: makeRichText(bullet[1]) }
+      });
+      continue;
+    }
+    const numbered = line.match(/^\d+\. (.+)$/);
+    if (numbered) {
+      blocks.push({
+        type: "numbered_list_item",
+        numbered_list_item: { rich_text: makeRichText(numbered[1]) }
+      });
+      continue;
+    }
+    const quote = line.match(/^> (.+)$/);
+    if (quote) {
+      blocks.push({
+        type: "quote",
+        quote: { rich_text: makeRichText(quote[1]) }
+      });
+      continue;
+    }
+    blocks.push({
+      type: "paragraph",
+      paragraph: { rich_text: makeRichText(line) }
+    });
   }
-}
-function printWithPager(text) {
-  process.stdout.write(text);
+  if (inFence && fenceLines.length > 0) {
+    const content = fenceLines.join("\n");
+    blocks.push({
+      type: "code",
+      code: {
+        rich_text: [
+          {
+            type: "text",
+            text: { content, link: null },
+            annotations: {
+              bold: false,
+              italic: false,
+              strikethrough: false,
+              underline: false,
+              code: false,
+              color: "default"
+            }
+          }
+        ],
+        // biome-ignore lint/suspicious/noExplicitAny: Notion SDK language type is too narrow
+        language: fenceLang
+      }
+    });
+  }
+  return blocks;
 }
 
-// src/commands/init.ts
-import { Command } from "commander";
-import { input, password, confirm } from "@inquirer/prompts";
-
 // src/errors/cli-error.ts
 var CliError = class extends Error {
-  constructor(code, message, suggestion) {
-    super(message);
+  constructor(code, message, suggestion, cause) {
+    super(message, { cause });
     this.code = code;
     this.suggestion = suggestion;
     this.name = "CliError";
@@ -141,6 +268,120 @@ var ErrorCodes = {
   UNKNOWN: "UNKNOWN"
 };
 
+// src/oauth/oauth-client.ts
+var _k = 90;
+var _d = (parts) => Buffer.from(parts.join(""), "base64").toString().split("").map((c2) => String.fromCharCode(c2.charCodeAt(0) ^ _k)).join("");
+var OAUTH_CLIENT_ID = _d([
+  "aWtu",
+  "PmJt",
+  "aDh3",
+  "b2Nu",
+  "OXdi",
+  "a2I+",
+  "d2I5",
+  "amh3",
+  "ampp",
+  "bTtj",
+  "Pm44",
+  "P2s8"
+]);
+var OAUTH_CLIENT_SECRET = _d([
+  "KT85",
+  "KD8u",
+  "BWMM",
+  "axcx",
+  "P28P",
+  "ahYp",
+  "MCti",
+  "MQtt",
+  "Hj4V",
+  "NywV",
+  "I2sp",
+  "bzlv",
+  "ECIK",
+  "NTAx",
+  "IGwA",
+  "ETU7",
+  "ahU="
+]);
+var OAUTH_REDIRECT_URI = "http://localhost:54321/oauth/callback";
+function buildAuthUrl(state) {
+  const params = new URLSearchParams({
+    client_id: OAUTH_CLIENT_ID,
+    redirect_uri: OAUTH_REDIRECT_URI,
+    response_type: "code",
+    owner: "user",
+    state
+  });
+  return `https://api.notion.com/v1/oauth/authorize?${params.toString()}`;
+}
+function basicAuth() {
+  return Buffer.from(`${OAUTH_CLIENT_ID}:${OAUTH_CLIENT_SECRET}`).toString(
+    "base64"
+  );
+}
+async function exchangeCode(code, redirectUri = OAUTH_REDIRECT_URI) {
+  const response = await fetch("https://api.notion.com/v1/oauth/token", {
+    method: "POST",
+    headers: {
+      Authorization: `Basic ${basicAuth()}`,
+      "Content-Type": "application/json",
+      "Notion-Version": "2022-06-28"
+    },
+    body: JSON.stringify({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: redirectUri
+    })
+  });
+  if (!response.ok) {
+    let errorMessage = `OAuth token exchange failed (HTTP ${response.status})`;
+    try {
+      const body = await response.json();
+      if (body.error_description) errorMessage = body.error_description;
+      else if (body.error) errorMessage = body.error;
+    } catch {
+    }
+    throw new CliError(
+      ErrorCodes.AUTH_INVALID,
+      errorMessage,
+      'Run "notion auth login" to restart the OAuth flow'
+    );
+  }
+  const data = await response.json();
+  return data;
+}
+async function refreshAccessToken(refreshToken) {
+  const response = await fetch("https://api.notion.com/v1/oauth/token", {
+    method: "POST",
+    headers: {
+      Authorization: `Basic ${basicAuth()}`,
+      "Content-Type": "application/json",
+      "Notion-Version": "2022-06-28"
+    },
+    body: JSON.stringify({
+      grant_type: "refresh_token",
+      refresh_token: refreshToken
+    })
+  });
+  if (!response.ok) {
+    let errorMessage = `OAuth token refresh failed (HTTP ${response.status})`;
+    try {
+      const body = await response.json();
+      if (body.error_description) errorMessage = body.error_description;
+      else if (body.error) errorMessage = body.error;
+    } catch {
+    }
+    throw new CliError(
+      ErrorCodes.AUTH_INVALID,
+      errorMessage,
+      'Run "notion auth login" to re-authenticate'
+    );
+  }
+  const data = await response.json();
+  return data;
+}
+
 // src/config/config.ts
 import { mkdir, readFile, rename, writeFile } from "fs/promises";
 import { parse, stringify } from "yaml";
@@ -149,7 +390,7 @@ import { parse, stringify } from "yaml";
 import { homedir } from "os";
 import { join } from "path";
 function getConfigDir() {
-  const xdgConfigHome = process.env["XDG_CONFIG_HOME"];
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME;
   const base = xdgConfigHome ? xdgConfigHome : join(homedir(), ".config");
   return join(base, "notion-cli");
 }
@@ -170,17 +411,19 @@ async function readGlobalConfig() {
     throw new CliError(
       ErrorCodes.CONFIG_READ_ERROR,
       `Failed to read config file: ${configPath}`,
-      'Check file permissions or run "notion init" to create a new config'
+      'Check file permissions or run "notion init" to create a new config',
+      err
     );
   }
   try {
     const parsed = parse(raw);
     return parsed ?? {};
-  } catch {
+  } catch (err) {
     throw new CliError(
       ErrorCodes.CONFIG_READ_ERROR,
       `Failed to parse config file: ${configPath}`,
-      'The config file may be corrupted. Delete it and run "notion init" to start fresh'
+      'The config file may be corrupted. Delete it and run "notion init" to start fresh',
+      err
     );
   }
 }
@@ -190,70 +433,203 @@ async function writeGlobalConfig(config) {
   const tmpPath = `${configPath}.tmp`;
   try {
     await mkdir(configDir, { recursive: true, mode: 448 });
-  } catch {
+  } catch (err) {
     throw new CliError(
       ErrorCodes.CONFIG_WRITE_ERROR,
       `Failed to create config directory: ${configDir}`,
-      "Check that you have write permissions to your home directory"
+      "Check that you have write permissions to your home directory",
+      err
     );
   }
   const content = stringify(config);
   try {
     await writeFile(tmpPath, content, { mode: 384 });
     await rename(tmpPath, configPath);
-  } catch {
+  } catch (err) {
     throw new CliError(
       ErrorCodes.CONFIG_WRITE_ERROR,
       `Failed to write config file: ${configPath}`,
-      "Check file permissions in the config directory"
+      "Check file permissions in the config directory",
+      err
     );
   }
 }
 
-// src/notion/client.ts
-import { Client, APIErrorCode, isNotionClientError } from "@notionhq/client";
-async function validateToken(token) {
-  const notion = new Client({ auth: token });
+// src/oauth/token-store.ts
+var OAUTH_EXPIRY_DURATION_MS = 60 * 60 * 1e3;
+async function saveOAuthTokens(profileName, response) {
+  const config = await readGlobalConfig();
+  const existing = config.profiles?.[profileName] ?? {};
+  const updatedProfile = {
+    ...existing,
+    oauth_access_token: response.access_token,
+    oauth_refresh_token: response.refresh_token,
+    oauth_expiry_ms: Date.now() + OAUTH_EXPIRY_DURATION_MS,
+    workspace_id: response.workspace_id,
+    workspace_name: response.workspace_name,
+    ...response.owner?.user?.id != null && {
+      oauth_user_id: response.owner.user.id
+    },
+    ...response.owner?.user?.name != null && {
+      oauth_user_name: response.owner.user.name
+    }
+  };
+  config.profiles = {
+    ...config.profiles,
+    [profileName]: updatedProfile
+  };
+  await writeGlobalConfig(config);
+}
+async function clearOAuthTokens(profileName) {
+  const config = await readGlobalConfig();
+  const existing = config.profiles?.[profileName];
+  if (!existing) return;
+  const {
+    oauth_access_token: _access,
+    oauth_refresh_token: _refresh,
+    oauth_expiry_ms: _expiry,
+    oauth_user_id: _userId,
+    oauth_user_name: _userName,
+    ...rest
+  } = existing;
+  config.profiles = {
+    ...config.profiles,
+    [profileName]: rest
+  };
+  await writeGlobalConfig(config);
+}
+
+// src/config/local-config.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+import { parse as parse2 } from "yaml";
+async function readLocalConfig() {
+  const localConfigPath = join2(process.cwd(), ".notion.yaml");
+  let raw;
   try {
-    const me = await notion.users.me({});
-    const bot = me;
-    const workspaceName = bot.bot?.workspace_name ?? "Unknown Workspace";
-    const workspaceId = bot.bot?.workspace_id ?? "";
-    return { workspaceName, workspaceId };
-  } catch (error2) {
-    if (isNotionClientError(error2) && error2.code === APIErrorCode.Unauthorized) {
-      throw new CliError(
-        ErrorCodes.AUTH_INVALID,
-        "Invalid integration token.",
-        "Check your token at notion.so/profile/integrations/internal"
-      );
+    raw = await readFile2(localConfigPath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return null;
     }
-    throw error2;
+    throw new CliError(
+      ErrorCodes.CONFIG_READ_ERROR,
+      `Failed to read local config: ${localConfigPath}`,
+      "Check file permissions",
+      err
+    );
   }
-}
-function createNotionClient(token) {
-  return new Client({ auth: token, timeoutMs: 12e4 });
+  let parsed;
+  try {
+    parsed = parse2(raw) ?? {};
+  } catch (err) {
+    throw new CliError(
+      ErrorCodes.CONFIG_INVALID,
+      `Failed to parse .notion.yaml`,
+      "Check that the file contains valid YAML",
+      err
+    );
+  }
+  if (parsed.profile !== void 0 && parsed.token !== void 0) {
+    throw new CliError(
+      ErrorCodes.CONFIG_INVALID,
+      '.notion.yaml cannot specify both "profile" and "token"',
+      'Use either "profile: <name>" to reference a saved profile, or "token: <value>" for a direct token'
+    );
+  }
+  return parsed;
 }
 
-// src/output/stderr.ts
-function stderrWrite(msg) {
-  process.stderr.write(msg + "\n");
-}
-function reportTokenSource(source) {
-  stderrWrite(dim(`Using token from ${source}`));
+// src/config/token.ts
+function isOAuthExpired(profile) {
+  if (profile.oauth_expiry_ms == null) return false;
+  return Date.now() >= profile.oauth_expiry_ms;
+}
+async function resolveOAuthToken(profileName, profile) {
+  if (!profile.oauth_access_token) return null;
+  if (!isOAuthExpired(profile)) {
+    return profile.oauth_access_token;
+  }
+  if (!profile.oauth_refresh_token) {
+    await clearOAuthTokens(profileName);
+    throw new CliError(
+      ErrorCodes.AUTH_NO_TOKEN,
+      "OAuth session expired and no refresh token is available.",
+      'Run "notion auth login" to re-authenticate'
+    );
+  }
+  try {
+    const refreshed = await refreshAccessToken(profile.oauth_refresh_token);
+    await saveOAuthTokens(profileName, refreshed);
+    return refreshed.access_token;
+  } catch (err) {
+    await clearOAuthTokens(profileName);
+    throw new CliError(
+      ErrorCodes.AUTH_NO_TOKEN,
+      'OAuth session expired. Run "notion auth login" to re-authenticate.',
+      "Your session was revoked or the refresh token has expired",
+      err
+    );
+  }
 }
-
-// src/errors/error-handler.ts
-function mapNotionErrorCode(code) {
-  switch (code) {
-    case "unauthorized":
-      return ErrorCodes.AUTH_INVALID;
-    case "rate_limited":
-      return ErrorCodes.API_RATE_LIMITED;
-    case "object_not_found":
-      return ErrorCodes.API_NOT_FOUND;
-    default:
-      return ErrorCodes.API_ERROR;
+async function resolveProfileToken(profileName, profile) {
+  const oauthToken = await resolveOAuthToken(profileName, profile);
+  if (oauthToken) {
+    return { token: oauthToken, source: "oauth" };
+  }
+  if (profile.token) {
+    return { token: profile.token, source: `profile: ${profileName}` };
+  }
+  return null;
+}
+async function resolveToken() {
+  const envToken = process.env.NOTION_API_TOKEN;
+  if (envToken) {
+    return { token: envToken, source: "NOTION_API_TOKEN" };
+  }
+  const localConfig = await readLocalConfig();
+  if (localConfig !== null) {
+    if (localConfig.token) {
+      return { token: localConfig.token, source: ".notion.yaml" };
+    }
+    if (localConfig.profile) {
+      const globalConfig2 = await readGlobalConfig();
+      const profile = globalConfig2.profiles?.[localConfig.profile];
+      if (profile) {
+        const result = await resolveProfileToken(localConfig.profile, profile);
+        if (result) return result;
+      }
+    }
+  }
+  const globalConfig = await readGlobalConfig();
+  if (globalConfig.active_profile) {
+    const profile = globalConfig.profiles?.[globalConfig.active_profile];
+    if (profile) {
+      const result = await resolveProfileToken(
+        globalConfig.active_profile,
+        profile
+      );
+      if (result) return result;
+    }
+  }
+  throw new CliError(
+    ErrorCodes.AUTH_NO_TOKEN,
+    "No authentication token found.",
+    'Run "notion init" to set up a profile'
+  );
+}
+
+// src/errors/error-handler.ts
+function mapNotionErrorCode(code) {
+  switch (code) {
+    case "unauthorized":
+      return ErrorCodes.AUTH_INVALID;
+    case "rate_limited":
+      return ErrorCodes.API_RATE_LIMITED;
+    case "object_not_found":
+      return ErrorCodes.API_NOT_FOUND;
+    default:
+      return ErrorCodes.API_ERROR;
   }
 }
 function withErrorHandling(fn) {
@@ -262,7 +638,8 @@ function withErrorHandling(fn) {
       await fn(...args);
     } catch (error2) {
       if (error2 instanceof CliError) {
-        process.stderr.write(error2.format() + "\n");
+        process.stderr.write(`${error2.format()}
+`);
         process.exit(1);
       }
       const { isNotionClientError: isNotionClientError2 } = await import("@notionhq/client");
@@ -273,7 +650,8 @@ function withErrorHandling(fn) {
           error2.message,
           code === ErrorCodes.AUTH_INVALID ? 'Run "notion init" to reconfigure your integration token' : void 0
         );
-        process.stderr.write(mappedError.format() + "\n");
+        process.stderr.write(`${mappedError.format()}
+`);
         process.exit(1);
       }
       const message = error2 instanceof Error ? error2.message : String(error2);
@@ -284,149 +662,828 @@ function withErrorHandling(fn) {
   });
 }
 
-// src/commands/init.ts
-function initCommand() {
-  const cmd = new Command("init");
-  cmd.description("authenticate with Notion and save a profile").action(withErrorHandling(async () => {
-    if (!process.stdin.isTTY) {
+// src/notion/client.ts
+import { APIErrorCode, Client, isNotionClientError } from "@notionhq/client";
+async function validateToken(token) {
+  const notion = new Client({ auth: token });
+  try {
+    const me = await notion.users.me({});
+    const bot = me;
+    const workspaceName = bot.bot?.workspace_name ?? "Unknown Workspace";
+    const workspaceId = bot.bot?.workspace_id ?? "";
+    return { workspaceName, workspaceId };
+  } catch (error2) {
+    if (isNotionClientError(error2) && error2.code === APIErrorCode.Unauthorized) {
       throw new CliError(
-        ErrorCodes.AUTH_NO_TOKEN,
-        "Cannot run interactive init in non-TTY mode.",
-        "Set NOTION_API_TOKEN environment variable or create .notion.yaml"
+        ErrorCodes.AUTH_INVALID,
+        "Invalid integration token.",
+        "Check your token at notion.so/profile/integrations/internal",
+        error2
       );
     }
-    const profileName = await input({
-      message: "Profile name:",
-      default: "default"
+    throw error2;
+  }
+}
+function createNotionClient(token) {
+  return new Client({ auth: token, timeoutMs: 12e4 });
+}
+
+// src/notion/url-parser.ts
+var NOTION_ID_REGEX = /^[0-9a-f]{32}$/i;
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var NOTION_URL_REGEX = /https?:\/\/(?:[a-zA-Z0-9-]+\.)?notion\.(?:so|site)\/.*?([0-9a-f]{32})(?:[?#]|$)/i;
+function throwInvalidId(input2) {
+  throw new CliError(
+    ErrorCodes.INVALID_ID,
+    `Cannot parse Notion ID from: ${input2}`,
+    "Provide a valid Notion URL or page/database ID"
+  );
+}
+function parseNotionId(input2) {
+  if (!input2) throwInvalidId(input2);
+  if (NOTION_ID_REGEX.test(input2)) {
+    return input2.toLowerCase();
+  }
+  if (UUID_REGEX.test(input2)) {
+    return input2.replace(/-/g, "").toLowerCase();
+  }
+  const urlMatch = NOTION_URL_REGEX.exec(input2);
+  if (urlMatch) {
+    return urlMatch[1].toLowerCase();
+  }
+  throwInvalidId(input2);
+}
+function toUuid(id) {
+  return `${id.slice(0, 8)}-${id.slice(8, 12)}-${id.slice(12, 16)}-${id.slice(16, 20)}-${id.slice(20)}`;
+}
+
+// src/output/color.ts
+import { Chalk } from "chalk";
+var _colorForced = false;
+function setColorForced(forced) {
+  _colorForced = forced;
+}
+function isColorEnabled() {
+  if (process.env.NO_COLOR) return false;
+  if (_colorForced) return true;
+  return Boolean(process.stderr.isTTY);
+}
+function createChalk() {
+  const level = isColorEnabled() ? void 0 : 0;
+  return new Chalk({ level });
+}
+function error(msg) {
+  return createChalk().red(msg);
+}
+function success(msg) {
+  return createChalk().green(msg);
+}
+function dim(msg) {
+  return createChalk().dim(msg);
+}
+function bold(msg) {
+  return createChalk().bold(msg);
+}
+
+// src/output/stderr.ts
+function stderrWrite(msg) {
+  process.stderr.write(`${msg}
+`);
+}
+function reportTokenSource(source) {
+  stderrWrite(dim(`Using token from ${source}`));
+}
+
+// src/services/write.service.ts
+async function addComment(client, pageId, text, options = {}) {
+  await client.comments.create({
+    parent: { page_id: pageId },
+    rich_text: [
+      {
+        type: "text",
+        text: { content: text, link: null },
+        annotations: {
+          bold: false,
+          italic: false,
+          strikethrough: false,
+          underline: false,
+          code: false,
+          color: "default"
+        }
+      }
+    ],
+    ...options.asUser && { display_name: { type: "user" } }
+  });
+}
+async function appendBlocks(client, blockId, blocks) {
+  await client.blocks.children.append({
+    block_id: blockId,
+    children: blocks
+  });
+}
+async function createPage(client, parentId, title, blocks) {
+  const response = await client.pages.create({
+    parent: { type: "page_id", page_id: parentId },
+    properties: {
+      title: {
+        title: [{ type: "text", text: { content: title, link: null } }]
+      }
+    },
+    children: blocks
+  });
+  return response.url;
+}
+
+// src/commands/append.ts
+function appendCommand() {
+  const cmd = new Command("append");
+  cmd.description("append markdown content to a Notion page").argument("<id/url>", "Notion page ID or URL").requiredOption("-m, --message <markdown>", "markdown content to append").action(
+    withErrorHandling(async (idOrUrl, opts) => {
+      const { token, source } = await resolveToken();
+      reportTokenSource(source);
+      const client = createNotionClient(token);
+      const pageId = parseNotionId(idOrUrl);
+      const uuid = toUuid(pageId);
+      const blocks = mdToBlocks(opts.message);
+      if (blocks.length === 0) {
+        process.stdout.write("Nothing to append.\n");
+        return;
+      }
+      await appendBlocks(client, uuid, blocks);
+      process.stdout.write(`Appended ${blocks.length} block(s).
+`);
+    })
+  );
+  return cmd;
+}
+
+// src/commands/auth/index.ts
+function authDefaultAction(authCmd2) {
+  return async () => {
+    authCmd2.help();
+  };
+}
+
+// src/commands/auth/login.ts
+import { select } from "@inquirer/prompts";
+import { Command as Command3 } from "commander";
+
+// src/oauth/oauth-flow.ts
+import { spawn } from "child_process";
+import { randomBytes } from "crypto";
+import {
+  createServer
+} from "http";
+import { createInterface } from "readline";
+function openBrowser(url) {
+  const platform = process.platform;
+  let cmd;
+  let args;
+  if (platform === "darwin") {
+    cmd = "open";
+    args = [url];
+  } else if (platform === "win32") {
+    cmd = "cmd";
+    args = ["/c", "start", url];
+  } else {
+    cmd = "xdg-open";
+    args = [url];
+  }
+  try {
+    const child = spawn(cmd, args, {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function manualFlow(url) {
+  process.stderr.write(
+    `
+Opening browser to:
+  ${url}
+
+Paste the full redirect URL here (${OAUTH_REDIRECT_URI}?code=...):
+> `
+  );
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stderr,
+    terminal: false
+  });
+  return new Promise((resolve, reject) => {
+    rl.once("line", (line) => {
+      rl.close();
+      try {
+        const parsed = new URL(line.trim());
+        const code = parsed.searchParams.get("code");
+        const state = parsed.searchParams.get("state");
+        const errorParam = parsed.searchParams.get("error");
+        if (errorParam === "access_denied") {
+          reject(
+            new CliError(
+              ErrorCodes.AUTH_INVALID,
+              "Notion OAuth access was denied.",
+              'Run "notion auth login" to try again'
+            )
+          );
+          return;
+        }
+        if (!code || !state) {
+          reject(
+            new CliError(
+              ErrorCodes.AUTH_INVALID,
+              "Invalid redirect URL \u2014 missing code or state parameter.",
+              "Make sure you paste the full redirect URL from the browser address bar"
+            )
+          );
+          return;
+        }
+        resolve({ code, state });
+      } catch {
+        reject(
+          new CliError(
+            ErrorCodes.AUTH_INVALID,
+            "Could not parse the pasted URL.",
+            "Make sure you paste the full redirect URL from the browser address bar"
+          )
+        );
+      }
     });
-    const token = await password({
-      message: "Integration token (from notion.so/profile/integrations/internal):",
-      mask: "*"
+    rl.once("close", () => {
+      reject(
+        new CliError(
+          ErrorCodes.AUTH_INVALID,
+          "No redirect URL received.",
+          'Run "notion auth login" to try again'
+        )
+      );
     });
-    stderrWrite("Validating token...");
-    const { workspaceName, workspaceId } = await validateToken(token);
-    stderrWrite(success(`\u2713 Connected to workspace: ${bold(workspaceName)}`));
-    const config = await readGlobalConfig();
-    if (config.profiles?.[profileName]) {
-      const replace = await confirm({
-        message: `Profile "${profileName}" already exists. Replace?`,
-        default: false
+  });
+}
+function handleCallbackRequest(req, res, ctx) {
+  if (ctx.settled) {
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end(
+      "<html><body><h1>Already handled. You can close this tab.</h1></body></html>"
+    );
+    return;
+  }
+  try {
+    const reqUrl = new URL(req.url ?? "/", "http://localhost:54321");
+    const code = reqUrl.searchParams.get("code");
+    const returnedState = reqUrl.searchParams.get("state");
+    const errorParam = reqUrl.searchParams.get("error");
+    if (errorParam === "access_denied") {
+      ctx.settled = true;
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(
+        "<html><body><h1>Access Denied</h1><p>You cancelled the Notion OAuth request. You can close this tab.</p></body></html>"
+      );
+      if (ctx.timeoutHandle) clearTimeout(ctx.timeoutHandle);
+      ctx.server.close(() => {
+        ctx.reject(
+          new CliError(
+            ErrorCodes.AUTH_INVALID,
+            "Notion OAuth access was denied.",
+            'Run "notion auth login" to try again'
+          )
+        );
       });
-      if (!replace) {
-        stderrWrite("Aborted.");
-        return;
-      }
+      return;
+    }
+    if (!code || !returnedState) {
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end("<html><body><p>Waiting for OAuth callback...</p></body></html>");
+      return;
+    }
+    if (returnedState !== ctx.expectedState) {
+      ctx.settled = true;
+      res.writeHead(400, { "Content-Type": "text/html" });
+      res.end(
+        "<html><body><h1>Security Error</h1><p>State mismatch \u2014 possible CSRF attempt. You can close this tab.</p></body></html>"
+      );
+      if (ctx.timeoutHandle) clearTimeout(ctx.timeoutHandle);
+      ctx.server.close(() => {
+        ctx.reject(
+          new CliError(
+            ErrorCodes.AUTH_INVALID,
+            "OAuth state mismatch \u2014 possible CSRF attempt. Aborting.",
+            'Run "notion auth login" to start a fresh OAuth flow'
+          )
+        );
+      });
+      return;
     }
-    const profiles = config.profiles ?? {};
-    profiles[profileName] = {
-      token,
-      workspace_name: workspaceName,
-      workspace_id: workspaceId
+    ctx.settled = true;
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end(
+      "<html><body><h1>Authenticated!</h1><p>You can close this tab and return to the terminal.</p></body></html>"
+    );
+    if (ctx.timeoutHandle) clearTimeout(ctx.timeoutHandle);
+    ctx.server.close(() => {
+      ctx.resolve({ code, state: returnedState });
+    });
+  } catch {
+    res.writeHead(500, { "Content-Type": "text/html" });
+    res.end("<html><body><h1>Error processing callback</h1></body></html>");
+  }
+}
+async function runOAuthFlow(options) {
+  const state = randomBytes(16).toString("hex");
+  const authUrl = buildAuthUrl(state);
+  if (options?.manual) {
+    return manualFlow(authUrl);
+  }
+  return new Promise((resolve, reject) => {
+    const ctx = {
+      expectedState: state,
+      settled: false,
+      timeoutHandle: null,
+      resolve,
+      reject,
+      // assigned below after server is created
+      server: null
     };
-    await writeGlobalConfig({
-      ...config,
-      profiles,
-      active_profile: profileName
+    const server = createServer(
+      (req, res) => handleCallbackRequest(req, res, ctx)
+    );
+    ctx.server = server;
+    server.on("error", (err) => {
+      if (ctx.settled) return;
+      ctx.settled = true;
+      if (ctx.timeoutHandle) clearTimeout(ctx.timeoutHandle);
+      reject(
+        new CliError(
+          ErrorCodes.AUTH_INVALID,
+          `Failed to start OAuth callback server: ${err.message}`,
+          "Make sure port 54321 is not in use, or use --manual flag"
+        )
+      );
     });
-    stderrWrite(success(`Profile "${profileName}" saved and set as active.`));
-    stderrWrite(dim("Checking integration access..."));
-    try {
-      const notion = createNotionClient(token);
-      const probe = await notion.search({ page_size: 1 });
-      if (probe.results.length === 0) {
-        stderrWrite("");
-        stderrWrite("\u26A0\uFE0F  Your integration has no pages connected.");
-        stderrWrite("   To grant access, open any Notion page or database:");
-        stderrWrite("     1. Click \xB7\xB7\xB7 (three dots) in the top-right corner");
-        stderrWrite('     2. Select "Connect to"');
-        stderrWrite(`     3. Choose "${workspaceName}"`);
-        stderrWrite("   Then re-run any notion command to confirm access.");
-      } else {
-        stderrWrite(success(`\u2713 Integration has access to content in ${bold(workspaceName)}.`));
+    server.listen(54321, "127.0.0.1", () => {
+      const browserOpened = openBrowser(authUrl);
+      if (!browserOpened) {
+        server.close();
+        ctx.settled = true;
+        if (ctx.timeoutHandle) clearTimeout(ctx.timeoutHandle);
+        manualFlow(authUrl).then(resolve, reject);
+        return;
       }
-    } catch {
-      stderrWrite(dim("(Could not verify integration access \u2014 run `notion ls` to check)"));
-    }
-  }));
-  return cmd;
+      process.stderr.write(
+        `
+Opening browser for Notion OAuth...
+If your browser didn't open, visit:
+  ${authUrl}
+
+Waiting for callback (up to 120 seconds)...
+`
+      );
+      ctx.timeoutHandle = setTimeout(() => {
+        if (ctx.settled) return;
+        ctx.settled = true;
+        server.close(() => {
+          reject(
+            new CliError(
+              ErrorCodes.AUTH_INVALID,
+              "OAuth login timed out after 120 seconds.",
+              'Run "notion auth login" to try again, or use --manual flag'
+            )
+          );
+        });
+      }, 12e4);
+    });
+  });
 }
 
-// src/commands/profile/list.ts
+// src/commands/init.ts
+import { confirm, input, password } from "@inquirer/prompts";
 import { Command as Command2 } from "commander";
-function profileListCommand() {
-  const cmd = new Command2("list");
-  cmd.description("list all authentication profiles").action(withErrorHandling(async () => {
-    const config = await readGlobalConfig();
-    const profiles = config.profiles ?? {};
-    const profileNames = Object.keys(profiles);
-    if (profileNames.length === 0) {
-      process.stdout.write("No profiles configured. Run `notion init` to get started.\n");
+async function runInitFlow() {
+  const profileName = await input({
+    message: "Profile name:",
+    default: "default"
+  });
+  const token = await password({
+    message: "Integration token (from notion.so/profile/integrations/internal):",
+    mask: "*"
+  });
+  stderrWrite("Validating token...");
+  const { workspaceName, workspaceId } = await validateToken(token);
+  stderrWrite(success(`\u2713 Connected to workspace: ${bold(workspaceName)}`));
+  const config = await readGlobalConfig();
+  if (config.profiles?.[profileName]) {
+    const replace = await confirm({
+      message: `Profile "${profileName}" already exists. Replace?`,
+      default: false
+    });
+    if (!replace) {
+      stderrWrite("Aborted.");
       return;
     }
-    for (const name of profileNames) {
-      const profile = profiles[name];
-      const isActive = config.active_profile === name;
-      const marker = isActive ? bold("* ") : "  ";
-      const activeLabel = isActive ? " (active)" : "";
-      const workspaceInfo = profile.workspace_name ? dim(` \u2014 ${profile.workspace_name}`) : "";
-      process.stdout.write(`${marker}${name}${activeLabel}${workspaceInfo}
-`);
-    }
-  }));
-  return cmd;
-}
-
-// src/commands/profile/use.ts
-import { Command as Command3 } from "commander";
-function profileUseCommand() {
-  const cmd = new Command3("use");
-  cmd.description("switch the active profile").argument("<name>", "profile name to activate").action(withErrorHandling(async (name) => {
-    const config = await readGlobalConfig();
-    const profiles = config.profiles ?? {};
-    if (!profiles[name]) {
-      throw new CliError(
-        ErrorCodes.AUTH_PROFILE_NOT_FOUND,
-        `Profile "${name}" not found.`,
-        `Run "notion profile list" to see available profiles`
+  }
+  const profiles = config.profiles ?? {};
+  profiles[profileName] = {
+    token,
+    workspace_name: workspaceName,
+    workspace_id: workspaceId
+  };
+  await writeGlobalConfig({
+    ...config,
+    profiles,
+    active_profile: profileName
+  });
+  stderrWrite(success(`Profile "${profileName}" saved and set as active.`));
+  stderrWrite(dim("Checking integration access..."));
+  try {
+    const notion = createNotionClient(token);
+    const probe = await notion.search({ page_size: 1 });
+    if (probe.results.length === 0) {
+      stderrWrite("");
+      stderrWrite("\u26A0\uFE0F  Your integration has no pages connected.");
+      stderrWrite("   To grant access, open any Notion page or database:");
+      stderrWrite("     1. Click \xB7\xB7\xB7 (three dots) in the top-right corner");
+      stderrWrite('     2. Select "Connect to"');
+      stderrWrite(`     3. Choose "${workspaceName}"`);
+      stderrWrite("   Then re-run any notion command to confirm access.");
+    } else {
+      stderrWrite(
+        success(
+          `\u2713 Integration has access to content in ${bold(workspaceName)}.`
+        )
       );
     }
-    await writeGlobalConfig({
-      ...config,
-      active_profile: name
-    });
-    stderrWrite(success(`Switched to profile "${name}".`));
-  }));
+  } catch {
+    stderrWrite(
+      dim("(Could not verify integration access \u2014 run `notion ls` to check)")
+    );
+  }
+  stderrWrite("");
+  stderrWrite(
+    dim("Write commands (comment, append, create-page) require additional")
+  );
+  stderrWrite(dim("capabilities in your integration settings:"));
+  stderrWrite(
+    dim("  notion.so/profile/integrations/internal \u2192 your integration \u2192")
+  );
+  stderrWrite(
+    dim(
+      '  Capabilities: enable "Read content", "Insert content", "Read comments", "Insert comments"'
+    )
+  );
+  stderrWrite("");
+  stderrWrite(
+    dim("To post comments and create pages attributed to your user account:")
+  );
+  stderrWrite(dim("  notion auth login"));
+}
+function initCommand() {
+  const cmd = new Command2("init");
+  cmd.description("authenticate with Notion and save a profile").action(
+    withErrorHandling(async () => {
+      if (!process.stdin.isTTY) {
+        throw new CliError(
+          ErrorCodes.AUTH_NO_TOKEN,
+          "Cannot run interactive init in non-TTY mode.",
+          "Set NOTION_API_TOKEN environment variable or create .notion.yaml"
+        );
+      }
+      await runInitFlow();
+    })
+  );
   return cmd;
 }
 
-// src/commands/profile/remove.ts
-import { Command as Command4 } from "commander";
-function profileRemoveCommand() {
-  const cmd = new Command4("remove");
-  cmd.description("remove an authentication profile").argument("<name>", "profile name to remove").action(withErrorHandling(async (name) => {
-    const config = await readGlobalConfig();
-    const profiles = { ...config.profiles ?? {} };
-    if (!profiles[name]) {
-      throw new CliError(
-        ErrorCodes.AUTH_PROFILE_NOT_FOUND,
-        `Profile "${name}" not found.`,
-        `Run "notion profile list" to see available profiles`
-      );
-    }
-    delete profiles[name];
-    const newActiveProfile = config.active_profile === name ? void 0 : config.active_profile;
-    await writeGlobalConfig({
-      ...config,
-      profiles,
-      active_profile: newActiveProfile
-    });
-    stderrWrite(success(`Profile "${name}" removed.`));
-  }));
+// src/commands/auth/login.ts
+function loginCommand() {
+  const cmd = new Command3("login");
+  cmd.description("authenticate with Notion \u2014 choose OAuth or integration token").option("--profile <name>", "profile name to store credentials in").option(
+    "--manual",
+    "print auth URL instead of opening browser (for headless OAuth)"
+  ).action(
+    withErrorHandling(async (opts) => {
+      if (!process.stdin.isTTY && !opts.manual) {
+        throw new CliError(
+          ErrorCodes.AUTH_NO_TOKEN,
+          "Cannot run interactive login in non-TTY mode.",
+          "Use --manual flag to get an auth URL you can open in a browser"
+        );
+      }
+      const method = await select({
+        message: "How do you want to authenticate with Notion?",
+        choices: [
+          {
+            name: "OAuth user login  (browser required)",
+            value: "oauth",
+            description: "Opens Notion in your browser. Comments and pages are attributed to your account. Tokens auto-refresh."
+          },
+          {
+            name: "Internal integration token  (CI/headless friendly)",
+            value: "token",
+            description: "Paste a token from notion.so/profile/integrations. No browser needed. Write ops attributed to integration bot."
+          }
+        ]
+      });
+      if (method === "oauth") {
+        let profileName = opts.profile;
+        if (!profileName) {
+          const config = await readGlobalConfig();
+          profileName = config.active_profile ?? "default";
+        }
+        const result = await runOAuthFlow({ manual: opts.manual });
+        const response = await exchangeCode(result.code);
+        await saveOAuthTokens(profileName, response);
+        const userName = response.owner?.user?.name ?? "unknown user";
+        const workspaceName = response.workspace_name ?? "unknown workspace";
+        stderrWrite(
+          success(`\u2713 Logged in as ${userName} to workspace ${workspaceName}`)
+        );
+        stderrWrite(
+          dim(
+            "Your comments and pages will now be attributed to your Notion account."
+          )
+        );
+      } else {
+        await runInitFlow();
+      }
+    })
+  );
   return cmd;
 }
 
-// src/commands/completion.ts
+// src/commands/auth/logout.ts
+import { select as select2 } from "@inquirer/prompts";
+import { Command as Command4 } from "commander";
+function profileLabel(name, profile) {
+  const parts = [];
+  if (profile.oauth_access_token)
+    parts.push(
+      `OAuth${profile.oauth_user_name ? ` (${profile.oauth_user_name})` : ""}`
+    );
+  if (profile.token) parts.push("integration token");
+  const authDesc = parts.length > 0 ? parts.join(" + ") : "no credentials";
+  const workspace = profile.workspace_name ? dim(` \u2014 ${profile.workspace_name}`) : "";
+  return `${bold(name)}  ${dim(authDesc)}${workspace}`;
+}
+function logoutCommand() {
+  const cmd = new Command4("logout");
+  cmd.description("remove a profile and its credentials").option(
+    "--profile <name>",
+    "profile name to remove (skips interactive selector)"
+  ).action(
+    withErrorHandling(async (opts) => {
+      const config = await readGlobalConfig();
+      const profiles = config.profiles ?? {};
+      const profileNames = Object.keys(profiles);
+      if (profileNames.length === 0) {
+        stderrWrite("No profiles configured.");
+        return;
+      }
+      let profileName = opts.profile;
+      if (!profileName) {
+        if (!process.stdin.isTTY) {
+          throw new CliError(
+            ErrorCodes.AUTH_NO_TOKEN,
+            "Cannot run interactive logout in non-TTY mode.",
+            "Use --profile <name> to specify the profile to remove"
+          );
+        }
+        profileName = await select2({
+          message: "Which profile do you want to log out of?",
+          choices: profileNames.map((name) => ({
+            // biome-ignore lint/style/noNonNullAssertion: key is from Object.keys, always present
+            name: profileLabel(name, profiles[name]),
+            value: name
+          }))
+        });
+      }
+      if (!profiles[profileName]) {
+        throw new CliError(
+          ErrorCodes.AUTH_PROFILE_NOT_FOUND,
+          `Profile "${profileName}" not found.`,
+          `Run "notion auth list" to see available profiles`
+        );
+      }
+      const updatedProfiles = { ...profiles };
+      delete updatedProfiles[profileName];
+      const newActiveProfile = config.active_profile === profileName ? void 0 : config.active_profile;
+      await writeGlobalConfig({
+        ...config,
+        profiles: updatedProfiles,
+        active_profile: newActiveProfile
+      });
+      stderrWrite(success(`\u2713 Logged out of profile "${profileName}".`));
+      if (newActiveProfile === void 0 && Object.keys(updatedProfiles).length > 0) {
+        stderrWrite(
+          dim(`Run "notion auth use <name>" to set a new active profile.`)
+        );
+      }
+    })
+  );
+  return cmd;
+}
+
+// src/commands/auth/status.ts
 import { Command as Command5 } from "commander";
+function statusCommand() {
+  const cmd = new Command5("status");
+  cmd.description("show authentication status for the active profile").option("--profile <name>", "profile name to check").action(
+    withErrorHandling(async (opts) => {
+      let profileName = opts.profile;
+      const config = await readGlobalConfig();
+      if (!profileName) {
+        profileName = config.active_profile ?? "default";
+      }
+      const profile = config.profiles?.[profileName];
+      stderrWrite(`Profile: ${profileName}`);
+      if (!profile) {
+        stderrWrite(
+          `  ${error("\u2717")} No profile found (run 'notion init' to create one)`
+        );
+        return;
+      }
+      if (profile.oauth_access_token) {
+        const userName = profile.oauth_user_name ?? "unknown";
+        const userId = profile.oauth_user_id ?? "unknown";
+        stderrWrite(
+          `  OAuth: ${success("\u2713")} Logged in as ${userName} (user: ${userId})`
+        );
+        if (profile.oauth_expiry_ms != null) {
+          const expiryDate = new Date(profile.oauth_expiry_ms).toISOString();
+          stderrWrite(dim(`         Access token expires: ${expiryDate}`));
+        }
+      } else {
+        stderrWrite(
+          `  OAuth: ${error("\u2717")} Not logged in (run 'notion auth login')`
+        );
+      }
+      if (profile.token) {
+        const tokenPreview = `${profile.token.substring(0, 10)}...`;
+        stderrWrite(
+          `  Internal token: ${success("\u2713")} Configured (${tokenPreview})`
+        );
+      } else {
+        stderrWrite(`  Internal token: ${error("\u2717")} Not configured`);
+      }
+      if (profile.oauth_access_token) {
+        stderrWrite(`  Active method: OAuth (user-attributed)`);
+      } else if (profile.token) {
+        stderrWrite(
+          `  Active method: Internal integration token (bot-attributed)`
+        );
+      } else {
+        stderrWrite(
+          dim(
+            `  Active method: None (run 'notion auth login' or 'notion init')`
+          )
+        );
+      }
+    })
+  );
+  return cmd;
+}
+
+// src/commands/comment-add.ts
+import { Command as Command6 } from "commander";
+function commentAddCommand() {
+  const cmd = new Command6("comment");
+  cmd.description("add a comment to a Notion page").argument("<id/url>", "Notion page ID or URL").requiredOption("-m, --message <text>", "comment text to post").action(
+    withErrorHandling(async (idOrUrl, opts) => {
+      const { token, source } = await resolveToken();
+      reportTokenSource(source);
+      const client = createNotionClient(token);
+      const id = parseNotionId(idOrUrl);
+      const uuid = toUuid(id);
+      await addComment(client, uuid, opts.message, {
+        asUser: source === "oauth"
+      });
+      process.stdout.write("Comment added.\n");
+    })
+  );
+  return cmd;
+}
+
+// src/commands/comments.ts
+import { Command as Command7 } from "commander";
+
+// src/output/format.ts
+var _mode = "auto";
+function setOutputMode(mode) {
+  _mode = mode;
+}
+function getOutputMode() {
+  return _mode;
+}
+function isatty() {
+  return Boolean(process.stdout.isTTY);
+}
+function isHumanMode() {
+  if (_mode === "json") return false;
+  if (_mode === "md") return false;
+  return true;
+}
+function formatJSON(data) {
+  return JSON.stringify(data, null, 2);
+}
+var COLUMN_CAPS = {
+  TITLE: 50,
+  ID: 36
+};
+var DEFAULT_MAX_COL_WIDTH = 40;
+function getColumnCap(header) {
+  return COLUMN_CAPS[header.toUpperCase()] ?? DEFAULT_MAX_COL_WIDTH;
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return `${str.slice(0, maxLen - 1)}\u2026`;
+}
+function formatTable(rows, headers) {
+  const colWidths = headers.map((header, colIdx) => {
+    const cap = getColumnCap(header);
+    const headerLen = header.length;
+    const maxRowLen = rows.reduce((max, row) => {
+      const cell = row[colIdx] ?? "";
+      return Math.max(max, cell.length);
+    }, 0);
+    return Math.min(Math.max(headerLen, maxRowLen), cap);
+  });
+  const sep = "\u2500";
+  const colSep = "  ";
+  const headerRow = headers.map((h, i) => h.padEnd(colWidths[i])).join(colSep);
+  const separatorRow = colWidths.map((w) => sep.repeat(w)).join(colSep);
+  const dataRows = rows.map(
+    (row) => headers.map((_, i) => {
+      const cell = row[i] ?? "";
+      return truncate(cell, colWidths[i]).padEnd(colWidths[i]);
+    }).join(colSep)
+  );
+  return [headerRow, separatorRow, ...dataRows].join("\n");
+}
+function printOutput(data, tableHeaders, tableRows) {
+  const mode = getOutputMode();
+  if (mode === "json") {
+    process.stdout.write(`${formatJSON(data)}
+`);
+  } else if (isHumanMode() && tableHeaders && tableRows) {
+    printWithPager(`${formatTable(tableRows, tableHeaders)}
+`);
+  }
+}
+function printWithPager(text) {
+  process.stdout.write(text);
+}
+
+// src/output/paginate.ts
+async function paginateResults(fetcher) {
+  const allResults = [];
+  let cursor;
+  let hasMore = true;
+  while (hasMore) {
+    const response = await fetcher(cursor);
+    allResults.push(...response.results);
+    cursor = response.next_cursor ?? void 0;
+    hasMore = response.has_more;
+  }
+  return allResults;
+}
+
+// src/commands/comments.ts
+function commentsCommand() {
+  const cmd = new Command7("comments");
+  cmd.description("list comments on a Notion page").argument("<id/url>", "Notion page ID or URL").option("--json", "output as JSON").action(
+    withErrorHandling(async (idOrUrl, opts) => {
+      if (opts.json) setOutputMode("json");
+      const id = parseNotionId(idOrUrl);
+      const uuid = toUuid(id);
+      const { token, source } = await resolveToken();
+      reportTokenSource(source);
+      const notion = createNotionClient(token);
+      const comments = await paginateResults(
+        (cursor) => notion.comments.list({ block_id: uuid, start_cursor: cursor })
+      );
+      if (comments.length === 0) {
+        process.stdout.write("No comments found on this page\n");
+        return;
+      }
+      const rows = comments.map((comment) => {
+        const text = comment.rich_text.map((t) => t.plain_text).join("");
+        return [
+          comment.created_time.split("T")[0],
+          `${comment.created_by.id.slice(0, 8)}...`,
+          text.slice(0, 80) + (text.length > 80 ? "\u2026" : "")
+        ];
+      });
+      printOutput(comments, ["DATE", "AUTHOR ID", "COMMENT"], rows);
+    })
+  );
+  return cmd;
+}
+
+// src/commands/completion.ts
+import { Command as Command8 } from "commander";
 var BASH_COMPLETION = `# notion bash completion
 _notion_completion() {
   local cur prev words cword
@@ -528,394 +1585,502 @@ complete -c notion -n '__fish_seen_subcommand_from completion' -a zsh -d 'zsh co
 complete -c notion -n '__fish_seen_subcommand_from completion' -a fish -d 'fish completion script'
 `;
 function completionCommand() {
-  const cmd = new Command5("completion");
-  cmd.description("output shell completion script").argument("<shell>", "shell type (bash, zsh, fish)").action(withErrorHandling(async (shell) => {
-    switch (shell) {
-      case "bash":
-        process.stdout.write(BASH_COMPLETION);
-        break;
-      case "zsh":
-        process.stdout.write(ZSH_COMPLETION);
-        break;
-      case "fish":
-        process.stdout.write(FISH_COMPLETION);
-        break;
-      default:
-        throw new CliError(
-          ErrorCodes.UNKNOWN,
-          `Unknown shell: "${shell}".`,
-          "Supported shells: bash, zsh, fish"
-        );
-    }
-  }));
-  return cmd;
-}
-
-// src/commands/search.ts
-import { Command as Command6 } from "commander";
-import { isFullPageOrDataSource } from "@notionhq/client";
-
-// src/config/local-config.ts
-import { readFile as readFile2 } from "fs/promises";
-import { join as join2 } from "path";
-import { parse as parse2 } from "yaml";
-async function readLocalConfig() {
-  const localConfigPath = join2(process.cwd(), ".notion.yaml");
-  let raw;
-  try {
-    raw = await readFile2(localConfigPath, "utf-8");
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      return null;
-    }
-    throw new CliError(
-      ErrorCodes.CONFIG_READ_ERROR,
-      `Failed to read local config: ${localConfigPath}`,
-      "Check file permissions"
-    );
-  }
-  let parsed;
-  try {
-    parsed = parse2(raw) ?? {};
-  } catch {
-    throw new CliError(
-      ErrorCodes.CONFIG_INVALID,
-      `Failed to parse .notion.yaml`,
-      "Check that the file contains valid YAML"
-    );
-  }
-  if (parsed.profile !== void 0 && parsed.token !== void 0) {
-    throw new CliError(
-      ErrorCodes.CONFIG_INVALID,
-      '.notion.yaml cannot specify both "profile" and "token"',
-      'Use either "profile: <name>" to reference a saved profile, or "token: <value>" for a direct token'
-    );
-  }
-  return parsed;
-}
-
-// src/config/token.ts
-async function resolveToken() {
-  const envToken = process.env["NOTION_API_TOKEN"];
-  if (envToken) {
-    return { token: envToken, source: "NOTION_API_TOKEN" };
-  }
-  const localConfig = await readLocalConfig();
-  if (localConfig !== null) {
-    if (localConfig.token) {
-      return { token: localConfig.token, source: ".notion.yaml" };
-    }
-    if (localConfig.profile) {
-      const globalConfig2 = await readGlobalConfig();
-      const profileToken = globalConfig2.profiles?.[localConfig.profile]?.token;
-      if (profileToken) {
-        return { token: profileToken, source: `profile: ${localConfig.profile}` };
+  const cmd = new Command8("completion");
+  cmd.description("output shell completion script").argument("<shell>", "shell type (bash, zsh, fish)").action(
+    withErrorHandling(async (shell) => {
+      switch (shell) {
+        case "bash":
+          process.stdout.write(BASH_COMPLETION);
+          break;
+        case "zsh":
+          process.stdout.write(ZSH_COMPLETION);
+          break;
+        case "fish":
+          process.stdout.write(FISH_COMPLETION);
+          break;
+        default:
+          throw new CliError(
+            ErrorCodes.UNKNOWN,
+            `Unknown shell: "${shell}".`,
+            "Supported shells: bash, zsh, fish"
+          );
       }
-    }
-  }
-  const globalConfig = await readGlobalConfig();
-  if (globalConfig.active_profile) {
-    const profileToken = globalConfig.profiles?.[globalConfig.active_profile]?.token;
-    if (profileToken) {
-      return { token: profileToken, source: `profile: ${globalConfig.active_profile}` };
-    }
-  }
-  throw new CliError(
-    ErrorCodes.AUTH_NO_TOKEN,
-    "No authentication token found.",
-    'Run "notion init" to set up a profile'
+    })
   );
+  return cmd;
 }
 
-// src/commands/search.ts
-function getTitle(item) {
-  if (item.object === "data_source") {
-    return item.title.map((t) => t.plain_text).join("") || "(untitled)";
-  }
-  const titleProp = Object.values(item.properties).find((p) => p.type === "title");
-  if (titleProp?.type === "title") {
-    return titleProp.title.map((t) => t.plain_text).join("") || "(untitled)";
+// src/commands/create-page.ts
+import { Command as Command9 } from "commander";
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
   }
-  return "(untitled)";
-}
-function toSdkFilterValue(type) {
-  return type === "database" ? "data_source" : "page";
-}
-function displayType(item) {
-  return item.object === "data_source" ? "database" : item.object;
-}
-function searchCommand() {
-  const cmd = new Command6("search");
-  cmd.description("search Notion workspace by keyword").argument("<query>", "search keyword").option("--type <type>", "filter by object type (page or database)", (val) => {
-    if (val !== "page" && val !== "database") {
-      throw new Error('--type must be "page" or "database"');
-    }
-    return val;
-  }).option("--cursor <cursor>", "start from this pagination cursor (from a previous --next hint)").option("--json", "force JSON output").action(
-    withErrorHandling(async (query, opts) => {
-      if (opts.json) {
-        setOutputMode("json");
-      }
-      const { token, source } = await resolveToken();
-      reportTokenSource(source);
-      const notion = createNotionClient(token);
-      const response = await notion.search({
-        query,
-        filter: opts.type ? { property: "object", value: toSdkFilterValue(opts.type) } : void 0,
-        start_cursor: opts.cursor,
-        page_size: 20
-      });
-      const fullResults = response.results.filter((r) => isFullPageOrDataSource(r));
-      if (fullResults.length === 0) {
-        process.stdout.write(`No results found for "${query}"
-`);
-        return;
-      }
-      const headers = ["TYPE", "TITLE", "ID", "MODIFIED"];
-      const rows = fullResults.map((item) => [
-        displayType(item),
-        getTitle(item),
-        item.id,
-        item.last_edited_time.split("T")[0]
-      ]);
-      printOutput(fullResults, headers, rows);
-      if (response.has_more && response.next_cursor) {
-        process.stderr.write(`
-  --next: notion search "${query}" --cursor ${response.next_cursor}
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function createPageCommand() {
+  const cmd = new Command9("create-page");
+  cmd.description("create a new Notion page under a parent page").requiredOption("--parent <id/url>", "parent page ID or URL").requiredOption("--title <title>", "page title").option(
+    "-m, --message <markdown>",
+    "inline markdown content for the page body"
+  ).action(
+    withErrorHandling(
+      async (opts) => {
+        const { token, source } = await resolveToken();
+        reportTokenSource(source);
+        const client = createNotionClient(token);
+        let markdown = "";
+        if (opts.message) {
+          markdown = opts.message;
+        } else if (!process.stdin.isTTY) {
+          markdown = await readStdin();
+        }
+        const blocks = mdToBlocks(markdown);
+        const parentUuid = toUuid(parseNotionId(opts.parent));
+        const url = await createPage(client, parentUuid, opts.title, blocks);
+        process.stdout.write(`${url}
 `);
       }
-    })
+    )
   );
   return cmd;
 }
 
-// src/commands/ls.ts
-import { Command as Command7 } from "commander";
-import { isFullPageOrDataSource as isFullPageOrDataSource2 } from "@notionhq/client";
-function getTitle2(item) {
-  if (item.object === "data_source") {
-    return item.title.map((t) => t.plain_text).join("") || "(untitled)";
-  }
-  const titleProp = Object.values(item.properties).find((p) => p.type === "title");
-  if (titleProp?.type === "title") {
-    return titleProp.title.map((t) => t.plain_text).join("") || "(untitled)";
+// src/commands/db/query.ts
+import { Command as Command10 } from "commander";
+
+// src/services/database.service.ts
+import { isFullPage } from "@notionhq/client";
+async function fetchDatabaseSchema(client, dbId) {
+  const ds = await client.dataSources.retrieve({ data_source_id: dbId });
+  const title = "title" in ds ? ds.title.map((rt) => rt.plain_text).join("") || dbId : dbId;
+  const properties = {};
+  if ("properties" in ds) {
+    for (const [name, prop] of Object.entries(ds.properties)) {
+      const config = {
+        id: prop.id,
+        name,
+        type: prop.type
+      };
+      if (prop.type === "select" && "select" in prop) {
+        config.options = prop.select.options;
+      } else if (prop.type === "status" && "status" in prop) {
+        config.options = prop.status.options;
+      } else if (prop.type === "multi_select" && "multi_select" in prop) {
+        config.options = prop.multi_select.options;
+      }
+      properties[name] = config;
+    }
   }
-  return "(untitled)";
-}
-function displayType2(item) {
-  return item.object === "data_source" ? "database" : item.object;
+  return { id: dbId, title, properties };
 }
-function lsCommand() {
-  const cmd = new Command7("ls");
-  cmd.description("list accessible Notion pages and databases").option("--type <type>", "filter by object type (page or database)", (val) => {
-    if (val !== "page" && val !== "database") {
-      throw new Error('--type must be "page" or "database"');
-    }
-    return val;
-  }).option("--cursor <cursor>", "start from this pagination cursor (from a previous --next hint)").option("--json", "force JSON output").action(
-    withErrorHandling(async (opts) => {
-      if (opts.json) {
-        setOutputMode("json");
-      }
-      const { token, source } = await resolveToken();
-      reportTokenSource(source);
-      const notion = createNotionClient(token);
-      const response = await notion.search({
-        start_cursor: opts.cursor,
-        page_size: 20
-      });
-      let items = response.results.filter((r) => isFullPageOrDataSource2(r));
-      if (opts.type) {
-        const filterType = opts.type;
-        items = items.filter(
-          (r) => filterType === "database" ? r.object === "data_source" : r.object === filterType
-        );
-      }
-      if (items.length === 0) {
-        process.stdout.write("No accessible content found\n");
-        return;
-      }
-      const headers = ["TYPE", "TITLE", "ID", "MODIFIED"];
-      const rows = items.map((item) => [
-        displayType2(item),
-        getTitle2(item),
-        item.id,
-        item.last_edited_time.split("T")[0]
-      ]);
-      printOutput(items, headers, rows);
-      if (response.has_more && response.next_cursor) {
-        process.stderr.write(`
-  --next: notion ls --cursor ${response.next_cursor}
-`);
-      }
+async function queryDatabase(client, dbId, opts = {}) {
+  const rawPages = await paginateResults(
+    (cursor) => client.dataSources.query({
+      data_source_id: dbId,
+      filter: opts.filter,
+      sorts: opts.sorts,
+      start_cursor: cursor,
+      page_size: 100
     })
   );
-  return cmd;
+  return rawPages.filter(isFullPage).map((page) => {
+    const propValues = {};
+    for (const [name, prop] of Object.entries(page.properties)) {
+      if (opts.columns && !opts.columns.includes(name)) continue;
+      propValues[name] = displayPropertyValue(prop);
+    }
+    return { id: page.id, properties: propValues, raw: page };
+  });
 }
-
-// src/commands/open.ts
-import { exec } from "child_process";
-import { promisify } from "util";
-import { Command as Command8 } from "commander";
-
-// src/notion/url-parser.ts
-var NOTION_ID_REGEX = /^[0-9a-f]{32}$/i;
-var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var NOTION_URL_REGEX = /https?:\/\/(?:[a-zA-Z0-9-]+\.)?notion\.(?:so|site)\/.*?([0-9a-f]{32})(?:[?#]|$)/i;
-function throwInvalidId(input2) {
-  throw new CliError(
-    ErrorCodes.INVALID_ID,
-    `Cannot parse Notion ID from: ${input2}`,
-    "Provide a valid Notion URL or page/database ID"
-  );
+function buildFilter(filterStrings, schema) {
+  if (!filterStrings.length) return void 0;
+  const filters = filterStrings.map((raw) => {
+    const eqIdx = raw.indexOf("=");
+    if (eqIdx === -1) {
+      throw new CliError(
+        ErrorCodes.INVALID_ARG,
+        `Invalid filter syntax: "${raw}"`,
+        'Use format: --filter "PropertyName=Value"'
+      );
+    }
+    const propName = raw.slice(0, eqIdx).trim();
+    const value = raw.slice(eqIdx + 1).trim();
+    const propConfig = schema.properties[propName];
+    if (!propConfig) {
+      const available = Object.keys(schema.properties).join(", ");
+      throw new CliError(
+        ErrorCodes.INVALID_ARG,
+        `Property "${propName}" not found`,
+        `Available properties: ${available}`
+      );
+    }
+    return buildPropertyFilter(propName, propConfig.type, value);
+  });
+  return filters.length === 1 ? filters[0] : { and: filters };
 }
-function parseNotionId(input2) {
-  if (!input2) throwInvalidId(input2);
-  if (NOTION_ID_REGEX.test(input2)) {
-    return input2.toLowerCase();
-  }
-  if (UUID_REGEX.test(input2)) {
-    return input2.replace(/-/g, "").toLowerCase();
-  }
-  const urlMatch = NOTION_URL_REGEX.exec(input2);
-  if (urlMatch) {
-    return urlMatch[1].toLowerCase();
+function buildPropertyFilter(property, type, value) {
+  switch (type) {
+    case "select":
+      return { property, select: { equals: value } };
+    case "status":
+      return { property, status: { equals: value } };
+    case "multi_select":
+      return { property, multi_select: { contains: value } };
+    case "checkbox":
+      return { property, checkbox: { equals: value.toLowerCase() === "true" } };
+    case "number":
+      return { property, number: { equals: Number(value) } };
+    case "title":
+      return { property, title: { contains: value } };
+    case "rich_text":
+      return { property, rich_text: { contains: value } };
+    case "url":
+      return { property, url: { contains: value } };
+    case "email":
+      return { property, email: { contains: value } };
+    default:
+      throw new CliError(
+        ErrorCodes.INVALID_ARG,
+        `Filtering by property type "${type}" is not supported`
+      );
   }
-  throwInvalidId(input2);
 }
-function toUuid(id) {
-  return `${id.slice(0, 8)}-${id.slice(8, 12)}-${id.slice(12, 16)}-${id.slice(16, 20)}-${id.slice(20)}`;
+function buildSorts(sortStrings) {
+  return sortStrings.map((raw) => {
+    const colonIdx = raw.lastIndexOf(":");
+    if (colonIdx === -1) {
+      return { property: raw.trim(), direction: "ascending" };
+    }
+    const property = raw.slice(0, colonIdx).trim();
+    const dir = raw.slice(colonIdx + 1).trim().toLowerCase();
+    return {
+      property,
+      direction: dir === "desc" || dir === "descending" ? "descending" : "ascending"
+    };
+  });
 }
-
-// src/commands/open.ts
-var execAsync = promisify(exec);
-function openCommand() {
-  const cmd = new Command8("open");
-  cmd.description("open a Notion page in the default browser").argument("<id/url>", "Notion page ID or URL").action(withErrorHandling(async (idOrUrl) => {
-    const id = parseNotionId(idOrUrl);
-    const url = `https://www.notion.so/${id}`;
-    const platform = process.platform;
-    const opener = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
-    await execAsync(`${opener} "${url}"`);
-    process.stdout.write(`Opening ${url}
-`);
-  }));
-  return cmd;
+function displayFormula(f) {
+  if (f.type === "string") return f.string ?? "";
+  if (f.type === "number")
+    return f.number !== null && f.number !== void 0 ? String(f.number) : "";
+  if (f.type === "boolean") return f.boolean ? "true" : "false";
+  if (f.type === "date") return f.date?.start ?? "";
+  return "";
 }
-
-// src/commands/users.ts
-import { Command as Command9 } from "commander";
-
-// src/output/paginate.ts
-async function paginateResults(fetcher) {
-  const allResults = [];
-  let cursor;
-  let hasMore = true;
-  while (hasMore) {
-    const response = await fetcher(cursor);
-    allResults.push(...response.results);
-    cursor = response.next_cursor ?? void 0;
-    hasMore = response.has_more;
+function displayDate(date) {
+  if (!date) return "";
+  return date.end ? `${date.start} \u2192 ${date.end}` : date.start;
+}
+function displayPropertyValue(prop) {
+  switch (prop.type) {
+    case "title":
+      return prop.title.map((r) => r.plain_text).join("").replace(/\n/g, " ");
+    case "rich_text":
+      return prop.rich_text.map((r) => r.plain_text).join("").replace(/\n/g, " ");
+    case "number":
+      return prop.number !== null && prop.number !== void 0 ? String(prop.number) : "";
+    case "select":
+      return prop.select?.name ?? "";
+    case "status":
+      return prop.status?.name ?? "";
+    case "multi_select":
+      return prop.multi_select.map((s) => s.name).join(", ");
+    case "date":
+      return displayDate(prop.date);
+    case "checkbox":
+      return prop.checkbox ? "\u2713" : "\u2717";
+    case "url":
+      return prop.url ?? "";
+    case "email":
+      return prop.email ?? "";
+    case "phone_number":
+      return prop.phone_number ?? "";
+    case "people":
+      return prop.people.map((p) => "name" in p && p.name ? p.name : p.id).join(", ");
+    case "relation":
+      return prop.relation.length > 0 ? `[${prop.relation.length}]` : "";
+    case "formula":
+      return displayFormula(prop.formula);
+    case "created_time":
+      return prop.created_time;
+    case "last_edited_time":
+      return prop.last_edited_time;
+    case "unique_id":
+      return prop.unique_id.prefix ? `${prop.unique_id.prefix}-${prop.unique_id.number}` : String(prop.unique_id.number ?? "");
+    default:
+      return "";
   }
-  return allResults;
 }
 
-// src/commands/users.ts
-function getEmailOrWorkspace(user) {
-  if (user.type === "person") {
-    return user.person.email ?? "\u2014";
+// src/commands/db/query.ts
+var SKIP_TYPES_IN_AUTO = /* @__PURE__ */ new Set(["relation", "rich_text", "people"]);
+function autoSelectColumns(schema, entries) {
+  const termWidth = process.stdout.columns || 120;
+  const COL_SEP = 2;
+  const candidates = Object.values(schema.properties).filter((p) => !SKIP_TYPES_IN_AUTO.has(p.type)).map((p) => p.name);
+  const widths = candidates.map((col) => {
+    const header = col.toUpperCase().length;
+    const maxData = entries.reduce(
+      (max, e) => Math.max(max, (e.properties[col] ?? "").length),
+      0
+    );
+    return Math.min(Math.max(header, maxData), 40);
+  });
+  const selected = [];
+  let usedWidth = 0;
+  for (let i = 0; i < candidates.length; i++) {
+    const needed = (selected.length > 0 ? COL_SEP : 0) + widths[i];
+    if (usedWidth + needed > termWidth) break;
+    selected.push(candidates[i]);
+    usedWidth += needed;
   }
-  if (user.type === "bot") {
-    const bot = user.bot;
-    return "workspace_name" in bot && bot.workspace_name ? bot.workspace_name : "\u2014";
+  if (selected.length === 0 && candidates.length > 0) {
+    selected.push(candidates[0]);
   }
-  return "\u2014";
-}
-function usersCommand() {
-  const cmd = new Command9("users");
-  cmd.description("list all users in the workspace").option("--json", "output as JSON").action(withErrorHandling(async (opts) => {
-    if (opts.json) setOutputMode("json");
-    const { token, source } = await resolveToken();
-    reportTokenSource(source);
-    const notion = createNotionClient(token);
-    const allUsers = await paginateResults(
-      (cursor) => notion.users.list({ start_cursor: cursor })
-    );
-    const users = allUsers.filter((u) => u.name !== void 0);
-    const rows = users.map((user) => [
-      user.type,
-      user.name ?? "(unnamed)",
-      getEmailOrWorkspace(user),
-      user.id
-    ]);
-    printOutput(users, ["TYPE", "NAME", "EMAIL / WORKSPACE", "ID"], rows);
-  }));
-  return cmd;
+  return selected;
 }
-
-// src/commands/comments.ts
-import { Command as Command10 } from "commander";
-function commentsCommand() {
-  const cmd = new Command10("comments");
-  cmd.description("list comments on a Notion page").argument("<id/url>", "Notion page ID or URL").option("--json", "output as JSON").action(withErrorHandling(async (idOrUrl, opts) => {
-    if (opts.json) setOutputMode("json");
-    const id = parseNotionId(idOrUrl);
-    const uuid = toUuid(id);
-    const { token, source } = await resolveToken();
-    reportTokenSource(source);
-    const notion = createNotionClient(token);
-    const comments = await paginateResults(
-      (cursor) => notion.comments.list({ block_id: uuid, start_cursor: cursor })
-    );
-    if (comments.length === 0) {
-      process.stdout.write("No comments found on this page\n");
-      return;
-    }
-    const rows = comments.map((comment) => {
-      const text = comment.rich_text.map((t) => t.plain_text).join("");
-      return [
-        comment.created_time.split("T")[0],
-        comment.created_by.id.slice(0, 8) + "...",
-        text.slice(0, 80) + (text.length > 80 ? "\u2026" : "")
-      ];
-    });
-    printOutput(comments, ["DATE", "AUTHOR ID", "COMMENT"], rows);
-  }));
-  return cmd;
+function dbQueryCommand() {
+  return new Command10("query").description("Query database entries with optional filtering and sorting").argument("<id>", "Notion database ID or URL").option(
+    "--filter <filter>",
+    'Filter entries (repeatable): --filter "Status=Done"',
+    collect,
+    []
+  ).option(
+    "--sort <sort>",
+    'Sort entries (repeatable): --sort "Name:asc"',
+    collect,
+    []
+  ).option(
+    "--columns <columns>",
+    'Comma-separated list of columns to display: --columns "Title,Status"'
+  ).option("--json", "Output raw JSON").action(
+    withErrorHandling(
+      async (id, options) => {
+        const { token } = await resolveToken();
+        const client = createNotionClient(token);
+        const dbId = parseNotionId(id);
+        const schema = await fetchDatabaseSchema(client, dbId);
+        const columns = options.columns ? options.columns.split(",").map((c2) => c2.trim()) : void 0;
+        const filter = options.filter.length ? buildFilter(options.filter, schema) : void 0;
+        const sorts = options.sort.length ? buildSorts(options.sort) : void 0;
+        const entries = await queryDatabase(client, dbId, {
+          filter,
+          sorts,
+          columns
+        });
+        if (options.json) {
+          process.stdout.write(`${formatJSON(entries.map((e) => e.raw))}
+`);
+          return;
+        }
+        if (entries.length === 0) {
+          process.stdout.write("No entries found.\n");
+          return;
+        }
+        const displayColumns = columns ?? autoSelectColumns(schema, entries);
+        const headers = displayColumns.map((c2) => c2.toUpperCase());
+        const rows = entries.map(
+          (entry) => displayColumns.map((col) => entry.properties[col] ?? "")
+        );
+        process.stdout.write(`${formatTable(rows, headers)}
+`);
+        process.stderr.write(`${entries.length} entries
+`);
+      }
+    )
+  );
+}
+function collect(value, previous) {
+  return previous.concat([value]);
 }
 
-// src/commands/read.ts
+// src/commands/db/schema.ts
 import { Command as Command11 } from "commander";
+function dbSchemaCommand() {
+  return new Command11("schema").description("Show database schema (property names, types, and options)").argument("<id>", "Notion database ID or URL").option("--json", "Output raw JSON").action(
+    withErrorHandling(async (id, options) => {
+      const { token } = await resolveToken();
+      const client = createNotionClient(token);
+      const dbId = parseNotionId(id);
+      const schema = await fetchDatabaseSchema(client, dbId);
+      if (options.json) {
+        process.stdout.write(`${formatJSON(schema)}
+`);
+        return;
+      }
+      const headers = ["PROPERTY", "TYPE", "OPTIONS"];
+      const rows = Object.values(schema.properties).map((prop) => [
+        prop.name,
+        prop.type,
+        prop.options ? prop.options.map((o) => o.name).join(", ") : ""
+      ]);
+      process.stdout.write(`${formatTable(rows, headers)}
+`);
+    })
+  );
+}
 
-// src/services/page.service.ts
-import { collectPaginatedAPI, isFullBlock } from "@notionhq/client";
-var MAX_CONCURRENT_REQUESTS = 3;
-async function fetchBlockTree(client, blockId, depth, maxDepth) {
-  if (depth >= maxDepth) return [];
-  const rawBlocks = await collectPaginatedAPI(client.blocks.children.list, {
-    block_id: blockId
-  });
-  const blocks = rawBlocks.filter(isFullBlock);
-  const SKIP_RECURSE = /* @__PURE__ */ new Set(["child_page", "child_database"]);
-  const nodes = [];
-  for (let i = 0; i < blocks.length; i += MAX_CONCURRENT_REQUESTS) {
-    const batch = blocks.slice(i, i + MAX_CONCURRENT_REQUESTS);
-    const batchNodes = await Promise.all(
-      batch.map(async (block) => {
-        const children = block.has_children && !SKIP_RECURSE.has(block.type) ? await fetchBlockTree(client, block.id, depth + 1, maxDepth) : [];
-        return { block, children };
-      })
-    );
-    nodes.push(...batchNodes);
+// src/commands/ls.ts
+import { isFullPageOrDataSource } from "@notionhq/client";
+import { Command as Command12 } from "commander";
+function getTitle(item) {
+  if (item.object === "data_source") {
+    return item.title.map((t) => t.plain_text).join("") || "(untitled)";
   }
-  return nodes;
+  const titleProp = Object.values(item.properties).find(
+    (p) => p.type === "title"
+  );
+  if (titleProp?.type === "title") {
+    return titleProp.title.map((t) => t.plain_text).join("") || "(untitled)";
+  }
+  return "(untitled)";
 }
-async function fetchPageWithBlocks(client, pageId) {
-  const page = await client.pages.retrieve({ page_id: pageId });
-  const blocks = await fetchBlockTree(client, pageId, 0, 10);
-  return { page, blocks };
+function displayType(item) {
+  return item.object === "data_source" ? "database" : item.object;
+}
+function lsCommand() {
+  const cmd = new Command12("ls");
+  cmd.description("list accessible Notion pages and databases").option(
+    "--type <type>",
+    "filter by object type (page or database)",
+    (val) => {
+      if (val !== "page" && val !== "database") {
+        throw new Error('--type must be "page" or "database"');
+      }
+      return val;
+    }
+  ).option(
+    "--cursor <cursor>",
+    "start from this pagination cursor (from a previous --next hint)"
+  ).option("--json", "force JSON output").action(
+    withErrorHandling(
+      async (opts) => {
+        if (opts.json) {
+          setOutputMode("json");
+        }
+        const { token, source } = await resolveToken();
+        reportTokenSource(source);
+        const notion = createNotionClient(token);
+        const response = await notion.search({
+          start_cursor: opts.cursor,
+          page_size: 20
+        });
+        let items = response.results.filter(
+          (r) => isFullPageOrDataSource(r)
+        );
+        if (opts.type) {
+          const filterType = opts.type;
+          items = items.filter(
+            (r) => filterType === "database" ? r.object === "data_source" : r.object === filterType
+          );
+        }
+        if (items.length === 0) {
+          process.stdout.write("No accessible content found\n");
+          return;
+        }
+        const headers = ["TYPE", "TITLE", "ID", "MODIFIED"];
+        const rows = items.map((item) => [
+          displayType(item),
+          getTitle(item),
+          item.id,
+          item.last_edited_time.split("T")[0]
+        ]);
+        printOutput(items, headers, rows);
+        if (response.has_more && response.next_cursor) {
+          process.stderr.write(
+            `
+  --next: notion ls --cursor ${response.next_cursor}
+`
+          );
+        }
+      }
+    )
+  );
+  return cmd;
 }
 
+// src/commands/open.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import { Command as Command13 } from "commander";
+var execAsync = promisify(exec);
+function openCommand() {
+  const cmd = new Command13("open");
+  cmd.description("open a Notion page in the default browser").argument("<id/url>", "Notion page ID or URL").action(
+    withErrorHandling(async (idOrUrl) => {
+      const id = parseNotionId(idOrUrl);
+      const url = `https://www.notion.so/${id}`;
+      const platform = process.platform;
+      const opener = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+      await execAsync(`${opener} "${url}"`);
+      process.stdout.write(`Opening ${url}
+`);
+    })
+  );
+  return cmd;
+}
+
+// src/commands/profile/list.ts
+import { Command as Command14 } from "commander";
+function profileListCommand() {
+  const cmd = new Command14("list");
+  cmd.description("list all authentication profiles").action(
+    withErrorHandling(async () => {
+      const config = await readGlobalConfig();
+      const profiles = config.profiles ?? {};
+      const profileNames = Object.keys(profiles);
+      if (profileNames.length === 0) {
+        process.stdout.write(
+          "No profiles configured. Run `notion auth login` to get started.\n"
+        );
+        return;
+      }
+      for (const name of profileNames) {
+        const profile = profiles[name];
+        const isActive = config.active_profile === name;
+        const marker = isActive ? bold("* ") : "  ";
+        const activeLabel = isActive ? " (active)" : "";
+        const workspaceInfo = profile.workspace_name ? dim(` \u2014 ${profile.workspace_name}`) : "";
+        process.stdout.write(
+          `${marker}${name}${activeLabel}${workspaceInfo}
+`
+        );
+      }
+    })
+  );
+  return cmd;
+}
+
+// src/commands/profile/use.ts
+import { Command as Command15 } from "commander";
+function profileUseCommand() {
+  const cmd = new Command15("use");
+  cmd.description("switch the active profile").argument("<name>", "profile name to activate").action(
+    withErrorHandling(async (name) => {
+      const config = await readGlobalConfig();
+      const profiles = config.profiles ?? {};
+      if (!profiles[name]) {
+        throw new CliError(
+          ErrorCodes.AUTH_PROFILE_NOT_FOUND,
+          `Profile "${name}" not found.`,
+          `Run "notion auth list" to see available profiles`
+        );
+      }
+      await writeGlobalConfig({
+        ...config,
+        active_profile: name
+      });
+      stderrWrite(success(`Switched to profile "${name}".`));
+    })
+  );
+  return cmd;
+}
+
+// src/commands/read.ts
+import { Command as Command16 } from "commander";
+
 // src/blocks/rich-text.ts
 function richTextToMd(richText) {
   return richText.map(segmentToMd).join("");
@@ -942,7 +2107,8 @@ function applyAnnotations(text, annotations) {
 
 // src/blocks/converters.ts
 function indentChildren(childrenMd) {
-  return childrenMd.split("\n").filter(Boolean).map((line) => "  " + line).join("\n") + "\n";
+  return `${childrenMd.split("\n").filter(Boolean).map((line) => `  ${line}`).join("\n")}
+`;
 }
 var converters = {
   paragraph(block) {
@@ -1053,376 +2219,47 @@ ${content}
     const b = block;
     return `### ${b.child_database.title}
 `;
-  },
-  link_preview(block) {
-    const b = block;
-    return `[${b.link_preview.url}](${b.link_preview.url})
-`;
-  }
-};
-function blockToMd(block, ctx) {
-  const converter = converters[block.type];
-  if (converter) {
-    return converter(block, ctx);
-  }
-  return `<!-- unsupported block: ${block.type} -->
-`;
-}
-
-// src/blocks/properties.ts
-function formatPropertyValue(name, prop) {
-  switch (prop.type) {
-    case "title":
-      return prop.title.map((rt) => rt.plain_text).join("");
-    case "rich_text":
-      return prop.rich_text.map((rt) => rt.plain_text).join("");
-    case "number":
-      return prop.number !== null ? String(prop.number) : "";
-    case "select":
-      return prop.select?.name ?? "";
-    case "status":
-      return prop.status?.name ?? "";
-    case "multi_select":
-      return prop.multi_select.map((s) => s.name).join(", ");
-    case "date":
-      if (!prop.date) return "";
-      return prop.date.end ? `${prop.date.start} \u2192 ${prop.date.end}` : prop.date.start;
-    case "checkbox":
-      return prop.checkbox ? "true" : "false";
-    case "url":
-      return prop.url ?? "";
-    case "email":
-      return prop.email ?? "";
-    case "phone_number":
-      return prop.phone_number ?? "";
-    case "people":
-      return prop.people.map((p) => "name" in p && p.name ? p.name : p.id).join(", ");
-    case "relation":
-      return prop.relation.map((r) => r.id).join(", ");
-    case "formula": {
-      const f = prop.formula;
-      if (f.type === "string") return f.string ?? "";
-      if (f.type === "number") return f.number !== null ? String(f.number) : "";
-      if (f.type === "boolean") return String(f.boolean);
-      if (f.type === "date") return f.date?.start ?? "";
-      return "";
-    }
-    case "rollup": {
-      const r = prop.rollup;
-      if (r.type === "number") return r.number !== null ? String(r.number) : "";
-      if (r.type === "date") return r.date?.start ?? "";
-      if (r.type === "array") return `[${r.array.length} items]`;
-      return "";
-    }
-    case "created_time":
-      return prop.created_time;
-    case "last_edited_time":
-      return prop.last_edited_time;
-    case "created_by":
-      return "name" in prop.created_by ? prop.created_by.name ?? prop.created_by.id : prop.created_by.id;
-    case "last_edited_by":
-      return "name" in prop.last_edited_by ? prop.last_edited_by.name ?? prop.last_edited_by.id : prop.last_edited_by.id;
-    case "files":
-      return prop.files.map((f) => {
-        if (f.type === "external") return f.external.url;
-        return f.name;
-      }).join(", ");
-    case "unique_id":
-      return prop.unique_id.prefix ? `${prop.unique_id.prefix}-${prop.unique_id.number}` : String(prop.unique_id.number ?? "");
-    default:
-      return "";
-  }
-}
-
-// src/blocks/render.ts
-function buildPropertiesHeader(page) {
-  const lines = ["---"];
-  for (const [name, prop] of Object.entries(page.properties)) {
-    const value = formatPropertyValue(name, prop);
-    if (value) {
-      lines.push(`${name}: ${value}`);
-    }
-  }
-  lines.push("---", "");
-  return lines.join("\n");
-}
-function renderBlockTree(blocks) {
-  const parts = [];
-  let listCounter = 0;
-  for (const node of blocks) {
-    if (node.block.type === "numbered_list_item") {
-      listCounter++;
-    } else {
-      listCounter = 0;
-    }
-    const childrenMd = node.children.length > 0 ? renderBlockTree(node.children) : "";
-    const md = blockToMd(node.block, {
-      listNumber: node.block.type === "numbered_list_item" ? listCounter : void 0,
-      childrenMd: childrenMd || void 0
-    });
-    parts.push(md);
-  }
-  return parts.join("");
-}
-function renderPageMarkdown({ page, blocks }) {
-  const header = buildPropertiesHeader(page);
-  const content = renderBlockTree(blocks);
-  return header + content;
-}
-
-// src/output/markdown.ts
-import { Chalk as Chalk2 } from "chalk";
-var c = new Chalk2({ level: 3 });
-function renderMarkdown(md) {
-  if (!isatty()) return md;
-  const lines = md.split("\n");
-  const out = [];
-  let inFence = false;
-  let fenceLang = "";
-  let fenceLines = [];
-  for (const line of lines) {
-    const fenceMatch = line.match(/^```(\w*)$/);
-    if (fenceMatch && !inFence) {
-      inFence = true;
-      fenceLang = fenceMatch[1] ?? "";
-      fenceLines = [];
-      continue;
-    }
-    if (line === "```" && inFence) {
-      inFence = false;
-      const header = fenceLang ? c.dim(`[${fenceLang}]`) : "";
-      if (header) out.push(header);
-      for (const fl of fenceLines) {
-        out.push(c.green("  " + fl));
-      }
-      out.push("");
-      continue;
-    }
-    if (inFence) {
-      fenceLines.push(line);
-      continue;
-    }
-    if (line === "---") {
-      out.push(c.dim("\u2500".repeat(40)));
-      continue;
-    }
-    if (/^<!--.*-->$/.test(line.trim())) {
-      continue;
-    }
-    const h1 = line.match(/^# (.+)/);
-    if (h1) {
-      out.push("\n" + c.bold.cyan(h1[1]));
-      continue;
-    }
-    const h2 = line.match(/^## (.+)/);
-    if (h2) {
-      out.push("\n" + c.bold.blue(h2[1]));
-      continue;
-    }
-    const h3 = line.match(/^### (.+)/);
-    if (h3) {
-      out.push("\n" + c.bold(h3[1]));
-      continue;
-    }
-    const h4 = line.match(/^#### (.+)/);
-    if (h4) {
-      out.push(c.bold.underline(h4[1]));
-      continue;
-    }
-    if (line.startsWith("> ")) {
-      out.push(c.yellow("\u258E ") + renderInline(line.slice(2)));
-      continue;
-    }
-    if (line === "---") {
-      out.push(c.dim("\u2500".repeat(40)));
-      continue;
-    }
-    const propMatch = line.match(/^([A-Za-z_][A-Za-z0-9_ ]*): (.+)$/);
-    if (propMatch) {
-      out.push(c.dim(propMatch[1] + ": ") + c.white(propMatch[2]));
-      continue;
-    }
-    const bulletMatch = line.match(/^(\s*)- (\[[ x]\] )?(.+)/);
-    if (bulletMatch) {
-      const indent = bulletMatch[1] ?? "";
-      const checkbox = bulletMatch[2];
-      const text = bulletMatch[3] ?? "";
-      if (checkbox) {
-        const checked = checkbox.trim() === "[x]";
-        const box = checked ? c.green("\u2611") : c.dim("\u2610");
-        out.push(indent + box + " " + renderInline(text));
-      } else {
-        out.push(indent + c.cyan("\u2022") + " " + renderInline(text));
-      }
-      continue;
-    }
-    const numMatch = line.match(/^(\s*)(\d+)\. (.+)/);
-    if (numMatch) {
-      const indent = numMatch[1] ?? "";
-      const num = numMatch[2] ?? "";
-      const text = numMatch[3] ?? "";
-      out.push(indent + c.cyan(num + ".") + " " + renderInline(text));
-      continue;
-    }
-    out.push(renderInline(line));
-  }
-  return out.join("\n") + "\n";
-}
-function renderInline(text) {
-  const codeSpans = [];
-  let result = text.replace(/`([^`]+)`/g, (_, code) => {
-    codeSpans.push(c.green(code));
-    return `\0CODE${codeSpans.length - 1}\0`;
-  });
-  result = result.replace(/!\[([^\]]*)\]\([^)]+\)/g, (_, alt) => alt ? c.dim(`[image: ${alt}]`) : c.dim("[image]")).replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, t, url) => c.cyan.underline(t) + c.dim(` (${url})`)).replace(/\*\*\*(.+?)\*\*\*/g, (_, t) => c.bold.italic(t)).replace(/\*\*(.+?)\*\*/g, (_, t) => c.bold(t)).replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, (_, t) => c.italic(t)).replace(/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, (_, t) => c.italic(t)).replace(/~~(.+?)~~/g, (_, t) => c.strikethrough(t));
-  result = result.replace(/\x00CODE(\d+)\x00/g, (_, i) => codeSpans[Number(i)] ?? "");
-  return result;
-}
-
-// src/commands/read.ts
-function readCommand() {
-  return new Command11("read").description("Read a Notion page as markdown").argument("<id>", "Notion page ID or URL").option("--json", "Output raw JSON instead of markdown").option("--md", "Output raw markdown (no terminal styling)").action(
-    withErrorHandling(async (id, options) => {
-      const { token } = await resolveToken();
-      const client = createNotionClient(token);
-      const pageId = parseNotionId(id);
-      const pageWithBlocks = await fetchPageWithBlocks(client, pageId);
-      if (options.json) {
-        process.stdout.write(JSON.stringify(pageWithBlocks, null, 2) + "\n");
-      } else {
-        const markdown = renderPageMarkdown(pageWithBlocks);
-        if (options.md || !isatty()) {
-          process.stdout.write(markdown);
-        } else {
-          process.stdout.write(renderMarkdown(markdown));
-        }
-      }
-    })
-  );
-}
-
-// src/commands/db/schema.ts
-import { Command as Command12 } from "commander";
-
-// src/services/database.service.ts
-import { isFullPage as isFullPage2 } from "@notionhq/client";
-async function fetchDatabaseSchema(client, dbId) {
-  const ds = await client.dataSources.retrieve({ data_source_id: dbId });
-  const title = "title" in ds ? ds.title.map((rt) => rt.plain_text).join("") || dbId : dbId;
-  const properties = {};
-  if ("properties" in ds) {
-    for (const [name, prop] of Object.entries(ds.properties)) {
-      const config = {
-        id: prop.id,
-        name,
-        type: prop.type
-      };
-      if (prop.type === "select" && "select" in prop) {
-        config.options = prop.select.options;
-      } else if (prop.type === "status" && "status" in prop) {
-        config.options = prop.status.options;
-      } else if (prop.type === "multi_select" && "multi_select" in prop) {
-        config.options = prop.multi_select.options;
-      }
-      properties[name] = config;
-    }
-  }
-  return { id: dbId, title, properties };
-}
-async function queryDatabase(client, dbId, opts = {}) {
-  const rawPages = await paginateResults(
-    (cursor) => client.dataSources.query({
-      data_source_id: dbId,
-      filter: opts.filter,
-      sorts: opts.sorts,
-      start_cursor: cursor,
-      page_size: 100
-    })
-  );
-  return rawPages.filter(isFullPage2).map((page) => {
-    const propValues = {};
-    for (const [name, prop] of Object.entries(page.properties)) {
-      if (opts.columns && !opts.columns.includes(name)) continue;
-      propValues[name] = displayPropertyValue(prop);
-    }
-    return { id: page.id, properties: propValues, raw: page };
-  });
-}
-function buildFilter(filterStrings, schema) {
-  if (!filterStrings.length) return void 0;
-  const filters = filterStrings.map((raw) => {
-    const eqIdx = raw.indexOf("=");
-    if (eqIdx === -1) {
-      throw new CliError(
-        ErrorCodes.INVALID_ARG,
-        `Invalid filter syntax: "${raw}"`,
-        'Use format: --filter "PropertyName=Value"'
-      );
-    }
-    const propName = raw.slice(0, eqIdx).trim();
-    const value = raw.slice(eqIdx + 1).trim();
-    const propConfig = schema.properties[propName];
-    if (!propConfig) {
-      const available = Object.keys(schema.properties).join(", ");
-      throw new CliError(
-        ErrorCodes.INVALID_ARG,
-        `Property "${propName}" not found`,
-        `Available properties: ${available}`
-      );
-    }
-    return buildPropertyFilter(propName, propConfig.type, value);
-  });
-  return filters.length === 1 ? filters[0] : { and: filters };
-}
-function buildPropertyFilter(property, type, value) {
-  switch (type) {
-    case "select":
-      return { property, select: { equals: value } };
-    case "status":
-      return { property, status: { equals: value } };
-    case "multi_select":
-      return { property, multi_select: { contains: value } };
-    case "checkbox":
-      return { property, checkbox: { equals: value.toLowerCase() === "true" } };
-    case "number":
-      return { property, number: { equals: Number(value) } };
-    case "title":
-      return { property, title: { contains: value } };
-    case "rich_text":
-      return { property, rich_text: { contains: value } };
-    case "url":
-      return { property, url: { contains: value } };
-    case "email":
-      return { property, email: { contains: value } };
-    default:
-      throw new CliError(
-        ErrorCodes.INVALID_ARG,
-        `Filtering by property type "${type}" is not supported`
-      );
-  }
-}
-function buildSorts(sortStrings) {
-  return sortStrings.map((raw) => {
-    const colonIdx = raw.lastIndexOf(":");
-    if (colonIdx === -1) {
-      return { property: raw.trim(), direction: "ascending" };
-    }
-    const property = raw.slice(0, colonIdx).trim();
-    const dir = raw.slice(colonIdx + 1).trim().toLowerCase();
-    return {
-      property,
-      direction: dir === "desc" || dir === "descending" ? "descending" : "ascending"
-    };
-  });
+  },
+  link_preview(block) {
+    const b = block;
+    return `[${b.link_preview.url}](${b.link_preview.url})
+`;
+  }
+};
+function blockToMd(block, ctx) {
+  const converter = converters[block.type];
+  if (converter) {
+    return converter(block, ctx);
+  }
+  return `<!-- unsupported block: ${block.type} -->
+`;
 }
-function displayPropertyValue(prop) {
+
+// src/blocks/properties.ts
+function formatFormula(f) {
+  if (f.type === "string") return f.string ?? "";
+  if (f.type === "number") return f.number !== null ? String(f.number) : "";
+  if (f.type === "boolean") return String(f.boolean);
+  if (f.type === "date") return f.date?.start ?? "";
+  return "";
+}
+function formatRollup(r) {
+  if (r.type === "number") return r.number !== null ? String(r.number) : "";
+  if (r.type === "date") return r.date?.start ?? "";
+  if (r.type === "array") return `[${r.array.length} items]`;
+  return "";
+}
+function formatUser(p) {
+  return "name" in p && p.name ? p.name : p.id;
+}
+function formatPropertyValue(_name, prop) {
   switch (prop.type) {
     case "title":
-      return prop.title.map((r) => r.plain_text).join("").replace(/\n/g, " ");
+      return prop.title.map((rt) => rt.plain_text).join("");
     case "rich_text":
-      return prop.rich_text.map((r) => r.plain_text).join("").replace(/\n/g, " ");
+      return prop.rich_text.map((rt) => rt.plain_text).join("");
     case "number":
-      return prop.number !== null && prop.number !== void 0 ? String(prop.number) : "";
+      return prop.number !== null ? String(prop.number) : "";
     case "select":
       return prop.select?.name ?? "";
     case "status":
@@ -1430,9 +2267,10 @@ function displayPropertyValue(prop) {
     case "multi_select":
       return prop.multi_select.map((s) => s.name).join(", ");
     case "date":
-      return prop.date ? prop.date.end ? `${prop.date.start} \u2192 ${prop.date.end}` : prop.date.start : "";
+      if (!prop.date) return "";
+      return prop.date.end ? `${prop.date.start} \u2192 ${prop.date.end}` : prop.date.start;
     case "checkbox":
-      return prop.checkbox ? "\u2713" : "\u2717";
+      return prop.checkbox ? "true" : "false";
     case "url":
       return prop.url ?? "";
     case "email":
@@ -1440,22 +2278,23 @@ function displayPropertyValue(prop) {
     case "phone_number":
       return prop.phone_number ?? "";
     case "people":
-      return prop.people.map((p) => "name" in p && p.name ? p.name : p.id).join(", ");
+      return prop.people.map(formatUser).join(", ");
     case "relation":
-      return prop.relation.length > 0 ? `[${prop.relation.length}]` : "";
-    case "formula": {
-      const f = prop.formula;
-      if (f.type === "string") return f.string ?? "";
-      if (f.type === "number")
-        return f.number !== null && f.number !== void 0 ? String(f.number) : "";
-      if (f.type === "boolean") return f.boolean ? "true" : "false";
-      if (f.type === "date") return f.date?.start ?? "";
-      return "";
-    }
+      return prop.relation.map((r) => r.id).join(", ");
+    case "formula":
+      return formatFormula(prop.formula);
+    case "rollup":
+      return formatRollup(prop.rollup);
     case "created_time":
       return prop.created_time;
     case "last_edited_time":
       return prop.last_edited_time;
+    case "created_by":
+      return "name" in prop.created_by ? prop.created_by.name ?? prop.created_by.id : prop.created_by.id;
+    case "last_edited_by":
+      return "name" in prop.last_edited_by ? prop.last_edited_by.name ?? prop.last_edited_by.id : prop.last_edited_by.id;
+    case "files":
+      return prop.files.map((f) => f.type === "external" ? f.external.url : f.name).join(", ");
     case "unique_id":
       return prop.unique_id.prefix ? `${prop.unique_id.prefix}-${prop.unique_id.number}` : String(prop.unique_id.number ?? "");
     default:
@@ -1463,95 +2302,354 @@ function displayPropertyValue(prop) {
   }
 }
 
-// src/commands/db/schema.ts
-function dbSchemaCommand() {
-  return new Command12("schema").description("Show database schema (property names, types, and options)").argument("<id>", "Notion database ID or URL").option("--json", "Output raw JSON").action(
-    withErrorHandling(async (id, options) => {
-      const { token } = await resolveToken();
-      const client = createNotionClient(token);
-      const dbId = parseNotionId(id);
-      const schema = await fetchDatabaseSchema(client, dbId);
-      if (options.json) {
-        process.stdout.write(formatJSON(schema) + "\n");
-        return;
-      }
-      const headers = ["PROPERTY", "TYPE", "OPTIONS"];
-      const rows = Object.values(schema.properties).map((prop) => [
-        prop.name,
-        prop.type,
-        prop.options ? prop.options.map((o) => o.name).join(", ") : ""
-      ]);
-      process.stdout.write(formatTable(rows, headers) + "\n");
-    })
+// src/blocks/render.ts
+function buildPropertiesHeader(page) {
+  const lines = ["---"];
+  for (const [name, prop] of Object.entries(page.properties)) {
+    const value = formatPropertyValue(name, prop);
+    if (value) {
+      lines.push(`${name}: ${value}`);
+    }
+  }
+  lines.push("---", "");
+  return lines.join("\n");
+}
+function renderBlockTree(blocks) {
+  const parts = [];
+  let listCounter = 0;
+  for (const node of blocks) {
+    if (node.block.type === "numbered_list_item") {
+      listCounter++;
+    } else {
+      listCounter = 0;
+    }
+    const childrenMd = node.children.length > 0 ? renderBlockTree(node.children) : "";
+    const md = blockToMd(node.block, {
+      listNumber: node.block.type === "numbered_list_item" ? listCounter : void 0,
+      childrenMd: childrenMd || void 0
+    });
+    parts.push(md);
+  }
+  return parts.join("");
+}
+function renderPageMarkdown({ page, blocks }) {
+  const header = buildPropertiesHeader(page);
+  const content = renderBlockTree(blocks);
+  return header + content;
+}
+
+// src/output/markdown.ts
+import { Chalk as Chalk2 } from "chalk";
+var c = new Chalk2({ level: 3 });
+function handleFenceLine(line, state, out) {
+  const fenceMatch = line.match(/^```(\w*)$/);
+  if (fenceMatch && !state.inFence) {
+    state.inFence = true;
+    state.fenceLang = fenceMatch[1] ?? "";
+    state.fenceLines = [];
+    return true;
+  }
+  if (line === "```" && state.inFence) {
+    state.inFence = false;
+    const header = state.fenceLang ? c.dim(`[${state.fenceLang}]`) : "";
+    if (header) out.push(header);
+    for (const fl of state.fenceLines) {
+      out.push(c.green(`  ${fl}`));
+    }
+    out.push("");
+    return true;
+  }
+  return false;
+}
+function handleHeading(line, out) {
+  const h1 = line.match(/^# (.+)/);
+  if (h1) {
+    out.push(`
+${c.bold.cyan(h1[1])}`);
+    return true;
+  }
+  const h2 = line.match(/^## (.+)/);
+  if (h2) {
+    out.push(`
+${c.bold.blue(h2[1])}`);
+    return true;
+  }
+  const h3 = line.match(/^### (.+)/);
+  if (h3) {
+    out.push(`
+${c.bold(h3[1])}`);
+    return true;
+  }
+  const h4 = line.match(/^#### (.+)/);
+  if (h4) {
+    out.push(c.bold.underline(h4[1]));
+    return true;
+  }
+  return false;
+}
+function handleListLine(line, out) {
+  const bulletMatch = line.match(/^(\s*)- (\[[ x]\] )?(.+)/);
+  if (bulletMatch) {
+    const indent = bulletMatch[1] ?? "";
+    const checkbox = bulletMatch[2];
+    const text = bulletMatch[3] ?? "";
+    if (checkbox) {
+      const checked = checkbox.trim() === "[x]";
+      const box = checked ? c.green("\u2611") : c.dim("\u2610");
+      out.push(`${indent + box} ${renderInline(text)}`);
+    } else {
+      out.push(`${indent + c.cyan("\u2022")} ${renderInline(text)}`);
+    }
+    return true;
+  }
+  const numMatch = line.match(/^(\s*)(\d+)\. (.+)/);
+  if (numMatch) {
+    const indent = numMatch[1] ?? "";
+    const num = numMatch[2] ?? "";
+    const text = numMatch[3] ?? "";
+    out.push(`${indent + c.cyan(`${num}.`)} ${renderInline(text)}`);
+    return true;
+  }
+  return false;
+}
+function renderMarkdown(md) {
+  if (!isatty()) return md;
+  const lines = md.split("\n");
+  const out = [];
+  const fence = { inFence: false, fenceLang: "", fenceLines: [] };
+  for (const line of lines) {
+    if (handleFenceLine(line, fence, out)) continue;
+    if (fence.inFence) {
+      fence.fenceLines.push(line);
+      continue;
+    }
+    if (line === "---") {
+      out.push(c.dim("\u2500".repeat(40)));
+      continue;
+    }
+    if (/^<!--.*-->$/.test(line.trim())) continue;
+    if (handleHeading(line, out)) continue;
+    if (line.startsWith("> ")) {
+      out.push(c.yellow("\u258E ") + renderInline(line.slice(2)));
+      continue;
+    }
+    const propMatch = line.match(/^([A-Za-z_][A-Za-z0-9_ ]*): (.+)$/);
+    if (propMatch) {
+      out.push(c.dim(`${propMatch[1]}: `) + c.white(propMatch[2]));
+      continue;
+    }
+    if (handleListLine(line, out)) continue;
+    out.push(renderInline(line));
+  }
+  return `${out.join("\n")}
+`;
+}
+function renderInline(text) {
+  const codeSpans = [];
+  let result = text.replace(/`([^`]+)`/g, (_, code) => {
+    codeSpans.push(c.green(code));
+    return `\0CODE${codeSpans.length - 1}\0`;
+  });
+  result = result.replace(
+    /!\[([^\]]*)\]\([^)]+\)/g,
+    (_, alt) => alt ? c.dim(`[image: ${alt}]`) : c.dim("[image]")
+  ).replace(
+    /\[([^\]]+)\]\(([^)]+)\)/g,
+    (_, t, url) => c.cyan.underline(t) + c.dim(` (${url})`)
+  ).replace(/\*\*\*(.+?)\*\*\*/g, (_, t) => c.bold.italic(t)).replace(/\*\*(.+?)\*\*/g, (_, t) => c.bold(t)).replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, (_, t) => c.italic(t)).replace(/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, (_, t) => c.italic(t)).replace(/~~(.+?)~~/g, (_, t) => c.strikethrough(t));
+  result = result.replace(
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: sentinel chars are intentional
+    /\x00CODE(\d+)\x00/g,
+    (_, i) => codeSpans[Number(i)] ?? ""
   );
+  return result;
 }
 
-// src/commands/db/query.ts
-import { Command as Command13 } from "commander";
-var SKIP_TYPES_IN_AUTO = /* @__PURE__ */ new Set(["relation", "rich_text", "people"]);
-function autoSelectColumns(schema, entries) {
-  const termWidth = process.stdout.columns || 120;
-  const COL_SEP = 2;
-  const candidates = Object.values(schema.properties).filter((p) => !SKIP_TYPES_IN_AUTO.has(p.type)).map((p) => p.name);
-  const widths = candidates.map((col) => {
-    const header = col.toUpperCase().length;
-    const maxData = entries.reduce((max, e) => Math.max(max, (e.properties[col] ?? "").length), 0);
-    return Math.min(Math.max(header, maxData), 40);
+// src/services/page.service.ts
+import {
+  collectPaginatedAPI,
+  isFullBlock
+} from "@notionhq/client";
+var MAX_CONCURRENT_REQUESTS = 3;
+async function fetchBlockTree(client, blockId, depth, maxDepth) {
+  if (depth >= maxDepth) return [];
+  const rawBlocks = await collectPaginatedAPI(client.blocks.children.list, {
+    block_id: blockId
   });
-  const selected = [];
-  let usedWidth = 0;
-  for (let i = 0; i < candidates.length; i++) {
-    const needed = (selected.length > 0 ? COL_SEP : 0) + widths[i];
-    if (usedWidth + needed > termWidth) break;
-    selected.push(candidates[i]);
-    usedWidth += needed;
-  }
-  if (selected.length === 0 && candidates.length > 0) {
-    selected.push(candidates[0]);
+  const blocks = rawBlocks.filter(isFullBlock);
+  const SKIP_RECURSE = /* @__PURE__ */ new Set(["child_page", "child_database"]);
+  const nodes = [];
+  for (let i = 0; i < blocks.length; i += MAX_CONCURRENT_REQUESTS) {
+    const batch = blocks.slice(i, i + MAX_CONCURRENT_REQUESTS);
+    const batchNodes = await Promise.all(
+      batch.map(async (block) => {
+        const children = block.has_children && !SKIP_RECURSE.has(block.type) ? await fetchBlockTree(client, block.id, depth + 1, maxDepth) : [];
+        return { block, children };
+      })
+    );
+    nodes.push(...batchNodes);
   }
-  return selected;
+  return nodes;
 }
-function dbQueryCommand() {
-  return new Command13("query").description("Query database entries with optional filtering and sorting").argument("<id>", "Notion database ID or URL").option("--filter <filter>", 'Filter entries (repeatable): --filter "Status=Done"', collect, []).option("--sort <sort>", 'Sort entries (repeatable): --sort "Name:asc"', collect, []).option("--columns <columns>", 'Comma-separated list of columns to display: --columns "Title,Status"').option("--json", "Output raw JSON").action(
+async function fetchPageWithBlocks(client, pageId) {
+  const page = await client.pages.retrieve({
+    page_id: pageId
+  });
+  const blocks = await fetchBlockTree(client, pageId, 0, 10);
+  return { page, blocks };
+}
+
+// src/commands/read.ts
+function readCommand() {
+  return new Command16("read").description("Read a Notion page as markdown").argument("<id>", "Notion page ID or URL").option("--json", "Output raw JSON instead of markdown").option("--md", "Output raw markdown (no terminal styling)").action(
     withErrorHandling(
       async (id, options) => {
         const { token } = await resolveToken();
         const client = createNotionClient(token);
-        const dbId = parseNotionId(id);
-        const schema = await fetchDatabaseSchema(client, dbId);
-        const columns = options.columns ? options.columns.split(",").map((c2) => c2.trim()) : void 0;
-        const filter = options.filter.length ? buildFilter(options.filter, schema) : void 0;
-        const sorts = options.sort.length ? buildSorts(options.sort) : void 0;
-        const entries = await queryDatabase(client, dbId, { filter, sorts, columns });
+        const pageId = parseNotionId(id);
+        const pageWithBlocks = await fetchPageWithBlocks(client, pageId);
         if (options.json) {
-          process.stdout.write(formatJSON(entries.map((e) => e.raw)) + "\n");
-          return;
+          process.stdout.write(
+            `${JSON.stringify(pageWithBlocks, null, 2)}
+`
+          );
+        } else {
+          const markdown = renderPageMarkdown(pageWithBlocks);
+          if (options.md || !isatty()) {
+            process.stdout.write(markdown);
+          } else {
+            process.stdout.write(renderMarkdown(markdown));
+          }
         }
-        if (entries.length === 0) {
-          process.stdout.write("No entries found.\n");
-          return;
+      }
+    )
+  );
+}
+
+// src/commands/search.ts
+import { isFullPageOrDataSource as isFullPageOrDataSource2 } from "@notionhq/client";
+import { Command as Command17 } from "commander";
+function getTitle2(item) {
+  if (item.object === "data_source") {
+    return item.title.map((t) => t.plain_text).join("") || "(untitled)";
+  }
+  const titleProp = Object.values(item.properties).find(
+    (p) => p.type === "title"
+  );
+  if (titleProp?.type === "title") {
+    return titleProp.title.map((t) => t.plain_text).join("") || "(untitled)";
+  }
+  return "(untitled)";
+}
+function toSdkFilterValue(type) {
+  return type === "database" ? "data_source" : "page";
+}
+function displayType2(item) {
+  return item.object === "data_source" ? "database" : item.object;
+}
+function searchCommand() {
+  const cmd = new Command17("search");
+  cmd.description("search Notion workspace by keyword").argument("<query>", "search keyword").option(
+    "--type <type>",
+    "filter by object type (page or database)",
+    (val) => {
+      if (val !== "page" && val !== "database") {
+        throw new Error('--type must be "page" or "database"');
+      }
+      return val;
+    }
+  ).option(
+    "--cursor <cursor>",
+    "start from this pagination cursor (from a previous --next hint)"
+  ).option("--json", "force JSON output").action(
+    withErrorHandling(
+      async (query, opts) => {
+        if (opts.json) {
+          setOutputMode("json");
         }
-        const displayColumns = columns ?? autoSelectColumns(schema, entries);
-        const headers = displayColumns.map((c2) => c2.toUpperCase());
-        const rows = entries.map(
-          (entry) => displayColumns.map((col) => entry.properties[col] ?? "")
+        const { token, source } = await resolveToken();
+        reportTokenSource(source);
+        const notion = createNotionClient(token);
+        const response = await notion.search({
+          query,
+          filter: opts.type ? { property: "object", value: toSdkFilterValue(opts.type) } : void 0,
+          start_cursor: opts.cursor,
+          page_size: 20
+        });
+        const fullResults = response.results.filter(
+          (r) => isFullPageOrDataSource2(r)
         );
-        process.stdout.write(formatTable(rows, headers) + "\n");
-        process.stderr.write(`${entries.length} entries
+        if (fullResults.length === 0) {
+          process.stdout.write(`No results found for "${query}"
 `);
+          return;
+        }
+        const headers = ["TYPE", "TITLE", "ID", "MODIFIED"];
+        const rows = fullResults.map((item) => [
+          displayType2(item),
+          getTitle2(item),
+          item.id,
+          item.last_edited_time.split("T")[0]
+        ]);
+        printOutput(fullResults, headers, rows);
+        if (response.has_more && response.next_cursor) {
+          process.stderr.write(
+            `
+  --next: notion search "${query}" --cursor ${response.next_cursor}
+`
+          );
+        }
       }
     )
   );
+  return cmd;
 }
-function collect(value, previous) {
-  return previous.concat([value]);
+
+// src/commands/users.ts
+import { Command as Command18 } from "commander";
+function getEmailOrWorkspace(user) {
+  if (user.type === "person") {
+    return user.person.email ?? "\u2014";
+  }
+  if (user.type === "bot") {
+    const bot = user.bot;
+    return "workspace_name" in bot && bot.workspace_name ? bot.workspace_name : "\u2014";
+  }
+  return "\u2014";
+}
+function usersCommand() {
+  const cmd = new Command18("users");
+  cmd.description("list all users in the workspace").option("--json", "output as JSON").action(
+    withErrorHandling(async (opts) => {
+      if (opts.json) setOutputMode("json");
+      const { token, source } = await resolveToken();
+      reportTokenSource(source);
+      const notion = createNotionClient(token);
+      const allUsers = await paginateResults(
+        (cursor) => notion.users.list({ start_cursor: cursor })
+      );
+      const users = allUsers.filter(
+        (u) => u.name !== void 0
+      );
+      const rows = users.map((user) => [
+        user.type,
+        user.name ?? "(unnamed)",
+        getEmailOrWorkspace(user),
+        user.id
+      ]);
+      printOutput(users, ["TYPE", "NAME", "EMAIL / WORKSPACE", "ID"], rows);
+    })
+  );
+  return cmd;
 }
 
 // src/cli.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
-var pkg = JSON.parse(readFileSync(join3(__dirname, "../package.json"), "utf-8"));
-var program = new Command14();
+var pkg = JSON.parse(
+  readFileSync(join3(__dirname, "../package.json"), "utf-8")
+);
+var program = new Command19();
 program.name("notion").description("Notion CLI \u2014 read Notion pages and databases from the terminal").version(pkg.version);
 program.option("--verbose", "show API requests/responses").option("--color", "force color output").option("--json", "force JSON output (overrides TTY detection)").option("--md", "force markdown output for page content");
 program.configureOutput({
@@ -1572,19 +2670,31 @@ program.hook("preAction", (thisCommand) => {
     setOutputMode("md");
   }
 });
-program.addCommand(initCommand());
-var profileCmd = new Command14("profile").description("manage authentication profiles");
+var authCmd = new Command19("auth").description("manage Notion authentication");
+authCmd.action(authDefaultAction(authCmd));
+authCmd.addCommand(loginCommand());
+authCmd.addCommand(logoutCommand());
+authCmd.addCommand(statusCommand());
+authCmd.addCommand(profileListCommand());
+authCmd.addCommand(profileUseCommand());
+program.addCommand(authCmd);
+program.addCommand(initCommand(), { hidden: true });
+var profileCmd = new Command19("profile").description(
+  "manage authentication profiles"
+);
 profileCmd.addCommand(profileListCommand());
 profileCmd.addCommand(profileUseCommand());
-profileCmd.addCommand(profileRemoveCommand());
-program.addCommand(profileCmd);
+program.addCommand(profileCmd, { hidden: true });
 program.addCommand(searchCommand());
 program.addCommand(lsCommand());
 program.addCommand(openCommand());
 program.addCommand(usersCommand());
 program.addCommand(commentsCommand());
 program.addCommand(readCommand());
-var dbCmd = new Command14("db").description("Database operations");
+program.addCommand(commentAddCommand());
+program.addCommand(appendCommand());
+program.addCommand(createPageCommand());
+var dbCmd = new Command19("db").description("Database operations");
 dbCmd.addCommand(dbSchemaCommand());
 dbCmd.addCommand(dbQueryCommand());
 program.addCommand(dbCmd);