@eightstate/escli 0.7.1 → 0.8.0

package/dist/commands/mcp/index.js

@@ -0,0 +1,23 @@
+import { BaseCommand } from '../../base-command.js';
+import { buildUsageError } from '../../lib/envelope.js';
+import { ErrorCode } from '@eightstate/contracts/errors';
+export default class McpTopic extends BaseCommand {
+    static errors = [ErrorCode.UsageInvalid];
+    static summary = 'Expose a local directory to ChatGPT via a remote MCP server';
+    static description = 'Register, serve, inspect, and revoke a local MCP machine exposed through a Cloudflare tunnel.';
+    static examples = [
+        '<%= config.bin %> mcp register --root . --label "work repo"',
+        '<%= config.bin %> mcp serve --root .',
+        '<%= config.bin %> mcp status',
+        '<%= config.bin %> mcp revoke --slug my-repo',
+    ];
+    static aliases = [];
+    static flags = {};
+    static args = {};
+    static enableJsonFlag = true;
+    static strict = true;
+    async execute() {
+        throw buildUsageError('usage: escli mcp <register|serve|status|revoke>');
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/mcp/register.js

@@ -0,0 +1,91 @@
+import { Flags } from '@oclif/core';
+import { z } from 'zod';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { BaseCommand } from '../../base-command.js';
+import { writeStderr } from '../../io/io.js';
+import { resolveCliToken } from '../../services/credentials.js';
+import { authRequired, DEFAULT_MCP_DOMAIN, maskSecret, usageError } from '../../services/mcp/common.js';
+import { CloudflareClient } from '../../services/mcp/cloudflare.js';
+import { validateRootDirectory, writeMachineConfig } from '../../services/mcp/config.js';
+import { McpGateClient } from '../../services/mcp/gate-client.js';
+export const McpRegisterDataSchema = z.object({
+    slug: z.string(),
+    label: z.string().optional(),
+    root_default: z.string(),
+    hostname: z.string(),
+    resource: z.string(),
+    port: z.number(),
+    machine_id: z.number(),
+    tunnel_id: z.string(),
+    dns_record_id: z.string(),
+    config_path: z.string(),
+    connector_url: z.string(),
+});
+export default class McpRegister extends BaseCommand {
+    static errors = [ErrorCode.AuthRequired, ErrorCode.UsageInvalid, ErrorCode.ConfigInvalid, ErrorCode.ApiError, ErrorCode.GateUnavailable, ErrorCode.GateInvalidResponse, ErrorCode.NetworkError];
+    static summary = 'Register a local directory as an MCP machine';
+    static examples = ['<%= config.bin %> mcp register --root . --label "repo"', '<%= config.bin %> mcp register --root . --slug my-repo'];
+    static enableJsonFlag = true;
+    static strict = true;
+    static flags = {
+        root: Flags.string({ description: 'Root directory to expose.', required: true }),
+        slug: Flags.string({ description: 'Machine slug. Defaults from --label, root basename, or hostname.' }),
+        port: Flags.integer({ description: 'Local MCP origin port.', default: 9315 }),
+        label: Flags.string({ description: 'Human label for this machine.' }),
+        'cf-account-id': Flags.string({ description: 'Cloudflare account ID. Defaults to CLOUDFLARE_ACCOUNT_ID.' }),
+        'cf-zone-id': Flags.string({ description: 'Cloudflare zone ID. Defaults to CLOUDFLARE_ZONE_ID.' }),
+        'cf-api-token': Flags.string({ description: 'Cloudflare API token. Defaults to CLOUDFLARE_API_TOKEN; never persisted.' }),
+    };
+    async execute() {
+        const flags = await this.parseFlags(McpRegister);
+        if (!resolveCliToken())
+            throw authRequired();
+        const root = await validateRootDirectory(flags.root);
+        const port = flags.port;
+        if (port < 1 || port > 65535)
+            throw usageError('--port must be between 1 and 65535');
+        const slug = normalizeSlug(flags.slug ?? flags.label ?? root.split('/').filter(Boolean).pop() ?? 'machine');
+        const hostname = `mcp-${slug}.${DEFAULT_MCP_DOMAIN}`;
+        const cf = new CloudflareClient({ accountId: flags['cf-account-id'], zoneId: flags['cf-zone-id'], apiToken: flags['cf-api-token'] });
+        let tunnelId;
+        let dnsRecordId;
+        try {
+            const tunnel = await cf.createTunnel(slug);
+            tunnelId = tunnel.id;
+            await cf.configureIngress(tunnel.id, hostname, port);
+            const dns = await cf.createDnsRecord(hostname, tunnel.id);
+            dnsRecordId = dns.id;
+            const gate = await new McpGateClient().createMachine({ slug, hostname, tunnel_id: tunnel.id, port, label: flags.label });
+            const config = {
+                slug,
+                label: flags.label,
+                root_default: root,
+                hostname: gate.hostname,
+                resource: gate.resource,
+                tunnel_id: tunnel.id,
+                tunnel_token: tunnel.token,
+                dns_record_id: dns.id,
+                port,
+                machine_id: gate.machine_id,
+                machine_secret: gate.machine_secret,
+                created_at: new Date().toISOString(),
+            };
+            const configPath = await writeMachineConfig(config);
+            if (!flags.quiet && !flags.json)
+                await writeStderr(`connector URL: ${gate.resource}/mcp\nconfig: ${configPath}\ntunnel: ${maskSecret(tunnel.id)}\n`);
+            return { slug, label: flags.label, root_default: root, hostname: gate.hostname, resource: gate.resource, port, machine_id: gate.machine_id, tunnel_id: tunnel.id, dns_record_id: dns.id, config_path: configPath, connector_url: `${gate.resource}/mcp` };
+        }
+        catch (error) {
+            const cleanup = [`Cloudflare tunnel id: ${tunnelId ?? '(not created)'}`, `Cloudflare DNS record id: ${dnsRecordId ?? '(not created)'}`].join('\n');
+            await writeStderr(`MCP register failed. Cleanup references:\n${cleanup}\n`);
+            throw error;
+        }
+    }
+}
+function normalizeSlug(value) {
+    const slug = value.toLowerCase().trim().replace(/[^a-z0-9]+/gu, '-').replace(/^-+|-+$/gu, '').slice(0, 63) || 'machine';
+    if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/u.test(slug))
+        throw usageError('could not derive a valid slug; pass --slug');
+    return slug;
+}
+//# sourceMappingURL=register.js.map

package/dist/commands/mcp/revoke.js

@@ -0,0 +1,40 @@
+import { Flags } from '@oclif/core';
+import { z } from 'zod';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { BaseCommand } from '../../base-command.js';
+import { CloudflareClient } from '../../services/mcp/cloudflare.js';
+import { deleteMachineConfig, resolveMachineConfig } from '../../services/mcp/config.js';
+import { McpGateClient } from '../../services/mcp/gate-client.js';
+export const McpRevokeDataSchema = z.object({ slug: z.string(), gate_revoked: z.boolean(), cloudflare_deleted: z.boolean(), local_config_deleted: z.boolean() });
+export default class McpRevoke extends BaseCommand {
+    static errors = [ErrorCode.ConfigInvalid, ErrorCode.AuthRequired, ErrorCode.GateUnavailable, ErrorCode.ApiError];
+    static summary = 'Revoke an MCP machine and optionally delete Cloudflare resources';
+    static examples = ['<%= config.bin %> mcp revoke --slug my-repo', '<%= config.bin %> mcp revoke --slug my-repo --cloudflare --yes'];
+    static enableJsonFlag = true;
+    static strict = true;
+    static flags = {
+        slug: Flags.string({ description: 'Machine slug. Optional only when one config exists.' }),
+        cloudflare: Flags.boolean({ description: 'Also delete Cloudflare DNS record and tunnel.', default: false }),
+        yes: Flags.boolean({ char: 'y', description: 'Skip confirmation for --cloudflare.', default: false }),
+        'cf-account-id': Flags.string({ description: 'Cloudflare account ID. Defaults to CLOUDFLARE_ACCOUNT_ID.' }),
+        'cf-zone-id': Flags.string({ description: 'Cloudflare zone ID. Defaults to CLOUDFLARE_ZONE_ID.' }),
+        'cf-api-token': Flags.string({ description: 'Cloudflare API token. Defaults to CLOUDFLARE_API_TOKEN; never persisted.' }),
+    };
+    async execute() {
+        const flags = await this.parseFlags(McpRevoke);
+        const config = await resolveMachineConfig(flags.slug);
+        await new McpGateClient().revokeMachine(config.slug);
+        let cloudflareDeleted = false;
+        if (flags.cloudflare) {
+            if (!flags.yes)
+                throw new Error('refusing to delete Cloudflare resources without --yes');
+            const cf = new CloudflareClient({ accountId: flags['cf-account-id'], zoneId: flags['cf-zone-id'], apiToken: flags['cf-api-token'] });
+            await cf.deleteDnsRecord(config.dns_record_id);
+            await cf.deleteTunnel(config.tunnel_id);
+            cloudflareDeleted = true;
+        }
+        const localConfigDeleted = await deleteMachineConfig(config.slug);
+        return { slug: config.slug, gate_revoked: true, cloudflare_deleted: cloudflareDeleted, local_config_deleted: localConfigDeleted };
+    }
+}
+//# sourceMappingURL=revoke.js.map

package/dist/commands/mcp/serve.js

@@ -0,0 +1,75 @@
+import { Flags } from '@oclif/core';
+import { z } from 'zod';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { BaseCommand } from '../../base-command.js';
+import { writeStderr } from '../../io/io.js';
+import { usageError } from '../../services/mcp/common.js';
+import { resolveMachineConfig, validateRootDirectory } from '../../services/mcp/config.js';
+import { startCloudflared } from '../../services/mcp/cloudflared.js';
+import { startMcpServer } from '../../services/mcp/server.js';
+export const McpServeDataSchema = z.object({ slug: z.string(), root: z.string(), local_url: z.string(), connector_url: z.string(), port: z.number() });
+export default class McpServe extends BaseCommand {
+    static errors = [ErrorCode.UsageInvalid, ErrorCode.ConfigInvalid, ErrorCode.FileNotFound, ErrorCode.Internal];
+    static summary = 'Serve the local MCP origin and Cloudflare tunnel';
+    static examples = ['<%= config.bin %> mcp serve --root .', '<%= config.bin %> mcp serve --root . --slug my-repo --verbose'];
+    static enableJsonFlag = true;
+    static strict = true;
+    static flags = {
+        root: Flags.string({ description: 'Root directory to expose.', required: true }),
+        slug: Flags.string({ description: 'Machine slug. Optional only when one config exists.' }),
+        port: Flags.integer({ description: 'Override local MCP origin port.' }),
+        verbose: Flags.boolean({ description: 'Print redacted per-call and cloudflared logs.', default: false }),
+    };
+    async execute() {
+        const flags = await this.parseFlags(McpServe);
+        const root = await validateRootDirectory(flags.root);
+        const config = await resolveMachineConfig(flags.slug);
+        const port = flags.port ?? config.port;
+        if (port < 1 || port > 65535)
+            throw usageError('--port must be between 1 and 65535');
+        const log = async (line) => {
+            if (flags.verbose && !flags.quiet && !flags.json)
+                await writeStderr(`${line.trimEnd()}\n`);
+        };
+        const server = await startMcpServer({ root, config: { ...config, port }, port, verbose: (line) => void log(line) });
+        let shuttingDown = false;
+        const runtime = {};
+        const shutdown = async (exitCode) => {
+            if (shuttingDown)
+                return;
+            shuttingDown = true;
+            await runtime.cloudflared?.stop().catch(() => { });
+            await server.close().catch(() => { });
+            process.exitCode = exitCode;
+        };
+        try {
+            runtime.cloudflared = await startCloudflared(config.tunnel_token, {
+                log: (line) => void log(line),
+                onExit: (code, signal) => {
+                    void writeStderr(`cloudflared exited (${code ?? signal ?? 'unknown'})\n`).then(() => shutdown(1));
+                },
+            });
+        }
+        catch (error) {
+            await server.close().catch(() => { });
+            throw error;
+        }
+        const onSignal = () => { void shutdown(0); };
+        process.once('SIGINT', onSignal);
+        process.once('SIGTERM', onSignal);
+        if (!flags.quiet && !flags.json) {
+            await writeStderr(`local MCP: ${server.url}\nconnector URL: ${config.resource}/mcp\ntunnel: running for ${config.hostname}\n`);
+        }
+        this.humanOutputHandled = true;
+        await new Promise((resolve) => {
+            const timer = setInterval(() => {
+                if (shuttingDown) {
+                    clearInterval(timer);
+                    resolve();
+                }
+            }, 100);
+        });
+        return { slug: config.slug, root, local_url: server.url, connector_url: `${config.resource}/mcp`, port };
+    }
+}
+//# sourceMappingURL=serve.js.map

package/dist/commands/mcp/status.js

@@ -0,0 +1,67 @@
+import { Flags } from '@oclif/core';
+import { z } from 'zod';
+import { hostname as osHostname } from 'node:os';
+import { createConnection } from 'node:net';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { BaseCommand } from '../../base-command.js';
+import { findCloudflared } from '../../services/mcp/cloudflared.js';
+import { machineConfigPath, resolveMachineConfig } from '../../services/mcp/config.js';
+import { McpGateClient } from '../../services/mcp/gate-client.js';
+export const McpStatusDataSchema = z.object({
+    slug: z.string(),
+    config_path: z.string(),
+    hostname: z.string(),
+    local_hostname: z.string(),
+    resource: z.string(),
+    port: z.number(),
+    listening: z.boolean(),
+    cloudflared_installed: z.boolean(),
+    gate: z.object({ available: z.boolean(), revoked_at: z.string().nullable().optional(), registered: z.boolean().optional(), error: z.string().optional() }),
+});
+export default class McpStatus extends BaseCommand {
+    static errors = [ErrorCode.ConfigInvalid];
+    static summary = 'Show MCP machine status';
+    static examples = ['<%= config.bin %> mcp status', '<%= config.bin %> mcp status --slug my-repo'];
+    static enableJsonFlag = true;
+    static strict = true;
+    static flags = {
+        slug: Flags.string({ description: 'Machine slug. Optional only when one config exists.' }),
+    };
+    async execute() {
+        const flags = await this.parseFlags(McpStatus);
+        const config = await resolveMachineConfig(flags.slug);
+        const [listening, cloudflaredInstalled, gate] = await Promise.all([
+            isListening(config.port),
+            findCloudflared().then(() => true).catch(() => false),
+            new McpGateClient().getMachineStatus(config.slug)
+                .then((status) => ({ available: true, registered: true, revoked_at: status.revoked_at }))
+                .catch((error) => ({ available: false, error: error instanceof Error ? error.message : String(error) })),
+        ]);
+        return {
+            slug: config.slug,
+            config_path: machineConfigPath(config.slug),
+            hostname: config.hostname,
+            local_hostname: osHostname(),
+            resource: config.resource,
+            port: config.port,
+            listening,
+            cloudflared_installed: cloudflaredInstalled,
+            gate,
+        };
+    }
+}
+function isListening(port) {
+    return new Promise((resolve) => {
+        const socket = createConnection({ host: '127.0.0.1', port });
+        socket.once('connect', () => {
+            socket.destroy();
+            resolve(true);
+        });
+        socket.once('error', () => resolve(false));
+        socket.setTimeout(1000, () => {
+            socket.destroy();
+            resolve(false);
+        });
+    });
+}
+//# sourceMappingURL=status.js.map

package/dist/commands/notion/comments/add.js

@@ -1,7 +1,7 @@
 import { Args, Flags } from '@oclif/core';
 import { renderKv } from '../../../io/render-kv.js';
 import { notionCommentsCreate } from '../../../services/notion.js';
-import { createBodyFromMarkdown, formatAuthor, formatCreated, joinMarkdown, kvEntries, notionCommentErrors, NotionCommentsCommand, parseTarget, shapeReceipt, } from '../../../lib/notion/comments/shared.js';
+import { createBodyFromMarkdown, createBodyWithRichTextMentions, formatAuthor, formatCreated, joinMarkdown, kvEntries, notionCommentErrors, NotionCommentsCommand, parseTarget, resolveCommentMentions, shapeReceipt, } from '../../../lib/notion/comments/shared.js';
 export default class NotionCommentsAdd extends NotionCommentsCommand {
     static errors = notionCommentErrors;
     static summary = 'Add a Notion comment to a page or block';
@@ -13,6 +13,7 @@ export default class NotionCommentsAdd extends NotionCommentsCommand {
     static aliases = [];
     static flags = {
         raw: Flags.boolean({ description: 'Emit the verbatim Notion response body.', default: false }),
+        mention: Flags.string({ description: 'Resolve @name/email/user-id placeholders to real Notion user mentions. Repeat or comma-separate.', multiple: true }),
     };
     static args = {
         target: Args.string({ description: 'Page or block ID/URL.', required: true }),
@@ -24,12 +25,14 @@ export default class NotionCommentsAdd extends NotionCommentsCommand {
         const { args, flags } = await this.parse(NotionCommentsAdd);
         const target = parseTarget(args.target);
         const markdown = joinMarkdown(args.markdown);
-        const result = await notionCommentsCreate({ body: createBodyFromMarkdown(target, markdown) });
+        const resolution = await resolveCommentMentions(markdown, flags.mention ?? []);
+        const body = resolution.mentions.length > 0 ? createBodyWithRichTextMentions(target, markdown, resolution.mentions) : createBodyFromMarkdown(target, markdown);
+        const result = await notionCommentsCreate({ body });
         this.setNext(null);
         if (flags.raw)
             return this.setRaw(result.raw);
         const action = target.kind === 'block' ? 'created_block_comment' : 'created_page_comment';
-        return shapeReceipt(result, { action, where: `${target.kind} ${target.id}`, body: markdown });
+        return shapeReceipt(result, { action, where: `${target.kind} ${target.id}`, body: markdown, warnings: resolution.warnings });
     }
     render(data) {
         const receipt = data;
@@ -41,6 +44,7 @@ export default class NotionCommentsAdd extends NotionCommentsCommand {
             author: formatAuthor({ author: receipt.author, author_kind: receipt.author_kind }),
             created_time: formatCreated(receipt.created_time),
             warning: receipt.warning,
+            warnings: receipt.warnings?.join('; '),
             body: receipt.body,
         }));
     }

package/dist/commands/notion/comments/reply.js

@@ -1,7 +1,7 @@
 import { Args, Flags } from '@oclif/core';
 import { renderKv } from '../../../io/render-kv.js';
 import { notionCommentsCreate } from '../../../services/notion.js';
-import { formatAuthor, formatCreated, joinMarkdown, kvEntries, notionCommentErrors, NotionCommentsCommand, replyBodyFromMarkdown, shapeReceipt, } from '../../../lib/notion/comments/shared.js';
+import { formatAuthor, formatCreated, joinMarkdown, kvEntries, notionCommentErrors, NotionCommentsCommand, replyBodyFromMarkdown, replyBodyWithRichTextMentions, resolveCommentMentions, shapeReceipt, } from '../../../lib/notion/comments/shared.js';
 export default class NotionCommentsReply extends NotionCommentsCommand {
     static errors = notionCommentErrors;
     static summary = 'Reply to a Notion discussion thread';
@@ -13,6 +13,7 @@ export default class NotionCommentsReply extends NotionCommentsCommand {
     static aliases = [];
     static flags = {
         raw: Flags.boolean({ description: 'Emit the verbatim Notion response body.', default: false }),
+        mention: Flags.string({ description: 'Resolve @name/email/user-id placeholders to real Notion user mentions. Repeat or comma-separate.', multiple: true }),
     };
     static args = {
         discussionId: Args.string({ description: 'Discussion ID.', required: true }),
@@ -23,11 +24,13 @@ export default class NotionCommentsReply extends NotionCommentsCommand {
     async execute() {
         const { args, flags } = await this.parse(NotionCommentsReply);
         const markdown = joinMarkdown(args.markdown);
-        const result = await notionCommentsCreate({ body: replyBodyFromMarkdown(args.discussionId, markdown) });
+        const resolution = await resolveCommentMentions(markdown, flags.mention ?? []);
+        const body = resolution.mentions.length > 0 ? replyBodyWithRichTextMentions(args.discussionId, markdown, resolution.mentions) : replyBodyFromMarkdown(args.discussionId, markdown);
+        const result = await notionCommentsCreate({ body });
         this.setNext(null);
         if (flags.raw)
             return this.setRaw(result.raw);
-        return shapeReceipt(result, { action: 'replied_to_discussion', body: markdown, discussionId: args.discussionId });
+        return shapeReceipt(result, { action: 'replied_to_discussion', body: markdown, discussionId: args.discussionId, warnings: resolution.warnings });
     }
     render(data) {
         const receipt = data;
@@ -38,6 +41,7 @@ export default class NotionCommentsReply extends NotionCommentsCommand {
             author: formatAuthor({ author: receipt.author, author_kind: receipt.author_kind }),
             created_time: formatCreated(receipt.created_time),
             warning: receipt.warning,
+            warnings: receipt.warnings?.join('; '),
             body: receipt.body,
         }));
     }

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

@@ -74,8 +74,8 @@ export default class NotionDbCreate extends BaseCommand {
         const dataSourceName = typedFlags['data-source-name'] ?? args.title;
         const views = [...parseViewFlags(typedFlags.view), ...await parseViewFileInput(typedFlags['view-file'])];
         const request = {
-            parent: typedFlags.parent,
-            title: args.title,
+            parent: databaseParentFromFlag(typedFlags.parent),
+            title: richTextTitle(args.title),
             initial_data_source: { name: dataSourceName, schema },
             views,
         };
@@ -198,6 +198,15 @@ export async function parseViewFileInput(value) {
     const views = Array.isArray(parsed) ? parsed : [parsed];
     return views.map((view, index) => parseViewRecord(view, `view-file[${index}]`));
 }
+export function databaseParentFromFlag(parent) {
+    const trimmed = parent.trim();
+    if (trimmed === 'workspace')
+        return { type: 'workspace', workspace: true };
+    return { type: 'page_id', page_id: normalizeNotionId(trimmed) };
+}
+export function richTextTitle(content) {
+    return [{ type: 'text', text: { content } }];
+}
 export function parseViewFlags(values) {
     return (values ?? []).map((value) => {
         const separator = value.indexOf(':');
@@ -478,17 +487,29 @@ function findRawView(value) {
     return values.map(recordValue).find((record) => record?.object === 'view');
 }
 function locationFromRaw(value) {
-    const databaseId = stringValue(value?.database_id);
+    const databaseId = stringValue(value?.database_id) ?? parentId(value?.parent, 'database_id');
     if (databaseId)
         return { database_id: databaseId };
-    const dashboardId = stringValue(value?.dashboard_view_id);
+    const dashboardId = stringValue(value?.dashboard_view_id) ?? parentId(value?.parent, 'view_id');
     if (dashboardId)
         return { dashboard_view_id: dashboardId };
-    const pageId = stringValue(value?.page_id);
+    const pageId = stringValue(value?.page_id) ?? parentId(value?.parent, 'page_id');
     if (pageId)
         return { page_id: pageId };
     return undefined;
 }
+function parentId(parent, key) {
+    return stringValue(recordValue(parent)?.[key]);
+}
+function normalizeNotionId(value) {
+    const uuid = value.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 = value.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();
+}
 function parentField(parent, fallback) {
     const record = recordValue(parent);
     const pageId = stringValue(record?.page_id);

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

@@ -45,9 +45,9 @@ export default class NotionDsCreate extends BaseCommand {
         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,
+            parent: { type: 'database_id', database_id: args.database_id },
+            title: [{ type: 'text', text: { content: args.name } }],
+            properties: schema,
             views,
         };
         if (flags['dry-run']) {

package/dist/commands/notion/page/replace-content.js

@@ -28,12 +28,9 @@ export default class NotionPageReplaceContent extends NotionWriteCommand {
         requireYes(flags.yes);
         const pageId = parseNotionId(args.page);
         const input = await readMarkdownInput(flags.file, flags.text);
-        // Canonical replace_content body — matches notion page replace and the
-        // page-content test contract. allow_deleting_content stays top-level and
-        // is only emitted when true.
         const body = {
             type: 'replace_content',
-            replace_content: { markdown: input.markdown },
+            replace_content: { new_str: input.markdown },
             ...(flags['allow-deleting-content'] ? { allow_deleting_content: true } : {}),
         };
         const result = await notionPagePatchMarkdown(pageId, body);

package/dist/commands/notion/page/replace-text.js

@@ -28,13 +28,10 @@ export default class NotionPageReplaceText extends NotionWriteCommand {
         this.outputFlags = flags;
         requireYes(flags.yes);
         const pageId = parseNotionId(args.page);
-        // Canonical update_content body — matches notion page edit and the
-        // page-content test contract. allow_deleting_content stays top-level and
-        // is only emitted when true; never nested inside update_content.
         const body = {
             type: 'update_content',
             update_content: {
-                content_updates: [{ old_str: flags.old, new_str: flags.new, replace_all_matches: flags['replace-all'] }],
+                content_updates: [{ old_str: flags.old, new_str: flags.new, ...(flags['replace-all'] ? { replace_all_matches: true } : {}) }],
             },
             ...(flags['allow-deleting-content'] ? { allow_deleting_content: true } : {}),
         };

package/dist/commands/notion/upload/index.js

@@ -9,6 +9,22 @@ import { EscliError } from '../../../lib/escli-error.js';
 import { hasManifestFlag } from '../../../lib/notion/manifest-pass.js';
 const MIB = 1024 * 1024;
 export { FileUploadReceiptSchema as NotionUploadDataSchema };
+function contentTypeForName(name) {
+    const lower = name.toLowerCase();
+    if (lower.endsWith('.txt') || lower.endsWith('.md') || lower.endsWith('.csv') || lower.endsWith('.json'))
+        return 'text/plain; charset=utf-8';
+    if (lower.endsWith('.png'))
+        return 'image/png';
+    if (lower.endsWith('.jpg') || lower.endsWith('.jpeg'))
+        return 'image/jpeg';
+    if (lower.endsWith('.gif'))
+        return 'image/gif';
+    if (lower.endsWith('.webp'))
+        return 'image/webp';
+    if (lower.endsWith('.pdf'))
+        return 'application/pdf';
+    return undefined;
+}
 export default class NotionUpload extends BaseCommand {
     static errors = fileUploadErrors;
     static summary = 'Upload local files to Notion file_upload storage';
@@ -89,18 +105,19 @@ export default class NotionUpload extends BaseCommand {
             const name = flags.name ?? file.name;
             const mode = decideMode(file.size, flags.mode);
             const parts = mode === 'multi_part' ? Math.max(1, Math.ceil(file.size / (flags['part-size-mib'] * MIB))) : undefined;
-            const created = await notionFileUploadCreate({ mode, filename: name, name, ...(parts ? { number_of_parts: parts } : {}) });
+            const contentType = contentTypeForName(name);
+            const created = await notionFileUploadCreate({ mode, filename: name, name, ...(contentType ? { content_type: contentType } : {}), ...(parts ? { number_of_parts: parts } : {}) });
             rawChain.push(created.raw);
             const id = fileUploadId(created.data);
             if (mode === 'single_part') {
-                const sent = await notionFileUploadSend(id, { file: file.bytes, filename: name });
+                const sent = await notionFileUploadSend(id, { file: file.bytes, filename: name, contentType });
                 rawChain.push(sent.raw);
             }
             else {
                 for (let index = 0; index < (parts ?? 1); index += 1) {
                     const start = index * flags['part-size-mib'] * MIB;
                     const end = Math.min(file.bytes.length, start + flags['part-size-mib'] * MIB);
-                    const sent = await notionFileUploadSend(id, { file: file.bytes.subarray(start, end), filename: name });
+                    const sent = await notionFileUploadSend(id, { file: file.bytes.subarray(start, end), filename: name, contentType, partNumber: index + 1 });
                     rawChain.push(sent.raw);
                 }
                 const completed = await notionFileUploadComplete(id);

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

@@ -45,11 +45,13 @@ export default class NotionViewCreate extends BaseCommand {
     }
     async execute() {
         const { args, flags } = await this.parse(NotionViewCreate);
+        const location = viewLocation(flags);
         const request = {
             name: args.name,
             data_source_id: flags['data-source'],
             type: parseViewType(flags.type),
-            location: viewLocation(flags),
+            ...location,
+            location,
             filter: await parseOptionalJsonInput(flags.filter, 'filter'),
             sorts: parseSortFlags(flags.sort),
             config: await parseOptionalJsonInput(flags.config, 'config'),

package/dist/lib/manifest.js

@@ -64,5 +64,5 @@ function inferOptionType(name, value) {
         return 'integer';
     return 'string';
 }
-const integerFlags = new Set(['compression', 'speakers-expected', 'limit', 'tokens', 'page', 'max-results', 'days', 'timeout', 'max-wait']);
+const integerFlags = new Set(['compression', 'speakers-expected', 'limit', 'tokens', 'page', 'max-results', 'days', 'timeout', 'max-wait', 'port']);
 //# sourceMappingURL=manifest.js.map