@postplus/cli 0.1.39 → 0.1.40

package/build/hosted-request-schemas.js

@@ -1,5 +1,5 @@
 import { Buffer } from 'node:buffer';
-import { MEDIA_ENDPOINT_HINTS, PUBLIC_CONTENT_DISCOVERY_TOOL_HINTS, PUBLIC_CONTENT_SOURCE_HINTS, RESEARCH_COLLECTION_HINTS, VIDEO_ANALYSIS_MODEL_HINTS, } from './hosted-schema-catalog.js';
+import { findMediaEndpoint, manifestTargetKeys, } from './hosted-manifest-index.js';
 const JSON_OBJECT_SCHEMA = {
     additionalProperties: true,
     type: 'object',
@@ -9,6 +9,40 @@ const OPERATION_ID_SCHEMA = {
     minLength: 1,
     type: 'string',
 };
+function toFieldContract(field) {
+    const contract = {
+        name: field.name,
+        kind: field.class,
+        flag: field.flag,
+        type: field.type,
+        required: field.required,
+    };
+    if (field.repeatable) {
+        contract.repeatable = true;
+    }
+    if (field.enumValues) {
+        contract.enumValues = field.enumValues;
+    }
+    if (field.min !== undefined) {
+        contract.min = field.min;
+    }
+    if (field.max !== undefined) {
+        contract.max = field.max;
+    }
+    if (field.default !== undefined) {
+        contract.default = field.default;
+    }
+    if (field.derivedFrom) {
+        contract.derivedFrom = field.derivedFrom;
+    }
+    return contract;
+}
+function toEndpointContract(endpoint) {
+    return {
+        endpointKey: endpoint.endpointKey,
+        fields: endpoint.fields.map(toFieldContract),
+    };
+}
 export function buildHostedRequestSchemaReport(input) {
     switch (input.domain) {
         case 'research':
@@ -17,198 +51,85 @@ export function buildHostedRequestSchemaReport(input) {
             return buildMediaSchemaReport(input.endpointKey ?? null);
         case 'publish':
             return buildPublishSchemaReport();
-        case 'mobile':
-            return buildMobileSchemaReport();
     }
 }
 function buildResearchSchemaReport(collectionKey) {
-    if (collectionKey && !RESEARCH_COLLECTION_HINTS[collectionKey]) {
-        throw new Error(`Unknown research collection ${collectionKey}. Known collections: ${Object.keys(RESEARCH_COLLECTION_HINTS).join(', ')}`);
+    const collectionKeys = manifestTargetKeys('research', 'hosted-collection');
+    const sourceKeys = manifestTargetKeys('research', 'public-content-collection');
+    if (collectionKey && !collectionKeys.includes(collectionKey)) {
+        throw new Error(`Unknown research collection ${collectionKey}. Known collections: ${collectionKeys.join(', ')}`);
     }
-    const collectionInput = collectionKey
-        ? RESEARCH_COLLECTION_HINTS[collectionKey]
-        : {
-            maxItems: 20,
-            query: 'electric toothbrush morning routine',
-        };
     return {
         schemaVersion: 1,
         domain: 'research',
-        command: 'postplus research collect --skill <skill-id> --collection-key <key> --input <hosted-envelope.json> --output <result.json>; postplus research capability --request <hosted-capability-request.json> --output <result.json>',
+        command: 'postplus research collect <collection-key> --request <input.json> --output <result.json>; postplus research scrape <source-key> --request <input-array.json> --output <result.json>',
         description: 'Schemas for files passed to hosted research commands.',
-        collectionKeys: Object.keys(RESEARCH_COLLECTION_HINTS).sort(),
+        collectionKeys,
         selectedCollectionKey: collectionKey ?? undefined,
-        sourceKeys: Object.keys(PUBLIC_CONTENT_SOURCE_HINTS).sort(),
-        toolKeys: Object.keys(PUBLIC_CONTENT_DISCOVERY_TOOL_HINTS).sort(),
+        sourceKeys,
         notes: [
-            'The collection key stays in the CLI flag, not inside the JSON file.',
-            'Put the skill-specific provider input under input.',
-            'Use --run-handle for polling instead of this envelope.',
-            'Use research capability for public-content sourceKey and discovery tool requests.',
-            'The CLI derives operationId before sending capability requests to PostPlus Cloud.',
+            'collect / scrape input is an opaque provider-shaped JSON object the agent authors; the collection/source key stays on the CLI flag, not inside the file.',
+            'Use --run-handle with research collect for polling instead of a new launch.',
+            'Use research scrape <source-key> with a JSON array of records for public-content sources.',
+            'The CLI derives operationId before sending requests to PostPlus Cloud.',
         ],
         schemas: [
             {
-                id: 'research.collection-envelope',
-                description: 'Hosted research collection input envelope.',
-                required: ['schemaVersion', 'input'],
-                jsonSchema: {
-                    additionalProperties: false,
-                    properties: {
-                        hostedOperationId: OPERATION_ID_SCHEMA,
-                        input: JSON_OBJECT_SCHEMA,
-                        operationId: OPERATION_ID_SCHEMA,
-                        quoteConfirmationToken: {
-                            minLength: 1,
-                            type: 'string',
-                        },
-                        schemaVersion: {
-                            const: 1,
-                        },
-                    },
-                    required: ['schemaVersion', 'input'],
-                    type: 'object',
-                },
-            },
-            {
-                id: 'public-content-collection.scrape',
-                description: 'Collect public content from a released sourceKey.',
-                required: ['capability', 'operation', 'sourceKey', 'input'],
-                jsonSchema: {
-                    additionalProperties: false,
-                    properties: {
-                        capability: { const: 'public-content-collection' },
-                        input: {
-                            items: JSON_OBJECT_SCHEMA,
-                            minItems: 1,
-                            type: 'array',
-                        },
-                        operation: { const: 'scrape' },
-                        operationId: OPERATION_ID_SCHEMA,
-                        quoteConfirmationToken: {
-                            minLength: 1,
-                            type: 'string',
-                        },
-                        sourceKey: {
-                            enum: Object.keys(PUBLIC_CONTENT_SOURCE_HINTS).sort(),
-                            type: 'string',
-                        },
-                    },
-                    required: ['capability', 'operation', 'sourceKey', 'input'],
-                    type: 'object',
-                },
-            },
-            {
-                id: 'public-content-collection.status',
-                description: 'Poll a public-content collection job.',
-                required: ['capability', 'operation', 'handle'],
-                jsonSchema: {
-                    additionalProperties: false,
-                    properties: {
-                        capability: { const: 'public-content-collection' },
-                        handle: {
-                            minLength: 1,
-                            type: 'string',
-                        },
-                        operation: { const: 'status' },
-                        operationId: OPERATION_ID_SCHEMA,
-                    },
-                    required: ['capability', 'operation', 'handle'],
-                    type: 'object',
-                },
+                id: 'research.collection-input',
+                description: 'Hosted research collection input: the provider-shaped JSON object placed in --request <file>.',
+                required: [],
+                jsonSchema: JSON_OBJECT_SCHEMA,
             },
             {
-                id: 'public-content-discovery.tool-call',
-                description: 'Run a hosted public-content discovery tool.',
-                required: ['capability', 'operation', 'toolKey', 'args'],
+                id: 'public-content-collection.scrape-input',
+                description: 'Public-content scrape input: a non-empty JSON array of provider-shaped records placed in --request <file>.',
+                required: [],
                 jsonSchema: {
-                    additionalProperties: false,
-                    properties: {
-                        args: JSON_OBJECT_SCHEMA,
-                        capability: { const: 'public-content-discovery' },
-                        operation: { const: 'tool-call' },
-                        operationId: OPERATION_ID_SCHEMA,
-                        quoteConfirmationToken: {
-                            minLength: 1,
-                            type: 'string',
-                        },
-                        toolKey: {
-                            enum: Object.keys(PUBLIC_CONTENT_DISCOVERY_TOOL_HINTS).sort(),
-                            type: 'string',
-                        },
-                    },
-                    required: ['capability', 'operation', 'toolKey', 'args'],
-                    type: 'object',
+                    items: JSON_OBJECT_SCHEMA,
+                    minItems: 1,
+                    type: 'array',
                 },
             },
         ],
-        examples: {
-            'research.collection-envelope': {
-                schemaVersion: 1,
-                input: collectionInput,
-            },
-            'public-content-collection.scrape': {
-                capability: 'public-content-collection',
-                operation: 'scrape',
-                sourceKey: 'youtube-videos',
-                input: PUBLIC_CONTENT_SOURCE_HINTS['youtube-videos'],
-            },
-            'public-content-collection.status': {
-                capability: 'public-content-collection',
-                operation: 'status',
-                handle: '<output.data.id>',
-            },
-            'public-content-discovery.tool-call': {
-                capability: 'public-content-discovery',
-                operation: 'tool-call',
-                toolKey: 'web-search',
-                args: PUBLIC_CONTENT_DISCOVERY_TOOL_HINTS['web-search'],
-            },
-        },
     };
 }
 function buildMediaSchemaReport(endpointKey) {
-    if (endpointKey && !MEDIA_ENDPOINT_HINTS[endpointKey]) {
-        throw new Error(`Unknown media endpoint ${endpointKey}. Known endpoints: ${Object.keys(MEDIA_ENDPOINT_HINTS).join(', ')}`);
+    const endpointKeys = manifestTargetKeys('media', 'media-generation');
+    const modelKeys = manifestTargetKeys('media', 'video-analysis');
+    if (endpointKey && !endpointKeys.includes(endpointKey)) {
+        throw new Error(`Unknown media endpoint ${endpointKey}. Known endpoints: ${endpointKeys.join(', ')}`);
     }
-    const endpointInput = endpointKey
-        ? MEDIA_ENDPOINT_HINTS[endpointKey]
-        : {
-            prompt: 'A realistic vertical short-form product reveal.',
-        };
-    const selectedEndpoint = endpointKey ?? '<endpoint-key>';
+    // When an endpoint is selected, narrow to that one field contract; otherwise
+    // publish every modelled endpoint's field contract.
+    const endpoints = endpointKey
+        ? [toEndpointContract(requireMediaEndpoint(endpointKey))]
+        : endpointKeys.map((key) => toEndpointContract(requireMediaEndpoint(key)));
     return {
         schemaVersion: 1,
         domain: 'media',
-        command: 'postplus media capability --request <hosted-capability-request.json> --output <result.json>',
-        description: 'Schemas for files passed to postplus media capability --request.',
-        endpointKeys: Object.keys(MEDIA_ENDPOINT_HINTS).sort(),
-        modelKeys: Object.keys(VIDEO_ANALYSIS_MODEL_HINTS).sort(),
+        command: 'postplus media <verb> <endpoint-key> --request <input.json> | --<flags> --output <result.json>',
+        description: 'Schemas for files passed to hosted media commands.',
+        endpointKeys,
+        modelKeys,
         selectedEndpointKey: endpointKey ?? undefined,
         notes: [
-            'Use media-generation request for async generation, transcription, and voice jobs.',
-            'Use media-generation status with the output.data.id handle returned by a pending request.',
-            'Use media-file operations for upload/download setup when a workflow needs hosted media storage.',
-            'Use video-analysis analyze for Gemini video understanding payloads.',
+            'Each media-generation endpoint declares its fields as intent (you write it), default (manifest-defaulted; write only to deviate), or runner-managed (minted by the CLI; no flag, never in the body).',
+            'Endpoint-specific input belongs under input; capability / endpointKey come from the verb + positional, not the body.',
+            'video-analysis analyze takes an opaque Gemini request object the agent authors verbatim under payload.',
             'The CLI derives operationId and billing dimensions before sending requests to PostPlus Cloud.',
-            'Endpoint-specific input belongs under input; top-level provider or billing fields are not public contract fields.',
+            'Run `postplus media <verb> <endpoint-key> --help` for a single endpoint flag/enum/default breakdown.',
         ],
         schemas: [
             {
                 id: 'media-generation.request',
                 description: 'Submit an async media generation/transcription job.',
-                required: [
-                    'capability',
-                    'operation',
-                    'endpointKey',
-                    'input',
-                ],
+                required: ['capability', 'operation', 'endpointKey', 'input'],
                 jsonSchema: {
                     additionalProperties: false,
                     properties: {
                         capability: { const: 'media-generation' },
                         endpointKey: {
-                            minLength: 1,
+                            enum: endpointKeys,
                             type: 'string',
                         },
                         input: JSON_OBJECT_SCHEMA,
@@ -219,37 +140,37 @@ function buildMediaSchemaReport(endpointKey) {
                             type: 'string',
                         },
                     },
-                    required: [
-                        'capability',
-                        'operation',
-                        'endpointKey',
-                        'input',
-                    ],
+                    required: ['capability', 'operation', 'endpointKey', 'input'],
                     type: 'object',
                 },
             },
             {
-                id: 'media-generation.status',
-                description: 'Poll an async media generation/transcription job.',
-                required: ['capability', 'operation', 'handle'],
+                id: 'video-analysis.analyze',
+                description: 'Run hosted Gemini video analysis.',
+                required: ['capability', 'operation', 'modelKey', 'payload'],
                 jsonSchema: {
                     additionalProperties: false,
                     properties: {
-                        capability: { const: 'media-generation' },
-                        handle: {
-                            minLength: 1,
+                        capability: { const: 'video-analysis' },
+                        modelKey: {
+                            enum: modelKeys,
                             type: 'string',
                         },
-                        operation: { const: 'status' },
+                        operation: { const: 'analyze' },
                         operationId: OPERATION_ID_SCHEMA,
+                        payload: JSON_OBJECT_SCHEMA,
+                        quoteConfirmationToken: {
+                            minLength: 1,
+                            type: 'string',
+                        },
                     },
-                    required: ['capability', 'operation', 'handle'],
+                    required: ['capability', 'operation', 'modelKey', 'payload'],
                     type: 'object',
                 },
             },
             {
                 id: 'media-file.create-upload-url',
-                description: 'Create a hosted media upload target.',
+                description: 'Create a hosted media upload target via `postplus media-file upload`.',
                 required: ['capability', 'operation', 'file'],
                 jsonSchema: {
                     additionalProperties: false,
@@ -276,72 +197,91 @@ function buildMediaSchemaReport(endpointKey) {
                     type: 'object',
                 },
             },
-            {
-                id: 'video-analysis.analyze',
-                description: 'Run hosted Gemini video analysis.',
-                required: ['capability', 'operation', 'modelKey', 'payload'],
-                jsonSchema: {
-                    additionalProperties: false,
-                    properties: {
-                        capability: { const: 'video-analysis' },
-                        estimatedUsage: JSON_OBJECT_SCHEMA,
-                        modelKey: {
-                            enum: Object.keys(VIDEO_ANALYSIS_MODEL_HINTS).sort(),
-                            type: 'string',
-                        },
-                        operation: { const: 'analyze' },
-                        operationId: OPERATION_ID_SCHEMA,
-                        payload: JSON_OBJECT_SCHEMA,
-                        quoteConfirmationToken: {
-                            minLength: 1,
-                            type: 'string',
-                        },
-                    },
-                    required: ['capability', 'operation', 'modelKey', 'payload'],
-                    type: 'object',
-                },
-            },
         ],
-        examples: {
-            'media-generation.request': {
-                capability: 'media-generation',
-                operation: 'request',
-                endpointKey: selectedEndpoint,
-                input: endpointInput,
-            },
-            'media-generation.status': {
-                capability: 'media-generation',
-                operation: 'status',
-                handle: '<output.data.id>',
-            },
-            'media-file.create-upload-url': {
-                capability: 'media-file',
-                operation: 'create-upload-url',
-                file: {
-                    mimeType: 'video/mp4',
-                    name: 'input.mp4',
-                    sizeBytes: 1048576,
-                },
-            },
-            'video-analysis.analyze': {
-                capability: 'video-analysis',
-                operation: 'analyze',
-                modelKey: 'gemini-video-analysis',
-                payload: VIDEO_ANALYSIS_MODEL_HINTS['gemini-video-analysis'],
-            },
-        },
+        endpoints,
     };
 }
+function requireMediaEndpoint(endpointKey) {
+    const endpoint = findMediaEndpoint(endpointKey);
+    if (!endpoint) {
+        throw new Error(`hosted-request-schemas: ${endpointKey} is not a modelled media-generation endpoint.`);
+    }
+    return endpoint;
+}
+const MANIFEST_FIELD_DEFAULTS = buildManifestFieldDefaults();
+const MANIFEST_DERIVED_DIMENSIONS = buildManifestDerivedDimensions();
+function buildManifestFieldDefaults() {
+    const index = new Map();
+    for (const key of manifestTargetKeys('media', 'media-generation')) {
+        const endpoint = findMediaEndpoint(key);
+        if (!endpoint) {
+            continue;
+        }
+        const byField = new Map();
+        for (const field of endpoint.fields) {
+            if (field.default !== undefined) {
+                byField.set(field.name, field.default);
+            }
+        }
+        index.set(key, byField);
+    }
+    return index;
+}
+function manifestFieldDefault(endpointKey, fieldName) {
+    return MANIFEST_FIELD_DEFAULTS.get(endpointKey)?.get(fieldName);
+}
+function buildManifestDerivedDimensions() {
+    const index = new Map();
+    for (const key of manifestTargetKeys('media', 'media-generation')) {
+        const endpoint = findMediaEndpoint(key);
+        if (!endpoint) {
+            continue;
+        }
+        const derived = endpoint.fields.flatMap((field) => field.class === 'runner-managed' && field.derivedFrom
+            ? [{ fieldName: field.name, sourceName: field.derivedFrom }]
+            : []);
+        if (derived.length > 0) {
+            index.set(key, derived);
+        }
+    }
+    return index;
+}
 export function buildMediaGenerationRequestDimensions(endpointKey, input) {
     const dimensions = {
         billableUnitCount: 1,
         operationKey: endpointKey,
     };
+    for (const derived of MANIFEST_DERIVED_DIMENSIONS.get(endpointKey) ?? []) {
+        const value = input[derived.sourceName] ??
+            manifestFieldDefault(endpointKey, derived.sourceName);
+        if (value !== undefined) {
+            dimensions[derived.fieldName] = value;
+        }
+    }
+    if (endpointKey.startsWith('image-')) {
+        const resolution = typeof input.resolution === 'string' && input.resolution.trim()
+            ? input.resolution.trim()
+            : manifestFieldDefault(endpointKey, 'resolution');
+        const quality = typeof input.quality === 'string' && input.quality.trim()
+            ? input.quality.trim()
+            : manifestFieldDefault(endpointKey, 'quality');
+        if (typeof resolution === 'string') {
+            dimensions.imageSize = resolution;
+        }
+        if (typeof quality === 'string') {
+            dimensions.quality = quality;
+        }
+    }
     if (endpointKey.startsWith('video-')) {
-        const duration = readPositiveNumber(input.duration) ?? 5;
+        const manifestResolution = manifestFieldDefault(endpointKey, 'resolution');
+        const duration = readPositiveNumber(input.duration) ??
+            readPositiveNumber(manifestFieldDefault(endpointKey, 'duration')) ??
+            5;
         const resolution = typeof input.resolution === 'string' && input.resolution.trim()
             ? input.resolution.trim()
-            : '720p';
+            : typeof manifestResolution === 'string'
+                ? manifestResolution
+                : '720p';
         dimensions.audioMode =
             endpointKey.startsWith('video-kling-v3-0-') && input.sound !== true
                 ? 'off'
@@ -376,14 +316,16 @@ function readPositiveNumber(value) {
     return value;
 }
 function buildPublishSchemaReport() {
+    const operations = manifestTargetKeys('publish', 'social-publishing');
     return {
         schemaVersion: 1,
         domain: 'publish',
-        command: 'postplus publish capability --request <hosted-capability-request.json> --output <result.json>',
-        description: 'Schema for files passed to postplus publish capability --request.',
+        command: 'postplus publish <operation> --request <input.json> --output <result.json>',
+        description: 'Schema for files passed to hosted publish commands.',
+        operations,
         notes: [
-            'Use social-publishing operations only through PostPlus Cloud.',
-            'Put the operation-specific publishing payload under input.',
+            'The operation is BOTH the CLI subcommand and the target; the operation-specific publishing payload goes under input in --request <file>.',
+            'Side-effecting operations may surface a quote-confirmation challenge; replay the fixed confirm/retry commands.',
         ],
         schemas: [
             {
@@ -396,93 +338,7 @@ function buildPublishSchemaReport() {
                         capability: { const: 'social-publishing' },
                         input: JSON_OBJECT_SCHEMA,
                         operation: {
-                            enum: [
-                                'analytics',
-                                'channel-settings',
-                                'create-post',
-                                'delete-post',
-                                'delete-post-group',
-                                'list-channels',
-                                'list-posts',
-                                'missing-content',
-                                'notifications',
-                                'set-release-id',
-                                'trigger-channel-tool',
-                                'update-post-status',
-                                'upload-file',
-                                'upload-from-url',
-                            ],
-                            type: 'string',
-                        },
-                        operationId: OPERATION_ID_SCHEMA,
-                        quoteConfirmationToken: {
-                            minLength: 1,
-                            type: 'string',
-                        },
-                    },
-                    required: ['capability', 'operation', 'input'],
-                    type: 'object',
-                },
-            },
-        ],
-        examples: {
-            'social-publishing.list-channels': {
-                capability: 'social-publishing',
-                operation: 'list-channels',
-                input: {},
-            },
-            'social-publishing.create-post': {
-                capability: 'social-publishing',
-                operation: 'create-post',
-                input: {
-                    body: {
-                        posts: [],
-                    },
-                },
-            },
-        },
-    };
-}
-function buildMobileSchemaReport() {
-    return {
-        schemaVersion: 1,
-        domain: 'mobile',
-        command: 'postplus mobile capability --request <hosted-capability-request.json> --output <result.json>',
-        description: 'Schema for files passed to postplus mobile capability --request.',
-        notes: [
-            'Use mobile-automation operations only through PostPlus Cloud.',
-            'Put the operation-specific mobile automation payload under input.',
-        ],
-        schemas: [
-            {
-                id: 'mobile-automation.request',
-                description: 'Run a hosted mobile automation operation.',
-                required: ['capability', 'operation', 'input'],
-                jsonSchema: {
-                    additionalProperties: false,
-                    properties: {
-                        capability: { const: 'mobile-automation' },
-                        input: JSON_OBJECT_SCHEMA,
-                        operation: {
-                            enum: [
-                                'cancel-tasks',
-                                'create-cloud-phones',
-                                'install-app',
-                                'list-cloud-phones',
-                                'list-installed-apps',
-                                'list-installable-apps',
-                                'query-phone-status',
-                                'query-tasks',
-                                'start-app',
-                                'start-cloud-phones',
-                                'stop-cloud-phones',
-                                'task-detail',
-                                'tiktok-login',
-                                'tiktok-publish-image-set',
-                                'tiktok-publish-video',
-                                'tiktok-warmup',
-                                'uninstall-app',
-                            ],
+                            enum: operations,
                             type: 'string',
                         },
                         operationId: OPERATION_ID_SCHEMA,
@@ -496,12 +352,5 @@ function buildMobileSchemaReport() {
                 },
             },
         ],
-        examples: {
-            'mobile-automation.list-cloud-phones': {
-                capability: 'mobile-automation',
-                operation: 'list-cloud-phones',
-                input: {},
-            },
-        },
     };
 }

package/build/index.js

@@ -7,7 +7,7 @@ import { formatAuthValidateReport, validateRemoteAuth, } from './auth-validate.j
 import { clearAuthState, formatAuthStatusReport, generateAuthStatusReport, } from './auth.js';
 import { readCurrentCliVersion } from './client-compatibility.js';
 import { formatDoctorReport, generateDoctorReport } from './doctor.js';
-import { runHostedDomainCommand } from './hosted-domain-commands.js';
+import { runHostedDomainCommand, runMediaFileCommand, } from './hosted-domain-commands.js';
 import { assertConfigFilePermissions } from './local-state.js';
 import { QUOTE_AUTO_CONFIRM_UNDER_ENV, QuoteAutoConfirmCeilingExceededError, QuoteConfirmationNonInteractiveError, confirmLargeCreditQuote, readLargeCreditQuoteConfirmationChallenge, resolveLargeCreditQuoteConfirmation, } from './quote-confirmation.js';
 import { POSTPLUS_SKILLS_CURRENT_DIRECTORY_INSTALL_COMMAND, POSTPLUS_SKILLS_INSTALL_COMMAND, formatPostPlusSkillsInstallCommand, loadPublicSkillCatalog, } from './skill-catalog.js';
@@ -44,13 +44,13 @@ Usage:
   postplus auth logout [--json]
   postplus doctor [--skill <skill-id>] [--json]
   postplus research schema [--collection-key <key>] [--json]
-  postplus research collect --skill <skill-id> --collection-key <key> --input <hosted-envelope.json> [--output <result.json>]
+  postplus research collect <collection-key> --request <input.json> [--skill <skill-id>] [--output <result.json>]
+  postplus research scrape <source-key> --request <input-array.json> [--skill <skill-id>] [--output <result.json>]
   postplus media schema [--endpoint <endpoint-key>] [--json]
-  postplus media capability --request <hosted-capability-request.json> [--output <result.json>]
+  postplus media <verb> <endpoint-key> --request <input.json> | --<flags> [--output <result.json>]
+  postplus media-file upload --input-file <path> [--mime <type>] [--skill <skill-id>] [--output <result.json>]
   postplus publish schema [--json]
-  postplus publish capability --request <hosted-capability-request.json> [--output <result.json>]
-  postplus mobile schema [--json]
-  postplus mobile capability --request <hosted-capability-request.json> [--output <result.json>]
+  postplus publish <operation> --request <input.json> [--output <result.json>]
   postplus quote confirm --json --challenge-file <path> [--auto-confirm-under <millicredits>]
   postplus skills verify [--json]
   postplus studio init|open|status   Open bundled Local Studio
@@ -417,12 +417,12 @@ async function main() {
         case 'media':
             process.exitCode = await runHostedDomainCommand('media', rest);
             return;
+        case 'media-file':
+            process.exitCode = await runMediaFileCommand(rest);
+            return;
         case 'publish':
             process.exitCode = await runHostedDomainCommand('publish', rest);
             return;
-        case 'mobile':
-            process.exitCode = await runHostedDomainCommand('mobile', rest);
-            return;
         case 'quote':
             process.exitCode = await runQuoteCommand(rest);
             return;