@postplus/cli 0.1.27 → 0.1.28

package/build/doctor.js

@@ -2,6 +2,7 @@ import { resolveFreshRemoteAuth, } from './auth-session.js';
 import { buildPostPlusClientCompatibilityHeaders, formatPostPlusCompatibilityError, } from './client-compatibility.js';
 import { resolveHostedBaseUrl } from './hosted-release.js';
 import { formatLocalDependencyReport, generateLocalDependencyReport, } from './local-dependencies.js';
+import { loadPublicSkillCatalog, } from './skill-catalog.js';
 import { readSubscriptionStatusField } from './subscription-status.js';
 function createPass(id, label, detail, severity = 'required') {
     return {
@@ -23,12 +24,16 @@ function createFail(id, label, detail, fix, input = {}) {
         metadata: input.metadata,
     };
 }
-export async function generateDoctorReport() {
+export async function generateDoctorReport(options = {}) {
     const hostedBaseUrl = await resolveHostedBaseUrl();
     const checks = [
         createPass('hosted_base_url', 'PostPlus Cloud', `Using ${hostedBaseUrl ?? 'https://postplus.io'}`),
     ];
-    checks.push(await checkLocalDependencies());
+    const skillScope = await resolveSkillScope(options.skillId);
+    if (skillScope) {
+        checks.push(createPass('skill_catalog', 'Skill selection', `Using ${skillScope.skill.skillId} from catalog ${skillScope.catalog.releaseId}`));
+    }
+    checks.push(await checkLocalDependencies(skillScope));
     if (!hostedBaseUrl) {
         checks.push(createFail('remote_auth', 'Remote auth', 'PostPlus Cloud base URL could not be resolved.', 'Configure POSTPLUS_API_BASE_URL or run `postplus auth login`.'));
         return buildDoctorReport(checks);
@@ -46,17 +51,40 @@ export async function generateDoctorReport() {
     const authCheck = await checkRemoteAuth(auth);
     checks.push(authCheck);
     if (authCheck.status === 'pass') {
-        checks.push(await checkHostedCapabilities(auth));
+        checks.push(await checkHostedCapabilities(auth, skillScope));
+    }
+    return buildDoctorReport(checks, options.skillId);
+}
+async function resolveSkillScope(skillId) {
+    if (!skillId) {
+        return null;
+    }
+    const catalog = await loadPublicSkillCatalog();
+    const skill = catalog.skills.find((entry) => entry.skillId === skillId);
+    if (!skill) {
+        throw new Error(`Unknown PostPlus skill: ${skillId}. Run \`postplus list\` to see released skill ids.`);
     }
-    return buildDoctorReport(checks);
+    return { catalog, skill };
 }
-async function checkLocalDependencies() {
+async function checkLocalDependencies(skillScope) {
     try {
-        const report = await generateLocalDependencyReport();
+        const report = await generateLocalDependencyReport(skillScope
+            ? {
+                loadCatalog: async () => ({
+                    ...skillScope.catalog,
+                    skills: [skillScope.skill],
+                }),
+            }
+            : {});
         const detail = formatLocalDependencyReport(report);
         if (!report.ok) {
-            return createFail('local_dependencies', 'Task-specific local media dependencies', detail, 'Run the affected PostPlus skill in a local agent. The installed postplus-shared rules tell the agent how to bootstrap approved missing media dependencies.', {
-                severity: 'task_specific',
+            const skillId = skillScope?.skill.skillId;
+            return createFail('local_dependencies', skillId
+                ? `Local dependencies for ${skillId}`
+                : 'Task-specific local media dependencies', detail, skillId
+                ? 'Run the selected PostPlus skill in a local agent. The installed postplus-shared rules tell the agent how to bootstrap approved missing dependencies.'
+                : 'Run the affected PostPlus skill in a local agent. The installed postplus-shared rules tell the agent how to bootstrap approved missing media dependencies.', {
+                severity: skillId ? 'required' : 'task_specific',
                 metadata: {
                     bootstrapRule: 'postplus-shared',
                     missingDependencies: report.checks
@@ -69,7 +97,9 @@ async function checkLocalDependencies() {
                 },
             });
         }
-        return createPass('local_dependencies', 'Local dependencies', detail);
+        return createPass('local_dependencies', skillScope
+            ? `Local dependencies for ${skillScope.skill.skillId}`
+            : 'Local dependencies', detail);
     }
     catch (error) {
         return createFail('local_dependencies', 'Local dependencies', error instanceof Error
@@ -77,13 +107,14 @@ async function checkLocalDependencies() {
             : 'Failed to check local dependencies.');
     }
 }
-function buildDoctorReport(checks) {
+function buildDoctorReport(checks, skillId) {
     const requiredOk = checks.every((check) => check.severity !== 'required' || check.status === 'pass');
     return {
         schemaVersion: 1,
         ok: checks.every((check) => check.status === 'pass'),
         requiredOk,
         checks,
+        ...(skillId ? { skillId } : {}),
     };
 }
 async function checkRemoteAuth(input) {
@@ -114,7 +145,7 @@ async function checkRemoteAuth(input) {
             : 'Failed to validate PostPlus Cloud auth.', 'Run `postplus auth validate` after confirming network access.');
     }
 }
-async function checkHostedCapabilities(input) {
+async function checkHostedCapabilities(input, skillScope) {
     try {
         let response = await requestWithAuth(input, '/api/postplus-cli/hosted/readiness');
         if (response.status === 401) {
@@ -127,17 +158,28 @@ async function checkHostedCapabilities(input) {
         if (!response.ok) {
             return createFail('hosted_capabilities', 'Hosted capabilities', readErrorMessage(payload, 'PostPlus Cloud hosted readiness check failed.'));
         }
-        const capabilities = Array.isArray(payload.capabilities)
-            ? payload.capabilities
-            : [];
-        const failedLabels = capabilities
-            .map(readCapabilityFailureLabel)
+        const capabilities = readHostedCapabilityEntries(payload.capabilities);
+        const relevantCapabilities = skillScope
+            ? filterCapabilitiesForSkill(capabilities, skillScope.skill.requirements)
+            : capabilities;
+        const failedLabels = relevantCapabilities
+            .map((value) => readCapabilityFailureLabel(value, skillScope))
             .filter((value) => value !== null);
-        if (payload.ok !== true || failedLabels.length > 0) {
-            return createFail('hosted_capabilities', 'Hosted capabilities', `Not ready: ${failedLabels.join(', ') || 'unknown capability failure'}`, 'Check PostPlus Cloud provider configuration and subscription state.');
+        if (skillScope && hasHostedRequirements(skillScope.skill.requirements)) {
+            const missingRequirements = collectMissingHostedRequirementLabels(relevantCapabilities, skillScope.skill.requirements);
+            failedLabels.push(...missingRequirements);
+        }
+        if (failedLabels.length > 0 ||
+            (!skillScope && payload.ok !== true && capabilities.length === 0)) {
+            const skillId = skillScope?.skill.skillId;
+            return createFail('hosted_capabilities', skillId ? `Hosted capabilities for ${skillId}` : 'Hosted capabilities', `Not ready: ${failedLabels.join(', ') || 'unknown capability failure'}`, 'Check PostPlus Cloud provider configuration and subscription state.', {
+                severity: skillId ? 'required' : 'task_specific',
+            });
         }
         const subscription = readSubscriptionStatusField(payload).label;
-        return createPass('hosted_capabilities', 'Hosted capabilities', `Ready (${capabilities.length} capability checks passed; subscription ${subscription})`);
+        return createPass('hosted_capabilities', skillScope
+            ? `Hosted capabilities for ${skillScope.skill.skillId}`
+            : 'Hosted capabilities', `Ready (${relevantCapabilities.length} capability checks passed; subscription ${subscription})`);
     }
     catch (error) {
         return createFail('hosted_capabilities', 'Hosted capabilities', error instanceof Error
@@ -145,7 +187,13 @@ async function checkHostedCapabilities(input) {
             : 'Failed to check hosted capability readiness.');
     }
 }
-function readCapabilityFailureLabel(value) {
+function readHostedCapabilityEntries(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((entry) => !!entry && typeof entry === 'object' && !Array.isArray(entry));
+}
+function readCapabilityFailureLabel(value, skillScope) {
     if (!value || typeof value !== 'object') {
         return 'invalid capability response';
     }
@@ -163,9 +211,12 @@ function readCapabilityFailureLabel(value) {
             .map(readReadinessCheckFailureLabel)
             .filter((check) => check !== null)
         : [];
-    return failedChecks.length > 0
+    const labelWithFailures = failedChecks.length > 0
         ? `${label} (${failedChecks.join(', ')})`
         : label;
+    return skillScope
+        ? `${labelWithFailures} for ${skillScope.skill.skillId}`
+        : labelWithFailures;
 }
 function readReadinessCheckFailureLabel(value) {
     if (!value || typeof value !== 'object') {
@@ -181,6 +232,128 @@ function readReadinessCheckFailureLabel(value) {
             ? record.id
             : 'unknown check';
 }
+function filterCapabilitiesForSkill(capabilities, requirements) {
+    if (!hasHostedRequirements(requirements)) {
+        return [];
+    }
+    return capabilities.filter((capability) => capabilityMatchesRequirements(capability, requirements));
+}
+function capabilityMatchesRequirements(capability, requirements) {
+    const identifiers = collectCapabilityIdentifiers(capability);
+    const hostedCapabilities = new Set(requirements.hostedCapabilities);
+    const requirementKeys = collectHostedRequirementKeys(requirements);
+    return identifiers.some((identifier) => {
+        if (identifier === 'media-file:upload' &&
+            hostedCapabilities.has('media-file') &&
+            !requiresHostedMediaFileUpload(requirements)) {
+            return false;
+        }
+        const [prefix, suffix] = splitCapabilityIdentifier(identifier);
+        if (prefix === 'media-file' &&
+            suffix &&
+            suffix !== 'upload' &&
+            hostedCapabilities.has('media-file')) {
+            return true;
+        }
+        if (hostedCapabilities.has(identifier)) {
+            return true;
+        }
+        if (prefix &&
+            suffix &&
+            hostedCapabilities.has(prefix) &&
+            requirementKeys.has(suffix)) {
+            return true;
+        }
+        return requirementKeys.has(identifier) || requirementKeys.has(suffix);
+    });
+}
+function requiresHostedMediaFileUpload(requirements) {
+    return (requirements.hostedCapabilities.includes('media-generation') ||
+        requirements.endpointKeys.length > 0);
+}
+function collectCapabilityIdentifiers(capability) {
+    const identifiers = new Set();
+    for (const key of [
+        'id',
+        'key',
+        'capability',
+        'capabilityKey',
+        'collectionKey',
+        'endpointKey',
+        'modelKey',
+        'sourceKey',
+        'accountConnection',
+    ]) {
+        const value = capability[key];
+        if (typeof value === 'string' && value.trim()) {
+            identifiers.add(value.trim());
+        }
+    }
+    if (Array.isArray(capability.checks)) {
+        for (const check of capability.checks) {
+            if (!check || typeof check !== 'object' || Array.isArray(check)) {
+                continue;
+            }
+            for (const identifier of collectCapabilityIdentifiers(check)) {
+                identifiers.add(identifier);
+            }
+        }
+    }
+    return [...identifiers];
+}
+function collectHostedRequirementKeys(requirements) {
+    return new Set([
+        ...requirements.accountConnections,
+        ...requirements.collectionKeys,
+        ...requirements.endpointKeys,
+        ...requirements.modelKeys,
+        ...requirements.sourceKeys,
+    ]);
+}
+function hasHostedRequirements(requirements) {
+    return (requirements.accountConnections.length > 0 ||
+        requirements.collectionKeys.length > 0 ||
+        requirements.endpointKeys.length > 0 ||
+        requirements.hostedCapabilities.length > 0 ||
+        requirements.modelKeys.length > 0 ||
+        requirements.sourceKeys.length > 0);
+}
+function collectMissingHostedRequirementLabels(capabilities, requirements) {
+    const availableIdentifiers = new Set(capabilities.flatMap(collectCapabilityIdentifiers));
+    const missing = [];
+    for (const capability of requirements.hostedCapabilities) {
+        if (![...availableIdentifiers].some((identifier) => identifierMatchesCapability(identifier, capability))) {
+            missing.push(capability);
+        }
+    }
+    for (const key of collectHostedRequirementKeys(requirements)) {
+        if (![...availableIdentifiers].some((identifier) => identifierMatchesKey(identifier, key))) {
+            missing.push(key);
+        }
+    }
+    return missing.map((value) => `${value} readiness check missing`);
+}
+function identifierMatchesKey(identifier, key) {
+    if (identifier === key) {
+        return true;
+    }
+    const [, suffix] = splitCapabilityIdentifier(identifier);
+    return suffix === key;
+}
+function identifierMatchesCapability(identifier, capability) {
+    if (identifier === capability) {
+        return true;
+    }
+    const [prefix] = splitCapabilityIdentifier(identifier);
+    return prefix === capability;
+}
+function splitCapabilityIdentifier(identifier) {
+    const index = identifier.indexOf(':');
+    if (index === -1) {
+        return [null, identifier];
+    }
+    return [identifier.slice(0, index), identifier.slice(index + 1)];
+}
 function readErrorMessage(payload, fallback) {
     const compatibilityError = formatPostPlusCompatibilityError(payload);
     if (compatibilityError) {

package/build/index.js

@@ -37,11 +37,11 @@ Usage:
   postplus auth status [--json]
   postplus auth validate [--json]
   postplus auth logout [--json]
-  postplus doctor [--json]
+  postplus doctor [--skill <skill-id>] [--json]
   postplus update
   postplus uninstall
   postplus list [--json]
-  postplus status [--json]
+  postplus status [--skill <skill-id>] [--json]
   postplus version
   postplus help
 
@@ -49,15 +49,15 @@ Skills:
   ${POSTPLUS_SKILLS_INSTALL_COMMAND}
 `);
 }
-async function runDoctor(json) {
-    const report = await generateDoctorReport();
-    if (json) {
+async function runDoctor(options) {
+    const report = await generateDoctorReport({ skillId: options.skillId });
+    if (options.json) {
         writeJson(report);
     }
     else {
         process.stdout.write(`${formatDoctorReport(report)}\n`);
     }
-    return report.ok ? 0 : 1;
+    return report.requiredOk ? 0 : 1;
 }
 async function runAuthStatus(json) {
     const report = await generateAuthStatusReport();
@@ -69,9 +69,9 @@ async function runAuthStatus(json) {
     }
     return report.ok ? 0 : 1;
 }
-async function runStatus(json) {
-    const report = await generateStatusReport();
-    if (json) {
+async function runStatus(options) {
+    const report = await generateStatusReport({ skillId: options.skillId });
+    if (options.json) {
         writeJson(report);
     }
     else {
@@ -119,6 +119,29 @@ async function runSkillUninstallCommand() {
 function writeJson(value) {
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
+function parseDiagnosticOptions(args) {
+    const options = {
+        json: false,
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--json') {
+            options.json = true;
+            continue;
+        }
+        if (arg === '--skill') {
+            const skillId = args[index + 1];
+            if (!skillId || skillId.startsWith('--')) {
+                throw new Error('Missing value for --skill.');
+            }
+            options.skillId = skillId;
+            index += 1;
+            continue;
+        }
+        throw new Error(`Unknown option for diagnostics command: ${arg}`);
+    }
+    return options;
+}
 async function runAuthLogout(json) {
     const report = await clearAuthState();
     if (json) {
@@ -199,7 +222,7 @@ async function main() {
             return;
         }
         case 'doctor':
-            process.exitCode = await runDoctor(json);
+            process.exitCode = await runDoctor(parseDiagnosticOptions(rest));
             return;
         case 'install':
             process.stderr.write(`PostPlus CLI does not install skills directly. Run \`${POSTPLUS_SKILLS_INSTALL_COMMAND}\`.\n`);
@@ -215,7 +238,7 @@ async function main() {
             process.exitCode = await runList(json);
             return;
         case 'status':
-            process.exitCode = await runStatus(json);
+            process.exitCode = await runStatus(parseDiagnosticOptions(rest));
             return;
         case 'auth': {
             const [subcommand, ...authRest] = rest;

package/build/skill-catalog.js

@@ -15,6 +15,15 @@ export const POSTPLUS_SKILLS_INSTALL_COMMAND = formatPostPlusSkillsInstallComman
 export const POSTPLUS_SKILLS_LIST_COMMAND = formatPostPlusSkillsListCommand();
 const POSTPLUS_SKILLS_INDEX_URL = 'https://raw.githubusercontent.com/PostPlusAI/postplus-skills/main/skills/INDEX.md';
 const POSTPLUS_SKILLS_CATALOG_URL = 'https://raw.githubusercontent.com/PostPlusAI/postplus-skills/main/skills/catalog.json';
+export const PUBLIC_SKILL_REQUIREMENT_KEYS = [
+    'accountConnections',
+    'collectionKeys',
+    'endpointKeys',
+    'hostedCapabilities',
+    'localDependencies',
+    'modelKeys',
+    'sourceKeys',
+];
 export async function loadPublicSkillCatalog(fetchFn = fetch, env = process.env) {
     const catalogUrl = resolvePostPlusSkillsCatalogUrl(env);
     const skillsSource = resolvePostPlusSkillsSource(env);
@@ -95,17 +104,7 @@ function parsePublicSkillCatalog(payload) {
         const path = typeof skill.path === 'string' && skill.path.trim()
             ? skill.path.trim()
             : null;
-        const requirements = skill.requirements &&
-            typeof skill.requirements === 'object' &&
-            !Array.isArray(skill.requirements)
-            ? skill.requirements
-            : {};
-        const localDependencies = Array.isArray(requirements.localDependencies)
-            ? requirements.localDependencies
-                .filter((value) => typeof value === 'string')
-                .map((value) => value.trim())
-                .filter(Boolean)
-            : [];
+        const requirements = parsePublicSkillRequirements(skill.requirements);
         const status = typeof skill.status === 'string' ? skill.status.trim() : '';
         if (!skillId ||
             !path ||
@@ -113,9 +112,10 @@ function parsePublicSkillCatalog(payload) {
             throw new Error('PostPlus public skill catalog has an invalid skill.');
         }
         return {
-            localDependencies,
+            localDependencies: requirements.localDependencies,
             skillId,
             path,
+            requirements,
         };
     });
     if (skills.length === 0) {
@@ -127,3 +127,40 @@ function parsePublicSkillCatalog(payload) {
         source,
     };
 }
+function parsePublicSkillRequirements(value) {
+    if (value === undefined) {
+        return createEmptyRequirements();
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('PostPlus public skill catalog has invalid skill requirements.');
+    }
+    const record = value;
+    const requirements = createEmptyRequirements();
+    for (const key of PUBLIC_SKILL_REQUIREMENT_KEYS) {
+        const raw = record[key];
+        if (raw === undefined) {
+            continue;
+        }
+        if (!Array.isArray(raw)) {
+            throw new Error(`PostPlus public skill catalog has invalid ${key} requirements.`);
+        }
+        requirements[key] = raw.map((item) => {
+            if (typeof item !== 'string' || !item.trim()) {
+                throw new Error(`PostPlus public skill catalog has invalid ${key} requirements.`);
+            }
+            return item.trim();
+        });
+    }
+    return requirements;
+}
+function createEmptyRequirements() {
+    return {
+        accountConnections: [],
+        collectionKeys: [],
+        endpointKeys: [],
+        hostedCapabilities: [],
+        localDependencies: [],
+        modelKeys: [],
+        sourceKeys: [],
+    };
+}

package/build/status.js

@@ -3,17 +3,17 @@ import { writeCurrentCliVersionToLocalConfig } from './client-compatibility.js';
 import { formatDoctorReport, generateDoctorReport, } from './doctor.js';
 import { formatSkillInstallStatusReport, generateSkillInstallStatusReport, } from './skill-management.js';
 import { formatUpdateStatusReport, generateUpdateStatusReport, } from './update-check.js';
-export async function generateStatusReport() {
-    return generateStatusReportWithDependencies();
+export async function generateStatusReport(options = {}) {
+    return generateStatusReportWithDependencies({}, options);
 }
-export async function generateStatusReportWithDependencies(dependencies = {}) {
+export async function generateStatusReportWithDependencies(dependencies = {}, options = {}) {
     await writeCurrentCliVersionToLocalConfig();
     const generateAuthStatus = dependencies.generateAuthStatus ?? generateAuthStatusReport;
     const generateDoctor = dependencies.generateDoctor ?? generateDoctorReport;
     const generateSkillStatus = dependencies.generateSkillStatus ?? generateSkillInstallStatusReport;
     const generateUpdateStatus = dependencies.generateUpdateStatus ?? generateUpdateStatusReport;
     const [doctor, auth, skills, updates] = await Promise.all([
-        generateDoctor(),
+        generateDoctor({ skillId: options.skillId }),
         generateAuthStatus(),
         generateSkillStatus(),
         generateUpdateStatus(),
@@ -25,6 +25,7 @@ export async function generateStatusReportWithDependencies(dependencies = {}) {
         auth,
         skills,
         updates,
+        ...(options.skillId ? { skillId: options.skillId } : {}),
     };
 }
 export function formatStatusReport(report) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postplus/cli",
-  "version": "0.1.27",
+  "version": "0.1.28",
   "packageManager": "pnpm@10.30.3+sha512.c961d1e0a2d8e354ecaa5166b822516668b7f44cb5bd95122d590dd81922f606f5473b6d23ec4a5be05e7fcd18e8488d47d978bbe981872f1145d06e9a740017",
   "type": "module",
   "description": "PostPlus CLI for PostPlus Cloud auth, status, and diagnostics.",