@eightstate/escli 0.5.0 → 0.7.0

package/dist/lib/notion/page/content-common.js

@@ -0,0 +1,473 @@
+import { readFile } from 'node:fs/promises';
+import { readFileSync } from 'node:fs';
+import { stdin } from 'node:process';
+import { Errors } from '@oclif/core';
+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 { writeStderr, writeStdout } from '../../../io/io.js';
+import { renderKv } from '../../../io/render-kv.js';
+import { renderTable } from '../../../io/render-table.js';
+import { NOTION_VERSION } from '../../../services/notion.js';
+import { hasManifestFlag } from '../manifest-pass.js';
+export const PAGE_CONTENT_ERROR_CODES = [
+    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.UsageInvalid,
+    ErrorCode.UsageRequired,
+    ErrorCode.FileNotFound,
+    ErrorCode.FileReadFailed,
+];
+export const PageRefArg = {
+    description: 'Notion page id or URL.',
+    required: true,
+};
+export const RawNotionBodySchema = z.unknown();
+export const NotionPageContentPageSchema = z.object({
+    id: z.string(),
+    title: z.string().optional(),
+    url: z.string().optional(),
+});
+export const PageContentReadDataSchema = z.object({
+    surface: z.literal('page-content'),
+    command: z.literal('read'),
+    page: NotionPageContentPageSchema,
+    content: z.object({
+        format: z.literal('notion-enhanced-markdown'),
+        chars_total: z.number().int().nonnegative(),
+        preview: z.string(),
+        notion_truncated: z.boolean(),
+        unknown_block_ids: z.array(z.string()),
+    }),
+    raw: RawNotionBodySchema.optional(),
+}).passthrough();
+export const PageContentEditDataSchema = z.object({
+    surface: z.literal('page-content'),
+    command: z.literal('edit'),
+    page: NotionPageContentPageSchema,
+    status: z.string(),
+    ops_requested: z.number().int().nonnegative(),
+    ops_applied: z.number().int().nonnegative(),
+    replace_all: z.boolean(),
+    allow_deleting_content: z.boolean(),
+    ops: z.array(z.object({ old: z.string(), new: z.string(), status: z.string() })),
+    after_excerpt: z.string(),
+    raw: RawNotionBodySchema.optional(),
+}).passthrough();
+export const PageContentReplaceDataSchema = z.object({
+    surface: z.literal('page-content'),
+    command: z.literal('replace'),
+    page: NotionPageContentPageSchema,
+    status: z.string(),
+    allow_deleting_content: z.boolean(),
+    submitted: z.object({ format: z.literal('notion-enhanced-markdown'), chars: z.number().int().nonnegative(), preview: z.string() }),
+    raw: RawNotionBodySchema.optional(),
+}).passthrough();
+export class RawBypassCommand extends BaseCommand {
+    async run() {
+        if (hasManifestFlag(this.argv)) {
+            await super.run();
+            return;
+        }
+        const start = Date.now();
+        let flags = {};
+        try {
+            flags = await this.parseFlags(this.ctor);
+            const data = await this.execute();
+            if (flags.raw === true || flags.json !== true)
+                return;
+            this.humanOutputHandled = true;
+            await writeStdout(`${JSON.stringify({ ok: true, data: withoutRaw(data), error: null, meta: notionCommandMeta() })}\n`);
+        }
+        catch (error) {
+            const escliError = normalizeError(error);
+            process.exitCode = escliError.exitCode;
+            const command = this.id ?? 'notion page';
+            if (flags.json === true) {
+                // --json contract: JSON envelope on stdout is the sole surface.
+                // No human card, no next-step text on stderr — automation parses
+                // exactly one stable stream.
+                await writeStdout(`${JSON.stringify({ ok: false, data: null, error: errorObject(escliError), meta: notionCommandMeta() })}\n`);
+            }
+            else {
+                await writeStdout(`${renderErrorCard(command, escliError)}\n`);
+                await writeStderr(`${nextStep(escliError)}\n`);
+            }
+        }
+        finally {
+            const _durationMs = Date.now() - start;
+            void _durationMs;
+        }
+        return undefined;
+    }
+    async parseFlags(command) {
+        const flags = await super.parseFlags(command);
+        if (flags.raw === true)
+            flags.json = false;
+        return flags;
+    }
+}
+function notionCommandMeta() {
+    return { next: null, notion_version: NOTION_VERSION };
+}
+function normalizeError(error) {
+    if (error instanceof EscliError)
+        return error;
+    if (error instanceof z.ZodError)
+        return new EscliError('input validation failed', { code: ErrorCode.ValidationFailed, exitCode: ExitCodes.Usage, details: error.issues });
+    if (error instanceof Errors.ExitError)
+        return new EscliError(error.message, { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+    if (error instanceof Errors.CLIError)
+        return new EscliError(error.message.replace(/\nSee more help with --help$/u, ''), { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+    if (error instanceof Error)
+        return new EscliError(error.message, { code: ErrorCode.Internal, exitCode: ExitCodes.Error });
+    return new EscliError('unknown error', { code: ErrorCode.Unknown, exitCode: ExitCodes.Error, details: error });
+}
+function errorObject(error) {
+    const requestId = requestIdFromDetails(error.details);
+    return {
+        code: error.code,
+        message: error.message,
+        next: nextStep(error),
+        exit: error.exitCode,
+        ...(requestId ? { request_id: requestId } : {}),
+        ...(error.causeCode ? { cause_code: error.causeCode } : {}),
+    };
+}
+function renderErrorCard(command, error) {
+    const cause = error.causeCode ?? error.code;
+    const requestId = requestIdFromDetails(error.details);
+    return renderKv([
+        ['error', `${command} failed (${cause})`],
+        ['reason', error.message],
+        ['next', nextStep(error)],
+        ['exit', error.exitCode],
+        ...(requestId ? [['request_id', requestId]] : []),
+    ]);
+}
+function nextStep(error) {
+    if (error.remediation?.hint)
+        return error.remediation.hint;
+    if (error.remediation?.command)
+        return `run ${error.remediation.command}`;
+    switch (error.code) {
+        case ErrorCode.NotionUnauthorized:
+        case ErrorCode.NotionEnrollmentRequired:
+        case ErrorCode.AuthRequired:
+            return 'run escli notion enroll or re-enroll this workspace';
+        case ErrorCode.NotionRestricted:
+        case ErrorCode.NotionNotFound:
+            return 'share the target with the Notion connection and grant the required capability';
+        case ErrorCode.NotionValidation:
+        case ErrorCode.UsageInvalid:
+        case ErrorCode.UsageRequired:
+        case ErrorCode.ValidationFailed:
+            return 'fix input, markdown, target type, or destructive guard flag before retrying';
+        case ErrorCode.NotionRateLimited:
+        case ErrorCode.ServiceUnavailable:
+        case ErrorCode.NetworkError:
+        case ErrorCode.NetworkTimeout:
+            return 'retry reads after delay; verify write outcome before repeating writes';
+        default:
+            return 'retry once, then file bug with request id if it repeats';
+    }
+}
+function requestIdFromDetails(details) {
+    const record = recordValue(details);
+    return stringValue(record?.request_id) ?? stringValue(recordValue(record?.details)?.request_id);
+}
+export function pageIdFromRef(input) {
+    const trimmed = input.trim();
+    const uuid = trimmed.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/iu)?.[0];
+    if (uuid)
+        return uuid;
+    const compact = trimmed.match(/[0-9a-f]{32}/iu)?.[0];
+    if (compact)
+        return compact.replace(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/u, '$1-$2-$3-$4-$5');
+    return trimmed;
+}
+export function pageTitle(page) {
+    return page.title && page.title.length > 0 ? page.title : 'Untitled';
+}
+export function pageLabel(page) {
+    return `${pageTitle(page)} (${page.id})`;
+}
+export function extractPageInfo(raw, fallbackId) {
+    const record = recordValue(raw);
+    const id = stringValue(record?.id) ?? fallbackId;
+    return {
+        id,
+        title: stringValue(record?.title) ?? titleFromProperties(record?.properties) ?? titleFromMarkdown(stringValue(record?.markdown) ?? ''),
+        url: stringValue(record?.url),
+    };
+}
+export function normalizeMarkdownBody(result, fallbackId) {
+    const data = recordValue(result.data) ?? {};
+    return {
+        object: stringValue(data.object),
+        id: stringValue(data.id) ?? fallbackId,
+        title: stringValue(data.title) ?? titleFromProperties(data.properties) ?? titleFromMarkdown(stringValue(data.markdown) ?? ''),
+        url: stringValue(data.url),
+        markdown: stringValue(data.markdown) ?? '',
+        truncated: booleanValue(data.truncated) ?? false,
+        unknown_block_ids: stringArrayValue(data.unknown_block_ids),
+    };
+}
+export function renderRead(data) {
+    const markdown = data.content.preview;
+    const trailer = `— page ${data.page.id} · title "${escapeTrailerValue(pageTitle(data.page))}" · preview chars ${data.content.preview.length}/${data.content.chars_total} · Notion truncated ${data.content.notion_truncated} · unknown blocks ${data.content.unknown_block_ids.length}`;
+    return markdown.length > 0 ? `${markdown}\n${trailer}` : trailer;
+}
+export function renderEdit(data) {
+    return [
+        renderKv([
+            ['ok', true],
+            ['command', 'page-content edit'],
+            ['page', pageLabel(data.page)],
+            ['status', data.status],
+            ['ops-requested', data.ops_requested],
+            ['ops-applied', data.ops_applied],
+            ['replace-all', data.replace_all],
+            ['allow-deleting-content', data.allow_deleting_content],
+        ]),
+        'ops:',
+        renderTable({
+            header: ['#', 'old', 'new', 'status'],
+            rows: data.ops.map((operation, index) => [index + 1, operation.old, operation.new, operation.status]),
+        }),
+        'after excerpt:',
+        data.after_excerpt,
+    ].join('\n\n');
+}
+export function renderReplace(data) {
+    return [
+        renderKv([
+            ['ok', true],
+            ['command', 'page-content replace'],
+            ['page', pageLabel(data.page)],
+            ['status', data.status],
+            ['allow-deleting-content', data.allow_deleting_content],
+            ['submitted', `${data.submitted.format}, ${data.submitted.chars} chars`],
+        ]),
+        'replacement preview:',
+        data.submitted.preview,
+    ].join('\n\n');
+}
+export async function emitRaw(raw) {
+    await writeStdout(`${JSON.stringify(redactAuthUrls(raw), null, 2)}\n`);
+}
+export function withoutRaw(data) {
+    const { raw: _raw, ...rest } = data;
+    void _raw;
+    return rest;
+}
+export async function readMarkdownSource(flags) {
+    const sources = [flags.markdown !== undefined, flags.file !== undefined, flags.stdin === true].filter(Boolean).length;
+    if (sources !== 1) {
+        throw new EscliError('provide exactly one content source: --markdown, --file, or --stdin', {
+            code: ErrorCode.UsageRequired,
+            exitCode: ExitCodes.Usage,
+        });
+    }
+    if (flags.markdown !== undefined)
+        return flags.markdown;
+    if (flags.file !== undefined) {
+        try {
+            return await readFile(flags.file, 'utf8');
+        }
+        catch (error) {
+            const nodeError = error;
+            throw new EscliError(`failed to read markdown file: ${nodeError.message}`, {
+                code: nodeError.code === 'ENOENT' ? ErrorCode.FileNotFound : ErrorCode.FileReadFailed,
+                exitCode: nodeError.code === 'ENOENT' ? ExitCodes.NotFound : ExitCodes.Error,
+                details: { path: flags.file },
+            });
+        }
+    }
+    return readAllStdin();
+}
+export function parseEditOperations(flags) {
+    if (flags.ops !== undefined) {
+        if (flags.old !== undefined || flags.new !== undefined) {
+            throw new EscliError('use either --ops or --old/--new pairs, not both', { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+        }
+        return parseOps(flags.ops);
+    }
+    const oldValues = flags.old ?? [];
+    const newValues = flags.new ?? [];
+    if (oldValues.length === 0 || newValues.length === 0 || oldValues.length !== newValues.length) {
+        throw new EscliError('provide matching --old and --new pairs, or --ops', { code: ErrorCode.UsageRequired, exitCode: ExitCodes.Usage });
+    }
+    return oldValues.map((oldValue, index) => ({
+        old_str: oldValue,
+        new_str: newValues[index] ?? '',
+        ...(flags['replace-all'] ? { replace_all_matches: true } : {}),
+    }));
+}
+export function buildEditBody(ops, allowDeletingContent) {
+    return {
+        type: 'update_content',
+        update_content: { content_updates: ops },
+        ...(allowDeletingContent ? { allow_deleting_content: true } : {}),
+    };
+}
+export function buildReplaceBody(markdown, allowDeletingContent) {
+    return {
+        type: 'replace_content',
+        replace_content: { markdown },
+        ...(allowDeletingContent ? { allow_deleting_content: true } : {}),
+    };
+}
+export function excerptMarkdown(markdown, maxLines = 9, maxChars = 900) {
+    const byLines = markdown.split(/\r?\n/u).slice(0, maxLines).join('\n');
+    return byLines.length > maxChars ? `${byLines.slice(0, maxChars).trimEnd()}…` : byLines;
+}
+export function previewMarkdown(markdown, maxLines = 80, maxChars = 4000) {
+    const byLines = markdown.split(/\r?\n/u).slice(0, maxLines).join('\n');
+    return byLines.length > maxChars ? byLines.slice(0, maxChars).trimEnd() : byLines;
+}
+export function operationStatuses(ops, after) {
+    return ops.map((operation) => ({
+        old: operation.old_str,
+        new: operation.new_str,
+        status: after.includes(operation.new_str) ? 'applied' : 'submitted',
+    }));
+}
+export function parentFromFlag(parent) {
+    const id = pageIdFromRef(parent);
+    const lower = parent.toLowerCase();
+    if (lower.includes('data_source') || lower.includes('data-source'))
+        return { data_source_id: id };
+    if (lower.includes('database'))
+        return { database_id: id };
+    return { page_id: id };
+}
+export function parseProperties(input) {
+    if (input === undefined)
+        return {};
+    const json = readJsonText(input);
+    if (json.trim().length === 0)
+        return {};
+    try {
+        return JSON.parse(json);
+    }
+    catch (error) {
+        throw new EscliError(`invalid properties JSON: ${error instanceof Error ? error.message : String(error)}`, {
+            code: ErrorCode.ValidationFailed,
+            exitCode: ExitCodes.Usage,
+        });
+    }
+}
+async function readAllStdin() {
+    const chunks = [];
+    for await (const chunk of stdin)
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    return Buffer.concat(chunks).toString('utf8');
+}
+function parseOps(input) {
+    const parsed = parseJsonOrAtFile(input);
+    const array = Array.isArray(parsed) ? parsed : recordValue(parsed)?.content_updates;
+    if (!Array.isArray(array)) {
+        throw new EscliError('--ops must be a JSON array or an object with content_updates', { code: ErrorCode.ValidationFailed, exitCode: ExitCodes.Usage });
+    }
+    return array.map((entry, index) => {
+        const record = recordValue(entry);
+        const oldValue = stringValue(record?.old_str ?? record?.old);
+        const newValue = stringValue(record?.new_str ?? record?.new);
+        if (oldValue === undefined || newValue === undefined) {
+            throw new EscliError(`invalid --ops entry at index ${index}: expected old_str/new_str`, { code: ErrorCode.ValidationFailed, exitCode: ExitCodes.Usage });
+        }
+        const replaceAll = booleanValue(record?.replace_all_matches);
+        return { old_str: oldValue, new_str: newValue, ...(replaceAll === undefined ? {} : { replace_all_matches: replaceAll }) };
+    });
+}
+function parseJsonOrAtFile(input) {
+    return JSON.parse(readJsonText(input));
+}
+function readJsonText(input) {
+    if (!input.startsWith('@'))
+        return input;
+    const path = input.slice(1);
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch (error) {
+        const nodeError = error;
+        throw new EscliError(`failed to read JSON file: ${nodeError.message}`, {
+            code: nodeError.code === 'ENOENT' ? ErrorCode.FileNotFound : ErrorCode.FileReadFailed,
+            exitCode: nodeError.code === 'ENOENT' ? ExitCodes.NotFound : ExitCodes.Error,
+            details: { path },
+        });
+    }
+}
+function titleFromMarkdown(markdown) {
+    return markdown.match(/^#\s+(.+)$/mu)?.[1]?.trim();
+}
+function titleFromProperties(properties) {
+    const props = recordValue(properties);
+    if (!props)
+        return undefined;
+    for (const value of Object.values(props)) {
+        const property = recordValue(value);
+        const title = arrayValue(property?.title)
+            .map((item) => stringValue(recordValue(item)?.plain_text) ?? stringValue(recordValue(recordValue(item)?.text)?.content))
+            .filter((item) => item !== undefined)
+            .join('');
+        if (title.length > 0)
+            return title;
+    }
+    return undefined;
+}
+function redactAuthUrls(value) {
+    if (Array.isArray(value))
+        return value.map(redactAuthUrls);
+    const record = recordValue(value);
+    if (!record)
+        return value;
+    return Object.fromEntries(Object.entries(record).map(([key, item]) => [key, key === 'upload_url' || key === 'complete_url' ? redactUrlQuery(item) : redactAuthUrls(item)]));
+}
+function redactUrlQuery(value) {
+    if (typeof value !== 'string')
+        return value;
+    try {
+        const url = new URL(value);
+        url.search = '';
+        return url.toString();
+    }
+    catch {
+        return value.replace(/\?.*$/u, '');
+    }
+}
+function escapeTrailerValue(value) {
+    return value.replaceAll('"', '\\"');
+}
+function recordValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function arrayValue(value) {
+    return Array.isArray(value) ? value : [];
+}
+function stringArrayValue(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+function stringValue(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function booleanValue(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+//# sourceMappingURL=content-common.js.map