@postplus/cli 0.1.28 → 0.1.30

package/README.md

@@ -24,7 +24,7 @@ PostPlus has three public surfaces that work together:
 
 - `https://postplus.io/`: the hosted product surface for account access, subscription state, and cloud-backed capabilities.
 - `https://github.com/PostPlusAI/postplus-skills`: the public skill repository that installs local marketing workflows into agent tools.
-- `https://github.com/PostPlusAI/postplus-cli`: the local command-line tool that signs you in, checks local readiness, and connects released skills to PostPlus account state.
+- `https://github.com/PostPlusAI/postplus-cli`: the local command-line tool that signs you in, checks local readiness, confirms high-credit hosted requests, and connects released skills to PostPlus account state.
 
 ## Install
 
@@ -34,6 +34,7 @@ Requires Node.js and npm.
 npm install -g @postplus/cli@latest
 postplus auth login
 npx -y skills add PostPlusAI/postplus-skills --global --full-depth --skill '*' --agent claude-code codex cursor github-copilot windsurf trae trae-cn --yes
+postplus skills verify
 ```
 
 Useful checks:

package/build/doctor.js

@@ -166,6 +166,11 @@ async function checkHostedCapabilities(input, skillScope) {
             .map((value) => readCapabilityFailureLabel(value, skillScope))
             .filter((value) => value !== null);
         if (skillScope && hasHostedRequirements(skillScope.skill.requirements)) {
+            const subscription = readSubscriptionStatusField(payload).label;
+            if (requiresSocialPublishingPlan(skillScope.skill.requirements) &&
+                subscription === 'none') {
+                failedLabels.push(`PostPlus Plus or Pro plan required; current subscription ${subscription}`);
+            }
             const missingRequirements = collectMissingHostedRequirementLabels(relevantCapabilities, skillScope.skill.requirements);
             failedLabels.push(...missingRequirements);
         }
@@ -261,7 +266,7 @@ function capabilityMatchesRequirements(capability, requirements) {
         if (prefix &&
             suffix &&
             hostedCapabilities.has(prefix) &&
-            requirementKeys.has(suffix)) {
+            (isWholeFamilyHostedCapability(prefix) || requirementKeys.has(suffix))) {
             return true;
         }
         return requirementKeys.has(identifier) || requirementKeys.has(suffix);
@@ -310,6 +315,12 @@ function collectHostedRequirementKeys(requirements) {
         ...requirements.sourceKeys,
     ]);
 }
+function isWholeFamilyHostedCapability(prefix) {
+    return prefix === 'social-publishing';
+}
+function requiresSocialPublishingPlan(requirements) {
+    return requirements.hostedCapabilities.includes('social-publishing');
+}
 function hasHostedRequirements(requirements) {
     return (requirements.accountConnections.length > 0 ||
         requirements.collectionKeys.length > 0 ||
@@ -337,6 +348,10 @@ function identifierMatchesKey(identifier, key) {
     if (identifier === key) {
         return true;
     }
+    if (key === 'social-publishing-workspace' &&
+        identifierMatchesCapability(identifier, 'social-publishing')) {
+        return true;
+    }
     const [, suffix] = splitCapabilityIdentifier(identifier);
     return suffix === key;
 }

package/build/index.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { readFile } from 'node:fs/promises';
 import { formatAuthRefreshReport, refreshRemoteAuth, revokeRemoteAuthAndReport, } from './auth-lifecycle.js';
 import { loginWithCloudHandoff } from './auth-login.js';
 import { formatAuthValidateReport, validateRemoteAuth, } from './auth-validate.js';
@@ -6,8 +7,9 @@ import { clearAuthState, formatAuthStatusReport, generateAuthStatusReport, } fro
 import { readCurrentCliVersion } from './client-compatibility.js';
 import { formatDoctorReport, generateDoctorReport } from './doctor.js';
 import { assertConfigFilePermissions } from './local-state.js';
+import { readLargeCreditQuoteConfirmationChallenge, resolveLargeCreditQuoteConfirmation, } from './quote-confirmation.js';
 import { POSTPLUS_SKILLS_INSTALL_COMMAND, loadPublicSkillCatalog, } from './skill-catalog.js';
-import { runPostPlusSkillUninstall, runPostPlusSkillUpdate, } from './skill-management.js';
+import { formatSkillBaselineVerifyReport, runPostPlusSkillUninstall, runPostPlusSkillUpdate, runPostPlusSkillVerify, } from './skill-management.js';
 import { formatStatusReport, generateStatusReport } from './status.js';
 import { refreshUpdateCheckCache, runCliSelfUpdateIfOutdated, } from './update-check.js';
 function printAuthHelp() {
@@ -38,6 +40,8 @@ Usage:
   postplus auth validate [--json]
   postplus auth logout [--json]
   postplus doctor [--skill <skill-id>] [--json]
+  postplus quote confirm --json --challenge-file <path>
+  postplus skills verify [--json]
   postplus update
   postplus uninstall
   postplus list [--json]
@@ -47,6 +51,9 @@ Usage:
 
 Skills:
   ${POSTPLUS_SKILLS_INSTALL_COMMAND}
+
+After first install, run:
+  postplus skills verify
 `);
 }
 async function runDoctor(options) {
@@ -116,6 +123,90 @@ async function runSkillUpdateCommand() {
 async function runSkillUninstallCommand() {
     return runPostPlusSkillUninstall();
 }
+async function runSkillsCommand(rest) {
+    const [subcommand] = rest;
+    switch (subcommand) {
+        case 'verify': {
+            const options = rest.slice(1);
+            const unknownOption = options.find((option) => option !== '--json');
+            if (unknownOption) {
+                process.stderr.write(`Unknown option for skills verify: ${unknownOption}\n`);
+                return 1;
+            }
+            const report = await runPostPlusSkillVerify();
+            if (options.includes('--json')) {
+                writeJson(report);
+            }
+            else {
+                process.stdout.write(`${formatSkillBaselineVerifyReport(report)}\n`);
+            }
+            return report.ok ? 0 : 1;
+        }
+        case 'help':
+        case '--help':
+        case '-h':
+        case undefined:
+            process.stdout.write(`PostPlus CLI — skills commands
+
+Usage:
+  postplus skills verify [--json]  Verify installed public skills and record the managed baseline
+
+Options:
+  --json    Output results as JSON
+`);
+            return 0;
+        default:
+            process.stderr.write(`Unknown skills command: ${subcommand}\n`);
+            return 1;
+    }
+}
+async function runQuoteCommand(rest) {
+    const [subcommand, ...options] = rest;
+    if (subcommand !== 'confirm') {
+        process.stderr.write(`Unknown quote command: ${subcommand ?? ''}\n`);
+        return 1;
+    }
+    const parsed = parseQuoteConfirmOptions(options);
+    if (!parsed.json) {
+        process.stderr.write('quote confirm requires --json.\n');
+        return 1;
+    }
+    if (!parsed.challengeFile) {
+        process.stderr.write('quote confirm requires --challenge-file.\n');
+        return 1;
+    }
+    const challenge = readLargeCreditQuoteConfirmationChallenge(JSON.parse(await readFile(parsed.challengeFile, 'utf8')));
+    if (!challenge) {
+        process.stderr.write('Invalid large credit quote confirmation challenge.\n');
+        return 1;
+    }
+    writeJson(await resolveLargeCreditQuoteConfirmation(challenge));
+    return 0;
+}
+function parseQuoteConfirmOptions(args) {
+    const options = {
+        challengeFile: null,
+        json: false,
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--json') {
+            options.json = true;
+            continue;
+        }
+        if (arg === '--challenge-file') {
+            const challengeFile = args[index + 1];
+            if (!challengeFile || challengeFile.startsWith('--')) {
+                throw new Error('Missing value for --challenge-file.');
+            }
+            options.challengeFile = challengeFile;
+            index += 1;
+            continue;
+        }
+        throw new Error(`Unknown option for quote confirm: ${arg}`);
+    }
+    return options;
+}
 function writeJson(value) {
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
@@ -215,6 +306,9 @@ async function main() {
             if (helpTopic === 'auth') {
                 printAuthHelp();
             }
+            else if (helpTopic === 'skills') {
+                await runSkillsCommand(['help']);
+            }
             else {
                 printHelp();
             }
@@ -224,6 +318,12 @@ async function main() {
         case 'doctor':
             process.exitCode = await runDoctor(parseDiagnosticOptions(rest));
             return;
+        case 'quote':
+            process.exitCode = await runQuoteCommand(rest);
+            return;
+        case 'skills':
+            process.exitCode = await runSkillsCommand(rest);
+            return;
         case 'install':
             process.stderr.write(`PostPlus CLI does not install skills directly. Run \`${POSTPLUS_SKILLS_INSTALL_COMMAND}\`.\n`);
             process.exitCode = 1;

package/build/quote-confirmation.js

@@ -0,0 +1,163 @@
+import readline from 'node:readline/promises';
+import { readLocalConfig, updateLocalConfig } from './local-state.js';
+const PRODUCT_ERROR_CODE = 'postplus_cli_quote_confirmation_required';
+export function readLargeCreditQuoteConfirmationChallenge(value) {
+    if (!value || typeof value !== 'object') {
+        return null;
+    }
+    const record = value;
+    const challenge = record.productErrorCode === PRODUCT_ERROR_CODE
+        ? record.quoteConfirmation
+        : record.quoteConfirmation && typeof record.quoteConfirmation === 'object'
+            ? record.quoteConfirmation
+            : value;
+    if (!challenge || typeof challenge !== 'object') {
+        return null;
+    }
+    const parsed = challenge;
+    if (typeof parsed.accountId !== 'string' ||
+        typeof parsed.action !== 'string' ||
+        typeof parsed.estimatedMillicredits !== 'number' ||
+        typeof parsed.featureLabel !== 'string' ||
+        typeof parsed.operationId !== 'string' ||
+        typeof parsed.requiredTierMillicredits !== 'number' ||
+        typeof parsed.reservedMillicredits !== 'number' ||
+        typeof parsed.serviceLabel !== 'string' ||
+        typeof parsed.token !== 'string') {
+        return null;
+    }
+    return {
+        accountId: parsed.accountId,
+        action: parsed.action,
+        billingUnit: typeof parsed.billingUnit === 'string' ? parsed.billingUnit : undefined,
+        drivers: parseDrivers(parsed.drivers),
+        estimatedCredits: typeof parsed.estimatedCredits === 'number'
+            ? parsed.estimatedCredits
+            : undefined,
+        estimatedMillicredits: parsed.estimatedMillicredits,
+        estimatedOnly: parsed.estimatedOnly === true,
+        featureLabel: parsed.featureLabel,
+        operationId: parsed.operationId,
+        requiredTierCredits: typeof parsed.requiredTierCredits === 'number'
+            ? parsed.requiredTierCredits
+            : undefined,
+        requiredTierMillicredits: parsed.requiredTierMillicredits,
+        reservedCredits: typeof parsed.reservedCredits === 'number'
+            ? parsed.reservedCredits
+            : undefined,
+        reservedMillicredits: parsed.reservedMillicredits,
+        serviceLabel: parsed.serviceLabel,
+        token: parsed.token,
+    };
+}
+export async function resolveLargeCreditQuoteConfirmation(challenge, dependencies = {
+    confirm: confirmLargeCreditQuote,
+}) {
+    const acknowledgedTierMillicredits = await readAcknowledgedTierMillicredits(challenge);
+    if (acknowledgedTierMillicredits < challenge.requiredTierMillicredits) {
+        await dependencies.confirm(challenge);
+        await writeAcknowledgedTierMillicredits(challenge);
+    }
+    return {
+        schemaVersion: 1,
+        token: challenge.token,
+    };
+}
+export async function confirmLargeCreditQuote(challenge) {
+    const terminal = readline.createInterface({
+        input: process.stdin,
+        output: process.stderr,
+    });
+    try {
+        const answer = await terminal.question(buildLargeCreditConfirmationPrompt(challenge));
+        if (answer.trim() !== 'CONFIRM') {
+            throw new Error('Large credit charge was not confirmed.');
+        }
+    }
+    finally {
+        terminal.close();
+    }
+}
+export function buildLargeCreditConfirmationPrompt(challenge) {
+    const lines = [
+        '',
+        'PostPlus large credit warning',
+        `This request crosses the ${formatCredits(challenge.requiredTierMillicredits)}-credit warning tier.`,
+        `Estimated charge: ${formatCredits(challenge.estimatedMillicredits)} credits${challenge.estimatedOnly ? ' (estimate)' : ''}.`,
+        `Reserved before execution: ${formatCredits(challenge.reservedMillicredits)} credits.`,
+        `Capability: ${formatText(challenge.featureLabel)} / ${formatText(challenge.action)}.`,
+        `Service: ${formatText(challenge.serviceLabel)}.`,
+    ];
+    const drivers = Array.isArray(challenge.drivers)
+        ? challenge.drivers.filter((driver) => {
+            return (driver &&
+                typeof driver === 'object' &&
+                typeof driver.label === 'string' &&
+                driver.value !== undefined &&
+                driver.value !== null);
+        })
+        : [];
+    if (drivers.length > 0) {
+        lines.push('High-credit drivers:');
+        for (const driver of drivers.slice(0, 8)) {
+            lines.push(`- ${driver.label}: ${String(driver.value)}`);
+        }
+    }
+    lines.push('PostPlus will warn again only when a future request crosses a higher tier.', 'Type CONFIRM to continue: ');
+    return lines.join('\n');
+}
+async function readAcknowledgedTierMillicredits(challenge) {
+    const config = await readLocalConfig();
+    const tier = config?.largeCreditConfirmation?.acknowledgedTierMillicreditsByAccountId?.[challenge.accountId];
+    return typeof tier === 'number' && Number.isSafeInteger(tier) && tier > 0
+        ? tier
+        : 0;
+}
+async function writeAcknowledgedTierMillicredits(challenge) {
+    await updateLocalConfig((current) => {
+        const config = current ?? {};
+        const largeCreditConfirmation = config.largeCreditConfirmation ?? {};
+        const currentTiers = largeCreditConfirmation.acknowledgedTierMillicreditsByAccountId ?? {};
+        const previousTier = currentTiers[challenge.accountId];
+        return {
+            ...config,
+            largeCreditConfirmation: {
+                ...largeCreditConfirmation,
+                acknowledgedTierMillicreditsByAccountId: {
+                    ...currentTiers,
+                    [challenge.accountId]: Math.max(typeof previousTier === 'number' &&
+                        Number.isSafeInteger(previousTier)
+                        ? previousTier
+                        : 0, challenge.requiredTierMillicredits),
+                },
+            },
+        };
+    });
+}
+function parseDrivers(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .filter((driver) => {
+        return Boolean(driver) && typeof driver === 'object';
+    })
+        .filter((driver) => typeof driver.label === 'string')
+        .map((driver) => ({
+        key: typeof driver.key === 'string' ? driver.key : undefined,
+        label: driver.label,
+        value: driver.value,
+    }));
+}
+function formatText(value) {
+    return value.trim() ? value : 'unknown';
+}
+function formatCredits(millicredits) {
+    const credits = millicredits / 1_000;
+    if (!Number.isFinite(credits)) {
+        return 'unknown';
+    }
+    return Number.isInteger(credits)
+        ? String(credits)
+        : credits.toFixed(3).replace(/0+$/, '').replace(/\.$/, '');
+}

package/build/skill-management.js

@@ -49,8 +49,38 @@ export async function runPostPlusSkillUninstall(dependencies = {
 export async function generateSkillInstallStatusReport(dependencies = {
     runCommand,
 }) {
+    return (await inspectPostPlusSkillInstall(dependencies)).report;
+}
+export async function runPostPlusSkillVerify(dependencies = {
+    runCommand,
+}) {
+    const inspection = await inspectPostPlusSkillInstall(dependencies);
+    const previousManagedSkillsReleaseId = inspection.report.managedSkillsReleaseId;
+    if (!inspection.report.ok) {
+        return {
+            ...inspection.report,
+            baselineUpdated: false,
+            previousManagedSkillsReleaseId,
+            verifiedSkillsReleaseId: null,
+        };
+    }
+    await writeManagedSkillBaseline({
+        releaseId: inspection.catalog.releaseId,
+        skillNames: inspection.requiredSkillNames,
+    });
+    await writeCurrentCliVersionToLocalConfig();
+    return {
+        ...inspection.report,
+        baselineUpdated: true,
+        managedSkillsReleaseId: inspection.catalog.releaseId,
+        previousManagedSkillsReleaseId,
+        verifiedSkillsReleaseId: inspection.catalog.releaseId,
+    };
+}
+async function inspectPostPlusSkillInstall(dependencies) {
     const catalog = await loadPublicSkillCatalog();
-    const requiredSkills = new Set(catalog.skills.map((skill) => skill.skillId));
+    const requiredSkillNames = catalog.skills.map((skill) => skill.skillId);
+    const requiredSkills = new Set(requiredSkillNames);
     const baseline = await readManagedSkillBaseline();
     const retiredManagedSkills = baseline.skillNames.filter((skillName) => !requiredSkills.has(skillName));
     try {
@@ -64,36 +94,44 @@ export async function generateSkillInstallStatusReport(dependencies = {
                 .filter((scope) => scope.trim().length > 0)),
         ].sort();
         return {
-            ok: missingSkills.length === 0,
-            error: null,
-            installCommand: formatPostPlusSkillsInstallCommand(catalog.source),
-            installedCount: installedNames.size,
-            managedSkillsReleaseId: baseline.releaseId,
-            missingSkills,
-            requiredCount: requiredSkills.size,
-            retiredManagedSkills,
-            scopes,
-            source: catalog.source,
-            updateCommand: formatPostPlusSkillUpdateCommand(),
-            uninstallCommand: formatPostPlusSkillUninstallCommand(),
+            catalog,
+            report: {
+                ok: missingSkills.length === 0,
+                error: null,
+                installCommand: formatPostPlusSkillsInstallCommand(catalog.source),
+                installedCount: installedNames.size,
+                managedSkillsReleaseId: baseline.releaseId,
+                missingSkills,
+                requiredCount: requiredSkills.size,
+                retiredManagedSkills,
+                scopes,
+                source: catalog.source,
+                updateCommand: formatPostPlusSkillUpdateCommand(),
+                uninstallCommand: formatPostPlusSkillUninstallCommand(),
+            },
+            requiredSkillNames,
         };
     }
     catch (error) {
         return {
-            ok: false,
-            error: error instanceof Error
-                ? error.message
-                : 'Failed to inspect installed PostPlus skills.',
-            installCommand: formatPostPlusSkillsInstallCommand(catalog.source),
-            installedCount: 0,
-            managedSkillsReleaseId: baseline.releaseId,
-            missingSkills: [...requiredSkills],
-            requiredCount: requiredSkills.size,
-            retiredManagedSkills,
-            scopes: [],
-            source: catalog.source,
-            updateCommand: formatPostPlusSkillUpdateCommand(),
-            uninstallCommand: formatPostPlusSkillUninstallCommand(),
+            catalog,
+            report: {
+                ok: false,
+                error: error instanceof Error
+                    ? error.message
+                    : 'Failed to inspect installed PostPlus skills.',
+                installCommand: formatPostPlusSkillsInstallCommand(catalog.source),
+                installedCount: 0,
+                managedSkillsReleaseId: baseline.releaseId,
+                missingSkills: [...requiredSkills],
+                requiredCount: requiredSkills.size,
+                retiredManagedSkills,
+                scopes: [],
+                source: catalog.source,
+                updateCommand: formatPostPlusSkillUpdateCommand(),
+                uninstallCommand: formatPostPlusSkillUninstallCommand(),
+            },
+            requiredSkillNames,
         };
     }
 }
@@ -122,6 +160,31 @@ export function formatSkillInstallStatusReport(report) {
     }
     return lines.join('\n');
 }
+export function formatSkillBaselineVerifyReport(report) {
+    const lines = ['PostPlus skills verify', ''];
+    if (report.error) {
+        lines.push(`[FAIL] Skill installer: ${report.error}`);
+    }
+    else if (report.ok) {
+        lines.push(`[PASS] Installed released skills: ${report.installedCount}/${report.requiredCount}`);
+    }
+    else {
+        lines.push(`[FAIL] Installed released skills: ${report.installedCount}/${report.requiredCount}`);
+    }
+    lines.push(`  Source: ${report.source}`);
+    lines.push(`  Previous managed baseline: ${report.previousManagedSkillsReleaseId ?? 'none'}`);
+    if (report.baselineUpdated && report.verifiedSkillsReleaseId) {
+        lines.push(`  Verified baseline: ${report.verifiedSkillsReleaseId}`);
+        lines.push('  Next: postplus status');
+    }
+    else {
+        lines.push('  Verified baseline: unchanged');
+    }
+    if (report.missingSkills.length > 0) {
+        lines.push(`  Missing: ${formatSkillList(report.missingSkills, 8)}`, `  Fix: ${report.installCommand}`);
+    }
+    return lines.join('\n');
+}
 export function buildPostPlusSkillUpdateArgs(skillNames) {
     if (skillNames.length === 0) {
         throw new Error('PostPlus public skill catalog has no released skills.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postplus/cli",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "packageManager": "pnpm@10.30.3+sha512.c961d1e0a2d8e354ecaa5166b822516668b7f44cb5bd95122d590dd81922f606f5473b6d23ec4a5be05e7fcd18e8488d47d978bbe981872f1145d06e9a740017",
   "type": "module",
   "description": "PostPlus CLI for PostPlus Cloud auth, status, and diagnostics.",
@@ -18,6 +18,7 @@
     "build/index.js",
     "build/local-dependencies.js",
     "build/local-state.js",
+    "build/quote-confirmation.js",
     "build/skill-catalog.js",
     "build/skill-management.js",
     "build/status.js",