@eightstate/escli 0.5.0 → 0.7.0

package/dist/lib/notion/trash-move/support.js

@@ -0,0 +1,300 @@
+import { Errors } from '@oclif/core';
+import { readFile } from 'node:fs/promises';
+import { basename } from 'node:path';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { ExitCodes } from '@eightstate/contracts/exit-codes';
+import { BaseCommand } from '../../../base-command.js';
+import { EscliError } from '../../escli-error.js';
+import { writeStderr, writeStdout } from '../../../io/io.js';
+import { renderKv } from '../../../io/render-kv.js';
+import { NOTION_VERSION } from '../../../services/notion.js';
+import { hasManifestFlag } from '../manifest-pass.js';
+export class NotionWriteCommand extends BaseCommand {
+    outputFlags = {};
+    rawBodies = [];
+    rememberResult(result) {
+        this.rawBodies.push(result.raw);
+        return result.data;
+    }
+    async run() {
+        if (hasManifestFlag(this.argv)) {
+            await super.run();
+            return;
+        }
+        try {
+            const data = await this.execute();
+            if (this.outputFlags.raw) {
+                await writeStdout(`${JSON.stringify(this.rawBodies.length > 1 ? this.rawBodies : this.rawBodies[0] ?? data)}\n`);
+                return;
+            }
+            if (this.outputFlags.json) {
+                await writeStdout(`${JSON.stringify(successEnvelope(data))}\n`);
+                return;
+            }
+            await writeStdout(`${this.render(data)}\n`);
+        }
+        catch (error) {
+            const escliError = toEscliError(error);
+            // Use the EscliError's exit code directly — derived from
+            // contracts/failure-taxonomy which is the single source of truth for
+            // notion.* → exit code mapping. No surface-specific override.
+            process.exitCode = escliError.exitCode;
+            if (this.outputFlags.json || argvHasJson(this.argv))
+                await writeStdout(`${JSON.stringify(errorEnvelope(escliError))}\n`);
+            // In --json mode, the JSON envelope on stdout is the contract; the
+            // human-readable text on stderr is supplementary. Suppress on --json
+            // so automation parses a single stable surface.
+            if (!(this.outputFlags.json || argvHasJson(this.argv)))
+                await writeStderr(`${actionableMessage(escliError)}\n`);
+        }
+    }
+}
+export function notionErrors() {
+    return [
+        ErrorCode.UsageRequired,
+        ErrorCode.UsageInvalid,
+        ErrorCode.UsageUnknownFlag,
+        ErrorCode.ValidationFailed,
+        ErrorCode.FileReadFailed,
+        ErrorCode.AuthRequired,
+        ErrorCode.NotionUnauthorized,
+        ErrorCode.NotionEnrollmentRequired,
+        ErrorCode.NotionRestricted,
+        ErrorCode.NotionNotFound,
+        ErrorCode.NotionValidation,
+        ErrorCode.NotionConflict,
+        ErrorCode.NotionRateLimited,
+        ErrorCode.NotionTimeoutUncertain,
+        ErrorCode.GateInvalidResponse,
+        ErrorCode.NetworkError,
+        ErrorCode.NetworkTimeout,
+        ErrorCode.ServiceUnavailable,
+        ErrorCode.ApiError,
+    ];
+}
+export function renderReceipt(rows) {
+    return renderKv(rows);
+}
+export function requireYes(yes) {
+    if (yes)
+        return;
+    if (!process.stdin.isTTY)
+        throw new EscliError('refusing destructive write in non-interactive mode; re-run with --yes', { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+    throw new EscliError('interactive confirmation is required; re-run with --yes after reviewing the command', { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+}
+export function parseNotionId(value) {
+    const decoded = decodeURIComponent(value);
+    const uuid = decoded.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.toLowerCase();
+    const compact = decoded.match(/[0-9a-f]{32}/iu)?.[0];
+    if (!compact)
+        return value;
+    return `${compact.slice(0, 8)}-${compact.slice(8, 12)}-${compact.slice(12, 16)}-${compact.slice(16, 20)}-${compact.slice(20)}`.toLowerCase();
+}
+export function recordValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+export function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+export function numberValue(value) {
+    const number = Number(value);
+    return Number.isFinite(number) ? number : undefined;
+}
+export function boolValue(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+export function pageRef(raw, fallbackId) {
+    const record = recordValue(raw);
+    return { id: stringValue(record?.id) ?? fallbackId, title: titleFromPage(raw) ?? 'Untitled' };
+}
+export function blockRef(raw, fallbackId) {
+    const record = recordValue(raw);
+    const type = stringValue(record?.type) ?? 'block';
+    return { id: stringValue(record?.id) ?? fallbackId, type, preview: blockPreview(record, type) };
+}
+export function parentRef(value) {
+    const parent = recordValue(value);
+    if (!parent)
+        return undefined;
+    const type = stringValue(parent.type) ?? 'unknown';
+    return {
+        type,
+        page_id: stringValue(parent.page_id),
+        data_source_id: stringValue(parent.data_source_id),
+        database_id: stringValue(parent.database_id),
+        block_id: stringValue(parent.block_id),
+        title: stringValue(parent.title) ?? stringValue(parent.name),
+    };
+}
+export function formatParent(parent) {
+    if (!parent)
+        return 'unknown';
+    const id = parent.page_id ?? parent.data_source_id ?? parent.database_id ?? parent.block_id ?? '';
+    const label = parent.type.replace(/_id$/u, '');
+    return `${label}${parent.title ? ` ${parent.title}` : ''}${id ? ` (${id})` : ''}`;
+}
+export function formatParentCompact(parent) {
+    if (!parent)
+        return 'unknown';
+    const id = parent.page_id ?? parent.data_source_id ?? parent.database_id ?? parent.block_id ?? '';
+    return `${parent.type}${id ? ` ${id}` : ''}`;
+}
+export function botName(raw) {
+    const record = recordValue(raw);
+    return stringValue(record?.bot_name) ?? stringValue(recordValue(record?.bot)?.name) ?? stringValue(recordValue(record?.last_edited_by)?.name) ?? '';
+}
+export function markdownPreview(value, max = 160) {
+    const markdown = stringValue(value) ?? '';
+    if (markdown.length <= max)
+        return markdown;
+    return `${markdown.slice(0, max).trimEnd()}...`;
+}
+export function estimateText(value) {
+    return { chars: value.length, lines: value.length === 0 ? 0 : value.split(/\r?\n/u).length };
+}
+export function formatEstimate(value) {
+    return `${value.chars.toLocaleString('en-US')} chars / ${value.lines.toLocaleString('en-US')} lines`;
+}
+export function deltaEstimate(before, after) {
+    return { chars: after.chars - before.chars, lines: after.lines - before.lines };
+}
+export async function readMarkdownInput(file, text) {
+    if ((file && text !== undefined) || (!file && text === undefined)) {
+        throw new EscliError('usage: choose exactly one content source: --file or --text', { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+    }
+    if (text !== undefined)
+        return { source: 'text', markdown: text };
+    try {
+        const path = file;
+        return { source: `file:${basename(path)}`, markdown: await readFile(path, 'utf8') };
+    }
+    catch (error) {
+        throw new EscliError(`failed to read markdown file: ${error instanceof Error ? error.message : String(error)}`, { code: ErrorCode.FileReadFailed, exitCode: ExitCodes.Usage, details: { file } });
+    }
+}
+export function exactOneDestination(toPage, toDataSource) {
+    if ((toPage && toDataSource) || (!toPage && !toDataSource)) {
+        throw new EscliError('usage: choose exactly one destination: --to-page or --to-data-source', { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+    }
+    if (toPage)
+        return { type: 'page_id', page_id: parseNotionId(toPage) };
+    return { type: 'data_source_id', data_source_id: parseNotionId(toDataSource) };
+}
+export function titleFromPage(raw) {
+    const record = recordValue(raw);
+    const direct = stringValue(record?.title) ?? stringValue(record?.name);
+    if (direct)
+        return direct;
+    const properties = recordValue(record?.properties);
+    for (const property of Object.values(properties ?? {})) {
+        const propertyRecord = recordValue(property);
+        if (propertyRecord?.type === 'title' && Array.isArray(propertyRecord.title)) {
+            const title = propertyRecord.title.map((part) => stringValue(recordValue(part)?.plain_text) ?? stringValue(recordValue(recordValue(part)?.text)?.content) ?? '').join('').trim();
+            if (title)
+                return title;
+        }
+    }
+    return undefined;
+}
+export function unknownBlockIds(raw) {
+    const ids = recordValue(raw)?.unknown_block_ids;
+    return Array.isArray(ids) ? ids.filter((id) => typeof id === 'string') : [];
+}
+function blockPreview(record, type) {
+    const direct = stringValue(record?.preview);
+    if (direct)
+        return direct;
+    const typed = recordValue(record?.[type]);
+    const richText = typed?.rich_text;
+    if (!Array.isArray(richText))
+        return '';
+    return richText.map((part) => stringValue(recordValue(part)?.plain_text) ?? '').join('').trim();
+}
+function successEnvelope(data) {
+    return { ok: true, data, error: null, meta: { next: null, notion_version: NOTION_VERSION } };
+}
+function errorEnvelope(error) {
+    return {
+        ok: false,
+        data: null,
+        error: {
+            code: error.code,
+            message: error.message,
+            data: error.details,
+            cause_code: error.causeCode,
+        },
+        meta: { next: null, notion_version: NOTION_VERSION },
+    };
+}
+function toEscliError(error) {
+    if (error instanceof EscliError)
+        return error;
+    if (error instanceof Errors.CLIError)
+        return new EscliError(cleanOclifMessage(error.message), { code: oclifCode(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.Unknown, details: error });
+}
+function oclifCode(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, '');
+}
+function actionableMessage(error) {
+    const cause = error.causeCode ?? '';
+    const message = error.message.toLowerCase();
+    if (error.message.startsWith('usage: choose exactly one destination'))
+        return error.message;
+    if (error.message.startsWith('refusing destructive write'))
+        return error.message;
+    if (error.message.startsWith('interactive confirmation'))
+        return error.message;
+    if (error.code === ErrorCode.NotionUnauthorized)
+        return 'Notion token is invalid or expired; run escli notion enroll';
+    if (error.code === ErrorCode.NotionEnrollmentRequired || error.code === ErrorCode.AuthRequired)
+        return 'No Notion bot token enrolled for this Clerk user; run escli notion enroll';
+    if (error.code === ErrorCode.NotionRestricted)
+        return 'Bot lacks access/capability. Share source and destination with the bot and grant update content.';
+    if (error.code === ErrorCode.NotionNotFound)
+        return 'Object not found or not shared with bot; verify ID and share target with integration';
+    if (error.code === ErrorCode.NotionRateLimited)
+        return `Notion rate limited this integration${retrySeconds(error.details)}; retry later`;
+    if (error.code === ErrorCode.NotionConflict)
+        return 'Notion conflict while writing; refetch current state before retrying';
+    if (error.code === ErrorCode.NotionValidation && (message.includes('multiple') || message.includes('more than one')))
+        return 'old text matched multiple places; re-run with --replace-all only if all matches should change';
+    if (error.code === ErrorCode.NotionValidation && (message.includes('not found') || message.includes('no match')))
+        return 'old text was not found; fetch page markdown and retry with exact text';
+    if (error.code === ErrorCode.NotionValidation && (message.includes('child') || message.includes('delete')))
+        return 'edit would delete child pages/databases; review affected_items and re-run with --allow-deleting-content --yes';
+    if (error.code === ErrorCode.NotionValidation && (message.includes('database') || cause.includes('database')))
+        return 'use --to-data-source <data_source_id>, not database_id; retrieve database to list data sources';
+    if (error.code === ErrorCode.NotionValidation && (message.includes('block') || message.includes('regular page')))
+        return 'destination for --to-page must be a regular page, not another block type';
+    if (error.code === ErrorCode.NotionValidation)
+        return `Notion rejected request shape: ${error.message}; check command flags`;
+    if (error.code === ErrorCode.ServiceUnavailable && (cause === 'gateway_timeout' || message.includes('timeout')))
+        return 'Notion timed out; refetch before retrying destructive writes';
+    if (error.code === ErrorCode.ServiceUnavailable)
+        return 'Notion unavailable; retry later';
+    if (error.code === ErrorCode.GateInvalidResponse)
+        return 'internal request serialization failed; report broker bug with request id if present';
+    return error.message;
+}
+function retrySeconds(details) {
+    const retryAfterMs = numberValue(recordValue(details)?.retry_after_ms);
+    return retryAfterMs === undefined ? '' : `; retry after ${Math.ceil(retryAfterMs / 1000)}s`;
+}
+function argvHasJson(argv) {
+    return argv.includes('--json');
+}
+//# sourceMappingURL=support.js.map

package/dist/lib/notion/upload/shared.js

@@ -0,0 +1,372 @@
+import { readFile, stat } from 'node:fs/promises';
+import { basename } from 'node:path';
+import { Flags } from '@oclif/core';
+import { z } from 'zod';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { ExitCodes } from '@eightstate/contracts/exit-codes';
+import { renderKv } from '../../../io/render-kv.js';
+import { writeStderr, writeStdout } from '../../../io/io.js';
+import { buildUsageError } from '../../../lib/envelope.js';
+import { EscliError } from '../../../lib/escli-error.js';
+import { NOTION_VERSION, notionBlocksAppendChildren, notionPagesPatchProps } from '../../../services/notion.js';
+export const fileUploadErrors = [
+    ErrorCode.UsageRequired,
+    ErrorCode.UsageInvalid,
+    ErrorCode.UsageUnknownFlag,
+    ErrorCode.ValidationFailed,
+    ErrorCode.FileNotFound,
+    ErrorCode.FileReadFailed,
+    ErrorCode.AuthRequired,
+    ErrorCode.GateCredentialUnavailable,
+    ErrorCode.GateInvalidResponse,
+    ErrorCode.NetworkError,
+    ErrorCode.NetworkTimeout,
+    ErrorCode.ServiceUnavailable,
+    ErrorCode.ApiError,
+    ErrorCode.NotionUnauthorized,
+    ErrorCode.NotionRestricted,
+    ErrorCode.NotionNotFound,
+    ErrorCode.NotionRateLimited,
+    ErrorCode.NotionValidation,
+    ErrorCode.NotionConflict,
+    ErrorCode.NotionTimeoutUncertain,
+    ErrorCode.NotionEnrollmentRequired,
+    ErrorCode.NotionBatchPartial,
+];
+export const rawFlag = Flags.boolean({ description: 'Emit verbatim Notion response body instead of shaped output.' });
+export const AttachTargetSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('none') }),
+    z.object({ kind: z.literal('block'), parent: z.string(), as: z.enum(['file', 'image', 'pdf', 'video', 'audio']), caption: z.string().optional() }),
+    z.object({ kind: z.literal('property'), page: z.string(), property: z.string(), replace_all: z.boolean() }),
+    z.object({ kind: z.literal('page'), page: z.string(), slot: z.enum(['cover', 'icon']) }),
+]);
+export const UploadedFileSchema = z.object({
+    name: z.string(),
+    file_upload_id: z.string(),
+    status: z.string(),
+    mode: z.enum(['single_part', 'multi_part']),
+    size_bytes: z.number().int().nonnegative().optional(),
+    parts: z.number().int().positive().optional(),
+    persistent: z.boolean(),
+});
+export const FileUploadReceiptSchema = z.object({
+    operation: z.literal('file-upload.upload'),
+    uploaded: z.number().int().nonnegative(),
+    attached: z.number().int().nonnegative(),
+    target: z.string().nullable(),
+    files: z.array(UploadedFileSchema),
+    next: z.string().nullable(),
+});
+export const FileUploadAttachReceiptSchema = z.object({
+    operation: z.literal('file-upload.attach'),
+    attached: z.number().int().nonnegative(),
+    target: z.string(),
+    created_block_id: z.string().nullable(),
+    file_upload_ids: z.array(z.string()),
+    file_upload_id: z.string().optional(),
+    next: z.string().nullable(),
+});
+export const FileUploadStatusReceiptSchema = z.object({
+    operation: z.literal('file-upload.status'),
+    checked: z.number().int().nonnegative(),
+    states: z.object({
+        attach_now: z.number().int().nonnegative(),
+        persistent: z.number().int().nonnegative(),
+        pending: z.number().int().nonnegative(),
+        dead: z.number().int().nonnegative(),
+    }),
+    uploads: z.array(z.object({ id: z.string(), name: z.string().optional(), status: z.string(), expiry_time: z.string().nullable().optional(), state: z.enum(['attach_now', 'persistent', 'pending', 'dead']) })),
+});
+export const FileUploadListReceiptSchema = z.object({
+    operation: z.literal('file-upload.list'),
+    count: z.number().int().nonnegative(),
+    filter: z.object({ status: z.string().optional(), created_after: z.string().optional(), page_size: z.number().int().positive() }),
+    counts_on_page: z.object({ attach_now: z.number().int().nonnegative(), persistent: z.number().int().nonnegative(), pending: z.number().int().nonnegative(), dead: z.number().int().nonnegative() }),
+    uploads: FileUploadStatusReceiptSchema.shape.uploads,
+    bot: z.string().optional(),
+});
+export async function emitNotionSuccess(command, version, data, durationMs) {
+    await writeStdout(`${JSON.stringify({ ok: true, data, error: null, meta: notionMeta(command, version, durationMs) })}\n`);
+}
+export async function emitNotionFailure(command, version, error, durationMs, json) {
+    const escliError = toEscliError(error);
+    process.exitCode = escliError.exitCode;
+    if (json) {
+        await writeStdout(`${JSON.stringify({ ok: false, data: null, error: { code: escliError.code, message: escliError.message, remediation: escliError.remediation, details: escliError.details, cause_code: escliError.causeCode }, meta: notionMeta(command, version, durationMs) })}\n`);
+        return;
+    }
+    await writeStderr(`${escliError.message}\n`);
+}
+function notionMeta(command, version, durationMs) {
+    return { schema_version: '1', escli_version: version, command, warnings: [], duration_ms: durationMs, next: null, notion_version: NOTION_VERSION };
+}
+function toEscliError(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 Error)
+        return new EscliError(error.message, { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+    return new EscliError('unknown error', { code: ErrorCode.Unknown, details: error });
+}
+export function parseAttachTarget(flags) {
+    const attachTo = stringFlag(flags['attach-to']);
+    if (attachTo)
+        return parseAttachTo(attachTo, flags);
+    const attach = stringFlag(flags.attach);
+    if (!attach)
+        return { kind: 'none' };
+    if (attach === 'block') {
+        const parent = requireFlag(flags.parent, '--parent is required for --attach block');
+        return { kind: 'block', parent, as: asFlag(flags.as), caption: stringFlag(flags.caption) };
+    }
+    if (attach === 'property') {
+        const page = requireFlag(flags.page, '--page is required for --attach property');
+        const property = requireFlag(flags.property, '--property is required for --attach property');
+        return { kind: 'property', page, property, replace_all: Boolean(flags['replace-all']) };
+    }
+    if (attach === 'page') {
+        const page = requireFlag(flags.page, '--page is required for --attach page');
+        const slot = slotFlag(flags.slot);
+        return { kind: 'page', page, slot };
+    }
+    throw buildUsageError('--attach must be block, property, or page');
+}
+export function parseAttachTo(value, flags) {
+    const [kind, first, ...rest] = value.split(':');
+    if (kind === 'block' && first)
+        return { kind: 'block', parent: first, as: asFlag(flags.as), caption: stringFlag(flags.caption) };
+    if (kind === 'property' && first && rest.length > 0)
+        return { kind: 'property', page: first, property: rest.join(':'), replace_all: Boolean(flags['replace-all']) };
+    if ((kind === 'cover' || kind === 'icon') && first)
+        return { kind: 'page', page: first, slot: kind };
+    throw buildUsageError('--attach-to must be block:<id>, property:<page-id>:<property>, cover:<page-id>, or icon:<page-id>');
+}
+export async function readLocalFile(path) {
+    let fileStat;
+    try {
+        fileStat = await stat(path);
+    }
+    catch {
+        throw new EscliError(`file not readable: ${path} — check path or permissions`, { code: ErrorCode.FileReadFailed, exitCode: ExitCodes.Usage });
+    }
+    if (fileStat.isDirectory())
+        throw new EscliError(`refusing directory upload: ${path} — pass files or an explicit glob`, { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+    try {
+        return { path, name: basename(path), size: fileStat.size, bytes: await readFile(path) };
+    }
+    catch {
+        throw new EscliError(`file not readable: ${path} — check path or permissions`, { code: ErrorCode.FileReadFailed, exitCode: ExitCodes.Usage });
+    }
+}
+export function decideMode(size, mode) {
+    const limit = 20 * 1024 * 1024;
+    if (mode === 'single' && size > limit)
+        throw new EscliError(`${formatBytes(size)} file exceeds 20 MB; use --mode auto or --mode multi`, { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+    if (mode === 'multi')
+        return 'multi_part';
+    return size <= limit ? 'single_part' : 'multi_part';
+}
+export async function emitRaw(raw) {
+    await writeStdout(`${JSON.stringify(stripRawUrls(raw))}\n`);
+}
+export async function attachUploadedFiles(target, files) {
+    if (target.kind === 'none')
+        return undefined;
+    if ((target.kind === 'page') && files.length !== 1)
+        throw new EscliError('page cover/icon accepts exactly one file_upload id', { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+    if (target.kind === 'block') {
+        const children = files.map((file) => ({
+            object: 'block',
+            type: target.as,
+            [target.as]: {
+                type: 'file_upload',
+                file_upload: { id: file.id },
+                ...(file.name ? { name: file.name } : {}),
+                ...(target.caption ? { caption: [{ type: 'text', text: { content: target.caption }, plain_text: target.caption }] } : {}),
+            },
+        }));
+        return notionBlocksAppendChildren(target.parent, children);
+    }
+    if (target.kind === 'property') {
+        const fileObjects = files.map((file) => ({ name: file.name ?? file.id, type: 'file_upload', file_upload: { id: file.id } }));
+        return notionPagesPatchProps(target.page, { [target.property]: { files: fileObjects, mode: target.replace_all ? 'replace_all' : 'append' } });
+    }
+    const file = files[0];
+    if (!file)
+        throw new EscliError('page cover/icon accepts exactly one file_upload id', { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+    return notionPagesPatchProps(target.page, { [target.slot]: { type: 'file_upload', file_upload: { id: file.id }, name: file.name ?? file.id } });
+}
+export function uploadState(item) {
+    if (item.status === 'pending')
+        return 'pending';
+    if (item.status === 'expired' || item.status === 'failed')
+        return 'dead';
+    if (item.status === 'uploaded' && item.expiry_time)
+        return 'attach_now';
+    return 'persistent';
+}
+export function fileUploadId(raw) {
+    const id = record(raw)?.id;
+    if (typeof id === 'string')
+        return id;
+    throw new EscliError('Notion file upload response missing id', { code: ErrorCode.GateInvalidResponse });
+}
+export function normalizeUpload(raw) {
+    const value = record(raw) ?? {};
+    return value;
+}
+export function listResults(raw) {
+    const results = record(raw)?.results;
+    return Array.isArray(results) ? results.map((item) => normalizeUpload(item)) : [];
+}
+export function createdBlockId(raw) {
+    const results = record(raw)?.results;
+    if (!Array.isArray(results))
+        return null;
+    const first = results[0];
+    const id = record(first)?.id;
+    return typeof id === 'string' ? id : null;
+}
+export function renderUploadReceipt(data) {
+    const lines = [
+        renderKv([
+            ['operation', data.operation],
+            ['uploaded', data.uploaded],
+            ['attached', data.attached],
+            ['target', data.target ?? 'none'],
+        ]),
+        '',
+        ...data.files.map((file) => `✓ ${file.name} ${file.size_bytes === undefined ? '' : `${formatBytes(file.size_bytes)} `}${file.mode}${file.parts ? ` ${file.parts}/${file.parts}` : ''} → ${file.file_upload_id} · ${file.status} · ${file.persistent ? 'persistent' : 'expires unless attached'}`),
+    ];
+    if (data.next)
+        lines.push('', renderKv([['next', data.next]]));
+    return lines.join('\n');
+}
+export function renderAttachReceipt(data) {
+    const lines = [`attached ${data.attached} file_upload${data.attached === 1 ? '' : 's'} to ${data.target}`];
+    if (data.created_block_id)
+        lines.push(renderKv([['new block', data.created_block_id]]));
+    lines.push('', ...data.file_upload_ids.map((id) => `✓ ${id} uploaded · attached · persistent`));
+    if (data.next)
+        lines.push(`next: ${data.next}`);
+    return lines.join('\n');
+}
+export function renderStatusReceipt(data) {
+    const groups = [
+        ['attach now', 'attach_now', '! ', 'uploaded · not yet persistent'],
+        ['persistent', 'persistent', '✓ ', 'uploaded · expiry cleared · reusable'],
+        ['pending', 'pending', '! ', 'pending · finish upload or restart'],
+        ['dead', 'dead', '✗ ', 're-upload required'],
+    ];
+    const lines = [renderKv([
+            ['operation', data.operation],
+            ['checked', data.checked],
+            ['attach_now', data.states.attach_now],
+            ['persistent', data.states.persistent],
+            ['pending', data.states.pending],
+            ['dead', data.states.dead],
+        ])];
+    for (const [label, state, prefix, fallback] of groups) {
+        const uploads = data.uploads.filter((upload) => upload.state === state);
+        if (uploads.length === 0)
+            continue;
+        lines.push('', `${label}:`);
+        for (const upload of uploads)
+            lines.push(`${prefix}${upload.id} ${upload.status} · ${upload.expiry_time && state === 'attach_now' ? `expires ${relativeExpiry(upload.expiry_time)} · not yet persistent` : fallback}`);
+    }
+    return lines.join('\n');
+}
+export function renderListReceipt(data) {
+    const bot = data.bot ? ` · bot ${data.bot}` : '';
+    const lines = [`file_uploads · ${data.count} recent${bot}`];
+    const urgent = data.uploads.filter((upload) => upload.state === 'attach_now' || upload.state === 'pending');
+    const reusable = data.uploads.filter((upload) => upload.state === 'persistent').slice(0, 2);
+    if (urgent.length > 0) {
+        lines.push('', 'urgent:');
+        for (const upload of urgent)
+            lines.push(`! ${upload.id} ${upload.name ?? ''} · ${upload.status} · ${upload.state === 'attach_now' ? `${upload.expiry_time ? `expires ${relativeExpiry(upload.expiry_time)} · ` : ''}attach now` : 'finish upload or restart'}`.replace(/\s+·/u, ' ·'));
+    }
+    if (reusable.length > 0) {
+        lines.push('', 'reusable:');
+        for (const upload of reusable)
+            lines.push(`✓ ${upload.id} ${upload.name ?? ''} · uploaded · persistent`.replace(/\s+·/u, ' ·'));
+    }
+    const hidden = data.uploads.filter((upload) => upload.state === 'persistent').length - reusable.length;
+    if (hidden > 0)
+        lines.push('', `${hidden} stable uploads hidden`);
+    if (urgent.length > 0)
+        lines.push(`next: escli notion file-upload status ${urgent.map((upload) => upload.id).join(' ')}`);
+    return lines.join('\n');
+}
+export function requireUploaded(upload) {
+    if (upload.status === 'pending')
+        throw new EscliError(`${upload.id ?? 'file_upload'} is still pending; finish upload or create a new upload`, { code: ErrorCode.NotionValidation, exitCode: ExitCodes.Usage, causeCode: 'file_upload.pending' });
+    if (upload.status === 'expired')
+        throw new EscliError(`${upload.id ?? 'file_upload'} expired before first attachment; re-upload the file`, { code: ErrorCode.NotionValidation, exitCode: ExitCodes.Usage, causeCode: 'file_upload.expired' });
+    if (upload.status === 'failed')
+        throw new EscliError(`${upload.id ?? 'file_upload'} failed in Notion storage; create a new upload`, { code: ErrorCode.NotionValidation, exitCode: ExitCodes.Usage, causeCode: 'file_upload.failed' });
+}
+function stripRawUrls(value) {
+    if (Array.isArray(value))
+        return value.map(stripRawUrls);
+    const valueRecord = record(value);
+    if (!valueRecord)
+        return value;
+    return Object.fromEntries(Object.entries(valueRecord).map(([key, entry]) => [key, (key === 'upload_url' || key === 'complete_url') && typeof entry === 'string' ? entry.split('?')[0] : stripRawUrls(entry)]));
+}
+function asFlag(value) {
+    if (value === 'image' || value === 'pdf' || value === 'video' || value === 'audio')
+        return value;
+    return 'file';
+}
+function slotFlag(value) {
+    if (value === 'cover' || value === 'icon')
+        return value;
+    throw buildUsageError('--slot must be cover or icon');
+}
+function stringFlag(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function requireFlag(value, message) {
+    const output = stringFlag(value);
+    if (!output)
+        throw buildUsageError(message);
+    return output;
+}
+export function targetLabel(target) {
+    if (target.kind === 'none')
+        return null;
+    if (target.kind === 'block')
+        return `block ${target.parent}`;
+    if (target.kind === 'property')
+        return `page property ${target.page} ${target.property}`;
+    return `page ${target.slot} ${target.page}`;
+}
+export function nextForTarget(target, createdBlock) {
+    if (target.kind === 'block' && createdBlock)
+        return `escli notion block get ${createdBlock}`;
+    if (target.kind === 'property')
+        return `escli notion fetch ${target.page} --properties ${target.property}`;
+    return null;
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function formatBytes(bytes) {
+    if (bytes >= 1024 * 1024)
+        return `${Math.round((bytes / 1024 / 1024) * 10) / 10} MB`;
+    if (bytes >= 1024)
+        return `${Math.round(bytes / 1024)} KB`;
+    return `${bytes} B`;
+}
+function relativeExpiry(value) {
+    const ms = Date.parse(value) - Date.now();
+    if (!Number.isFinite(ms))
+        return value;
+    const minutes = Math.max(0, Math.round(ms / 60_000));
+    if (minutes >= 60)
+        return `in ${Math.round(minutes / 60)}h`;
+    return `in ${minutes}m`;
+}
+//# sourceMappingURL=shared.js.map