@catafal/notion-cli 5.9.0

package/dist/commands/list.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const workspace_cache_1 = require("../utils/workspace-cache");
+const helper_1 = require("../helper");
+const base_flags_1 = require("../base-flags");
+const errors_1 = require("../errors");
+const table_formatter_1 = require("../utils/table-formatter");
+const fuzzy_1 = require("../utils/fuzzy");
+class List extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(List);
+        try {
+            // Load cache
+            const cache = await (0, workspace_cache_1.loadCache)();
+            if (!cache) {
+                // Use enhanced error factory for workspace not synced
+                throw errors_1.NotionCLIErrorFactory.workspaceNotSynced('');
+            }
+            // Calculate cache age
+            const lastSyncTime = new Date(cache.lastSync);
+            const cacheAgeMs = Date.now() - lastSyncTime.getTime();
+            const cacheAgeHours = cacheAgeMs / (1000 * 60 * 60);
+            const isStale = cacheAgeHours > 24;
+            let databases = cache.databases;
+            // Apply fuzzy name filter if --filter is provided.
+            // Checks substring on full title, then Levenshtein on individual words
+            // so "daly" matches "Daily Psychology Lecture" via the word "daily".
+            if (flags.filter) {
+                const query = flags.filter.toLowerCase().trim();
+                const threshold = Math.max(2, Math.floor(query.length / 4));
+                databases = databases
+                    .map(db => {
+                    // Substring match on full title (cheapest check)
+                    if (db.titleNormalized.includes(query)) {
+                        return { db, dist: 0 };
+                    }
+                    // Fuzzy match on individual words in the title
+                    const words = db.titleNormalized.split(/[\s\-_]+/);
+                    let bestWordDist = Infinity;
+                    for (const word of words) {
+                        const dist = (0, fuzzy_1.levenshtein)(query, word);
+                        if (dist < bestWordDist)
+                            bestWordDist = dist;
+                    }
+                    return { db, dist: bestWordDist };
+                })
+                    .filter(({ dist }) => dist <= threshold)
+                    .sort((a, b) => a.dist - b.dist)
+                    .map(({ db }) => db);
+            }
+            // Build comprehensive metadata
+            const metadata = {
+                cache_info: {
+                    last_sync: cache.lastSync,
+                    cache_age_ms: cacheAgeMs,
+                    cache_age_hours: parseFloat(cacheAgeHours.toFixed(2)),
+                    is_stale: isStale,
+                    stale_threshold_hours: 24,
+                    cache_version: cache.version,
+                    cache_location: await (0, workspace_cache_1.getCachePath)(),
+                },
+                ttls: {
+                    workspace_cache: 'persists until next sync',
+                    recommended_sync_interval_hours: 24,
+                    in_memory: {
+                        data_source_ms: parseInt(process.env.NOTION_CLI_CACHE_DS_TTL || '600000', 10),
+                        page_ms: parseInt(process.env.NOTION_CLI_CACHE_PAGE_TTL || '60000', 10),
+                        user_ms: parseInt(process.env.NOTION_CLI_CACHE_USER_TTL || '3600000', 10),
+                        block_ms: parseInt(process.env.NOTION_CLI_CACHE_BLOCK_TTL || '30000', 10),
+                    },
+                },
+                stats: {
+                    total_databases: databases.length,
+                    databases_with_urls: databases.filter(db => db.url).length,
+                    total_aliases: databases.reduce((sum, db) => sum + db.aliases.length, 0),
+                },
+            };
+            // Add freshness warning if stale (non-JSON mode)
+            if (isStale && !flags.json && !flags['compact-json'] && !flags.markdown && !flags.pretty) {
+                this.warn(`Cache is ${cacheAgeHours.toFixed(1)} hours old. Consider running: notion-cli sync`);
+            }
+            if (databases.length === 0) {
+                if (flags.json) {
+                    this.log(JSON.stringify({
+                        success: true,
+                        data: {
+                            databases: [],
+                        },
+                        metadata,
+                    }, null, 2));
+                }
+                else {
+                    this.log('No databases found in cache.');
+                    this.log('Your integration may not have access to any databases.');
+                }
+                process.exit(0);
+                return;
+            }
+            // Define columns for table output
+            const columns = {
+                title: {
+                    header: 'Title',
+                    get: (row) => row.title,
+                },
+                id: {
+                    header: 'ID',
+                    get: (row) => row.id,
+                },
+                aliases: {
+                    header: 'Aliases (first 3)',
+                    get: (row) => row.aliases.slice(0, 3).join(', '),
+                },
+                url: {
+                    header: 'URL',
+                    get: (row) => row.url || '',
+                },
+            };
+            // Handle compact JSON output
+            if (flags['compact-json']) {
+                (0, helper_1.outputCompactJson)(databases);
+                process.exit(0);
+                return;
+            }
+            // Handle markdown table output
+            if (flags.markdown) {
+                (0, helper_1.outputMarkdownTable)(databases, columns);
+                process.exit(0);
+                return;
+            }
+            // Handle pretty table output
+            if (flags.pretty) {
+                (0, helper_1.outputPrettyTable)(databases, columns);
+                process.exit(0);
+                return;
+            }
+            // Handle JSON output for automation
+            if (flags.json) {
+                this.log(JSON.stringify({
+                    success: true,
+                    data: {
+                        databases: databases.map(db => ({
+                            id: db.id,
+                            title: db.title,
+                            aliases: db.aliases,
+                            url: db.url,
+                            lastEditedTime: db.lastEditedTime,
+                        })),
+                    },
+                    metadata,
+                }, null, 2));
+                process.exit(0);
+                return;
+            }
+            // Handle table output (default)
+            this.log(`\nCached Databases (${databases.length} total)`);
+            this.log(`Last synced: ${lastSyncTime.toLocaleString()} (${cacheAgeHours.toFixed(1)} hours ago)`);
+            if (isStale) {
+                this.log(`⚠️  Cache is stale. Run: notion-cli sync`);
+            }
+            this.log('');
+            const options = {
+                printLine: this.log.bind(this),
+                ...flags,
+            };
+            (0, table_formatter_1.formatTable)(databases, columns, options);
+            this.log(`\nTip: Run "notion-cli sync" to refresh the cache.`);
+            process.exit(0);
+        }
+        catch (error) {
+            const cliError = error instanceof errors_1.NotionCLIError
+                ? error
+                : (0, errors_1.wrapNotionError)(error, {
+                    endpoint: 'workspace.list'
+                });
+            if (flags.json) {
+                this.log(JSON.stringify(cliError.toJSON(), null, 2));
+            }
+            else {
+                this.error(cliError.toHumanString());
+            }
+            process.exit(1);
+        }
+    }
+}
+List.description = 'List all cached databases from your workspace';
+List.aliases = ['db:list', 'ls'];
+List.examples = [
+    {
+        description: 'List all cached databases',
+        command: 'notion-cli list',
+    },
+    {
+        description: 'Filter databases by name (fuzzy match)',
+        command: 'notion-cli list --filter "tasks"',
+    },
+    {
+        description: 'List databases in markdown format',
+        command: 'notion-cli list --markdown',
+    },
+    {
+        description: 'List databases in JSON format',
+        command: 'notion-cli list --json',
+    },
+    {
+        description: 'List databases in pretty table format',
+        command: 'notion-cli list --pretty',
+    },
+];
+List.flags = {
+    ...table_formatter_1.tableFlags,
+    ...base_flags_1.AutomationFlags,
+    ...base_flags_1.OutputFormatFlags,
+    filter: core_1.Flags.string({
+        char: 'f',
+        description: 'Filter databases by name (supports fuzzy/typo-tolerant matching)',
+    }),
+};
+exports.default = List;

