@catafal/notion-cli 5.9.0

package/dist/commands/bookmark/list.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const bookmarks_1 = require("../../utils/bookmarks");
+const table_formatter_1 = require("../../utils/table-formatter");
+const base_flags_1 = require("../../base-flags");
+/**
+ * List all saved bookmarks.
+ * Shows name, type, ID, and which one is the default.
+ */
+class BookmarkList extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(BookmarkList);
+        const data = await (0, bookmarks_1.loadBookmarks)();
+        const entries = Object.entries(data.bookmarks);
+        if (flags.json) {
+            this.log(JSON.stringify({
+                success: true,
+                data: { bookmarks: data.bookmarks, default: data.default },
+                timestamp: new Date().toISOString()
+            }, null, 2));
+            process.exit(0);
+            return;
+        }
+        if (entries.length === 0) {
+            this.log('No bookmarks saved yet.');
+            this.log('Create one with: notion-cli bookmark set <name> <ID_OR_URL>');
+            process.exit(0);
+            return;
+        }
+        // Build rows for table display
+        const rows = entries.map(([name, bm]) => ({
+            name,
+            type: bm.type,
+            id: bm.id,
+            default: name === data.default ? '*' : '',
+        }));
+        const columns = {
+            name: {},
+            type: {},
+            id: {},
+            default: {},
+        };
+        (0, table_formatter_1.formatTable)(rows, columns, { printLine: this.log.bind(this), ...flags });
+        process.exit(0);
+    }
+}
+BookmarkList.description = 'List all saved bookmarks';
+BookmarkList.aliases = ['bm:ls'];
+BookmarkList.examples = [
+    {
+        description: 'List bookmarks',
+        command: '$ notion-cli bookmark list',
+    },
+];
+BookmarkList.flags = {
+    ...table_formatter_1.tableFlags,
+    ...base_flags_1.AutomationFlags,
+};
+exports.default = BookmarkList;

package/dist/commands/bookmark/remove.d.ts

@@ -0,0 +1,26 @@
+import { Command } from '@oclif/core';
+/**
+ * Remove a saved bookmark by name.
+ * If the removed bookmark was the default, the default is cleared.
+ */
+export default class BookmarkRemove extends Command {
+    static description: string;
+    static aliases: string[];
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static args: {
+        name: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'page-size': import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        retry: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        timeout: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'no-cache': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        minimal: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/bookmark/remove.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const bookmarks_1 = require("../../utils/bookmarks");
+const base_flags_1 = require("../../base-flags");
+/**
+ * Remove a saved bookmark by name.
+ * If the removed bookmark was the default, the default is cleared.
+ */
+class BookmarkRemove extends core_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(BookmarkRemove);
+        const existed = await (0, bookmarks_1.removeBookmark)(args.name);
+        if (flags.json) {
+            this.log(JSON.stringify({
+                success: existed,
+                data: { name: args.name, removed: existed },
+                timestamp: new Date().toISOString()
+            }, null, 2));
+            process.exit(0);
+            return;
+        }
+        if (existed) {
+            this.log(`Removed bookmark "${args.name}"`);
+        }
+        else {
+            this.log(`Bookmark "${args.name}" not found.`);
+            this.log('Run `notion-cli bookmark list` to see saved bookmarks.');
+        }
+        process.exit(0);
+    }
+}
+BookmarkRemove.description = 'Remove a saved bookmark';
+BookmarkRemove.aliases = ['bm:rm'];
+BookmarkRemove.examples = [
+    {
+        description: 'Remove a bookmark',
+        command: '$ notion-cli bookmark remove inbox',
+    },
+];
+BookmarkRemove.args = {
+    name: core_1.Args.string({ required: true, description: 'Bookmark name to remove' }),
+};
+BookmarkRemove.flags = {
+    ...base_flags_1.AutomationFlags,
+};
+exports.default = BookmarkRemove;

package/dist/commands/bookmark/set.d.ts

