@postplus/cli 0.1.38 → 0.1.39

package/build/hosted-domain-commands.js

@@ -17,10 +17,7 @@ const HOSTED_DOMAIN_CAPABILITIES = {
     media: new Set(['media-file', 'media-generation', 'video-analysis']),
     mobile: new Set(['mobile-automation']),
     publish: new Set(['social-publishing']),
-    research: new Set([
-        'public-content-collection',
-        'public-content-discovery',
-    ]),
+    research: new Set(['public-content-collection', 'public-content-discovery']),
 };
 export async function runHostedDomainCommand(domain, args) {
     const [subcommand, ...rest] = args;
@@ -69,6 +66,16 @@ async function runResearchCollect(args) {
         `postplus-cli:research:${collectionKey}:${randomUUID()}`;
     const quoteConfirmationToken = flags.values.get('quote-confirmation-token') ??
         normalizeString(envelope.quoteConfirmationToken);
+    // Optional per-request cost ceiling (USD) overriding the hosted default.
+    const maxChargeFlag = flags.values.get('max-charge-usd');
+    let maxTotalChargeUsd;
+    if (maxChargeFlag !== undefined) {
+        const parsed = Number(maxChargeFlag);
+        if (!Number.isFinite(parsed) || parsed <= 0) {
+            throw new Error('--max-charge-usd must be a positive number of USD.');
+        }
+        maxTotalChargeUsd = parsed;
+    }
     const payload = await postHostedJson({
         body: {
             collectionKey,
@@ -76,6 +83,7 @@ async function runResearchCollect(args) {
             operationId,
             quoteConfirmationToken: quoteConfirmationToken ?? undefined,
             skillName,
+            maxTotalChargeUsd,
         },
         pathName: '/api/postplus-cli/hosted/collection',
         skillName,
@@ -348,7 +356,7 @@ function printResearchHelp() {
 
 Usage:
   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 --skill <skill-id> --collection-key <key> --input <hosted-envelope.json> [--max-charge-usd <usd>] [--output <result.json>]
   postplus research collect --run-handle <runHandle> [--output <result.json>]
   postplus research capability --request <hosted-capability-request.json> [--output <result.json>]
 `);

package/build/hosted-schema-catalog.js

@@ -1,60 +1,72 @@
 // Generated from the PostPlus Cloud hosted catalog release gate.
 // Keep keys in sync with apps/web hosted capability and collection catalogs.
+//
+// The result-count field in each hint is a fetch-volume example using the actor's
+// REAL input field (it shapes how much the actor fetches, not the cost ceiling).
+// Total spend is bounded server-side by a per-request USD budget — pay-per-event
+// actors via Apify maxTotalChargeUsd, Bright Data Facebook via
+// limit_multiple_results — so these values are starting points, not the cap.
+// Field names matter: clockworks TikTok actors fetch per resultsPerPage /
+// maxProfilesPerQuery / commentsPerPost (maxItems is a run option they ignore as
+// input) and apidojo youtube-comments uses maxItems (not maxComments).
 export const RESEARCH_COLLECTION_HINTS = {
     'google-trends-fast': {
-        queries: ['portable blender'],
+        enableTrendingSearches: false,
+        geo: 'US',
+        keyword: 'portable blender',
+        timeframe: 'today 12-m',
     },
     'instagram-comments': {
         directUrls: ['https://www.instagram.com/p/example/'],
-        resultsLimit: 5,
+        resultsLimit: 20,
     },
     'instagram-email-search': {
         Country: 'www',
         Email_Type: '0',
         Keyword: 'skincare creator',
-        Limit: '10',
+        Limit: '25',
         social_network: 'instagram.com/',
     },
     'instagram-hashtags': {
         hashtags: ['desksetup'],
-        resultsLimit: 3,
+        resultsLimit: 10,
     },
     'instagram-posts': {
-        resultsLimit: 3,
+        resultsLimit: 12,
         username: ['openai'],
     },
     'instagram-profiles': {
-        resultsLimit: 3,
         usernames: ['instagram'],
     },
     'instagram-search': {
-        searchLimit: 3,
+        searchLimit: 10,
         searchTerms: ['skincare routine'],
         searchType: 'user',
     },
     'tiktok-ads-top': {
         include_analytics: true,
-        limit: 1,
+        limit: 20,
     },
     'tiktok-comments': {
+        commentsPerPost: 20,
         postURLs: ['https://www.tiktok.com/@example/video/1234567890'],
-        resultsPerPage: 5,
     },
     'tiktok-profiles': {
+        resultsPerPage: 12,
         usernames: ['tiktok'],
     },
     'tiktok-related-videos': {
-        maxItems: 3,
         postURLs: ['https://www.tiktok.com/@example/video/1234567890'],
+        resultsPerPage: 10,
     },
     'tiktok-users': {
-        maxItems: 5,
+        maxProfilesPerQuery: 10,
         searchQueries: ['skincare creator'],
     },
     'tiktok-videos': {
-        maxItems: 3,
         proxyCountryCode: 'US',
         queries: ['portable blender'],
+        resultsPerPage: 10,
         searchSection: '/video',
     },
     'youtube-channel-summary': {
@@ -64,7 +76,7 @@ export const RESEARCH_COLLECTION_HINTS = {
         maxVideosPerChannel: 0,
     },
     'youtube-comments': {
-        maxComments: 10,
+        maxItems: 50,
         startUrls: ['https://www.youtube.com/watch?v=dQw4w9WgXcQ'],
     },
     'youtube-video-download': {
@@ -74,6 +86,7 @@ export const RESEARCH_COLLECTION_HINTS = {
 export const PUBLIC_CONTENT_SOURCE_HINTS = {
     'facebook-group-posts': [
         {
+            num_of_posts: 25,
             url: 'https://www.facebook.com/groups/example',
         },
     ],
@@ -84,6 +97,7 @@ export const PUBLIC_CONTENT_SOURCE_HINTS = {
     ],
     'facebook-profile-posts': [
         {
+            num_of_posts: 25,
             url: 'https://www.facebook.com/openai',
         },
     ],

package/build/skill-management.js

@@ -1,9 +1,15 @@
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 import { writeCurrentCliVersionToLocalConfig } from './client-compatibility.js';
 import { runCommand, runInteractiveCommand } from './command-runner.js';
 import { clearManagedSkillBaseline, readManagedSkillBaseline, writeManagedSkillBaseline, } from './local-state.js';
 import { POSTPLUS_SKILLS_AGENT_TARGETS, formatPostPlusSkillsInstallCommand, resolvePostPlusSkillsSource, loadPublicSkillCatalog, } from './skill-catalog.js';
 import { clearUpdateCheckCache } from './update-check.js';
 const NPX_SKILLS = ['-y', 'skills'];
+const SKILLS_INSTALLER_GLOBAL_LOCK_PATH = ['.agents', '.skill-lock.json'];
+const SKILLS_INSTALLER_PROJECT_LOCK_PATH = 'skills-lock.json';
+const SKILLS_INSTALLER_POSTPLUS_SOURCE = 'postplusai/postplus-skills';
 const DEFAULT_SKILL_MUTATION_OPTIONS = {
     scope: 'global',
 };
@@ -12,8 +18,10 @@ export async function runPostPlusSkillUpdate(dependencies = {
 }, options = DEFAULT_SKILL_MUTATION_OPTIONS) {
     const catalog = await loadPublicSkillCatalog();
     const skillNames = catalog.skills.map((skill) => skill.skillId);
+    const releasedSkills = new Set(skillNames);
     const baseline = await readManagedSkillBaseline();
-    const retiredSkillNames = baseline.skillNames.filter((skillName) => !skillNames.includes(skillName));
+    const lockedSkillNames = await readPostPlusInstallerLockedSkillEntries(options.scope).then((entries) => entries.map((entry) => entry.name));
+    const retiredSkillNames = mergeSkillNames(baseline.skillNames, lockedSkillNames).filter((skillName) => !releasedSkills.has(skillName));
     if (skillNames.length === 0) {
         throw new Error('PostPlus public skill catalog has no released skills.');
     }
@@ -45,7 +53,8 @@ export async function runPostPlusSkillUninstall(dependencies = {
     const catalog = await loadPublicSkillCatalog();
     const skillNames = catalog.skills.map((skill) => skill.skillId);
     const baseline = await readManagedSkillBaseline();
-    const allKnownSkillNames = mergeSkillNames(skillNames, baseline.skillNames);
+    const lockedSkillNames = await readPostPlusInstallerLockedSkillEntries(options.scope).then((entries) => entries.map((entry) => entry.name));
+    const allKnownSkillNames = mergeSkillNames(mergeSkillNames(skillNames, baseline.skillNames), lockedSkillNames);
     if (allKnownSkillNames.length === 0) {
         throw new Error('PostPlus public skill catalog has no released skills.');
     }
@@ -96,9 +105,20 @@ async function inspectPostPlusSkillInstall(dependencies, options = {}) {
     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));
+    const baselineRetiredManagedSkills = baseline.skillNames.filter((skillName) => !requiredSkills.has(skillName));
     try {
         const installed = await listInstalledSkills(dependencies);
+        const baselineRetiredSkills = new Set(baselineRetiredManagedSkills);
+        const lockedSkills = new Set((await readPostPlusInstallerLockedSkillEntries()).map((entry) => `${entry.scope}:${entry.name}`));
+        const installedRetiredManagedSkills = [
+            ...new Set(installed
+                .filter((skill) => baselineRetiredSkills.has(skill.name) ||
+                lockedSkills.has(`${skill.scope}:${skill.name}`))
+                .map((skill) => skill.name)),
+        ]
+            .filter((skillName) => !requiredSkills.has(skillName))
+            .sort((a, b) => a.localeCompare(b));
+        const retiredManagedSkills = mergeSkillNames(baselineRetiredManagedSkills, installedRetiredManagedSkills);
         const postPlusInstalled = installed.filter((skill) => requiredSkills.has(skill.name));
         const installedNames = new Set(postPlusInstalled.map((skill) => skill.name));
         const missingSkills = [...requiredSkills].filter((skill) => !installedNames.has(skill));
@@ -110,7 +130,8 @@ async function inspectPostPlusSkillInstall(dependencies, options = {}) {
                 baseline,
                 releaseId: catalog.releaseId,
                 skillNames: requiredSkillNames,
-            })) {
+            }) &&
+            installedRetiredManagedSkills.length === 0) {
             await writeManagedSkillBaseline({
                 releaseId: catalog.releaseId,
                 skillNames: requiredSkillNames,
@@ -128,7 +149,8 @@ async function inspectPostPlusSkillInstall(dependencies, options = {}) {
         return {
             catalog,
             report: {
-                ok: missingSkills.length === 0,
+                ok: missingSkills.length === 0 &&
+                    installedRetiredManagedSkills.length === 0,
                 error: null,
                 installCommand: formatPostPlusSkillsInstallCommand(catalog.source),
                 installedCount: installedNames.size,
@@ -157,7 +179,7 @@ async function inspectPostPlusSkillInstall(dependencies, options = {}) {
                 managedSkillsReleaseId: baseline.releaseId,
                 missingSkills: [...requiredSkills],
                 requiredCount: requiredSkills.size,
-                retiredManagedSkills,
+                retiredManagedSkills: baselineRetiredManagedSkills,
                 scopes: [],
                 source: catalog.source,
                 updateCommand: formatPostPlusSkillUpdateCommand(),
@@ -212,6 +234,9 @@ export function formatSkillBaselineVerifyReport(report) {
     else {
         lines.push('  Verified baseline: unchanged');
     }
+    if (report.retiredManagedSkills.length > 0) {
+        lines.push(`  Retired managed skills: ${formatSkillList(report.retiredManagedSkills, 8)}`, `  Cleanup (global): ${report.updateCommand}`, `  Cleanup (current directory): ${formatPostPlusSkillUpdateCommand('current-directory')}`);
+    }
     if (report.missingSkills.length > 0) {
         lines.push(`  Missing: ${formatSkillList(report.missingSkills, 8)}`, `  Fix (global): ${report.installCommand}`, `  Fix (current directory): ${formatPostPlusSkillsInstallCommand(report.source, 'current-directory')}`);
     }
@@ -274,6 +299,106 @@ function haveSameSkillNames(left, right) {
     return (normalizedLeft.length === normalizedRight.length &&
         normalizedLeft.every((value, index) => value === normalizedRight[index]));
 }
+async function readPostPlusInstallerLockedSkillEntries(scope) {
+    const lockPaths = scope === 'global'
+        ? [{ path: getSkillsInstallerGlobalLockPath(), scope: 'global' }]
+        : scope === 'current-directory'
+            ? [
+                {
+                    path: getSkillsInstallerProjectLockPath(),
+                    scope: 'project',
+                },
+            ]
+            : [
+                {
+                    path: getSkillsInstallerProjectLockPath(),
+                    scope: 'project',
+                },
+                {
+                    path: getSkillsInstallerGlobalLockPath(),
+                    scope: 'global',
+                },
+            ];
+    const entries = await Promise.all(lockPaths.map((lock) => readPostPlusInstallerLockedSkillNamesFromPath(lock.path).then((skillNames) => skillNames.map((name) => ({
+        name,
+        scope: lock.scope,
+    })))));
+    return entries
+        .flat()
+        .sort((left, right) => left.scope.localeCompare(right.scope) ||
+        left.name.localeCompare(right.name));
+}
+async function readPostPlusInstallerLockedSkillNamesFromPath(lockPath) {
+    try {
+        const raw = await readFile(lockPath, 'utf8');
+        const payload = JSON.parse(raw);
+        if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+            return [];
+        }
+        const record = payload;
+        if (typeof record.version !== 'number') {
+            return [];
+        }
+        if (!record.skills || typeof record.skills !== 'object') {
+            return [];
+        }
+        return Object.entries(record.skills)
+            .filter(([, entry]) => isPostPlusSkillsInstallerLockEntry(entry))
+            .map(([skillName]) => skillName.trim())
+            .filter(Boolean)
+            .sort((a, b) => a.localeCompare(b));
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code === 'ENOENT') {
+            return [];
+        }
+        throw error;
+    }
+}
+function isPostPlusSkillsInstallerLockEntry(entry) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+        return false;
+    }
+    const record = entry;
+    const source = typeof record.source === 'string' ? record.source.trim() : '';
+    const sourceUrl = typeof record.sourceUrl === 'string' ? record.sourceUrl.trim() : '';
+    return (normalizeSkillsInstallerSource(source) ===
+        SKILLS_INSTALLER_POSTPLUS_SOURCE ||
+        normalizeSkillsInstallerSource(sourceUrl) ===
+            SKILLS_INSTALLER_POSTPLUS_SOURCE);
+}
+function normalizeSkillsInstallerSource(value) {
+    let normalized = value.trim().replace(/\\/g, '/');
+    if (normalized.length === 0) {
+        return '';
+    }
+    const sshMatch = normalized.match(/^git@[^:]+:(.+)$/);
+    if (sshMatch) {
+        normalized = sshMatch[1] ?? '';
+    }
+    else if (/^https?:\/\//i.test(normalized) || /^ssh:\/\//i.test(normalized)) {
+        try {
+            normalized = new URL(normalized).pathname.replace(/^\/+/, '');
+        }
+        catch {
+            return normalized.toLowerCase();
+        }
+    }
+    return normalized
+        .replace(/\.git$/i, '')
+        .replace(/\/+$/, '')
+        .toLowerCase();
+}
+function getSkillsInstallerGlobalLockPath() {
+    const xdgStateHome = process.env.XDG_STATE_HOME?.trim();
+    return xdgStateHome
+        ? join(xdgStateHome, 'skills', '.skill-lock.json')
+        : join(homedir(), ...SKILLS_INSTALLER_GLOBAL_LOCK_PATH);
+}
+function getSkillsInstallerProjectLockPath() {
+    return join(process.cwd(), SKILLS_INSTALLER_PROJECT_LOCK_PATH);
+}
 async function listInstalledSkills(dependencies) {
     const project = await listInstalledSkillsForScope(dependencies, []);
     const global = await listInstalledSkillsForScope(dependencies, ['--global']);

package/package.json

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