@jordancoin/notioncli 1.1.0 → 1.2.1

package/README.md

@@ -34,9 +34,21 @@ Zero UUIDs. One command. You're ready to go.
 
 ---
 
-## What's New (v1.1)
+## What's New
 
-notioncli now understands Notion as a **graph**, not just a table.
+### v1.2 — Multi-Workspace, Database Management & File Uploads
+
+- 🏢 **Multi-workspace** — Named profiles for multiple Notion accounts (`workspace add/use/list/remove`, `--workspace` flag)
+- 🤖 **`me`** — Show integration/bot identity and owner
+- 📦 **`move`** — Move pages between databases by alias
+- 📋 **`templates`** — List page templates available for a database
+- 🏗️ **`db-create`** — Create new databases with custom property schemas
+- ✏️ **`db-update`** — Add/remove columns, rename databases
+- 📎 **`upload`** — Upload files to pages (MIME-aware, supports images/docs/text)
+- 🔍 **`props`** — Quick page property inspector (cleaner than `get` for debugging)
+- 🐛 **Fixed** canonical `database_id` resolution for the 2025 dual-ID system
+
+### v1.1 — Relations, Rollups & Blocks
 
 - 🔗 **Relations** — `get` resolves linked page titles automatically. New `notion relations` command for exploring connected pages.
 - 📊 **Rollups** — Numbers, dates, and arrays are parsed into readable values. No more raw JSON blobs.
@@ -267,6 +279,86 @@ $ notion comments tasks --filter "Name=Ship feature"
 $ notion comment tasks "Shipped! 🚀" --filter "Name=Ship feature"
 ```
 
+### `notion me` — Integration Identity
+
+```
+$ notion me
+Bot: Stargazer
+ID: 8fd93059-5e54-44a5-8efd-800069da9497
+Type: bot
+Owner: Workspace
+```
+
+### `notion props` — Quick Property Inspector
+
+A fast way to inspect a single page's properties:
+
+```
+$ notion props tasks --filter "Name=Ship v1.1"
+Page: a1b2c3d4-5678-90ab-cdef-1234567890ab
+URL: https://www.notion.so/...
+Name: Ship v1.1
+Status: Done
+Priority: High
+Date: 2026-02-09
+```
+
+### `notion move` — Move Pages Between Databases
+
+```bash
+$ notion move tasks --filter "Name=Archived task" --to archive
+✅ Moved page: a1b2c3d4…
+   URL: https://notion.so/...
+```
+
+Accepts alias + filter for the source page, and an alias or page ID for `--to`.
+
+### `notion templates` — List Database Templates
+
+```bash
+$ notion templates projects
+id        │ title              │ url
+──────────┼────────────────────┼──────────────────
+a1b2c3d4… │ Project Template   │ https://notion.so/...
+```
+
+### `notion db-create` — Create a Database
+
+```bash
+$ notion db-create <parent-page-id> "My New DB" --prop "Name:title" --prop "Status:select" --prop "Priority:number"
+✅ Created database: a1b2c3d4…
+   Title: My New DB
+   Properties: Name, Status, Priority
+```
+
+### `notion db-update` — Update Database Schema
+
+Add or remove columns, rename databases:
+
+```bash
+$ notion db-update projects --add-prop "Rating:number" --add-prop "Category:select"
+✅ Updated database: a1b2c3d4…
+   Added: Rating:number, Category:select
+
+$ notion db-update projects --remove-prop "Old Column"
+✅ Updated database: a1b2c3d4…
+   Removed: Old Column
+
+$ notion db-update projects --title "Renamed Projects"
+✅ Updated database: a1b2c3d4…
+   Title: Renamed Projects
+```
+
+### `notion upload` — Upload Files to Pages
+
+```bash
+$ notion upload tasks --filter "Name=Ship feature" ./screenshot.png
+✅ Uploaded: screenshot.png (142.3 KB)
+   Page: a1b2c3d4…
+```
+
+Supports images, PDFs, text files, documents, and more. MIME types are detected automatically from file extensions.
+
 ### `notion alias` — Manage Aliases
 
 Aliases are created automatically by `notion init`, but you can manage them:
@@ -278,6 +370,38 @@ notion alias add tasks <database-id>           # Add manually
 notion alias remove tasks                      # Remove one
 ```
 