@@ -0,0 +1,29 @@
+import { Command } from '@oclif/core';
+/**
+ * Save a bookmark — a named shortcut to a Notion page or database.
+ * Once saved, the name works anywhere an ID or URL does.
+ */
+export default class BookmarkSet extends Command {
+    static description: string;
+    static aliases: string[];
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static args: {
+        name: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        target: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'page-size': import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        retry: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        timeout: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'no-cache': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        minimal: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        type: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        default: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/bookmark/set.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const bookmarks_1 = require("../../utils/bookmarks");
+const notion_resolver_1 = require("../../utils/notion-resolver");
+const notion = require("../../notion");
+const base_flags_1 = require("../../base-flags");
+const errors_1 = require("../../errors");
+/**
+ * Save a bookmark — a named shortcut to a Notion page or database.
+ * Once saved, the name works anywhere an ID or URL does.
+ */
+class BookmarkSet extends core_1.Command {
+    async run() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        const { args, flags } = await this.parse(BookmarkSet);
+        const resourceType = flags.type;
+        try {
+            // Resolve target to a valid Notion ID (validates it exists)
+            const resolvedId = await (0, notion_resolver_1.resolveNotionId)(args.target, resourceType);
+            // Fetch resource to confirm access and get title for display
+            let title = 'Untitled';
+            if (resourceType === 'database') {
+                const db = await notion.retrieveDataSource(resolvedId);
+                title = ((_b = (_a = db.title) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.plain_text) || 'Untitled';
+            }
+            else {
+                const page = await notion.retrievePage({ page_id: resolvedId });
+                title = ((_f = (_e = (_d = (_c = page.properties) === null || _c === void 0 ? void 0 : _c.title) === null || _d === void 0 ? void 0 : _d.title) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.plain_text) ||
+                    ((_k = (_j = (_h = (_g = page.properties) === null || _g === void 0 ? void 0 : _g.Name) === null || _h === void 0 ? void 0 : _h.title) === null || _j === void 0 ? void 0 : _j[0]) === null || _k === void 0 ? void 0 : _k.plain_text) || 'Untitled';
+            }
+            // Save bookmark
+            await (0, bookmarks_1.setBookmark)(args.name, resolvedId, resourceType);
+            // Set as default if requested
+            if (flags.default) {
+                await (0, bookmarks_1.setDefaultBookmark)(args.name);
+            }
+            if (flags.json) {
+                this.log(JSON.stringify({
+                    success: true,
+                    data: { name: args.name, id: resolvedId, type: resourceType, title, default: flags.default },
+                    timestamp: new Date().toISOString()
+                }, null, 2));
+            }
+            else {
+                this.log(`Saved bookmark "${args.name}" → ${title} (${resourceType})`);
+                if (flags.default) {
+                    this.log(`Set as default bookmark for quick capture.`);
+                }
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const cliError = error instanceof errors_1.NotionCLIError
+                ? error
+                : (0, errors_1.wrapNotionError)(error, { endpoint: 'bookmark.set', resourceType });
+            if (flags.json) {
+                this.log(JSON.stringify(cliError.toJSON(), null, 2));
+            }
+            else {
+                this.error(cliError.toHumanString());
+            }
+            process.exit(1);
+        }
+    }
+}
+BookmarkSet.description = 'Save a named shortcut to a Notion page or database';
+BookmarkSet.aliases = ['bm:set'];
+BookmarkSet.examples = [
+    {
+        description: 'Bookmark a database as "inbox" and set it as default',
+        command: '$ notion-cli bookmark set inbox DB_ID_OR_URL --default',
+    },
+    {
+        description: 'Bookmark a page',
+        command: '$ notion-cli bookmark set notes PAGE_URL --type page',
+    },
+];
+BookmarkSet.args = {
+    name: core_1.Args.string({ required: true, description: 'Bookmark name (e.g. "inbox", "tasks")' }),
+    target: core_1.Args.string({ required: true, description: 'Notion ID, URL, or database name' }),
+};
+BookmarkSet.flags = {
+    type: core_1.Flags.string({
+        char: 't',
+        description: 'Resource type',
+        options: ['database', 'page'],
+        default: 'database',
+    }),
+    default: core_1.Flags.boolean({
+        description: 'Also set as the default bookmark (used by `quick` command)',
+        default: false,
+    }),
+    ...base_flags_1.AutomationFlags,
+};
+exports.default = BookmarkSet;

package/dist/commands/browse.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class Browse extends Command {
+    static description: string;
+    static aliases: string[];
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static args: {
+        page_id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/browse.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const notion_resolver_1 = require("../utils/notion-resolver");
+const errors_1 = require("../errors");
+const interactive_navigator_1 = require("../utils/interactive-navigator");
+class Browse extends core_1.Command {
+    async run() {
+        const { args } = await this.parse(Browse);
+        try {
+            const pageId = await (0, notion_resolver_1.resolveNotionId)(args.page_id, 'page');
+            await (0, interactive_navigator_1.startNavigator)(pageId, this.log.bind(this));
+        }
+        catch (error) {
+            const cliError = error instanceof errors_1.NotionCLIError
+                ? error
+                : (0, errors_1.wrapNotionError)(error, {
+                    resourceType: 'page',
+                    attemptedId: args.page_id,
+                    endpoint: 'browse',
+                });
+            this.error(cliError.toHumanString());
+        }
+    }
+}
+Browse.description = 'Interactively navigate a Notion page tree with arrow keys';
+Browse.aliases = ['nav'];
+Browse.examples = [
+    {
+        description: 'Browse a page by ID',
+        command: '$ notion-cli browse PAGE_ID',
+    },
+    {
+        description: 'Browse a page by URL',
+        command: '$ notion-cli browse https://notion.so/My-Page-abc123',
+    },
+];
+Browse.args = {
+    page_id: core_1.Args.string({
+        required: true,
+        description: 'Page ID, URL, or name to start browsing from',
+    }),
+};
+exports.default = Browse;

package/dist/commands/cache/info.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+export default class CacheInfo extends Command {
+    static description: string;
+    static aliases: string[];
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'page-size': import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        retry: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        timeout: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'no-cache': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        minimal: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/cache/info.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_flags_1 = require("../../base-flags");
+const workspace_cache_1 = require("../../utils/workspace-cache");
+const cache_1 = require("../../cache");
+const errors_1 = require("../../errors");
+class CacheInfo extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(CacheInfo);
+        try {
+            // Get workspace cache
+            const workspaceCache = await (0, workspace_cache_1.loadCache)();
+            const cachePath = await (0, workspace_cache_1.getCachePath)();
+            // Get in-memory cache stats
+            const inMemoryStats = cache_1.cacheManager.getStats();
+            const hitRate = cache_1.cacheManager.getHitRate();
+            // Calculate workspace cache age if available
+            let workspaceInfo = null;
+            if (workspaceCache) {
+                const lastSyncTime = new Date(workspaceCache.lastSync);
+                const cacheAgeMs = Date.now() - lastSyncTime.getTime();
+                const cacheAgeHours = cacheAgeMs / (1000 * 60 * 60);
+                const isStale = cacheAgeHours > 24;
+                workspaceInfo = {
+                    databases_cached: workspaceCache.databases.length,
+                    last_sync: workspaceCache.lastSync,
+                    cache_age_ms: cacheAgeMs,
+                    cache_age_hours: parseFloat(cacheAgeHours.toFixed(2)),
+                    is_stale: isStale,
+                    stale_threshold_hours: 24,
+                    cache_version: workspaceCache.version,
+                    cache_location: cachePath,
+                };
+            }
+            // Build comprehensive cache info
+            const cacheInfo = {
+                in_memory: {
+                    enabled: cache_1.cacheManager.isEnabled(),
+                    stats: {
+                        size: inMemoryStats.size,
+                        hits: inMemoryStats.hits,
+                        misses: inMemoryStats.misses,
+                        sets: inMemoryStats.sets,
+                        evictions: inMemoryStats.evictions,
+                        hit_rate: parseFloat((hitRate * 100).toFixed(2)),
+                    },
+                    ttls_ms: {
+                        data_source: parseInt(process.env.NOTION_CLI_CACHE_DS_TTL || '600000', 10),
+                        page: parseInt(process.env.NOTION_CLI_CACHE_PAGE_TTL || '60000', 10),
+                        user: parseInt(process.env.NOTION_CLI_CACHE_USER_TTL || '3600000', 10),
+                        block: parseInt(process.env.NOTION_CLI_CACHE_BLOCK_TTL || '30000', 10),
+                    },
+                    max_size: parseInt(process.env.NOTION_CLI_CACHE_MAX_SIZE || '1000', 10),
+                },
+                workspace: workspaceInfo,
+                recommendations: {
+                    sync_interval_hours: 24,
+                    next_sync: workspaceCache ?
+                        new Date(new Date(workspaceCache.lastSync).getTime() + 24 * 60 * 60 * 1000).toISOString() :
+                        null,
+                    action_needed: !workspaceCache ? 'Run "notion-cli sync" to initialize cache' :
+                        (workspaceInfo && workspaceInfo.is_stale) ? 'Cache is stale, run "notion-cli sync"' :
+                            'Cache is fresh',
+                },
+            };
+            // JSON output
+            if (flags.json) {
+                this.log(JSON.stringify({
+                    success: true,
+                    data: cacheInfo,
+                    metadata: {
+                        timestamp: new Date().toISOString(),
+                        command: 'cache:info',
+                    },
+                }, null, 2));
+                process.exit(0);
+            }
+            // Human-readable output
+            this.log('Cache Configuration');
+            this.log('='.repeat(60));
+            this.log('\nIn-Memory Cache:');
+            this.log(`  Enabled: ${cacheInfo.in_memory.enabled ? 'Yes' : 'No'}`);
+            this.log(`  Size: ${inMemoryStats.size} / ${cacheInfo.in_memory.max_size}`);
+            this.log(`  Hits: ${inMemoryStats.hits}`);
+            this.log(`  Misses: ${inMemoryStats.misses}`);
+            this.log(`  Hit Rate: ${(hitRate * 100).toFixed(1)}%`);
+            this.log(`  Evictions: ${inMemoryStats.evictions}`);
+            this.log('\n  TTLs (milliseconds):');
+            this.log(`    Data Sources: ${cacheInfo.in_memory.ttls_ms.data_source} (${(cacheInfo.in_memory.ttls_ms.data_source / 60000).toFixed(0)} min)`);
+            this.log(`    Pages: ${cacheInfo.in_memory.ttls_ms.page} (${(cacheInfo.in_memory.ttls_ms.page / 1000).toFixed(0)} sec)`);
+            this.log(`    Users: ${cacheInfo.in_memory.ttls_ms.user} (${(cacheInfo.in_memory.ttls_ms.user / 60000).toFixed(0)} min)`);
+            this.log(`    Blocks: ${cacheInfo.in_memory.ttls_ms.block} (${(cacheInfo.in_memory.ttls_ms.block / 1000).toFixed(0)} sec)`);
+            this.log('\nWorkspace Cache:');
+            if (workspaceInfo) {
+                this.log(`  Databases: ${workspaceInfo.databases_cached}`);
+                this.log(`  Last Sync: ${new Date(workspaceInfo.last_sync).toLocaleString()}`);
+                this.log(`  Age: ${workspaceInfo.cache_age_hours} hours`);
+                this.log(`  Status: ${workspaceInfo.is_stale ? '⚠️  STALE' : '✓ Fresh'}`);
+                this.log(`  Location: ${workspaceInfo.cache_location}`);
+            }
+            else {
+                this.log(`  Status: Not initialized`);
+                this.log(`  Action: Run "notion-cli sync"`);
+            }
+            this.log('\nRecommendations:');
+            this.log(`  Sync Interval: Every ${cacheInfo.recommendations.sync_interval_hours} hours`);
+            if (cacheInfo.recommendations.next_sync) {
+                this.log(`  Next Sync: ${new Date(cacheInfo.recommendations.next_sync).toLocaleString()}`);
+            }
+            this.log(`  Action: ${cacheInfo.recommendations.action_needed}`);
+            process.exit(0);
+        }
+        catch (error) {
+            const cliError = error instanceof errors_1.NotionCLIError
+                ? error
+                : (0, errors_1.wrapNotionError)(error instanceof Error ? error : new Error(String(error)), {
+                    endpoint: 'cache.info'
+                });
+            if (flags.json) {
+                this.log(JSON.stringify(cliError.toJSON(), null, 2));
+            }
+            else {
+                this.error(cliError.toHumanString());
+            }
+            process.exit(1);
+        }
+    }
+}
+CacheInfo.description = 'Show cache statistics and configuration';
+CacheInfo.aliases = ['cache:stats', 'cache:status'];
+CacheInfo.examples = [
+    {
+        description: 'Show cache info in JSON format',
+        command: 'notion-cli cache:info --json',
+    },
+    {
+        description: 'Show cache statistics',
+        command: 'notion-cli cache:info',
+    },
+];
+CacheInfo.flags = {
+    ...base_flags_1.AutomationFlags,
+};
+exports.default = CacheInfo;

package/dist/commands/config/set-token.d.ts

@@ -0,0 +1,22 @@
+import { Command } from '@oclif/core';
+export default class ConfigSetToken extends Command {
+    static description: string;
+    static aliases: string[];
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static args: {
+        token: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'page-size': import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        retry: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        timeout: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'no-cache': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        minimal: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/config/set-token.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const readline = require("readline");
+const base_flags_1 = require("../../base-flags");
+const errors_1 = require("../../errors");
+const shell_config_1 = require("../../utils/shell-config");
+const token_validator_1 = require("../../utils/token-validator");
+class ConfigSetToken extends core_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(ConfigSetToken);
+        try {
+            // Get token from args or prompt
+            let token = args.token;
+            if (!token) {
+                if (flags.json) {
+                    throw new errors_1.NotionCLIError(errors_1.NotionCLIErrorCode.TOKEN_MISSING, 'Token required in JSON mode', [
+                        {
+                            description: 'Provide the token as an argument',
+                            command: 'notion-cli config set-token ntn_your_token_here --json'
+                        }
+                    ]);
+                }
+                // Interactive prompt
+                const rl = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                token = await new Promise((resolve) => {
+                    rl.question('Enter your Notion integration token: ', (answer) => {
+                        rl.close();
+                        resolve(answer.trim());
+                    });
+                });
+            }
+            // Validate token format — Notion tokens start with "secret_" (legacy) or "ntn_" (current)
+            if (!token || (!token.startsWith('secret_') && !token.startsWith('ntn_'))) {
+                throw new errors_1.NotionCLIError(errors_1.NotionCLIErrorCode.TOKEN_INVALID, 'Invalid token format - Notion tokens must start with "secret_" or "ntn_"', [
+                    {
+                        description: 'Get your integration token from Notion',
+                        link: 'https://developers.notion.com/docs/create-a-notion-integration'
+                    },
+                    {
+                        description: 'Tokens should look like: ntn_abc123... or secret_abc123...',
+                    }
+                ], {
+                    userInput: (0, token_validator_1.maskToken)(token),
+                    metadata: { tokenFormat: 'invalid' }
+                });
+            }
+            // Persist token to shell rc file (~/.zshrc, ~/.bashrc, etc.)
+            const { rcFile, shell } = await (0, shell_config_1.persistToken)(token);
+            if (flags.json) {
+                this.log(JSON.stringify({
+                    success: true,
+                    message: 'Token saved successfully',
+                    rcFile,
+                    shell,
+                    nextSteps: [
+                        `Reload your shell: source ${rcFile}`,
+                        'Run: notion-cli sync',
+                    ],
+                }, null, 2));
+            }
+            else {
+                this.log(`\n✓ Token saved to ${rcFile}`);
+                this.log('\nNext steps:');
+                this.log(`  1. Reload your shell: source ${rcFile}`);
+                this.log(`  2. Or restart your terminal`);
+                this.log(`  3. Run: notion-cli sync`);
+                this.log('\nWould you like to sync your workspace now? (y/n)');
+                const rl = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                const answer = await new Promise((resolve) => {
+                    rl.question('> ', (answer) => {
+                        rl.close();
+                        resolve(answer.trim().toLowerCase());
+                    });
+                });
+                if (answer === 'y' || answer === 'yes') {
+                    // Set token in current process
+                    process.env.NOTION_TOKEN = token;
+                    // Run sync command - dynamic import to avoid circular dependencies
+                    this.log('\nRunning sync...\n');
+                    const { default: Sync } = await Promise.resolve().then(() => require('../sync.js'));
+                    await Sync.run([]);
+                }
+                else {
+                    this.log('\nSkipping sync. You can run it manually with: notion-cli sync');
+                }
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const cliError = error instanceof errors_1.NotionCLIError
+                ? error
+                : (0, errors_1.wrapNotionError)(error instanceof Error ? error : new Error(String(error)), {
+                    endpoint: 'config.set-token'
+                });
+            if (flags.json) {
+                this.log(JSON.stringify(cliError.toJSON(), null, 2));
+            }
+            else {
+                this.error(cliError.toHumanString());
+            }
+            process.exit(1);
+        }
+    }
+}
+ConfigSetToken.description = 'Set NOTION_TOKEN in your shell configuration file';
+ConfigSetToken.aliases = ['config:token'];
+ConfigSetToken.examples = [
+    {
+        description: 'Set Notion token interactively',
+        command: 'notion-cli config set-token',
+    },
+    {
+        description: 'Set Notion token directly',
+        command: 'notion-cli config set-token ntn_abc123...',
+    },
+    {
+        description: 'Set token with JSON output',
+        command: 'notion-cli config set-token ntn_abc123... --json',
+    },
+];
+ConfigSetToken.args = {
+    token: core_1.Args.string({
+        description: 'Notion integration token (starts with secret_ or ntn_)',
+        required: false,
+    }),
+};
+ConfigSetToken.flags = {
+    ...base_flags_1.AutomationFlags,
+};
+exports.default = ConfigSetToken;