@jordancoin/notioncli 1.0.0 → 1.2.0

package/bin/notion.js

@@ -19,12 +19,35 @@ function saveConfig(config) {
 }
 
 /**
- * Resolve API key: env var → config file → error with setup instructions
+ * Get the active workspace name from --workspace flag or config.
+ */
+function getWorkspaceName() {
+  return program.opts().workspace || undefined;
+}
+
+/**
+ * Get the active workspace config { apiKey, aliases, name }.
+ */
+function getWorkspaceConfig() {
+  const config = loadConfig();
+  const ws = helpers.resolveWorkspace(config, getWorkspaceName());
+  if (ws.error) {
+    console.error(`Error: ${ws.error}`);
+    if (ws.available && ws.available.length > 0) {
+      console.error(`Available workspaces: ${ws.available.join(', ')}`);
+    }
+    process.exit(1);
+  }
+  return ws;
+}
+
+/**
+ * Resolve API key: env var → workspace config → error with setup instructions
  */
 function getApiKey() {
   if (process.env.NOTION_API_KEY) return process.env.NOTION_API_KEY;
-  const config = loadConfig();
-  if (config.apiKey) return config.apiKey;
+  const ws = getWorkspaceConfig();
+  if (ws.apiKey) return ws.apiKey;
   console.error('Error: No Notion API key found.');
   console.error('');
   console.error('Set it up with one of:');
@@ -40,14 +63,14 @@ function getApiKey() {
  * If given a raw UUID, we use it for both IDs (the SDK figures it out).
  */
 function resolveDb(aliasOrId) {
-  const config = loadConfig();
-  if (config.aliases && config.aliases[aliasOrId]) {
-    return config.aliases[aliasOrId];
+  const ws = getWorkspaceConfig();
+  if (ws.aliases && ws.aliases[aliasOrId]) {
+    return ws.aliases[aliasOrId];
   }
   if (UUID_REGEX.test(aliasOrId)) {
     return { database_id: aliasOrId, data_source_id: aliasOrId };
   }
-  const aliasNames = config.aliases ? Object.keys(config.aliases) : [];
+  const aliasNames = ws.aliases ? Object.keys(ws.aliases) : [];
   console.error(`Unknown database alias: "${aliasOrId}"`);
   if (aliasNames.length > 0) {
     console.error(`Available aliases: ${aliasNames.join(', ')}`);
@@ -64,14 +87,14 @@ function resolveDb(aliasOrId) {
  * Returns { pageId, dbIds } where dbIds is non-null when resolved via alias.
  */
 async function resolvePageId(aliasOrId, filterStr) {
-  const config = loadConfig();
-  if (config.aliases && config.aliases[aliasOrId]) {
+  const ws = getWorkspaceConfig();
+  if (ws.aliases && ws.aliases[aliasOrId]) {
     if (!filterStr) {
       console.error('When using an alias, --filter is required to identify a specific page.');
       console.error(`Example: notion update ${aliasOrId} --filter "Name=My Page" --prop "Status=Done"`);
       process.exit(1);
     }
-    const dbIds = config.aliases[aliasOrId];
+    const dbIds = ws.aliases[aliasOrId];
     const notion = getNotion();
     const filter = await buildFilter(dbIds, filterStr);
     const res = await notion.dataSources.query({
@@ -94,7 +117,7 @@ async function resolvePageId(aliasOrId, filterStr) {
   }
   // Check if it looks like a UUID — if not, it's probably a typo'd alias
   if (!UUID_REGEX.test(aliasOrId)) {
-    const aliasNames = config.aliases ? Object.keys(config.aliases) : [];
+    const aliasNames = ws.aliases ? Object.keys(ws.aliases) : [];
     console.error(`Unknown alias: "${aliasOrId}"`);
     if (aliasNames.length > 0) {
       console.error(`Available aliases: ${aliasNames.join(', ')}`);
@@ -203,8 +226,9 @@ async function buildFilter(dbIds, filterStr) {
 program
   .name('notion')
   .description('A powerful CLI for the Notion API — query databases, manage pages, and automate your workspace from the terminal.')
-  .version('1.0.0')
-  .option('--json', 'Output raw JSON instead of formatted tables');
+  .version('1.2.0')
+  .option('--json', 'Output raw JSON instead of formatted tables')
+  .option('-w, --workspace <name>', 'Use a specific workspace profile');
 
 // ─── init ──────────────────────────────────────────────────────────────────────
 program
@@ -213,6 +237,7 @@ program
   .option('--key <api-key>', 'Notion integration API key (starts with ntn_)')
   .action(async (opts) => {
     const config = loadConfig();
+    const wsName = getWorkspaceName() || config.activeWorkspace || 'default';
     const apiKey = opts.key || process.env.NOTION_API_KEY;
 
     if (!apiKey) {
@@ -225,12 +250,16 @@ program
       console.error('  4. Share your databases with the integration');
       console.error('');
       console.error('Then run: notion init --key ntn_your_api_key');
+      console.error('  Or with workspace: notion init --workspace work --key ntn_your_api_key');
       process.exit(1);
     }
 
-    config.apiKey = apiKey;
+    if (!config.workspaces) config.workspaces = {};
+    if (!config.workspaces[wsName]) config.workspaces[wsName] = { aliases: {} };
+    config.workspaces[wsName].apiKey = apiKey;
+    config.activeWorkspace = wsName;
     saveConfig(config);
-    console.log(`✅ API key saved to ${CONFIG_PATH}`);
+    console.log(`✅ API key saved to workspace "${wsName}" in ${CONFIG_PATH}`);
     console.log('');
 
     // Discover databases
@@ -247,7 +276,7 @@ program
         return;
       }
 
-      if (!config.aliases) config.aliases = {};
+      const aliases = config.workspaces[wsName].aliases || {};
 
       console.log(`Found ${res.results.length} database${res.results.length !== 1 ? 's' : ''}:\n`);
 
@@ -255,7 +284,7 @@ program
       for (const db of res.results) {
         const title = richTextToPlain(db.title) || '';
         const dsId = db.id;
-        const dbId = db.database_id || dsId;
+        const dbId = (db.parent && db.parent.type === 'database_id' && db.parent.database_id) || db.database_id || dsId;
 
         // Auto-generate a slug from the title
         let slug = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 30);
@@ -264,12 +293,12 @@ program
         // Avoid collisions — append a number if needed
         let finalSlug = slug;
         let counter = 2;
-        while (config.aliases[finalSlug] && config.aliases[finalSlug].data_source_id !== dsId) {
+        while (aliases[finalSlug] && aliases[finalSlug].data_source_id !== dsId) {
           finalSlug = `${slug}-${counter}`;
           counter++;
         }
 
-        config.aliases[finalSlug] = {
+        aliases[finalSlug] = {
           database_id: dbId,
           data_source_id: dsId,
         };
@@ -278,9 +307,10 @@ program
         added.push(finalSlug);
       }
 
+      config.workspaces[wsName].aliases = aliases;
       saveConfig(config);
       console.log('');
-      console.log(`${added.length} alias${added.length !== 1 ? 'es' : ''} saved automatically.`);
+      console.log(`${added.length} alias${added.length !== 1 ? 'es' : ''} saved to workspace "${wsName}".`);
       console.log('');
       console.log('Ready! Try:');
       if (added.length > 0) {
@@ -308,7 +338,9 @@ alias
   .description('Add a database alias (auto-discovers data_source_id)')
   .action(async (name, databaseId) => {
     const config = loadConfig();
-    if (!config.aliases) config.aliases = {};
+    const wsName = getWorkspaceName() || config.activeWorkspace || 'default';
+    if (!config.workspaces[wsName]) config.workspaces[wsName] = { aliases: {} };
+    const aliases = config.workspaces[wsName].aliases || {};
 
     // Try to discover the data_source_id by searching for this database
     const notion = getNotion();
@@ -328,9 +360,9 @@ alias
 
       if (match) {
         dataSourceId = match.id;
-        // The database_id might differ from data_source_id
-        const dbId = match.database_id || databaseId;
-        config.aliases[name] = {
+        // The database_id might differ from data_source_id — check parent
+        const dbId = (match.parent && match.parent.type === 'database_id' && match.parent.database_id) || match.database_id || databaseId;
+        aliases[name] = {
           database_id: dbId,
           data_source_id: dataSourceId,
         };
@@ -340,7 +372,7 @@ alias
         console.log(`   data_source_id: ${dataSourceId}`);
       } else {
         // Couldn't find via search — use the ID for both
-        config.aliases[name] = {
+        aliases[name] = {
           database_id: databaseId,
           data_source_id: databaseId,
         };
@@ -349,7 +381,7 @@ alias
       }
     } catch (err) {
       // Fallback: use same ID for both
-      config.aliases[name] = {
+      aliases[name] = {
         database_id: databaseId,
         data_source_id: databaseId,
       };
@@ -357,6 +389,7 @@ alias
       console.log(`   (Auto-discovery failed: ${err.message})`);
     }
 
+    config.workspaces[wsName].aliases = aliases;
     saveConfig(config);
   });
 
@@ -364,16 +397,17 @@ alias
   .command('list')
   .description('Show all configured database aliases')
   .action(() => {
-    const config = loadConfig();
-    const aliases = config.aliases || {};
+    const ws = getWorkspaceConfig();
+    const aliases = ws.aliases || {};
     const names = Object.keys(aliases);
 
     if (names.length === 0) {
-      console.log('No aliases configured.');
+      console.log(`No aliases in workspace "${ws.name}".`);
       console.log('Add one with: notion alias add <name> <database-id>');
       return;
     }
 
+    console.log(`Workspace: ${ws.name}\n`);
     const rows = names.map(name => ({
       alias: name,
       database_id: aliases[name].database_id,
@@ -387,17 +421,20 @@ alias
   .description('Remove a database alias')
   .action((name) => {
     const config = loadConfig();
-    if (!config.aliases || !config.aliases[name]) {
-      console.error(`Alias "${name}" not found.`);
-      const names = config.aliases ? Object.keys(config.aliases) : [];
+    const wsName = getWorkspaceName() || config.activeWorkspace || 'default';
+    const aliases = config.workspaces[wsName]?.aliases || {};
+    if (!aliases[name]) {
+      console.error(`Alias "${name}" not found in workspace "${wsName}".`);
+      const names = Object.keys(aliases);
       if (names.length > 0) {
         console.error(`Available: ${names.join(', ')}`);
       }
       process.exit(1);
     }
-    delete config.aliases[name];
+    delete aliases[name];
+    config.workspaces[wsName].aliases = aliases;
     saveConfig(config);
-    console.log(`✅ Removed alias "${name}"`);
+    console.log(`✅ Removed alias "${name}" from workspace "${wsName}"`);
   });
 
 alias
@@ -405,22 +442,104 @@ alias
   .description('Rename a database alias')
   .action((oldName, newName) => {
     const config = loadConfig();
-    if (!config.aliases || !config.aliases[oldName]) {
-      console.error(`Alias "${oldName}" not found.`);
-      const names = config.aliases ? Object.keys(config.aliases) : [];
+    const wsName = getWorkspaceName() || config.activeWorkspace || 'default';
+    const aliases = config.workspaces[wsName]?.aliases || {};
+    if (!aliases[oldName]) {
+      console.error(`Alias "${oldName}" not found in workspace "${wsName}".`);
+      const names = Object.keys(aliases);
       if (names.length > 0) {
         console.error(`Available: ${names.join(', ')}`);
       }
       process.exit(1);
     }
-    if (config.aliases[newName]) {
+    if (aliases[newName]) {
       console.error(`Alias "${newName}" already exists. Remove it first or pick a different name.`);
       process.exit(1);
     }
-    config.aliases[newName] = config.aliases[oldName];
-    delete config.aliases[oldName];
+    aliases[newName] = aliases[oldName];
+    delete aliases[oldName];
+    config.workspaces[wsName].aliases = aliases;
+    saveConfig(config);
+    console.log(`✅ Renamed "${oldName}" → "${newName}" in workspace "${wsName}"`);
+  });
+
+// ─── workspace ─────────────────────────────────────────────────────────────────
+const workspace = program
+  .command('workspace')
+  .description('Manage workspace profiles (multiple Notion accounts)');
+
+workspace
+  .command('add <name>')
+  .description('Add a new workspace profile')
+  .requiredOption('--key <api-key>', 'Notion API key for this workspace')
+  .action(async (name, opts) => {
+    const config = loadConfig();
+    if (config.workspaces[name]) {
+      console.error(`Workspace "${name}" already exists. Use "notion init --workspace ${name} --key ..." to update it.`);
+      process.exit(1);
+    }
+    config.workspaces[name] = { apiKey: opts.key, aliases: {} };
+    saveConfig(config);
+    console.log(`✅ Added workspace "${name}"`);
+    console.log('');
+    console.log(`Discover databases: notion init --workspace ${name}`);
+    console.log(`Or set as active:   notion workspace use ${name}`);
+  });
+
+workspace
+  .command('list')
+  .description('List all workspace profiles')
+  .action(() => {
+    const config = loadConfig();
+    const names = Object.keys(config.workspaces || {});
+    if (names.length === 0) {
+      console.log('No workspaces configured. Run: notion init --key ntn_...');
+      return;
+    }
+    for (const name of names) {
+      const ws = config.workspaces[name];
+      const active = name === config.activeWorkspace ? ' ← active' : '';
+      const aliasCount = Object.keys(ws.aliases || {}).length;
+      const keyPreview = ws.apiKey ? `${ws.apiKey.slice(0, 8)}...` : '(no key)';
+      console.log(`  ${name}${active}`);
+      console.log(`    Key: ${keyPreview} | Aliases: ${aliasCount}`);
+    }
+  });
+
+workspace
+  .command('use <name>')
+  .description('Set the active workspace')
+  .action((name) => {
+    const config = loadConfig();
+    if (!config.workspaces[name]) {
+      console.error(`Workspace "${name}" not found.`);
+      const names = Object.keys(config.workspaces || {});
+      if (names.length > 0) {
+        console.error(`Available: ${names.join(', ')}`);
+      }
+      process.exit(1);
+    }
+    config.activeWorkspace = name;
     saveConfig(config);
-    console.log(`✅ Renamed "${oldName}" → "${newName}"`);
+    console.log(`✅ Active workspace: ${name}`);
+  });
+
+workspace
+  .command('remove <name>')
+  .description('Remove a workspace profile')
+  .action((name) => {
+    const config = loadConfig();
+    if (!config.workspaces[name]) {
+      console.error(`Workspace "${name}" not found.`);
+      process.exit(1);
+    }
+    if (name === config.activeWorkspace) {
+      console.error(`Cannot remove the active workspace. Switch first: notion workspace use <other>`);
+      process.exit(1);
+    }
+    delete config.workspaces[name];
+    saveConfig(config);
+    console.log(`✅ Removed workspace "${name}"`);
   });
 
 // ─── search ────────────────────────────────────────────────────────────────────
@@ -619,7 +738,43 @@ program
       console.log('');
       console.log('Properties:');
       for (const [name, prop] of Object.entries(page.properties)) {
-        console.log(`  ${name}: ${propValue(prop)}`);
+        if (prop.type === 'relation') {
+          const rels = prop.relation || [];
+          if (rels.length === 0) {
+            console.log(`  ${name}: (none)`);
+          } else {
+            // Resolve relation titles
+            const titles = [];
+            for (const rel of rels) {
+              try {
+                const linked = await notion.pages.retrieve({ page_id: rel.id });
+                let t = '';
+                for (const [, p] of Object.entries(linked.properties)) {
+                  if (p.type === 'title') { t = propValue(p); break; }
+                }
+                titles.push(t || rel.id.slice(0, 8) + '…');
+              } catch {
+                titles.push(rel.id.slice(0, 8) + '…');
+              }
+            }
+            console.log(`  ${name}: ${titles.join(', ')}`);
+          }
+        } else if (prop.type === 'rollup') {
+          const r = prop.rollup;
+          if (!r) {
+            console.log(`  ${name}: (empty)`);
+          } else if (r.type === 'number') {
+            console.log(`  ${name}: ${r.number != null ? r.number : '(empty)'}`);
+          } else if (r.type === 'date') {
+            console.log(`  ${name}: ${r.date ? r.date.start : '(empty)'}`);
+          } else if (r.type === 'array' && r.array) {
+            console.log(`  ${name}: ${r.array.map(item => propValue(item)).join(', ')}`);
+          } else {
+            console.log(`  ${name}: ${JSON.stringify(r)}`);
+          }
+        } else {
+          console.log(`  ${name}: ${propValue(prop)}`);
+        }
       }
     } catch (err) {
       console.error('Get failed:', err.message);
@@ -632,6 +787,7 @@ program
   .command('blocks <page-or-alias>')
   .description('Get page content as rendered blocks by ID or alias + filter')
   .option('--filter <key=value>', 'Filter to find the page (required when using an alias)')
+  .option('--ids', 'Show block IDs alongside content (for editing/deleting)')
   .action(async (target, opts, cmd) => {
     try {
       const notion = getNotion();
@@ -663,7 +819,8 @@ program
           : type === 'code' ? '```\n'
           : '';
         const suffix = type === 'code' ? '\n```' : '';
-        console.log(`${prefix}${text}${suffix}`);
+        const idTag = opts.ids ? `[${block.id.slice(0, 8)}] ` : '';
+        console.log(`${idTag}${prefix}${text}${suffix}`);
       }
     } catch (err) {
       console.error('Blocks failed:', err.message);
@@ -671,6 +828,165 @@ program
     }
   });
 
+// ─── block-edit ────────────────────────────────────────────────────────────────
+program
+  .command('block-edit <block-id> <text>')
+  .description('Update a block\'s text content')
+  .action(async (blockId, text, opts, cmd) => {
+    try {
+      const notion = getNotion();
+      // First retrieve the block to know its type
+      const block = await notion.blocks.retrieve({ block_id: blockId });
+      const type = block.type;
+
+      // Build the update payload based on block type
+      const supportedTextTypes = [
+        'paragraph', 'heading_1', 'heading_2', 'heading_3',
+        'bulleted_list_item', 'numbered_list_item', 'quote', 'callout', 'toggle',
+      ];
+
+      if (type === 'to_do') {
+        const res = await notion.blocks.update({
+          block_id: blockId,
+          to_do: {
+            rich_text: [{ text: { content: text } }],
+            checked: block.to_do?.checked || false,
+          },
+        });
+        if (getGlobalJson(cmd)) { console.log(JSON.stringify(res, null, 2)); return; }
+        console.log(`✅ Updated ${type} block: ${blockId.slice(0, 8)}…`);
+      } else if (supportedTextTypes.includes(type)) {
+        const res = await notion.blocks.update({
+          block_id: blockId,
+          [type]: {
+            rich_text: [{ text: { content: text } }],
+          },
+        });
+        if (getGlobalJson(cmd)) { console.log(JSON.stringify(res, null, 2)); return; }
+        console.log(`✅ Updated ${type} block: ${blockId.slice(0, 8)}…`);
+      } else if (type === 'code') {
+        const res = await notion.blocks.update({
+          block_id: blockId,
+          code: {
+            rich_text: [{ text: { content: text } }],
+            language: block.code?.language || 'plain text',
+          },
+        });
+        if (getGlobalJson(cmd)) { console.log(JSON.stringify(res, null, 2)); return; }
+        console.log(`✅ Updated code block: ${blockId.slice(0, 8)}…`);
+      } else {
+        console.error(`Block type "${type}" doesn't support text editing.`);
+        console.error('Supported types: paragraph, headings, lists, to_do, quote, callout, toggle, code');
+        process.exit(1);
+      }
+    } catch (err) {
+      console.error('Block edit failed:', err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── block-delete ──────────────────────────────────────────────────────────────
+program
+  .command('block-delete <block-id>')
+  .description('Delete a block from a page')
+  .action(async (blockId, opts, cmd) => {
+    try {
+      const notion = getNotion();
+      const res = await notion.blocks.delete({ block_id: blockId });
+      if (getGlobalJson(cmd)) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+      console.log(`🗑️  Deleted block: ${blockId.slice(0, 8)}…`);
+    } catch (err) {
+      console.error('Block delete failed:', err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── relations ─────────────────────────────────────────────────────────────────
+program
+  .command('relations <page-or-alias>')
+  .description('Show all relation and rollup properties with resolved titles')
+  .option('--filter <key=value>', 'Filter to find the page (required when using an alias)')
+  .action(async (target, opts, cmd) => {
+    try {
+      const notion = getNotion();
+      const { pageId } = await resolvePageId(target, opts.filter);
+      const page = await notion.pages.retrieve({ page_id: pageId });
+
+      if (getGlobalJson(cmd)) {
+        console.log(JSON.stringify(page, null, 2));
+        return;
+      }
+
+      let found = false;
+
+      for (const [name, prop] of Object.entries(page.properties)) {
+        if (prop.type === 'relation') {
+          const rels = prop.relation || [];
+          if (rels.length === 0) {
+            console.log(`\n${name}: (no linked pages)`);
+            continue;
+          }
+          found = true;
+          console.log(`\n${name}: ${rels.length} linked page${rels.length !== 1 ? 's' : ''}`);
+
+          // Resolve each related page title
+          const rows = [];
+          for (const rel of rels) {
+            try {
+              const linked = await notion.pages.retrieve({ page_id: rel.id });
+              let title = '';
+              for (const [, p] of Object.entries(linked.properties)) {
+                if (p.type === 'title') {
+                  title = propValue(p);
+                  break;
+                }
+              }
+              rows.push({
+                id: rel.id.slice(0, 8) + '…',
+                title: title || '(untitled)',
+                url: linked.url || '',
+              });
+            } catch {
+              rows.push({ id: rel.id.slice(0, 8) + '…', title: '(access denied)', url: '' });
+            }
+          }
+          printTable(rows, ['id', 'title', 'url']);
+        }
+
+        if (prop.type === 'rollup') {
+          found = true;
+          const r = prop.rollup;
+          console.log(`\n${name} (rollup):`);
+          if (!r) {
+            console.log('  (empty)');
+            continue;
+          }
+          if (r.type === 'number') {
+            console.log(`  ${r.function || 'value'}: ${r.number}`);
+          } else if (r.type === 'date') {
+            console.log(`  ${r.date ? r.date.start : '(empty)'}`);
+          } else if (r.type === 'array' && r.array) {
+            for (const item of r.array) {
+              console.log(`  • ${propValue(item)}`);
+            }
+          } else {
+            console.log(`  ${JSON.stringify(r)}`);
+          }
+        }
+      }
+
+      if (!found) {
+        console.log('This page has no relation or rollup properties.');
+      }
+    } catch (err) {
+      console.error('Relations failed:', err.message);
+      process.exit(1);
+    }
+  });
+
 // ─── dbs ───────────────────────────────────────────────────────────────────────
 program
   .command('dbs')
@@ -843,5 +1159,417 @@ program
     }
   });
 
+// ─── me ────────────────────────────────────────────────────────────────────────
+program
+  .command('me')
+  .description('Show details about the current integration/bot')
+  .action(async (opts, cmd) => {
+    try {
+      const notion = getNotion();
+      const me = await notion.users.me({});
+      if (getGlobalJson(cmd)) {
+        console.log(JSON.stringify(me, null, 2));
+        return;
+      }
+      console.log(`Bot: ${me.name || '(unnamed)'}`);
+      console.log(`ID: ${me.id}`);
+      console.log(`Type: ${me.type}`);
+      if (me.bot?.owner) {
+        const owner = me.bot.owner;
+        console.log(`Owner: ${owner.type === 'workspace' ? 'Workspace' : owner.user?.name || owner.type}`);
+      }
+      if (me.avatar_url) {
+        console.log(`Avatar: ${me.avatar_url}`);
+      }
+    } catch (err) {
+      console.error('Me failed:', err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── move ──────────────────────────────────────────────────────────────────────
+program
+  .command('move <page-or-alias>')
+  .description('Move a page to a new parent (page or database)')
+  .option('--filter <key=value>', 'Filter to find the page (required when using an alias)')
+  .option('--to <parent-id-or-alias>', 'Destination parent (page ID, database alias, or database ID)')
+  .action(async (target, opts, cmd) => {
+    try {
+      if (!opts.to) {
+        console.error('--to is required. Specify a parent page ID or database alias.');
+        process.exit(1);
+      }
+      const notion = getNotion();
+      const { pageId } = await resolvePageId(target, opts.filter);
+
+      // Resolve --to target
+      let parent;
+      const ws = getWorkspaceConfig();
+      if (ws.aliases && ws.aliases[opts.to]) {
+        const db = ws.aliases[opts.to];
+        // pages.move() requires data_source_id parent, not database_id
+        parent = { type: 'data_source_id', data_source_id: db.data_source_id };
+      } else if (UUID_REGEX.test(opts.to)) {
+        // Assume page ID — user can also pass a database_id
+        parent = { type: 'page_id', page_id: opts.to };
+      } else {
+        console.error(`Unknown destination: "${opts.to}". Use a page ID or database alias.`);
+        const aliasNames = ws.aliases ? Object.keys(ws.aliases) : [];
+        if (aliasNames.length > 0) {
+          console.error(`Available aliases: ${aliasNames.join(', ')}`);
+        }
+        process.exit(1);
+      }
+
+      const res = await notion.pages.move({ page_id: pageId, parent });
+      if (getGlobalJson(cmd)) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+      console.log(`✅ Moved page: ${pageId.slice(0, 8)}…`);
+      if (res.url) console.log(`   URL: ${res.url}`);
+    } catch (err) {
+      console.error('Move failed:', err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── templates ─────────────────────────────────────────────────────────────────
+program
+  .command('templates <database>')
+  .description('List page templates available for a database')
+  .action(async (db, opts, cmd) => {
+    try {
+      const notion = getNotion();
+      const dbIds = resolveDb(db);
+      const res = await notion.dataSources.listTemplates({
+        data_source_id: dbIds.data_source_id,
+      });
+      if (getGlobalJson(cmd)) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+      if (!res.results || res.results.length === 0) {
+        console.log('No templates found for this database.');
+        return;
+      }
+      const rows = res.results.map(t => {
+        let title = '';
+        if (t.properties) {
+          for (const [, prop] of Object.entries(t.properties)) {
+            if (prop.type === 'title') {
+              title = propValue(prop);
+              break;
+            }
+          }
+        }
+        return {
+          id: t.id,
+          title: title || '(untitled)',
+          url: t.url || '',
+        };
+      });
+      printTable(rows, ['id', 'title', 'url']);
+    } catch (err) {
+      console.error('Templates failed:', err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── db-create ─────────────────────────────────────────────────────────────────
+program
+  .command('db-create <parent-page-id> <title>')
+  .description('Create a new database under a page')
+  .option('--prop <name:type...>', 'Property definition — repeatable (e.g. --prop "Status:select" --prop "Priority:number")', (v, prev) => prev.concat([v]), [])
+  .option('--alias <name>', 'Auto-create an alias for the new database')
+  .action(async (parentPageId, title, opts, cmd) => {
+    try {
+      const notion = getNotion();
+
+      // Build properties — always include a title property
+      const properties = {};
+      let hasTitleProp = false;
+
+      for (const kv of opts.prop) {
+        const colonIdx = kv.indexOf(':');
+        if (colonIdx === -1) {
+          console.error(`Invalid property format: ${kv} (expected name:type)`);
+          console.error('Supported types: title, rich_text, number, select, multi_select, date, checkbox, url, email, phone_number, status');
+          process.exit(1);
+        }
+        const name = kv.slice(0, colonIdx);
+        const type = kv.slice(colonIdx + 1).toLowerCase();
+        if (type === 'title') hasTitleProp = true;
+        properties[name] = { [type]: {} };
+      }
+
+      // Ensure there's a title property
+      if (!hasTitleProp) {
+        properties['Name'] = { title: {} };
+      }
+
+      const res = await notion.databases.create({
+        parent: { type: 'page_id', page_id: parentPageId },
+        title: [{ text: { content: title } }],
+        properties,
+      });
+
+      if (getGlobalJson(cmd)) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+
+      console.log(`✅ Created database: ${res.id.slice(0, 8)}…`);
+      console.log(`   Title: ${title}`);
+      console.log(`   Properties: ${Object.keys(properties).join(', ')}`);
+
+      // Auto-create alias if requested
+      if (opts.alias) {
+        const config = loadConfig();
+        const wsName = getWorkspaceName() || config.activeWorkspace || 'default';
+        if (!config.workspaces[wsName]) config.workspaces[wsName] = { aliases: {} };
+        if (!config.workspaces[wsName].aliases) config.workspaces[wsName].aliases = {};
+        config.workspaces[wsName].aliases[opts.alias] = {
+          database_id: res.database_id || res.id,
+          data_source_id: res.id,
+        };
+        saveConfig(config);
+        console.log(`   Alias: ${opts.alias}`);
+      }
+    } catch (err) {
+      console.error('Database create failed:', err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── db-update ─────────────────────────────────────────────────────────────────
+program
+  .command('db-update <database>')
+  .description('Update a database title or add properties')
+  .option('--title <text>', 'New database title')
+  .option('--add-prop <name:type...>', 'Add a property (e.g. --add-prop "Priority:number")', (v, prev) => prev.concat([v]), [])
+  .option('--remove-prop <name...>', 'Remove a property by name', (v, prev) => prev.concat([v]), [])
+  .action(async (db, opts, cmd) => {
+    try {
+      const notion = getNotion();
+      const dbIds = resolveDb(db);
+
+      // databases.update() requires the canonical database_id, which may differ
+      // from data_source_id. Resolve via dataSources.retrieve().parent.database_id.
+      let canonicalId = dbIds.database_id;
+      if (canonicalId === dbIds.data_source_id) {
+        try {
+          const ds = await notion.dataSources.retrieve({ data_source_id: canonicalId });
+          if (ds.parent && ds.parent.type === 'database_id') {
+            canonicalId = ds.parent.database_id;
+          }
+        } catch (_) { /* fall through with what we have */ }
+      }
+
+      const params = { database_id: canonicalId };
+
+      if (opts.title) {
+        params.title = [{ text: { content: opts.title } }];
+      }
+
+      if (opts.addProp.length > 0 || opts.removeProp.length > 0) {
+        params.properties = {};
+
+        for (const kv of opts.addProp) {
+          const colonIdx = kv.indexOf(':');
+          if (colonIdx === -1) {
+            console.error(`Invalid property format: ${kv} (expected name:type)`);
+            process.exit(1);
+          }
+          const name = kv.slice(0, colonIdx);
+          const type = kv.slice(colonIdx + 1).toLowerCase();
+          params.properties[name] = { [type]: {} };
+        }
+
+        for (const name of opts.removeProp) {
+          params.properties[name] = null;
+        }
+      }
+
+      const res = await notion.databases.update(params);
+
+      if (getGlobalJson(cmd)) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+
+      console.log(`✅ Updated database: ${(dbIds.database_id || dbIds.data_source_id).slice(0, 8)}…`);
+      if (opts.title) console.log(`   Title: ${opts.title}`);
+      if (opts.addProp.length > 0) console.log(`   Added: ${opts.addProp.join(', ')}`);
+      if (opts.removeProp.length > 0) console.log(`   Removed: ${opts.removeProp.join(', ')}`);
+    } catch (err) {
+      console.error('Database update failed:', err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── upload ────────────────────────────────────────────────────────────────────
+program
+  .command('upload <page-or-alias> <file-path>')
+  .description('Upload a file to a page')
+  .option('--filter <key=value>', 'Filter to find the page (required when using an alias)')
+  .action(async (target, filePath, opts, cmd) => {
+    try {
+      const notion = getNotion();
+      const { pageId } = await resolvePageId(target, opts.filter);
+
+      // Resolve file path
+      const absPath = path.resolve(filePath);
+      if (!fs.existsSync(absPath)) {
+        console.error(`File not found: ${absPath}`);
+        process.exit(1);
+      }
+
+      const filename = path.basename(absPath);
+      const fileData = fs.readFileSync(absPath);
+      const fileSize = fileData.length;
+
+      // Detect MIME type from extension
+      const MIME_MAP = {
+        '.txt': 'text/plain', '.csv': 'text/csv', '.html': 'text/html',
+        '.json': 'application/json', '.pdf': 'application/pdf',
+        '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml',
+        '.mp4': 'video/mp4', '.mp3': 'audio/mpeg', '.wav': 'audio/wav',
+        '.zip': 'application/zip', '.doc': 'application/msword',
+        '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        '.xls': 'application/vnd.ms-excel',
+        '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      };
+      const ext = path.extname(filename).toLowerCase();
+      const mimeType = MIME_MAP[ext] || 'application/octet-stream';
+
+      // Step 1: Create file upload
+      const upload = await notion.fileUploads.create({
+        parent: { type: 'page_id', page_id: pageId },
+        filename,
+      });
+      const uploadId = upload.id;
+
+      // Step 2: Send file data with correct content type
+      await notion.fileUploads.send({
+        file_upload_id: uploadId,
+        file: { data: new Blob([fileData], { type: mimeType }), filename },
+        part_number: '1',
+      });
+
+      // Step 3: Append file block to page (no complete() needed — attach directly)
+      await notion.blocks.children.append({
+        block_id: pageId,
+        children: [{
+          object: 'block',
+          type: 'file',
+          file: {
+            type: 'file_upload',
+            file_upload: { id: uploadId },
+          },
+        }],
+      });
+
+      if (getGlobalJson(cmd)) {
+        console.log(JSON.stringify({ upload_id: uploadId, filename, size: fileSize, page_id: pageId }, null, 2));
+        return;
+      }
+
+      const sizeStr = fileSize > 1024 * 1024
+        ? `${(fileSize / (1024 * 1024)).toFixed(1)} MB`
+        : `${(fileSize / 1024).toFixed(1)} KB`;
+
+      console.log(`✅ Uploaded: ${filename} (${sizeStr})`);
+      console.log(`   Page: ${pageId.slice(0, 8)}…`);
+    } catch (err) {
+      console.error('Upload failed:', err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── props ─────────────────────────────────────────────────────────────────────
+program
+  .command('props <page-or-alias>')
+  .description('List all properties with full paginated values')
+  .option('--filter <key=value>', 'Filter to find the page (required when using an alias)')
+  .action(async (target, opts, cmd) => {
+    try {
+      const notion = getNotion();
+      const { pageId } = await resolvePageId(target, opts.filter);
+      const page = await notion.pages.retrieve({ page_id: pageId });
+
+      if (getGlobalJson(cmd)) {
+        console.log(JSON.stringify(page, null, 2));
+        return;
+      }
+
+      console.log(`Page: ${page.id}`);
+      console.log(`URL:  ${page.url}\n`);
+
+      for (const [name, prop] of Object.entries(page.properties)) {
+        // For paginated properties (relation, rollup, rich_text, title, people),
+        // use the property retrieval endpoint to get full values
+        const needsPagination = ['relation', 'rollup', 'rich_text', 'title', 'people'].includes(prop.type);
+
+        if (needsPagination && prop.id) {
+          try {
+            const fullProp = await notion.pages.properties.retrieve({
+              page_id: pageId,
+              property_id: prop.id,
+            });
+
+            if (fullProp.results) {
+              // Paginated property — collect all results
+              const items = fullProp.results;
+              if (prop.type === 'relation') {
+                if (items.length === 0) {
+                  console.log(`  ${name}: (none)`);
+                } else {
+                  const titles = [];
+                  for (const item of items) {
+                    const relId = item.relation?.id;
+                    if (relId) {
+                      try {
+                        const linked = await notion.pages.retrieve({ page_id: relId });
+                        let t = '';
+                        for (const [, p] of Object.entries(linked.properties)) {
+                          if (p.type === 'title') { t = propValue(p); break; }
+                        }
+                        titles.push(t || relId.slice(0, 8) + '…');
+                      } catch {
+                        titles.push(relId.slice(0, 8) + '…');
+                      }
+                    }
+                  }
+                  console.log(`  ${name}: ${titles.join(', ')}`);
+                }
+              } else if (prop.type === 'rich_text' || prop.type === 'title') {
+                const text = items.map(i => i[prop.type]?.plain_text || '').join('');
+                console.log(`  ${name}: ${text}`);
+              } else if (prop.type === 'people') {
+                const people = items.map(i => i.people?.name || i.people?.id || '').join(', ');
+                console.log(`  ${name}: ${people}`);
+              } else {
+                console.log(`  ${name}: ${JSON.stringify(items)}`);
+              }
+            } else {
+              // Non-paginated response
+              console.log(`  ${name}: ${propValue(fullProp)}`);
+            }
+          } catch {
+            // Fallback to basic propValue
+            console.log(`  ${name}: ${propValue(prop)}`);
+          }
+        } else {
+          console.log(`  ${name}: ${propValue(prop)}`);
+        }
+      }
+    } catch (err) {
+      console.error('Props failed:', err.message);
+      process.exit(1);
+    }
+  });
+
 // ─── Run ───────────────────────────────────────────────────────────────────────
 program.parse();