@postplus/cli 0.1.12 → 0.1.14

package/README.md

@@ -11,7 +11,7 @@ Instead of asking you to choose tools first, PostPlus starts from the job you wa
 ```text
 "Find creators for this product."
 "Analyze why this competitor video works."
-"Tell me whether this product has TikTok Shop potential."
+"Tell me whether this product has marketplace potential."
 "Turn these references into a short-form video brief."
 "Package the research into a client-ready Feishu report."
 ```
@@ -23,7 +23,7 @@ The agent then routes the work, collects evidence, makes the judgment explicit,
 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/RealProductStudio/postplus-skills`: the public skill repository that installs local marketing workflows into agent tools.
+- `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.
 
 ## Install
@@ -39,8 +39,7 @@ npx -y skills add PostPlusAI/postplus-skills --full-depth --skill '*' --agent cl
 Useful checks:
 
 ```bash
-postplus auth status
-postplus doctor
+postplus status
 npx -y skills add PostPlusAI/postplus-skills --list --full-depth
 ```
 
@@ -163,7 +162,7 @@ Use PostPlus when you need to decide whether a product, category, or channel is
 Example requests:
 
 ```text
-"Does this product fit TikTok Shop or Amazon better?"
+"Does this product fit Amazon or a content-led launch better?"
 "Find 1688 suppliers and compare them against demand signals."
 "Analyze whether this category has enough content proof to test."
 ```
@@ -245,7 +244,7 @@ Typical outputs:
 
 ```text
 Product idea
--> collect TikTok, Amazon, TikTok Shop, Xiaohongshu, Google Trends, or 1688 evidence
+-> collect TikTok, Amazon, Xiaohongshu, Google Trends, or 1688 evidence
 -> compare demand, content fit, supply, price, and risk
 -> produce a go / no-go / test-first recommendation
 ```
@@ -306,7 +305,7 @@ Examples: social media routing, creator discovery routing, media routing, patter
 
 For collecting and analyzing public signals from platforms, marketplaces, search behavior, and social content.
 
-Examples: TikTok, TikTok ads, Instagram, X, YouTube, LinkedIn, Facebook, Xiaohongshu, 1688, Amazon, TikTok Shop, Google Trends.
+Examples: TikTok, TikTok ads, Instagram, X, YouTube, LinkedIn, Facebook, Xiaohongshu, 1688, Amazon, Google Trends.
 
 ### 3. Decide and Shortlist
 
@@ -346,7 +345,7 @@ This is not a full catalog. It is a practical map of the problems PostPlus is me
 |---|---|---|
 | Understand a market or audience | Topic listening, trend discovery, competitor snapshots, comment mining, audience language, demand signals | TikTok, Instagram, X, YouTube, LinkedIn, Facebook, Xiaohongshu, Google Trends, Amazon reviews |
 | Find creators or KOL/KOC partners | Creator discovery, profile enrichment, content-fit scoring, shortlist building, contact signal extraction, outreach prep | TikTok creators, Instagram creators, Xiaohongshu accounts, X accounts, creator graph, follower bands, engagement proxy |
-| Decide whether a product is worth testing | Product selection, marketplace comparison, channel fit, price bands, review analysis, supply-side checks, sourcing judgment | Amazon, TikTok Shop, 1688, Google Trends, Xiaohongshu commerce, supplier ranking, SKU, MOQ, margin risk |
+| Decide whether a product is worth testing | Product selection, marketplace comparison, channel fit, price bands, review analysis, supply-side checks, sourcing judgment | Amazon, 1688, Google Trends, Xiaohongshu commerce, supplier ranking, SKU, MOQ, margin risk |
 | Turn references into creative direction | Reference decoding, hook analysis, visual grammar, benchmark-to-brief, persona packs, storyboard planning, prompt QA | TikTok videos, Reels, Xiaohongshu notes, short-form hooks, UGC, product demo, lifestyle, testimonial |
 | Produce media assets | Transcription, subtitles, frame extraction, B-roll planning, image generation, video generation, voice generation, edit packaging | Whisper, SRT/VTT/ASS, B-roll, storyboard grid, hosted media generation, image prompts, video requests |
 | Plan content and messaging | Positioning, content strategy, copywriting, social content, email sequences, SEO, AI search, launch planning | Blog, landing page, LinkedIn, X, Xiaohongshu, cold email, content pillars, hooks, objections, offers |
