@eightstate/escli 0.5.0 → 0.7.0

package/dist/commands/notion/db/row/update.js

@@ -0,0 +1,165 @@
+import { Args, Flags } from '@oclif/core';
+import { hasManifestFlag } from '../../../../lib/notion/manifest-pass.js';
+import { z } from 'zod';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { ExitCodes } from '@eightstate/contracts/exit-codes';
+import { BaseCommand } from '../../../../base-command.js';
+import { EscliError } from '../../../../lib/escli-error.js';
+import { writeStdout } from '../../../../io/io.js';
+import { NOTION_VERSION, notionPagesPatchProps, proxy } from '../../../../services/notion.js';
+import { dbWriteErrors, emitErrorEnvelope, emitSuccessEnvelope, normalizeUpdate, rawOutput, readIdsFileRows, readJsonObjectInput, renderUpdate, stripCommandFields, toEscliError, } from '../../../../lib/notion/db-row/common.js';
+export const NotionDbRowUpdateDataSchema = z.union([
+    z.object({
+        action: z.literal('updated'),
+        page: z.object({ id: z.string(), title: z.string(), url: z.string() }),
+        changes: z.array(z.object({
+            property: z.string(),
+            type: z.string().optional(),
+            from: z.unknown(),
+            to: z.unknown(),
+            cleared: z.boolean().optional(),
+        })),
+        unchanged: z.array(z.string()),
+        last_edited_time: z.string(),
+        bot: z.string(),
+    }).passthrough(),
+    z.object({
+        action: z.literal('updated (batch)'),
+        rows_count: z.number().int(),
+        ok_count: z.number().int(),
+        err_count: z.number().int(),
+        rows: z.array(z.object({
+            index: z.number().int(),
+            id: z.string(),
+            status: z.enum(['ok', 'err']),
+            reason: z.string(),
+        }).passthrough()),
+        bot: z.string(),
+    }).passthrough(),
+]);
+export default class NotionDbRowUpdate extends BaseCommand {
+    static errors = dbWriteErrors;
+    static summary = 'Update Notion data-source row properties';
+    static description = 'Update typed properties on one Notion data-source row, or sequentially update rows from an NDJSON --ids-file batch.';
+    static examples = [
+        '<%= config.bin %> notion db row update 23f104cd-477e-8120-9a61-f2a2b73a9c11 --properties \'{"Status":{"status":{"name":"In Progress"}}}\'',
+        '<%= config.bin %> notion db row update --ids-file updates.ndjson',
+        '<%= config.bin %> notion db row update --ids-file - --raw',
+    ];
+    static aliases = ['notion db update row', 'notion ds row update'];
+    static flags = {
+        properties: Flags.string({ description: 'Typed Notion properties as JSON, @file, or - for stdin.' }),
+        'ids-file': Flags.string({ description: 'NDJSON batch file path, or - for stdin.' }),
+        raw: Flags.boolean({ description: 'Emit verbatim Notion response body or ordered batch body chain.', default: false }),
+    };
+    static args = {
+        page_id: Args.string({ description: 'Target Notion page/row ID.', required: false }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async run() {
+        if (hasManifestFlag(this.argv)) {
+            await super.run();
+            return;
+        }
+        const start = Date.now();
+        let json = this.argv.includes('--json');
+        try {
+            const { args, flags } = await this.parse(NotionDbRowUpdate);
+            json = Boolean(flags.json);
+            if (flags['ids-file']) {
+                const batch = await this.executeBatch(flags['ids-file']);
+                if (batch.err_count > 0)
+                    process.exitCode = ExitCodes.Error;
+                if (flags.raw) {
+                    await writeStdout(`${JSON.stringify(batch.raw)}\n`);
+                    return;
+                }
+                const cleanBatch = stripCommandFields(batch);
+                if (json)
+                    await emitSuccessEnvelope(this.id ?? 'notion db row update', this.config.version, cleanBatch, Date.now() - start);
+                else
+                    await writeStdout(`${renderUpdate(batch)}\n`);
+                return;
+            }
+            if (!args.page_id) {
+                throw new EscliError('page_id is required unless --ids-file is provided', { code: ErrorCode.UsageRequired, exitCode: ExitCodes.Usage });
+            }
+            const properties = await readJsonObjectInput(flags.properties, 'properties');
+            const data = await updateOne(args.page_id, properties);
+            if (flags.raw) {
+                await writeStdout(`${JSON.stringify(data.raw)}\n`);
+                return;
+            }
+            const cleanData = stripCommandFields(data);
+            if (json)
+                await emitSuccessEnvelope(this.id ?? 'notion db row update', this.config.version, cleanData, Date.now() - start);
+            else
+                await writeStdout(`${renderUpdate(data)}\n`);
+        }
+        catch (error) {
+            await emitErrorEnvelope(this.id ?? 'notion db row update', this.config.version, toEscliError(error), Date.now() - start, json);
+        }
+    }
+    async execute() {
+        const { args, flags } = await this.parse(NotionDbRowUpdate);
+        if (flags['ids-file']) {
+            const batch = await this.executeBatch(flags['ids-file']);
+            if (batch.err_count > 0)
+                process.exitCode = ExitCodes.Error;
+            return flags.raw ? batch.raw : stripCommandFields(batch);
+        }
+        if (!args.page_id)
+            throw new EscliError('page_id is required unless --ids-file is provided', { code: ErrorCode.UsageRequired, exitCode: ExitCodes.Usage });
+        const properties = await readJsonObjectInput(flags.properties, 'properties');
+        const data = await updateOne(args.page_id, properties);
+        return flags.raw ? data.raw : stripCommandFields(data);
+    }
+    async executeBatch(idsFile) {
+        const rows = await readIdsFileRows(idsFile);
+        const outcomes = [];
+        // Fail-fast on writes: stop at the first error so later rows are not
+        // mutated. Partial progress (rows processed before the failure) is
+        // returned in the outcomes array; exit code is set to 1 by the caller.
+        for (const [index, row] of rows.entries()) {
+            try {
+                const data = await updateOne(row.id, row.properties);
+                outcomes.push({ index: index + 1, id: row.id, status: 'ok', reason: '', data, raw: data.raw });
+            }
+            catch (error) {
+                outcomes.push({ index: index + 1, id: row.id, status: 'err', reason: errorReason(error), raw: errorRaw(error) });
+                break;
+            }
+        }
+        const errCount = outcomes.filter((row) => row.status === 'err').length;
+        const firstOk = outcomes.find((row) => row.status === 'ok');
+        const batch = {
+            action: 'updated (batch)',
+            rows_count: outcomes.length,
+            ok_count: outcomes.length - errCount,
+            err_count: errCount,
+            rows: outcomes,
+            bot: firstOk?.data?.bot ?? '',
+            raw: outcomes.map((row) => row.raw),
+            meta: { next: null, notion_version: NOTION_VERSION },
+        };
+        return batch;
+    }
+}
+async function updateOne(pageId, properties) {
+    const before = await proxy('GET', `/v1/pages/${encodeURIComponent(pageId)}`);
+    const after = await notionPagesPatchProps(pageId, properties);
+    return normalizeUpdate(after, before.raw, properties);
+}
+function errorReason(error) {
+    if (error instanceof EscliError)
+        return `${error.causeCode ?? error.code} — ${error.message}`;
+    return error instanceof Error ? error.message : String(error);
+}
+function errorRaw(error) {
+    if (error instanceof EscliError)
+        return { error: { code: error.code, cause_code: error.causeCode, message: error.message, details: error.details } };
+    return rawOutput(error);
+}
+export { NotionDbRowUpdate };
+//# sourceMappingURL=update.js.map

package/dist/commands/notion/ds/create.js

@@ -0,0 +1,73 @@
+import { Args, Flags } from '@oclif/core';
+import { hasManifestFlag } from '../../../lib/notion/manifest-pass.js';
+import { BaseCommand } from '../../../base-command.js';
+import { writeStdout } from '../../../io/io.js';
+import { proxy } from '../../../services/notion.js';
+import { dryRunData, emitRawOrReturn, maybeDryRunWarning, normalizeDsCreateResponse, normalizeSchemaFlagArgv, notionCreateErrors, parseSchemaInput, parseViewFileInput, parseViewFlags, renderDsCreate, } from '../db/create.js';
+export default class NotionDsCreate extends BaseCommand {
+    static errors = notionCreateErrors;
+    static summary = 'Create a Notion data source under a database';
+    static description = 'Add another table/data source with its own schema under an existing Notion database, optionally requesting views over it.';
+    static examples = [
+        '<%= config.bin %> notion ds create 362e7f31-7d53-4f6a-a0f6-7a7a7b68b0dc Accounts --schema accounts.schema.json --view table:"All accounts"',
+        '<%= config.bin %> notion ds create 362e7f31-7d53-4f6a-a0f6-7a7a7b68b0dc Accounts --schema accounts.schema.json --dry-run',
+        '<%= config.bin %> --json notion ds create 362e7f31-7d53-4f6a-a0f6-7a7a7b68b0dc Accounts --schema accounts.schema.json',
+    ];
+    static aliases = ['notion data-source create', 'n ds create', 'n data-source create'];
+    static flags = {
+        'schema-input': Flags.string({ description: 'Schema JSON path, inline JSON, or - for stdin.', required: true, helpValue: 'schema' }),
+        view: Flags.string({ description: 'View as <type:name>.', multiple: true }),
+        'view-file': Flags.string({ description: 'JSON file containing richer view specs.' }),
+        raw: Flags.boolean({ description: 'Emit verbatim Notion response body.', default: false }),
+        'dry-run': Flags.boolean({ description: 'Validate inputs and print the create payload without writing to Notion.', default: false }),
+    };
+    static args = {
+        database_id: Args.string({ description: 'Database ID or URL.', required: true }),
+        name: Args.string({ description: 'Data source name.', required: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async run() {
+        if (hasManifestFlag(this.argv)) {
+            await super.run();
+            return;
+        }
+        normalizeSchemaFlagArgv(this.argv);
+        if (this.argv.includes('--raw')) {
+            await this.execute();
+            return;
+        }
+        await super.run();
+    }
+    async execute() {
+        const { args, flags } = await this.parse(NotionDsCreate);
+        const typedFlags = flags;
+        const schema = await parseSchemaInput(typedFlags['schema-input']);
+        const views = [...parseViewFlags(typedFlags.view), ...await parseViewFileInput(typedFlags['view-file'])];
+        const request = {
+            parent: { database_id: args.database_id },
+            name: args.name,
+            schema,
+            views,
+        };
+        if (flags['dry-run']) {
+            await maybeDryRunWarning(flags, 'data source create');
+            const data = { ...dryRunData('data_source', request), database_id: args.database_id };
+            if (!typedFlags.json) {
+                await writeStdout(`${renderDsCreate(data)}\n`);
+                this.humanOutputHandled = true;
+            }
+            return data;
+        }
+        const result = await proxy('POST', '/v1/data_sources', { body: request });
+        const payload = await emitRawOrReturn(result, typedFlags.raw);
+        const data = normalizeDsCreateResponse(payload, args.database_id, args.name);
+        if (!typedFlags.json && !typedFlags.raw) {
+            await writeStdout(`${renderDsCreate(data)}\n`);
+            this.humanOutputHandled = true;
+        }
+        return { ...data, raw: result.raw };
+    }
+}
+export { renderDsCreate };
+//# sourceMappingURL=create.js.map

package/dist/commands/notion/enroll.js

@@ -0,0 +1,302 @@
+import { Flags, Errors } from '@oclif/core';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { ExitCodes } from '@eightstate/contracts/exit-codes';
+import { BaseCommand } from '../../base-command.js';
+import { buildUsageError } from '../../lib/envelope.js';
+import { EscliError } from '../../lib/escli-error.js';
+import { renderKv } from '../../io/render-kv.js';
+import { writeStderr, writeStdout } from '../../io/io.js';
+import { enroll, NOTION_VERSION } from '../../services/notion.js';
+import { hasManifestFlag } from '../../lib/notion/manifest-pass.js';
+const VERIFY_OPTIONS = ['identity', 'read', 'comments', 'users', 'all'];
+export default class NotionEnroll extends BaseCommand {
+    static errors = [ErrorCode.UsageRequired, ErrorCode.UsageInvalid, ErrorCode.UsageUnknownFlag, ErrorCode.ValidationFailed, ErrorCode.AuthRequired, ErrorCode.NotionEnrollmentRequired, ErrorCode.NotionUnauthorized, ErrorCode.NotionRestricted, ErrorCode.NotionNotFound, ErrorCode.NotionRateLimited, ErrorCode.NotionValidation, ErrorCode.NotionConflict, ErrorCode.NotionTimeoutUncertain, ErrorCode.GateInvalidResponse, ErrorCode.NetworkError, ErrorCode.NetworkTimeout, ErrorCode.ServiceUnavailable, ErrorCode.ApiError, ErrorCode.Internal];
+    static summary = "Store/replace this Clerk user's server-side Notion bot token";
+    static description = 'Validate a Notion internal-connection bot token and send it once to Eightstate custody. The token is never accepted as a CLI argument and is never printed.';
+    static examples = ['<%= config.bin %> notion enroll', 'printf %s "$NOTION_TOKEN" | <%= config.bin %> notion enroll --token-stdin', '<%= config.bin %> notion enroll --token-env NOTION_TOKEN --expect-workspace "Eight State"'];
+    static aliases = [];
+    static flags = {
+        'token-stdin': Flags.boolean({ description: 'Read the Notion token from stdin exactly once.' }),
+        'token-env': Flags.string({ description: 'Read the Notion token from the named environment variable.' }),
+        replace: Flags.boolean({ description: 'Replace an existing enrollment after confirming workspace/bot.', default: false }),
+        'expect-workspace': Flags.string({ description: 'Fail without storing if the verified workspace does not contain this text.' }),
+        'expect-bot': Flags.string({ description: 'Fail without storing if the verified bot name/id does not contain this text.' }),
+        label: Flags.string({ description: 'Human label stored beside the custody record.' }),
+        'probe-page': Flags.string({ description: 'Page/block ID or URL used for non-mutating read/comment probes.' }),
+        verify: Flags.string({ description: 'Verification depth.', options: [...VERIFY_OPTIONS], default: 'identity' }),
+        raw: Flags.boolean({ description: 'Emit verbatim ordered Notion response body chain.', default: false }),
+    };
+    static args = {};
+    static enableJsonFlag = true;
+    static strict = true;
+    outputHandled = false;
+    async run() {
+        if (hasManifestFlag(this.argv)) {
+            await super.run();
+            return;
+        }
+        await runNotionCommand(this);
+    }
+    async execute() {
+        const { flags } = await this.parse(NotionEnroll);
+        validateVerify(flags.verify, flags['probe-page']);
+        const token = await resolveEnrollmentToken({ tokenStdin: flags['token-stdin'], tokenEnv: flags['token-env'] });
+        const result = await enroll(token, { force: flags.replace === true });
+        const data = normalizeRecord(result.data);
+        if (flags.raw) {
+            await writeStdout(`${JSON.stringify(result.raw)}\n`);
+            this.outputHandled = true;
+            return data;
+        }
+        if (!flags.json) {
+            await writeStdout(`${renderEnroll(data)}\n`);
+            this.outputHandled = true;
+        }
+        return data;
+    }
+}
+export async function runNotionCommand(command) {
+    const wantsJson = command.argv.includes('--json');
+    try {
+        const data = await command.execute();
+        if (command.outputHandled)
+            return;
+        if (wantsJson)
+            await writeStdout(`${JSON.stringify(successEnvelope(data))}\n`);
+    }
+    catch (error) {
+        const escliError = toEscliError(error);
+        process.exitCode = escliError.exitCode;
+        if (wantsJson) {
+            await writeStdout(`${JSON.stringify(errorEnvelope(escliError))}\n`);
+            return;
+        }
+        await writeStderr(`${escliError.message}\n`);
+    }
+}
+export function successEnvelope(data) {
+    return { ok: true, data, error: null, meta: notionEnvelopeMeta() };
+}
+export function errorEnvelope(error) {
+    return {
+        ok: false,
+        data: null,
+        error: {
+            code: error.code,
+            message: error.message,
+            ...(error.remediation === undefined ? {} : { remediation: error.remediation }),
+            ...(error.details === undefined ? {} : { details: error.details }),
+            ...(error.causeCode === undefined ? {} : { cause_code: error.causeCode }),
+        },
+        meta: notionEnvelopeMeta(),
+    };
+}
+export function notionEnvelopeMeta() {
+    return { next: null, notion_version: NOTION_VERSION };
+}
+export function renderEnroll(data) {
+    const enrollment = recordValue(data.enrollment) ?? data;
+    const identity = recordValue(data.notion_identity) ?? recordValue(data.identity) ?? recordValue(data.bot) ?? data;
+    const clerkUser = recordValue(data.clerk_user);
+    const capabilities = recordValue(data.capabilities);
+    const rows = [
+        ['notion enrollment', stringValue(data.status) ?? 'ready'],
+        ['clerk_user', stringValue(clerkUser?.id) ?? stringValue(data.clerk_user_id) ?? ''],
+        ['bot', formatBot(identity)],
+        ['workspace', stringValue(identity.workspace_name) ?? stringValue(data.workspace_name) ?? ''],
+        ['verified', formatEnrollCapabilities(capabilities)],
+        ['custody', formatEnrollCustody(enrollment)],
+        ['next', stringValue(data.next) ?? 'whoami --probe-page <page_id> --verify read'],
+    ];
+    return renderKv(rows);
+}
+export function validateVerify(verify, probePage) {
+    if ((verify === 'read' || verify === 'comments') && !probePage) {
+        throw buildUsageError(`--verify ${verify} requires --probe-page`, ErrorCode.UsageRequired);
+    }
+}
+async function resolveEnrollmentToken(input) {
+    if (input.tokenStdin && input.tokenEnv)
+        throw buildUsageError('usage: choose only one token source: --token-stdin or --token-env NAME');
+    let token;
+    if (input.tokenEnv)
+        token = process.env[input.tokenEnv];
+    else if (input.tokenStdin)
+        token = await readStdinOnce();
+    else if (process.stdin.isTTY)
+        token = await promptForTokenAndOptionalGuards();
+    else
+        throw buildUsageError('usage: non-interactive enroll requires --token-stdin or --token-env NAME');
+    if (token === undefined)
+        throw buildUsageError('usage: non-interactive enroll requires --token-stdin or --token-env NAME');
+    const trimmed = token.trim();
+    if (!trimmed)
+        throw buildUsageError('usage: Notion token was empty');
+    return trimmed;
+}
+async function promptForTokenAndOptionalGuards() {
+    await writeStderr('Create/open a Notion internal connection, enable needed capabilities,\nshare target pages/databases with the connection, then paste its token.\nThe token is sent once to Eightstate custody and is never printed or stored locally.\n');
+    return promptLine('Notion internal connection token: ', true);
+}
+async function promptLine(label, hidden) {
+    await writeStderr(label);
+    const input = process.stdin;
+    const wasRaw = input.isRaw;
+    return new Promise((resolve, reject) => {
+        let value = '';
+        const cleanup = () => {
+            input.off('data', onData);
+            if (input.setRawMode)
+                input.setRawMode(Boolean(wasRaw));
+            input.pause();
+        };
+        const finish = () => {
+            cleanup();
+            void writeStderr('\n');
+            resolve(value);
+        };
+        const fail = (error) => {
+            cleanup();
+            void writeStderr('\n');
+            reject(error);
+        };
+        const onData = (chunk) => {
+            for (const character of chunk.toString('utf8')) {
+                if (character === '\u0003') {
+                    fail(new EscliError('prompt cancelled', { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage }));
+                    return;
+                }
+                if (character === '\r' || character === '\n') {
+                    finish();
+                    return;
+                }
+                if (character === '\u007f' || character === '\b') {
+                    value = value.slice(0, -1);
+                    if (!hidden)
+                        void writeStderr('\b \b');
+                    continue;
+                }
+                value += character;
+                if (!hidden)
+                    void writeStderr(character);
+            }
+        };
+        if (input.setRawMode)
+            input.setRawMode(true);
+        input.on('data', onData);
+        input.resume();
+    });
+}
+function readStdinOnce() {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        const onData = (chunk) => {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        };
+        const onEnd = () => {
+            cleanup();
+            resolve(Buffer.concat(chunks).toString('utf8'));
+        };
+        const onError = (error) => {
+            cleanup();
+            reject(new EscliError(`failed to read token from stdin: ${error.message}`, { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage }));
+        };
+        const cleanup = () => {
+            process.stdin.off('data', onData);
+            process.stdin.off('end', onEnd);
+            process.stdin.off('error', onError);
+            process.stdin.pause();
+        };
+        process.stdin.on('data', onData);
+        process.stdin.once('end', onEnd);
+        process.stdin.once('error', onError);
+        process.stdin.resume();
+    });
+}
+function formatEnrollCapabilities(capabilities) {
+    return [
+        `identity ${capabilityWord(capabilities?.identity, 'verified')}`,
+        `read ${capabilityWord(capabilities?.read_content, 'unprobed')}`,
+        `comments ${capabilityWord(capabilities?.read_comments, 'unprobed')}`,
+        `users ${capabilityWord(capabilities?.user_info, 'limited')}`,
+    ].join(' | ');
+}
+export function formatWhoamiCapabilities(capabilities) {
+    const parts = [
+        `identity ${capabilityWord(capabilities?.identity, 'verified')}`,
+        `read ${capabilityWord(capabilities?.read_content, 'unverified')}`,
+    ];
+    const write = capabilities?.write_content ?? capabilities?.update_content ?? capabilities?.insert_content;
+    if (write !== undefined)
+        parts.push(`write ${capabilityWord(write, 'unverified')}`);
+    else
+        parts.push('write unverified');
+    parts.push(`comments ${capabilityWord(capabilities?.read_comments, 'unverified')}`);
+    parts.push(`users ${capabilityWord(capabilities?.user_info, 'limited')}`);
+    return parts.join(' | ');
+}
+function capabilityWord(value, fallback) {
+    const normalized = typeof value === 'object' && value !== null && !Array.isArray(value) ? stringValue(value.status) : stringValue(value);
+    if (!normalized)
+        return fallback;
+    if (normalized === 'verified')
+        return '✓';
+    return normalized.replaceAll('_', '-');
+}
+function formatEnrollCustody(enrollment) {
+    const storedAt = stringValue(enrollment.stored_at);
+    if (storedAt)
+        return `server-side token stored ${storedAt}; token never printed`;
+    return 'server-side token stored; token never printed';
+}
+export function formatBot(identity) {
+    const name = stringValue(identity.name) ?? stringValue(identity.bot_name) ?? 'unknown';
+    const type = stringValue(identity.type) ?? 'bot';
+    const id = stringValue(identity.user_id) ?? stringValue(identity.id) ?? stringValue(identity.bot_user_id) ?? '';
+    return id ? `${name} (${type} ${compactId(id)})` : `${name} (${type})`;
+}
+export function compactId(id) {
+    if (id.includes('…'))
+        return id;
+    const clean = id.replaceAll('-', '');
+    if (clean.length <= 12)
+        return id;
+    return `${clean.slice(0, 4)}…${clean.slice(-3)}`;
+}
+export function recordValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+export function normalizeRecord(value) {
+    return recordValue(value) ?? { value };
+}
+export function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function toEscliError(error) {
+    if (error instanceof EscliError) {
+        // Exit codes for notion.* are owned by contracts/failure-taxonomy; no
+        // surface-specific override here. NotionEnrollmentRequired → Auth and
+        // NotionConflict → Error come through automatically.
+        return error;
+    }
+    if (error instanceof Errors.ExitError)
+        return new EscliError(error.message, { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage, details: { oclif_exit: error.oclif?.exit } });
+    if (error instanceof Errors.CLIError)
+        return new EscliError(cleanOclifMessage(error.message), { code: classifyOclifUsageError(error), exitCode: ExitCodes.Usage, details: { oclif_exit: error.oclif?.exit } });
+    if (error instanceof Error)
+        return new EscliError(error.message, { code: ErrorCode.Internal });
+    return new EscliError('unknown error', { code: ErrorCode.Internal, details: error });
+}
+function classifyOclifUsageError(error) {
+    const name = error.constructor.name;
+    const message = error.message;
+    if (name === 'NonExistentFlagsError' || message.startsWith('Nonexistent flag') || message.startsWith('Unexpected flag'))
+        return ErrorCode.UsageUnknownFlag;
+    if (name === 'RequiredArgsError' || message.startsWith('Missing ') || message.includes('expects a value'))
+        return ErrorCode.UsageRequired;
+    return ErrorCode.UsageInvalid;
+}
+function cleanOclifMessage(message) {
+    return message.replace(/\nSee more help with --help$/u, '');
+}
+//# sourceMappingURL=enroll.js.map

package/dist/commands/notion/index.js

@@ -0,0 +1,24 @@
+import { BaseCommand } from '../../base-command.js';
+import { buildUsageError } from '../../lib/envelope.js';
+import { ErrorCode } from '@eightstate/contracts/errors';
+export default class NotionTopic extends BaseCommand {
+    static errors = [ErrorCode.UsageInvalid];
+    static summary = 'Read and write Notion under a per-user AI bot identity';
+    static description = 'Token-lean by default; JSON opt-in via --json. Use notion enroll | whoami | page | db | search | comments | upload.';
+    static examples = [
+        '<%= config.bin %> notion enroll',
+        '<%= config.bin %> notion whoami',
+        '<%= config.bin %> notion page read <id>',
+        '<%= config.bin %> notion db query <data-source-id>',
+        '<%= config.bin %> notion search "roadmap"',
+    ];
+    static aliases = ['n'];
+    static flags = {};
+    static args = {};
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        throw buildUsageError('usage: escli notion <enroll|whoami|page|db|ds|view|search|comments|upload|block>');
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/notion/page/edit.js

@@ -0,0 +1,73 @@
+import { Args, Flags } from '@oclif/core';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { writeStdout } from '../../../io/io.js';
+import { notionPagePatchMarkdown } from '../../../services/notion.js';
+import { PAGE_CONTENT_ERROR_CODES, PageContentEditDataSchema, PageRefArg, buildEditBody, emitRaw, excerptMarkdown, normalizeMarkdownBody, operationStatuses, pageIdFromRef, parseEditOperations, renderEdit, withoutRaw, RawBypassCommand, } from '../../../lib/notion/page/content-common.js';
+export { PageContentEditDataSchema };
+export default class NotionPageEdit extends RawBypassCommand {
+    static errors = [...PAGE_CONTENT_ERROR_CODES, ErrorCode.UsageUnknownFlag];
+    static summary = 'Edit page body markdown';
+    static description = 'Apply targeted exact search-and-replace edits through Notion update_content.';
+    static examples = [
+        '<%= config.bin %> notion page edit 362e1f4a-7d8c-81b0-9f6e-f2c9a7b630dc --old "Review command surfaces" --new "Review page-content output contract"',
+        '<%= config.bin %> notion page edit 362e1f4a-7d8c-81b0-9f6e-f2c9a7b630dc --old foo --new bar --replace-all',
+        '<%= config.bin %> notion page edit 362e1f4a-7d8c-81b0-9f6e-f2c9a7b630dc --ops ops.json --raw',
+    ];
+    static aliases = [];
+    static flags = {
+        old: Flags.string({ description: 'Exact old string to replace.', multiple: true }),
+        new: Flags.string({ description: 'Replacement string.', multiple: true }),
+        ops: Flags.string({ description: 'JSON operations array or @file.' }),
+        'replace-all': Flags.boolean({ description: 'Replace all matches for --old/--new operations.', default: false }),
+        'allow-deleting-content': Flags.boolean({ description: 'Allow deletion of nested child pages/databases if Notion detects it.', default: false }),
+        raw: Flags.boolean({ description: 'Emit the verbatim Notion response body.', default: false }),
+    };
+    static args = {
+        page: Args.string(PageRefArg),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        const { args, flags } = await this.parse(NotionPageEdit);
+        const pageId = pageIdFromRef(args.page);
+        const ops = parseEditOperations(flags);
+        const result = await notionPagePatchMarkdown(pageId, buildEditBody(ops, flags['allow-deleting-content']));
+        if (flags.raw) {
+            await emitRaw(result.raw);
+            this.humanOutputHandled = true;
+            return {
+                surface: 'page-content',
+                command: 'edit',
+                page: { id: pageId },
+                status: 'changed',
+                ops_requested: ops.length,
+                ops_applied: 0,
+                replace_all: flags['replace-all'],
+                allow_deleting_content: flags['allow-deleting-content'],
+                ops: ops.map((operation) => ({ old: operation.old_str, new: operation.new_str, status: 'submitted' })),
+                after_excerpt: '',
+                raw: result.raw,
+            };
+        }
+        const body = normalizeMarkdownBody(result, pageId);
+        const statuses = operationStatuses(ops, body.markdown);
+        const data = {
+            surface: 'page-content',
+            command: 'edit',
+            page: { id: body.id, title: body.title, url: body.url },
+            status: 'changed',
+            ops_requested: ops.length,
+            ops_applied: statuses.filter((operation) => operation.status === 'applied').length,
+            replace_all: flags['replace-all'],
+            allow_deleting_content: flags['allow-deleting-content'],
+            ops: statuses,
+            after_excerpt: excerptMarkdown(body.markdown),
+        };
+        if (flags.json)
+            return withoutRaw(data);
+        await writeStdout(`${renderEdit(data)}\n`);
+        this.humanOutputHandled = true;
+        return data;
+    }
+}
+//# sourceMappingURL=edit.js.map