@postplus/cli 0.1.12 → 0.1.13

package/README.md

@@ -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
 ```
 
@@ -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/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.13",
   "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"