+### `notion workspace` — Multi-Workspace Profiles
+
+Manage multiple Notion accounts (work, personal, client projects):
+
+```bash
+# Add a workspace
+notion workspace add work --key ntn_your_work_key
+notion workspace add personal --key ntn_your_personal_key
+
+# List workspaces
+notion workspace list
+#   default ← active
+#     Key: ntn_3871... | Aliases: 5
+#   work
+#     Key: ntn_ab12... | Aliases: 0
+
+# Switch active workspace
+notion workspace use work
+
+# Discover databases for a workspace
+notion init --workspace work
+
+# Per-command override (no switching needed)
+notion query tasks --workspace personal
+notion -w work add projects --prop "Name=Q2 Plan"
+
+# Remove a workspace
+notion workspace remove old-client
+```
+
+Aliases are scoped per workspace — same alias name in different workspaces won't collide. Old single-key configs are auto-migrated to a "default" workspace.
+
 ### `--json` — Raw JSON Output
 
 Add `--json` to any command for the raw Notion API response:

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.1.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}"`);
+    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(`✅ 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 ────────────────────────────────────────────────────────────────────
@@ -1040,5 +1159,463 @@ 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: {} };
+      }
+
+      // 2025 API: databases.create() only handles title property reliably.
+      // Non-title properties must be added via dataSources.update() after creation.
+      const titleProps = {};
+      const extraProps = {};
+      for (const [name, prop] of Object.entries(properties)) {
+        if (prop.title) {
+          titleProps[name] = prop;
+        } else {
+          extraProps[name] = prop;
+        }
+      }
+      // Ensure title property exists in create call
+      if (Object.keys(titleProps).length === 0) {
+        titleProps['Name'] = { title: {} };
+      }
+
+      const res = await notion.databases.create({
+        parent: { type: 'page_id', page_id: parentPageId },
+        title: [{ text: { content: title } }],
+        properties: titleProps,
+      });
+
+      // Extract correct dual IDs from response
+      const databaseId = res.id;
+      const dataSourceId = (res.data_sources && res.data_sources[0])
+        ? res.data_sources[0].id
+        : res.id;
+
+      // Add non-title properties via dataSources.update()
+      if (Object.keys(extraProps).length > 0) {
+        await notion.dataSources.update({
+          data_source_id: dataSourceId,
+          properties: extraProps,
+        });
+      }
+
+      if (getGlobalJson(cmd)) {
+        console.log(JSON.stringify(res, null, 2));
+        return;
+      }
+
+      console.log(`✅ Created database: ${databaseId.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: databaseId,
+          data_source_id: dataSourceId,
+        };
+        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);
+
+      // 2025 API: property changes go through dataSources.update(), NOT databases.update().
+      // databases.update() silently ignores property modifications.
+      // Title changes still go through databases.update().
+      let canonicalId = dbIds.database_id;
+      const dataSourceId = dbIds.data_source_id;
+
+      // Resolve canonical database_id if both IDs are the same
+      if (canonicalId === dataSourceId) {
+        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 */ }
+      }
+
+      // Build property changes for dataSources.update()
+      let propChanges = null;
+      if (opts.addProp.length > 0 || opts.removeProp.length > 0) {
+        propChanges = {};
+
+        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();
+          propChanges[name] = { [type]: {} };
+        }
+
+        for (const name of opts.removeProp) {
+          propChanges[name] = null;
+        }
+      }
+
+      let res;
+
+      // Title changes go through databases.update()
+      if (opts.title) {
+        res = await notion.databases.update({
+          database_id: canonicalId,
+          title: [{ text: { content: opts.title } }],
+        });
+      }
+
+      // Property changes go through dataSources.update()
+      if (propChanges) {
+        res = await notion.dataSources.update({
+          data_source_id: dataSourceId,
+          properties: propChanges,
+        });
+      }
+
+      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();

package/lib/helpers.js