package/dist/commands/open.d.ts

@@ -0,0 +1,29 @@
+import { Command } from '@oclif/core';
+/**
+ * Search for a Notion page or database and open it in the browser.
+ * Accepts bookmark names, database names, IDs, URLs, or search queries.
+ *
+ * Uses execFile (not exec) to prevent shell injection — URL is passed
+ * as an argument array, never interpolated into a shell string.
+ */
+export default class Open extends Command {
+    static description: string;
+    static aliases: string[];
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static args: {
+        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>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/open.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const child_process_1 = require("child_process");
+const notion_resolver_1 = require("../utils/notion-resolver");
+const notion = require("../notion");
+const helper_1 = require("../helper");
+const base_flags_1 = require("../base-flags");
+const errors_1 = require("../errors");
+/**
+ * Search for a Notion page or database and open it in the browser.
+ * Accepts bookmark names, database names, IDs, URLs, or search queries.
+ *
+ * Uses execFile (not exec) to prevent shell injection — URL is passed
+ * as an argument array, never interpolated into a shell string.
+ */
+class Open extends core_1.Command {
+    async run() {
+        var _a, _b;
+        const { args, flags } = await this.parse(Open);
+        try {
+            // Try resolving as database first, then as page
+            let url;
+            let title = 'Untitled';
+            try {
+                const id = await (0, notion_resolver_1.resolveNotionId)(args.target, 'database');
+                const db = await notion.retrieveDataSource(id);
+                url = db.url;
+                title = ((_b = (_a = db.title) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.plain_text) || 'Untitled';
+            }
+            catch {
+                // Not a database — try as page
+                const id = await (0, notion_resolver_1.resolveNotionId)(args.target, 'page');
+                const page = await notion.retrievePage({ page_id: id });
+                url = page.url;
+                title = (0, helper_1.getPageTitle)(page);
+            }
+            if (!url) {
+                this.error('Could not find a URL for the resolved resource.');
+                process.exit(1);
+                return;
+            }
+            // Open in browser using execFile (safe — no shell injection)
+            const opener = process.platform === 'darwin' ? 'open' : 'xdg-open';
+            (0, child_process_1.execFile)(opener, [url], (err) => {
+                if (err && !flags.json) {
+                    this.warn(`Could not open browser: ${err.message}`);
+                    this.log(`URL: ${url}`);
+                }
+            });
+            if (flags.json) {
+                this.log(JSON.stringify({
+                    success: true,
+                    data: { title, url },
+                    timestamp: new Date().toISOString()
+                }, null, 2));
+            }
+            else {
+                this.log(`Opened: ${title}`);
+                this.log(url);
+            }
+            process.exit(0);
+        }
+        catch (error) {
+            const cliError = error instanceof errors_1.NotionCLIError
+                ? error
+                : (0, errors_1.wrapNotionError)(error, { endpoint: 'open', resourceType: 'page' });
+            if (flags.json) {
+                this.log(JSON.stringify(cliError.toJSON(), null, 2));
+            }
+            else {
+                this.error(cliError.toHumanString());
+            }
+            process.exit(1);
+        }
+    }
+}
+Open.description = 'Open a Notion page or database in your browser';
+Open.aliases = ['o'];
+Open.examples = [
+    {
+        description: 'Open a bookmarked database',
+        command: '$ notion-cli open inbox',
+    },
+    {
+        description: 'Search and open a page',
+        command: '$ notion-cli open "weekly meeting"',
+    },
+    {
+        description: 'Open by ID or URL',
+        command: '$ notion-cli open PAGE_ID',
+    },
+];
+Open.args = {
+    target: core_1.Args.string({ required: true, description: 'Bookmark name, page/database name, ID, or URL' }),
+};
+Open.flags = {
+    ...base_flags_1.AutomationFlags,
+};
+exports.default = Open;

package/dist/commands/page/create.d.ts

@@ -0,0 +1,33 @@
+import { Command } from '@oclif/core';
+export default class PageCreate 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>;
+        columns: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        sort: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        filter: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        csv: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        extended: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'no-truncate': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'no-header': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        parent_page_id: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        parent_data_source_id: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        file_path: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        title_property: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        properties: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'simple-properties': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        raw: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/page/create.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const table_formatter_1 = require("../../utils/table-formatter");
+const notion = require("../../notion");
+const fs = require("fs");
+const path = require("path");
+const markdown_to_blocks_1 = require("../../utils/markdown-to-blocks");
+const helper_1 = require("../../helper");
+const notion_resolver_1 = require("../../utils/notion-resolver");
+const base_flags_1 = require("../../base-flags");
+const errors_1 = require("../../errors");
+const property_expander_1 = require("../../utils/property-expander");
+class PageCreate extends core_1.Command {
+    async run() {
+        var _a;
+        const { flags } = await this.parse(PageCreate);
+        try {
+            let pageProps;
+            let pageParent;
+            if (flags.parent_page_id) {
+                // Resolve parent page ID from URL, direct ID, or name (future)
+                const parentPageId = await (0, notion_resolver_1.resolveNotionId)(flags.parent_page_id, 'page');
+                pageParent = {
+                    page_id: parentPageId,
+                };
+            }
+            else {
+                // Resolve parent database ID from URL, direct ID, or name (future)
+                const parentDataSourceId = await (0, notion_resolver_1.resolveNotionId)(flags.parent_data_source_id, 'database');
+                pageParent = {
+                    data_source_id: parentDataSourceId,
+                };
+            }
+            // Auto-detect title property: sub-pages use "title", database pages use "Name"
+            // User can override with -t flag
+            const titleProperty = (_a = flags.title_property) !== null && _a !== void 0 ? _a : (flags.parent_page_id ? 'title' : 'Name');
+            // Build properties object
+            let properties = {};
+            // Handle properties flag
+            if (flags.properties) {
+                try {
+                    const parsedProps = JSON.parse(flags.properties);
+                    if (flags['simple-properties']) {
+                        if (flags.parent_page_id) {
+                            // Sub-pages only have a title property — expand it directly without schema
+                            const titleValue = parsedProps[titleProperty] || parsedProps['title'] || parsedProps['Title'];
+                            if (titleValue && typeof titleValue === 'string') {
+                                properties[titleProperty] = {
+                                    title: [{ text: { content: titleValue } }]
+                                };
+                            }
+                            else {
+                                throw new Error('Sub-page creation with -S requires a title property.\n' +
+                                    `Example: --properties '{"${titleProperty}": "My Page"}'`);
+                            }
+                        }
+                        else if (flags.parent_data_source_id) {
+                            // Database pages — use schema-based expansion
+                            const parentDataSourceId = await (0, notion_resolver_1.resolveNotionId)(flags.parent_data_source_id, 'database');
+                            const dbSchema = await notion.retrieveDataSource(parentDataSourceId);
+                            properties = await (0, property_expander_1.expandSimpleProperties)(parsedProps, dbSchema.properties);
+                        }
+                        else {
+                            throw new Error('The --simple-properties flag requires either -p (sub-page) or -d (database) to be set.');
+                        }
+                    }
+                    else {
+                        // Use raw Notion format
+                        properties = parsedProps;
+                    }
+                }
+                catch (error) {
+                    if (error.message.includes('Unexpected token') || error.message.includes('JSON')) {
+                        throw new Error(`Invalid JSON in --properties flag: ${error.message}\n` +
+                            `Example: --properties '{"Name": "Task", "Status": "Done"}'`);
+                    }
+                    throw error;
+                }
+            }
+            if (flags.file_path) {
+                // Resolve path and prevent directory traversal outside cwd
+                const basePath = path.resolve('./');
+                const p = path.resolve(basePath, flags.file_path);
+                if (!p.startsWith(basePath)) {
+                    throw new Error(`Invalid file path: must be within current directory`);
+                }
+                const fileName = path.basename(flags.file_path);
+                const md = fs.readFileSync(p, { encoding: 'utf-8' });
+                const blocks = (0, markdown_to_blocks_1.markdownToBlocks)(md);
+                // Extract title from H1 heading or use filename without extension
+                const extractTitle = (markdown, filename) => {
+                    const h1Match = markdown.match(/^#\s+(.+)$/m);
+                    if (h1Match && h1Match[1]) {
+                        return h1Match[1].trim();
+                    }
+                    // Fallback: use filename without extension
+                    return filename.replace(/\.md$/, '');
+                };
+                const pageTitle = extractTitle(md, fileName);
+                // If no properties were provided via flag, use extracted title
+                if (!flags.properties) {
+                    properties = {
+                        [titleProperty]: {
+                            title: [{ text: { content: pageTitle } }],
+                        },
+                    };
+                }
+                else {
+                    // Merge with existing properties, but ensure title is set
+                    if (!properties[titleProperty]) {
+                        properties[titleProperty] = {
+                            title: [{ text: { content: pageTitle } }],
+                        };
+                    }
+                }
+                pageProps = {
+                    parent: pageParent,
+                    properties,
+                    children: blocks,
+                };
+            }
+            else {
+                pageProps = {
+                    parent: pageParent,
+                    properties,
+                };
+            }
+            const res = await notion.createPage(pageProps);
+            // Handle JSON output for automation
+            if (flags.json) {
+                this.log(JSON.stringify({
+                    success: true,
+                    data: res,
+                    timestamp: new Date().toISOString()
+                }, null, 2));
+                process.exit(0);
+                return;
+            }
+            // Handle raw JSON output (legacy)
+            if (flags.raw) {
+                (0, helper_1.outputRawJson)(res);
+                process.exit(0);
+                return;
+            }
+            // Handle table output
+            const columns = {
+                title: {
+                    get: (row) => {
+                        return (0, helper_1.getPageTitle)(row);
+                    },
+                },
+                object: {},
+                id: {},
+                url: {},
+            };
+            const options = {
+                printLine: this.log.bind(this),
+                ...flags,
+            };
+            (0, table_formatter_1.formatTable)([res], columns, options);
+            process.exit(0);
+        }
+        catch (error) {
+            const cliError = error instanceof errors_1.NotionCLIError
+                ? error
+                : (0, errors_1.wrapNotionError)(error, {
+                    resourceType: 'page',
+                    endpoint: 'pages.create'
+                });
+            if (flags.json) {
+                this.log(JSON.stringify(cliError.toJSON(), null, 2));
+            }
+            else {
+                this.error(cliError.toHumanString());
+            }
+            process.exit(1);
+        }
+    }
+}
+PageCreate.description = 'Create a page';
+PageCreate.aliases = ['page:c'];
+PageCreate.examples = [
+    {
+        description: 'Create a page via interactive mode',
+        command: `$ notion-cli page create`,
+    },
+    {
+        description: 'Create a page with a specific parent_page_id',
+        command: `$ notion-cli page create -p PARENT_PAGE_ID`,
+    },
+    {
+        description: 'Create a page with a parent page URL',
+        command: `$ notion-cli page create -p https://notion.so/PARENT_PAGE_ID`,
+    },
+    {
+        description: 'Create a page with a specific parent_db_id',
+        command: `$ notion-cli page create -d PARENT_DB_ID`,
+    },
+    {
+        description: 'Create a page with simple properties (recommended for AI agents)',
+        command: `$ notion-cli page create -d DATA_SOURCE_ID -S --properties '{"Name": "My Task", "Status": "In Progress", "Due Date": "2025-12-31"}'`,
+    },
+    {
+        description: 'Create a page with simple properties using relative dates',
+        command: `$ notion-cli page create -d DATA_SOURCE_ID -S --properties '{"Name": "Review", "Due Date": "tomorrow", "Priority": "High"}'`,
+    },
+    {
+        description: 'Create a page with simple properties and multi-select',
+        command: `$ notion-cli page create -d DATA_SOURCE_ID -S --properties '{"Name": "Bug Fix", "Tags": ["urgent", "bug"], "Status": "Done"}'`,
+    },
+    {
+        description: 'Create a page with a specific source markdown file and parent_page_id',
+        command: `$ notion-cli page create -f ./path/to/source.md -p PARENT_PAGE_ID`,
+    },
+    {
+        description: 'Create a page with a specific source markdown file and parent_db_id',
+        command: `$ notion-cli page create -f ./path/to/source.md -d PARENT_DB_ID`,
+    },
+    {
+        description: 'Create a page with a specific source markdown file and output raw json with parent_page_id',
+        command: `$ notion-cli page create -f ./path/to/source.md -p PARENT_PAGE_ID -r`,
+    },
+    {
+        description: 'Create a page and output JSON for automation',
+        command: `$ notion-cli page create -p PARENT_PAGE_ID --json`,
+    },
+];
+PageCreate.flags = {
+    parent_page_id: core_1.Flags.string({
+        char: 'p',
+        description: 'Parent page ID or URL (to create a sub-page)',
+    }),
+    parent_data_source_id: core_1.Flags.string({
+        char: 'd',
+        description: 'Parent data source ID or URL (to create a page in a table)',
+    }),
+    file_path: core_1.Flags.string({
+        char: 'f',
+        description: 'Path to a source markdown file',
+    }),
+    title_property: core_1.Flags.string({
+        char: 't',
+        description: 'Title property name (auto-detected: "title" for sub-pages, "Name" for databases)',
+    }),
+    properties: core_1.Flags.string({
+        description: 'Page properties as JSON string',
+    }),
+    'simple-properties': core_1.Flags.boolean({
+        char: 'S',
+        description: 'Use simplified property format (flat key-value pairs, recommended for AI agents)',
+        default: false,
+    }),
+    raw: core_1.Flags.boolean({
+        char: 'r',
+        description: 'output raw json',
+    }),
+    ...table_formatter_1.tableFlags,
+    ...base_flags_1.AutomationFlags,
+};
+exports.default = PageCreate;