@@ -393,4 +392,3 @@ The best first prompt includes:
 - the target platform if you already know it
 - any reference links, files, accounts, or assets
 - the artifact you want at the end
-

package/build/auth-login.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { createServer } from 'node:http';
 import { requireHostedBaseUrl } from './hosted-release.js';
 import { setLocalSession } from './local-state.js';
+export const CLI_AUTH_HANDOFF_TIMEOUT_MS = 30 * 60 * 1000;
 export async function loginWithBrowserHandoff() {
     const baseUrl = await requireHostedBaseUrl();
     const handoff = await createCliAuthHandoffServer({
@@ -18,7 +19,7 @@ export async function loginWithBrowserHandoff() {
         'Open this URL in your browser to continue:',
         loginUrl,
         '',
-        'Waiting for browser sign-in...',
+        'Waiting for browser sign-in (up to 30 minutes)...',
         '',
     ].join('\n'));
     try {
@@ -84,7 +85,7 @@ export function formatCliSessionAuthError(payload) {
     }
     return 'Failed to validate the browser session for PostPlus CLI.';
 }
-async function createCliAuthHandoffServer(input) {
+export async function createCliAuthHandoffServer(input) {
     const requestId = randomUUID();
     return new Promise((resolve, reject) => {
         let settled = false;
@@ -107,6 +108,7 @@ async function createCliAuthHandoffServer(input) {
                 response.writeHead(204, {
                     'Access-Control-Allow-Headers': 'Content-Type',
                     'Access-Control-Allow-Methods': 'POST, OPTIONS',
+                    'Access-Control-Allow-Private-Network': 'true',
                     'Access-Control-Allow-Origin': allowOrigin,
                     'Access-Control-Max-Age': '600',
                     Vary: 'Origin',
@@ -184,7 +186,7 @@ async function createCliAuthHandoffServer(input) {
                     rejectPayload?.(new Error('Timed out waiting for the browser sign-in handoff.'));
                 }
                 server.close();
-            }, 5 * 60 * 1000);
+            }, CLI_AUTH_HANDOFF_TIMEOUT_MS);
             resolve({
                 bridgeUrl: `http://127.0.0.1:${address.port}/handoff`,
                 close: async () => new Promise((innerResolve, innerReject) => {

package/build/command-runner.js

@@ -0,0 +1,60 @@
+import { spawn } from 'node:child_process';
+import { mkdtemp, open, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+export async function runCommand(command, args, options = {}) {
+    const tempDir = await mkdtemp(join(tmpdir(), 'postplus-cli-command-'));
+    const stdoutPath = join(tempDir, 'stdout.txt');
+    const stdoutFile = await open(stdoutPath, 'w');
+    try {
+        const result = await new Promise((resolve, reject) => {
+            const child = spawn(command, args, {
+                stdio: ['ignore', stdoutFile.fd, 'pipe'],
+            });
+            const stderr = [];
+            const timer = setTimeout(() => {
+                child.kill('SIGTERM');
+                reject(new Error(`Command timed out: ${command} ${args.join(' ')}`));
+            }, options.timeoutMs ?? 60_000);
+            child.stderr?.on('data', (chunk) => {
+                stderr.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+            });
+            child.on('error', (error) => {
+                clearTimeout(timer);
+                reject(error);
+            });
+            child.on('exit', (code) => {
+                clearTimeout(timer);
+                const stderrText = Buffer.concat(stderr).toString('utf8');
+                if (code === 0) {
+                    resolve({
+                        stderr: stderrText,
+                        stdout: '',
+                    });
+                    return;
+                }
+                reject(new Error(`Command failed (${code ?? 'unknown'}): ${command} ${args.join(' ')}${stderrText ? `\n${stderrText}` : ''}`));
+            });
+        });
+        await stdoutFile.close();
+        return {
+            ...result,
+            stdout: await readFile(stdoutPath, 'utf8'),
+        };
+    }
+    finally {
+        await stdoutFile.close().catch(() => { });
+        await rm(tempDir, { force: true, recursive: true });
+    }
+}
+export async function runInteractiveCommand(command, args) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: 'inherit',
+        });
+        child.on('error', reject);
+        child.on('exit', (code) => {
+            resolve(code ?? 1);
+        });
+    });
+}

package/build/index.js

@@ -6,8 +6,9 @@ import { clearAuthState, formatAuthStatusReport, generateAuthStatusReport, } fro
 import { formatDoctorReport, generateDoctorReport, } from './doctor.js';
 import { assertConfigFilePermissions } from './local-state.js';
 import { POSTPLUS_SKILLS_INSTALL_COMMAND, loadPublicSkillCatalog, } from './skill-catalog.js';
+import { runPostPlusSkillUninstall, runPostPlusSkillUpdate, } from './skill-management.js';
 import { formatStatusReport, generateStatusReport } from './status.js';
-const REMOVED_SKILL_COMMAND_MESSAGE = `PostPlus CLI no longer installs skills directly. Run \`${POSTPLUS_SKILLS_INSTALL_COMMAND}\`.`;
+import { refreshUpdateCheckBaseline } from './update-check.js';
 function printAuthHelp() {
     process.stdout.write(`PostPlus CLI — auth commands
 
@@ -36,6 +37,8 @@ Usage:
   postplus auth validate [--json]
   postplus auth logout [--json]
   postplus doctor [--json]
+  postplus update
+  postplus uninstall
   postplus list [--json]
   postplus status [--json]
   postplus help
@@ -93,6 +96,16 @@ async function runList(json) {
     process.stdout.write(`${lines.join('\n')}\n`);
     return 0;
 }
+async function runSkillUpdateCommand() {
+    const exitCode = await runPostPlusSkillUpdate();
+    if (exitCode === 0) {
+        await refreshUpdateCheckBaseline().catch(() => { });
+    }
+    return exitCode;
+}
+async function runSkillUninstallCommand() {
+    return runPostPlusSkillUninstall();
+}
 function writeJson(value) {
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
@@ -177,10 +190,14 @@ async function main() {
             process.exitCode = await runDoctor(json);
             return;
         case 'install':
+            process.stderr.write(`PostPlus CLI does not install skills directly. Run \`${POSTPLUS_SKILLS_INSTALL_COMMAND}\`.\n`);
+            process.exitCode = 1;
+            return;
         case 'update':
+            process.exitCode = await runSkillUpdateCommand();
+            return;
         case 'uninstall':
-            process.stderr.write(`${REMOVED_SKILL_COMMAND_MESSAGE}\n`);
-            process.exitCode = 1;
+            process.exitCode = await runSkillUninstallCommand();
             return;
         case 'list':
             process.exitCode = await runList(json);

package/build/skill-management.js

@@ -0,0 +1,155 @@
+import { POSTPLUS_SKILLS_INSTALL_COMMAND, POSTPLUS_SKILLS_REPO, loadPublicSkillCatalog, } from './skill-catalog.js';
+import { runCommand, runInteractiveCommand } from './command-runner.js';
+const SKILLS_AGENTS = ['claude-code', 'codex', 'cursor'];
+const NPX_SKILLS = ['-y', 'skills'];
+export async function runPostPlusSkillUpdate() {
+    const catalog = await loadPublicSkillCatalog();
+    const skillNames = catalog.skills.map((skill) => skill.skillId);
+    if (skillNames.length === 0) {
+        throw new Error('PostPlus public skill catalog has no released skills.');
+    }
+    return runInteractiveCommand('npx', buildPostPlusSkillUpdateArgs(skillNames));
+}
+export async function runPostPlusSkillUninstall() {
+    const catalog = await loadPublicSkillCatalog();
+    const skillNames = catalog.skills.map((skill) => skill.skillId);
+    if (skillNames.length === 0) {
+        throw new Error('PostPlus public skill catalog has no released skills.');
+    }
+    return runInteractiveCommand('npx', buildPostPlusSkillUninstallArgs(skillNames));
+}
+export async function generateSkillInstallStatusReport(dependencies = {
+    runCommand,
+}) {
+    const catalog = await loadPublicSkillCatalog();
+    const requiredSkills = new Set(catalog.skills.map((skill) => skill.skillId));
+    try {
+        const installed = await listInstalledSkills(dependencies);
+        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));
+        const scopes = [
+            ...new Set(postPlusInstalled
+                .map((skill) => skill.scope)
+                .filter((scope) => scope.trim().length > 0)),
+        ].sort();
+        return {
+            ok: missingSkills.length === 0,
+            error: null,
+            installCommand: POSTPLUS_SKILLS_INSTALL_COMMAND,
+            installedCount: installedNames.size,
+            missingSkills,
+            requiredCount: requiredSkills.size,
+            scopes,
+            source: POSTPLUS_SKILLS_REPO,
+            updateCommand: formatPostPlusSkillUpdateCommand(),
+            uninstallCommand: formatPostPlusSkillUninstallCommand(),
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof Error
+                ? error.message
+                : 'Failed to inspect installed PostPlus skills.',
+            installCommand: POSTPLUS_SKILLS_INSTALL_COMMAND,
+            installedCount: 0,
+            missingSkills: [...requiredSkills],
+            requiredCount: requiredSkills.size,
+            scopes: [],
+            source: POSTPLUS_SKILLS_REPO,
+            updateCommand: formatPostPlusSkillUpdateCommand(),
+            uninstallCommand: formatPostPlusSkillUninstallCommand(),
+        };
+    }
+}
+export function formatSkillInstallStatusReport(report) {
+    const lines = ['PostPlus skills status', ''];
+    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(`  Scope: ${report.scopes.length > 0 ? report.scopes.join(', ') : 'none detected'}`);
+    if (report.missingSkills.length > 0) {
+        lines.push(`  Missing: ${formatSkillList(report.missingSkills, 8)}`, `  Fix: ${report.installCommand}`);
+    }
+    else {
+        lines.push(`  Update: ${report.updateCommand}`);
+    }
+    return lines.join('\n');
+}
+export function buildPostPlusSkillUpdateArgs(skillNames) {
+    return [...NPX_SKILLS, 'update', ...skillNames, '--yes'];
+}
+export function buildPostPlusSkillUninstallArgs(skillNames) {
+    return [
+        ...NPX_SKILLS,
+        'remove',
+        ...skillNames,
+        '--agent',
+        ...SKILLS_AGENTS,
+        '--yes',
+    ];
+}
+export function formatPostPlusSkillUpdateCommand() {
+    return 'postplus update';
+}
+export function formatPostPlusSkillUninstallCommand() {
+    return 'postplus uninstall';
+}
+async function listInstalledSkills(dependencies) {
+    const [project, global] = await Promise.all([
+        listInstalledSkillsForScope(dependencies, []),
+        listInstalledSkillsForScope(dependencies, ['--global']),
+    ]);
+    const byKey = new Map();
+    for (const skill of [...project, ...global]) {
+        byKey.set(`${skill.scope}:${skill.name}:${skill.path}`, skill);
+    }
+    return [...byKey.values()];
+}
+async function listInstalledSkillsForScope(dependencies, scopeArgs) {
+    const result = await dependencies.runCommand('npx', [...NPX_SKILLS, 'list', '--json', ...scopeArgs], {
+        timeoutMs: 60_000,
+    });
+    const parsed = JSON.parse(result.stdout);
+    if (!Array.isArray(parsed)) {
+        throw new Error('`skills list --json` returned an invalid payload.');
+    }
+    return parsed.map(normalizeInstalledSkillEntry);
+}
+function normalizeInstalledSkillEntry(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('`skills list --json` returned an invalid skill entry.');
+    }
+    const record = value;
+    const name = typeof record.name === 'string' ? record.name.trim() : '';
+    const skillPath = typeof record.path === 'string' ? record.path.trim() : '';
+    const scope = typeof record.scope === 'string' ? record.scope.trim() : '';
+    const agents = Array.isArray(record.agents)
+        ? record.agents
+            .filter((agent) => typeof agent === 'string')
+            .map((agent) => agent.trim())
+            .filter(Boolean)
+        : [];
+    if (!name || !skillPath || !scope) {
+        throw new Error('`skills list --json` returned an incomplete skill entry.');
+    }
+    return {
+        agents,
+        name,
+        path: skillPath,
+        scope,
+    };
+}
+function formatSkillList(skills, limit) {
+    const visible = skills.slice(0, limit);
+    const rest = skills.length - visible.length;
+    return rest > 0 ? `${visible.join(', ')} (+${rest} more)` : visible.join(', ');
+}

package/build/status.js

@@ -1,14 +1,27 @@
 import { formatAuthStatusReport, generateAuthStatusReport, } from './auth.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() {
-    const [doctor, auth] = await Promise.all([
-        generateDoctorReport(),
-        generateAuthStatusReport(),
+    return generateStatusReportWithDependencies();
+}
+export async function generateStatusReportWithDependencies(dependencies = {}) {
+    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(),
+        generateAuthStatus(),
+        generateSkillStatus(),
+        generateUpdateStatus(),
     ]);
     return {
-        ok: doctor.ok && auth.ok,
+        ok: doctor.ok && auth.ok && skills.ok && updates.ok,
         doctor,
         auth,
+        skills,
+        updates,
     };
 }
 export function formatStatusReport(report) {
@@ -20,5 +33,9 @@ export function formatStatusReport(report) {
         formatDoctorReport(report.doctor),
         '',
         formatAuthStatusReport(report.auth),
+        '',
+        formatSkillInstallStatusReport(report.skills),
+        '',
+        formatUpdateStatusReport(report.updates),
     ].join('\n');
 }

package/build/update-check.js

@@ -0,0 +1,229 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { getPostPlusConfigDir } from './local-state.js';
+import { POSTPLUS_SKILLS_REPO } from './skill-catalog.js';
+const UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1000;
+const UPDATE_CHECK_CACHE_FILE = 'update-check.json';
+const NPM_PACKAGE_NAME = '@postplus/cli';
+const NPM_LATEST_URL = `https://registry.npmjs.org/${encodeURIComponent(NPM_PACKAGE_NAME)}/latest`;
+const POSTPLUS_SKILLS_MAIN_URL = 'https://api.github.com/repos/PostPlusAI/postplus-skills/commits/main';
+export async function generateUpdateStatusReport(input = {}, dependencies = {
+    fetchFn: fetch,
+}) {
+    const currentVersion = await readCurrentCliVersion();
+    const cache = await readUpdateCheckCache();
+    if (cache &&
+        !input.force &&
+        cache.cli.currentVersion === currentVersion &&
+        Date.now() - Date.parse(cache.checkedAt) < UPDATE_CHECK_TTL_MS) {
+        return buildUpdateReport({
+            cache,
+            currentVersion,
+            previousSkillRevision: cache.skills.latestRevision,
+            source: 'cache',
+        });
+    }
+    try {
+        const [latestCliVersion, latestSkillRevision] = await Promise.all([
+            fetchLatestCliVersion(dependencies.fetchFn),
+            fetchLatestSkillRevision(dependencies.fetchFn),
+        ]);
+        const nextCache = {
+            checkedAt: new Date().toISOString(),
+            cli: {
+                currentVersion,
+                latestVersion: latestCliVersion,
+            },
+            skills: {
+                latestRevision: latestSkillRevision,
+            },
+        };
+        await writeUpdateCheckCache(nextCache);
+        return buildUpdateReport({
+            cache: nextCache,
+            currentVersion,
+            previousSkillRevision: input.resetSkillBaseline
+                ? latestSkillRevision
+                : cache?.skills.latestRevision ?? latestSkillRevision,
+            source: 'remote',
+        });
+    }
+    catch (error) {
+        const warning = error instanceof Error ? error.message : 'Update check failed.';
+        if (cache) {
+            return {
+                ...buildUpdateReport({
+                    cache,
+                    currentVersion,
+                    previousSkillRevision: cache.skills.latestRevision,
+                    source: 'cache',
+                }),
+                warning,
+            };
+        }
+        return {
+            checkedAt: null,
+            ok: true,
+            source: 'unavailable',
+            cli: {
+                currentVersion,
+                latestVersion: null,
+                updateAvailable: false,
+                updateCommand: 'npm install -g @postplus/cli',
+            },
+            skills: {
+                currentRevision: null,
+                latestRevision: null,
+                updateAvailable: false,
+                updateCommand: 'postplus update',
+            },
+            warning,
+        };
+    }
+}
+export async function refreshUpdateCheckBaseline() {
+    await generateUpdateStatusReport({
+        force: true,
+        resetSkillBaseline: true,
+    });
+}
+export function formatUpdateStatusReport(report) {
+    const lines = ['PostPlus update status', ''];
+    const cliMarker = report.cli.updateAvailable ? '[WARN]' : '[PASS]';
+    lines.push(`${cliMarker} CLI: ${report.cli.currentVersion}${report.cli.latestVersion ? ` (latest ${report.cli.latestVersion})` : ''}`);
+    if (report.cli.updateAvailable) {
+        lines.push(`  Update: ${report.cli.updateCommand}`);
+    }
+    const skillMarker = report.skills.updateAvailable ? '[WARN]' : '[PASS]';
+    lines.push(`${skillMarker} Skills: ${report.skills.latestRevision
+        ? `release ${shortRevision(report.skills.latestRevision)}`
+        : 'release unknown'}`);
+    if (report.skills.updateAvailable) {
+        lines.push(`  Update: ${report.skills.updateCommand}`);
+    }
+    lines.push(`  Checked: ${report.checkedAt ?? 'not checked'} (${report.source})`);
+    if (report.warning) {
+        lines.push(`  Warning: ${report.warning}`);
+    }
+    return lines.join('\n');
+}
+function buildUpdateReport(input) {
+    return {
+        checkedAt: input.cache.checkedAt,
+        ok: true,
+        source: input.source,
+        cli: {
+            currentVersion: input.currentVersion,
+            latestVersion: input.cache.cli.latestVersion,
+            updateAvailable: compareVersions(input.cache.cli.latestVersion, input.currentVersion) > 0,
+            updateCommand: 'npm install -g @postplus/cli',
+        },
+        skills: {
+            currentRevision: input.previousSkillRevision,
+            latestRevision: input.cache.skills.latestRevision,
+            updateAvailable: input.cache.skills.latestRevision !== input.previousSkillRevision,
+            updateCommand: 'postplus update',
+        },
+        warning: null,
+    };
+}
+async function readCurrentCliVersion() {
+    const packageJsonPath = new URL('../package.json', import.meta.url);
+    const raw = await readFile(packageJsonPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.version !== 'string' || !parsed.version.trim()) {
+        throw new Error('Could not read the current PostPlus CLI version.');
+    }
+    return parsed.version.trim();
+}
+async function fetchLatestCliVersion(fetchFn) {
+    const response = await fetchFn(NPM_LATEST_URL, {
+        headers: {
+            accept: 'application/json',
+            'user-agent': `postplus-cli-update-check/${await readCurrentCliVersion()}`,
+        },
+        signal: AbortSignal.timeout(15_000),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to check latest PostPlus CLI version (${response.status}).`);
+    }
+    const payload = (await response.json());
+    if (typeof payload.version !== 'string' || !payload.version.trim()) {
+        throw new Error('NPM returned an invalid PostPlus CLI version payload.');
+    }
+    return payload.version.trim();
+}
+async function fetchLatestSkillRevision(fetchFn) {
+    const response = await fetchFn(POSTPLUS_SKILLS_MAIN_URL, {
+        headers: {
+            accept: 'application/vnd.github+json',
+            'user-agent': `postplus-cli-update-check/${await readCurrentCliVersion()}`,
+        },
+        signal: AbortSignal.timeout(15_000),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to check latest ${POSTPLUS_SKILLS_REPO} revision (${response.status}).`);
+    }
+    const payload = (await response.json());
+    if (typeof payload.sha === 'string' && payload.sha.trim()) {
+        return payload.sha.trim();
+    }
+    return createHash('sha256')
+        .update(JSON.stringify(payload))
+        .digest('hex');
+}
+async function readUpdateCheckCache() {
+    try {
+        const raw = await readFile(getUpdateCheckCachePath(), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.checkedAt !== 'string' ||
+            typeof parsed.cli?.currentVersion !== 'string' ||
+            typeof parsed.cli?.latestVersion !== 'string' ||
+            typeof parsed.skills?.latestRevision !== 'string') {
+            return null;
+        }
+        return parsed;
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+}
+async function writeUpdateCheckCache(cache) {
+    const cachePath = getUpdateCheckCachePath();
+    await mkdir(dirname(cachePath), { recursive: true });
+    await writeFile(cachePath, `${JSON.stringify(cache, null, 2)}\n`, 'utf8');
+}
+function getUpdateCheckCachePath() {
+    return join(getPostPlusConfigDir(), UPDATE_CHECK_CACHE_FILE);
+}
+function compareVersions(a, b) {
+    const left = parseVersion(a);
+    const right = parseVersion(b);
+    const length = Math.max(left.length, right.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftPart = left[index] ?? 0;
+        const rightPart = right[index] ?? 0;
+        if (leftPart > rightPart) {
+            return 1;
+        }
+        if (leftPart < rightPart) {
+            return -1;
+        }
+    }
+    return 0;
+}
+function parseVersion(value) {
+    return value
+        .replace(/^[^\d]*/, '')
+        .split(/[.-]/)
+        .map((part) => Number.parseInt(part, 10))
+        .map((part) => (Number.isFinite(part) ? part : 0));
+}
+function shortRevision(revision) {
+    return revision.length > 12 ? revision.slice(0, 12) : revision;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postplus/cli",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "packageManager": "pnpm@10.30.3+sha512.c961d1e0a2d8e354ecaa5166b822516668b7f44cb5bd95122d590dd81922f606f5473b6d23ec4a5be05e7fcd18e8488d47d978bbe981872f1145d06e9a740017",
   "type": "module",
   "description": "PostPlus CLI for PostPlus Cloud auth, status, and diagnostics.",
@@ -10,12 +10,15 @@
     "build/auth-login.js",
     "build/auth-validate.js",
     "build/auth.js",
+    "build/command-runner.js",
     "build/doctor.js",
     "build/hosted-release.js",
     "build/index.js",
     "build/local-state.js",
     "build/skill-catalog.js",
+    "build/skill-management.js",
     "build/status.js",
+    "build/update-check.js",
     "LICENSE",
     "NOTICE",
     "README.md"