@@ -17,14 +17,43 @@ function getConfigPaths(overrideDir) {
 }
 
 function loadConfig(configPath) {
+  let config;
   try {
     if (fs.existsSync(configPath)) {
-      return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
     }
   } catch (err) {
     // Corrupted config — start fresh
   }
-  return { aliases: {} };
+  if (!config) config = { activeWorkspace: 'default', workspaces: { default: { aliases: {} } } };
+  return migrateConfig(config);
+}
+
+/**
+ * Migrate old flat config → multi-workspace format.
+ * Old: { apiKey, aliases }
+ * New: { activeWorkspace, workspaces: { name: { apiKey, aliases } } }
+ */
+function migrateConfig(config) {
+  if (config.workspaces) return config; // already migrated
+  // Old format detected — wrap in "default" workspace
+  const ws = { aliases: config.aliases || {} };
+  if (config.apiKey) ws.apiKey = config.apiKey;
+  return { activeWorkspace: 'default', workspaces: { default: ws } };
+}
+
+/**
+ * Get the config for a specific workspace (or the active one).
+ * Returns { apiKey, aliases } for that workspace.
+ */
+function resolveWorkspace(config, workspaceName) {
+  const name = workspaceName || config.activeWorkspace || 'default';
+  const ws = config.workspaces && config.workspaces[name];
+  if (!ws) {
+    const available = config.workspaces ? Object.keys(config.workspaces) : [];
+    return { error: `Unknown workspace: "${name}"`, available, name };
+  }
+  return { apiKey: ws.apiKey, aliases: ws.aliases || {}, name };
 }
 
 function saveConfig(config, configDir, configPath) {
@@ -292,6 +321,8 @@ function buildFilterFromSchema(schema, filterStr) {
 module.exports = {
   getConfigPaths,
   loadConfig,
+  migrateConfig,
+  resolveWorkspace,
   saveConfig,
   richTextToPlain,
   propValue,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jordancoin/notioncli",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "A powerful CLI for the Notion API — query databases, manage pages, and automate your workspace from the terminal.",
   "main": "bin/notion.js",
   "bin": {

package/skill/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: notion
-description: Notion API for creating and managing pages, databases, blocks, relations, and rollups via the notioncli CLI tool.
+description: Notion API for creating and managing pages, databases, blocks, relations, rollups, and multi-workspace profiles via the notioncli CLI tool.
 homepage: https://github.com/JordanCoin/notioncli
 metadata:
   openclaw:
@@ -166,6 +166,39 @@ notion comment <page-id> "Looks good, shipping this!"          # By page ID
 notion comment tasks "AI review complete ✅" --filter "Name=Ship feature"  # By alias + filter
 ```
 
+### Page Inspector
+
+```bash
+notion props tasks --filter "Name=Ship feature"    # Quick property dump
+notion me                                          # Show bot identity and owner
+```
+
+### Database Management
+
+```bash
+notion db-create <parent-page-id> "New DB" --prop "Name:title" --prop "Status:select"
+notion db-update tasks --add-prop "Rating:number"      # Add a column
+notion db-update tasks --remove-prop "Old Column"      # Remove a column
+notion db-update tasks --title "Renamed DB"            # Rename database
+notion templates tasks                                 # List page templates
+```
+
+### Moving Pages
+
+```bash
+notion move tasks --filter "Name=Done task" --to archive     # Move by alias
+notion move tasks --filter "Name=Done task" --to <page-id>   # Move to page
+```
+
+### File Uploads
+
+```bash
+notion upload tasks --filter "Name=Ship feature" ./report.pdf
+notion upload <page-id> ./screenshot.png
+```
+
+Supports images, PDFs, text files, documents. MIME types auto-detected from extension.
+
 ### Search
 
 ```bash
@@ -253,6 +286,29 @@ notion delete tasks --filter "Name=Old task"
 notion delete workouts --filter "Date=2026-02-09"
 ```
 
+### 9. Manage database schema
+
+```bash
+notion db-update tasks --add-prop "Priority:select"    # Add column
+notion db-update tasks --remove-prop "Old Field"       # Remove column
+notion db-create <parent-page-id> "New DB" --prop "Name:title" --prop "Status:select"
+```
+
+### 10. Move pages and upload files
+
+```bash
+notion move tasks --filter "Name=Done" --to archive
+notion upload tasks --filter "Name=Ship feature" ./report.pdf
+```
+
+### 11. Inspect and debug
+
+```bash
+notion me                                       # Check integration identity
+notion props tasks --filter "Name=Ship feature" # Quick property dump
+notion templates tasks                          # List available templates
+```
+
 ## Property Type Reference
 
 When using `--prop key=value`, the CLI auto-detects the property type from the database schema:
@@ -271,6 +327,27 @@ When using `--prop key=value`, the CLI auto-detects the property type from the d
 | `phone_number` | `Phone=+1234567890` | Phone number string |
 | `status` | `Status=In Progress` | Status property |
 
+## Multi-Workspace Profiles
+
+Manage multiple Notion accounts from one CLI:
+
+```bash
+notion workspace add work --key ntn_work_key       # Add workspace
+notion workspace add personal --key ntn_personal    # Add another
+notion workspace list                               # Show all
+notion workspace use work                           # Switch active
+notion workspace remove old                         # Remove one
+
+# Per-command override
+notion query tasks --workspace personal
+notion -w work add projects --prop "Name=Q2 Plan"
+
+# Init with workspace
+notion init --workspace work --key ntn_work_key
+```
+
+Aliases are scoped per workspace. Old single-key configs auto-migrate to a "default" workspace.
+
 ## Notion API 2025 — Dual IDs
 
 The Notion API (2025-09-03) uses dual IDs for databases: a `database_id` and a `data_source_id`. notioncli handles this automatically — when you run `notion init` or `notion alias add`, both IDs are discovered and stored. You never need to think about it.

package/test/mock.test.js

@@ -34,44 +34,61 @@ describe('Config management', () => {
 
   it('loadConfig returns empty config for missing file', () => {
     const config = loadConfig(configPath);
-    assert.deepEqual(config, { aliases: {} });
+    assert.equal(config.activeWorkspace, 'default');
+    assert.ok(config.workspaces.default);
+    assert.deepEqual(config.workspaces.default.aliases, {});
   });
 
   it('loadConfig returns empty config for corrupted file', () => {
     fs.mkdirSync(configDir, { recursive: true });
     fs.writeFileSync(configPath, 'not json at all!!!');
     const config = loadConfig(configPath);
-    assert.deepEqual(config, { aliases: {} });
+    assert.equal(config.activeWorkspace, 'default');
+    assert.ok(config.workspaces.default);
   });
 
   it('saveConfig creates directory and file', () => {
-    const config = { aliases: { test: { database_id: 'db1', data_source_id: 'ds1' } } };
+    const config = { activeWorkspace: 'default', workspaces: { default: { aliases: { test: { database_id: 'db1', data_source_id: 'ds1' } } } } };
     saveConfig(config, configDir, configPath);
     assert.ok(fs.existsSync(configPath));
   });
 
   it('loadConfig reads back saved config', () => {
     const config = {
-      apiKey: 'ntn_test_key',
-      aliases: {
-        projects: { database_id: 'db-123', data_source_id: 'ds-456' },
+      activeWorkspace: 'default',
+      workspaces: {
+        default: {
+          apiKey: 'ntn_test_key',
+          aliases: {
+            projects: { database_id: 'db-123', data_source_id: 'ds-456' },
+          },
+        },
       },
     };
     saveConfig(config, configDir, configPath);
     const loaded = loadConfig(configPath);
-    assert.equal(loaded.apiKey, 'ntn_test_key');
-    assert.deepEqual(loaded.aliases.projects, {
+    assert.equal(loaded.workspaces.default.apiKey, 'ntn_test_key');
+    assert.deepEqual(loaded.workspaces.default.aliases.projects, {
       database_id: 'db-123',
       data_source_id: 'ds-456',
     });
   });
 
   it('saveConfig overwrites existing config', () => {
-    saveConfig({ aliases: { a: { database_id: '1', data_source_id: '1' } } }, configDir, configPath);
-    saveConfig({ aliases: { b: { database_id: '2', data_source_id: '2' } } }, configDir, configPath);
+    saveConfig({ activeWorkspace: 'default', workspaces: { default: { aliases: { a: { database_id: '1', data_source_id: '1' } } } } }, configDir, configPath);
+    saveConfig({ activeWorkspace: 'default', workspaces: { default: { aliases: { b: { database_id: '2', data_source_id: '2' } } } } }, configDir, configPath);
     const loaded = loadConfig(configPath);
-    assert.ok(!loaded.aliases.a);
-    assert.ok(loaded.aliases.b);
+    assert.ok(!loaded.workspaces.default.aliases.a);
+    assert.ok(loaded.workspaces.default.aliases.b);
+  });
+
+  it('loadConfig auto-migrates old flat format', () => {
+    const oldConfig = { apiKey: 'ntn_old', aliases: { tasks: { database_id: 'db1', data_source_id: 'ds1' } } };
+    saveConfig(oldConfig, configDir, configPath);
+    const loaded = loadConfig(configPath);
+    assert.equal(loaded.activeWorkspace, 'default');
+    assert.equal(loaded.workspaces.default.apiKey, 'ntn_old');
+    assert.deepEqual(loaded.workspaces.default.aliases.tasks, { database_id: 'db1', data_source_id: 'ds1' });
   });
 });
 
@@ -108,14 +125,18 @@ describe('resolveDb logic (pure)', () => {
 
   it('known alias resolves to database_id + data_source_id', () => {
     const config = {
-      aliases: {
-        projects: { database_id: 'db-aaa', data_source_id: 'ds-bbb' },
+      activeWorkspace: 'default',
+      workspaces: {
+        default: {
+          aliases: {
+            projects: { database_id: 'db-aaa', data_source_id: 'ds-bbb' },
+          },
+        },
       },
     };
     saveConfig(config, configDir, configPath);
     const loaded = loadConfig(configPath);
-    const alias = 'projects';
-    const result = loaded.aliases[alias];
+    const result = loaded.workspaces.default.aliases.projects;
     assert.ok(result);
     assert.equal(result.database_id, 'db-aaa');
     assert.equal(result.data_source_id, 'ds-bbb');
@@ -132,9 +153,9 @@ describe('resolveDb logic (pure)', () => {
   });
 
   it('config with no aliases returns empty aliases object', () => {
-    saveConfig({ aliases: {} }, configDir, configPath);
+    saveConfig({ activeWorkspace: 'default', workspaces: { default: { aliases: {} } } }, configDir, configPath);
     const loaded = loadConfig(configPath);
-    assert.deepEqual(Object.keys(loaded.aliases), []);
+    assert.deepEqual(Object.keys(loaded.workspaces.default.aliases), []);
   });
 });