@postplus/cli 0.1.31 → 0.1.33

package/README.md

@@ -63,8 +63,9 @@ postplus studio status
 ```
 
 Studio creates a visible `PostPlus Studio/` folder in the current working
-directory. Assets, workflow files, activity, and provenance live inside that
-folder; hidden runtime cache and logs stay under `PostPlus Studio/.postplus/`.
+directory and opens the bundled local dashboard from the public CLI package.
+Assets, workflow files, activity, and provenance live inside that folder; hidden
+runtime cache and logs stay under `PostPlus Studio/.postplus/`.
 
 ## The Vision
 

package/build/index.js

@@ -43,7 +43,7 @@ Usage:
   postplus doctor [--skill <skill-id>] [--json]
   postplus quote confirm --json --challenge-file <path>
   postplus skills verify [--json]
-  postplus studio init|open|status
+  postplus studio init|open|status   Open bundled Local Studio
   postplus update [--current-directory]
   postplus uninstall [--current-directory]
   postplus list [--json]

package/build/skill-management.js

@@ -2,6 +2,7 @@ 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 DEFAULT_SKILL_MUTATION_OPTIONS = {
     scope: 'global',
@@ -31,6 +32,7 @@ export async function runPostPlusSkillUpdate(dependencies = {
         skillNames,
     });
     await writeCurrentCliVersionToLocalConfig();
+    await clearUpdateCheckCache();
     return 0;
 }
 export async function runPostPlusSkillUninstall(dependencies = {
@@ -46,6 +48,7 @@ export async function runPostPlusSkillUninstall(dependencies = {
     const exitCode = await dependencies.runInteractiveCommand('npx', buildPostPlusSkillUninstallArgs(allKnownSkillNames, options.scope));
     if (exitCode === 0) {
         await clearManagedSkillBaseline();
+        await clearUpdateCheckCache();
     }
     return exitCode;
 }
@@ -72,6 +75,7 @@ export async function runPostPlusSkillVerify(dependencies = {
         skillNames: inspection.requiredSkillNames,
     });
     await writeCurrentCliVersionToLocalConfig();
+    await clearUpdateCheckCache();
     return {
         ...inspection.report,
         baselineUpdated: true,

package/build/studio-server.js

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+import http from 'node:http';
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+export async function startStudioServer(argv = process.argv.slice(2)) {
+    const options = parseOptions(argv);
+    const server = http.createServer(async (request, response) => {
+        try {
+            await handleRequest(request, response, options);
+        }
+        catch (error) {
+            sendJson(response, 500, {
+                error: error instanceof Error ? error.message : String(error),
+                ok: false,
+            });
+        }
+    });
+    await new Promise((resolveListen, rejectListen) => {
+        server.once('error', rejectListen);
+        server.listen(options.port, options.host, () => {
+            server.off('error', rejectListen);
+            resolveListen();
+        });
+    });
+    process.on('SIGTERM', () => {
+        server.close(() => process.exit(0));
+    });
+    process.on('SIGINT', () => {
+        server.close(() => process.exit(0));
+    });
+    return server;
+}
+function parseOptions(argv) {
+    const options = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === '--studio-root') {
+            const value = readOptionValue(argv, index, arg);
+            options.studioRoot = resolve(value);
+            index += 1;
+            continue;
+        }
+        if (arg === '--host') {
+            options.host = readOptionValue(argv, index, arg);
+            index += 1;
+            continue;
+        }
+        if (arg === '--port') {
+            const value = Number(readOptionValue(argv, index, arg));
+            if (!Number.isInteger(value) || value <= 0) {
+                throw new Error('--port must be a positive integer.');
+            }
+            options.port = value;
+            index += 1;
+            continue;
+        }
+        if (arg === '--help' || arg === '-h') {
+            process.stdout.write(`Usage:
+  node build/studio-server.js --studio-root <dir> --host 127.0.0.1 --port 3978
+`);
+            process.exit(0);
+        }
+        throw new Error(`Unknown Studio server option: ${arg}`);
+    }
+    if (!options.studioRoot) {
+        throw new Error('Studio server requires --studio-root.');
+    }
+    return {
+        host: options.host ?? '127.0.0.1',
+        port: options.port ?? 3978,
+        studioRoot: options.studioRoot,
+    };
+}
+function readOptionValue(argv, index, name) {
+    const value = argv[index + 1];
+    if (!value || value.startsWith('--')) {
+        throw new Error(`Missing value for ${name}.`);
+    }
+    return value;
+}
+async function handleRequest(request, response, options) {
+    const url = new URL(request.url ?? '/', `http://${options.host}`);
+    if (request.method !== 'GET') {
+        sendJson(response, 405, { error: 'Method not allowed.', ok: false });
+        return;
+    }
+    if (url.pathname === '/api/health') {
+        sendJson(response, 200, { ok: true });
+        return;
+    }
+    if (url.pathname === '/api/project') {
+        sendJson(response, 200, await readStudioSnapshot(options.studioRoot));
+        return;
+    }
+    if (url.pathname === '/' ||
+        url.pathname === '/dashboard' ||
+        url.pathname === '/dashboard/') {
+        sendHtml(response, renderDashboardHtml());
+        return;
+    }
+    sendJson(response, 404, { error: 'Not found.', ok: false });
+}
+async function readStudioSnapshot(studioRoot) {
+    return {
+        activity: await readJsonLines(join(studioRoot, 'activity.jsonl')),
+        manifest: await readJsonFile(join(studioRoot, 'manifest.json')),
+        pipeline: await readJsonFile(join(studioRoot, 'pipeline.json')),
+        project: await readJsonFile(join(studioRoot, 'project.json')),
+        provenance: await readJsonLines(join(studioRoot, 'provenance.jsonl')),
+        studio: await readJsonFile(join(studioRoot, 'studio.json')),
+        studioRoot,
+    };
+}
+async function readJsonFile(path) {
+    if (!existsSync(path)) {
+        return null;
+    }
+    return JSON.parse(await readFile(path, 'utf8'));
+}
+async function readJsonLines(path) {
+    if (!existsSync(path)) {
+        return [];
+    }
+    const lines = (await readFile(path, 'utf8'))
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean);
+    return lines.slice(-50).map((line) => JSON.parse(line));
+}
+function sendJson(response, statusCode, payload) {
+    response.writeHead(statusCode, {
+        'cache-control': 'no-store',
+        'content-type': 'application/json; charset=utf-8',
+    });
+    response.end(`${JSON.stringify(payload, null, 2)}\n`);
+}
+function sendHtml(response, html) {
+    response.writeHead(200, {
+        'cache-control': 'no-store',
+        'content-type': 'text/html; charset=utf-8',
+    });
+    response.end(html);
+}
+function renderDashboardHtml() {
+    return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>PostPlus Studio</title>
+  <style>
+    :root { color-scheme: light; font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+    body { margin: 0; background: #f7f7f4; color: #1f2933; }
+    header { border-bottom: 1px solid #d6d8dc; background: #ffffff; padding: 20px 28px; }
+    main { display: grid; gap: 16px; grid-template-columns: 280px minmax(0, 1fr); padding: 20px 28px 28px; }
+    h1 { font-size: 22px; line-height: 1.2; margin: 0 0 6px; }
+    h2 { font-size: 13px; letter-spacing: 0; line-height: 1.25; margin: 0 0 10px; text-transform: uppercase; color: #5b6472; }
+    p { margin: 0; }
+    .subtle { color: #627083; font-size: 13px; }
+    .panel { background: #ffffff; border: 1px solid #d8dce2; border-radius: 8px; padding: 14px; min-width: 0; }
+    .stack { display: grid; gap: 12px; }
+    .grid { display: grid; gap: 12px; grid-template-columns: repeat(3, minmax(0, 1fr)); }
+    .row { align-items: center; display: flex; justify-content: space-between; gap: 12px; border-top: 1px solid #edf0f2; padding-top: 10px; margin-top: 10px; }
+    .label { color: #5b6472; font-size: 12px; }
+    .value { font-size: 13px; font-weight: 600; overflow-wrap: anywhere; }
+    .step { border: 1px solid #dfe3e8; border-radius: 6px; padding: 10px; background: #fbfbfa; }
+    .step-title { font-size: 13px; font-weight: 700; }
+    .status { color: #0f766e; font-size: 12px; margin-top: 4px; }
+    pre { background: #111827; border-radius: 8px; color: #e5e7eb; font-size: 12px; line-height: 1.45; margin: 0; max-height: 420px; overflow: auto; padding: 12px; white-space: pre-wrap; }
+    @media (max-width: 840px) { main { grid-template-columns: 1fr; padding: 16px; } header { padding: 18px 16px; } .grid { grid-template-columns: 1fr; } }
+  </style>
+</head>
+<body>
+  <header>
+    <h1>PostPlus Studio</h1>
+    <p class="subtle" id="studio-root">Loading workspace...</p>
+  </header>
+  <main>
+    <section class="stack">
+      <div class="panel">
+        <h2>Project</h2>
+        <div class="row"><span class="label">Name</span><span class="value" id="project-name">-</span></div>
+        <div class="row"><span class="label">Status</span><span class="value" id="project-status">-</span></div>
+      </div>
+      <div class="panel">
+        <h2>Pipeline</h2>
+        <div id="pipeline-steps" class="stack"></div>
+      </div>
+    </section>
+    <section class="stack">
+      <div class="grid">
+        <div class="panel"><h2>Assets</h2><p class="value" id="asset-count">-</p></div>
+        <div class="panel"><h2>Activity</h2><p class="value" id="activity-count">-</p></div>
+        <div class="panel"><h2>Provenance</h2><p class="value" id="provenance-count">-</p></div>
+      </div>
+      <div class="panel">
+        <h2>Workspace JSON</h2>
+        <pre id="snapshot">{}</pre>
+      </div>
+    </section>
+  </main>
+  <script>
+    const text = (id, value) => { document.getElementById(id).textContent = value ?? '-'; };
+    const render = async () => {
+      const response = await fetch('/api/project');
+      const data = await response.json();
+      const project = data.project || {};
+      const pipeline = data.pipeline || {};
+      const manifest = data.manifest || {};
+      text('studio-root', data.studioRoot || '');
+      text('project-name', project.name || project.project_id || 'PostPlus Studio');
+      text('project-status', project.status || 'active');
+      text('asset-count', Array.isArray(manifest.assets) ? String(manifest.assets.length) : '0');
+      text('activity-count', Array.isArray(data.activity) ? String(data.activity.length) : '0');
+      text('provenance-count', Array.isArray(data.provenance) ? String(data.provenance.length) : '0');
+      const steps = Array.isArray(pipeline.steps) ? pipeline.steps : [];
+      document.getElementById('pipeline-steps').innerHTML = steps.map((step) =>
+        '<div class="step"><div class="step-title">' + escapeHtml(step.name || step.id || 'Step') + '</div><div class="status">' + escapeHtml(step.status || 'pending') + '</div></div>'
+      ).join('') || '<p class="subtle">No pipeline steps yet.</p>';
+      document.getElementById('snapshot').textContent = JSON.stringify(data, null, 2);
+    };
+    const escapeHtml = (value) => String(value).replace(/[&<>"']/g, (char) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[char]));
+    render().catch((error) => {
+      document.getElementById('snapshot').textContent = error.stack || error.message || String(error);
+    });
+  </script>
+</body>
+</html>`;
+}
+if (process.argv[1] && basename(process.argv[1])?.startsWith('studio-server')) {
+    startStudioServer().catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.stack || error.message : String(error)}\n`);
+        process.exit(1);
+    });
+}

package/build/studio.js

@@ -1,6 +1,7 @@
-import { spawn, spawnSync } from 'node:child_process';
-import { access, mkdir, writeFile, } from 'node:fs/promises';
-import { constants as fsConstants } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { access, mkdir, readFile, writeFile, } from 'node:fs/promises';
+import { closeSync, constants as fsConstants, openSync } from 'node:fs';
+import net from 'node:net';
 import { platform } from 'node:os';
 import { basename, dirname, join, resolve, } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -12,6 +13,10 @@ export async function runStudioCommand(args) {
         printStudioHelp();
         return 0;
     }
+    if (rest.some((arg) => ['help', '--help', '-h'].includes(arg))) {
+        printStudioHelp();
+        return 0;
+    }
     const options = parseStudioOptions(rest);
     switch (subcommand) {
         case 'init': {
@@ -43,7 +48,8 @@ Usage:
   postplus studio open [--workdir <dir>] [--port 3978] [--no-browser] [--json]
   postplus studio status [--workdir <dir>] [--json]
 
-Studio creates a visible "PostPlus Studio" folder inside the selected working directory.
+Local Studio is a public local workspace included in the PostPlus CLI package.
+Studio creates a visible "PostPlus Studio" folder inside the selected working directory and opens the bundled local dashboard.
 `);
 }
 function parseStudioOptions(args) {
@@ -192,76 +198,155 @@ async function getStudioStatus(workdir) {
 }
 async function openStudio(options) {
     const { studioRoot } = await initializeStudio(options.workdir);
-    const runtimeRoot = await resolveStudioRuntimeRoot();
-    const launcher = join(runtimeRoot, 'skills/00-core/postplus-workspace-dashboard/scripts/launch_workspace_dashboard.mjs');
-    const result = spawnSync(process.execPath, [
-        launcher,
+    const parsed = await launchBundledStudioServer(studioRoot, options.port);
+    if (options.browser) {
+        openSystemBrowser(parsed.url);
+    }
+    return {
+        ok: true,
+        studioRoot,
+        ...parsed,
+    };
+}
+async function launchBundledStudioServer(studioRoot, startPort) {
+    const existing = await readLiveStudioServerState(studioRoot);
+    if (existing) {
+        return {
+            logPath: existing.logPath,
+            pid: existing.pid,
+            reused: true,
+            url: existing.dashboardUrl,
+        };
+    }
+    const host = '127.0.0.1';
+    const port = await findAvailablePort(startPort, host);
+    const baseUrl = `http://${host}:${port}`;
+    const dashboardUrl = `${baseUrl}/dashboard/`;
+    const logDir = join(studioRoot, '.postplus', 'logs');
+    await mkdir(logDir, { recursive: true });
+    const logPath = join(logDir, 'studio-server.log');
+    const logFd = openSync(logPath, 'a');
+    const serverEntrypoint = resolveBundledStudioServerEntrypoint();
+    const packageRoot = resolveCliPackageRoot();
+    const child = spawn(process.execPath, [
+        ...buildNodeLoaderArgs(serverEntrypoint),
+        serverEntrypoint,
         '--studio-root',
         studioRoot,
         '--host',
-        '127.0.0.1',
+        host,
         '--port',
-        String(options.port),
-        '--skip-build',
+        String(port),
     ], {
-        cwd: runtimeRoot,
-        encoding: 'utf8',
+        cwd: packageRoot,
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
     });
-    if (result.status !== 0) {
-        throw new Error(result.stderr || result.stdout || 'Failed to open Studio.');
+    child.unref();
+    closeSync(logFd);
+    try {
+        await waitForStudioServer(baseUrl, logPath);
     }
-    const parsed = JSON.parse(result.stdout);
-    if (options.browser) {
-        openSystemBrowser(parsed.url);
+    catch (error) {
+        if (child.pid) {
+            try {
+                process.kill(child.pid);
+            }
+            catch {
+                // The process already exited; the readiness error below carries the failure.
+            }
+        }
+        throw error;
     }
-    return {
-        ok: true,
-        runtimeRoot,
+    const state = {
+        baseUrl,
+        dashboardUrl,
+        logPath,
+        pid: child.pid,
+        startedAt: new Date().toISOString(),
         studioRoot,
-        ...parsed,
     };
+    await writeJson(getStudioServerStatePath(studioRoot), state);
+    return {
+        logPath,
+        pid: child.pid,
+        reused: false,
+        url: dashboardUrl,
+    };
+}
+function resolveBundledStudioServerEntrypoint() {
+    const currentModulePath = fileURLToPath(import.meta.url);
+    const extension = currentModulePath.endsWith('.ts') ? '.ts' : '.js';
+    return join(dirname(currentModulePath), `studio-server${extension}`);
+}
+function resolveCliPackageRoot() {
+    return dirname(dirname(fileURLToPath(import.meta.url)));
+}
+function buildNodeLoaderArgs(entrypoint) {
+    return entrypoint.endsWith('.ts') ? ['--import', 'tsx'] : [];
 }
-async function resolveStudioRuntimeRoot() {
-    const envRoot = process.env.POSTPLUS_STUDIO_RUNTIME_ROOT?.trim();
-    if (envRoot) {
-        return assertStudioRuntimeRoot(resolve(envRoot));
+async function readLiveStudioServerState(studioRoot) {
+    const state = await readJsonIfExists(getStudioServerStatePath(studioRoot));
+    if (!state?.baseUrl || !state.dashboardUrl) {
+        return null;
     }
-    const candidates = [
-        process.cwd(),
-        dirname(fileURLToPath(import.meta.url)),
-        ...ancestorDirs(process.cwd()),
-    ];
-    for (const base of candidates) {
-        for (const candidate of [
-            base,
-            join(base, 'packages/vibe_marketing'),
-            join(base, '../packages/vibe_marketing'),
-            join(base, '../../packages/vibe_marketing'),
-        ]) {
-            if (await isStudioRuntimeRoot(resolve(candidate))) {
-                return resolve(candidate);
-            }
+    if (await canFetchStudioServer(state.baseUrl)) {
+        return state;
+    }
+    return null;
+}
+function getStudioServerStatePath(studioRoot) {
+    return join(studioRoot, '.postplus', 'studio-server.json');
+}
+async function readJsonIfExists(path) {
+    if (!(await pathExists(path))) {
+        return null;
+    }
+    try {
+        return JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+async function waitForStudioServer(baseUrl, logPath) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < 5000) {
+        if (await canFetchStudioServer(baseUrl)) {
+            return;
         }
+        await new Promise((resolveDelay) => setTimeout(resolveDelay, 150));
     }
-    throw new Error('PostPlus Studio runtime was not found. Set POSTPLUS_STUDIO_RUNTIME_ROOT to the vibe_marketing authoring repo.');
+    throw new Error(`Studio server did not become ready at ${baseUrl}. See log: ${logPath}`);
 }
-function ancestorDirs(start) {
-    const dirs = [];
-    let current = resolve(start);
-    while (dirname(current) !== current) {
-        current = dirname(current);
-        dirs.push(current);
+async function canFetchStudioServer(baseUrl) {
+    try {
+        const response = await fetch(`${baseUrl.replace(/\/$/u, '')}/api/health`, {
+            signal: AbortSignal.timeout(1200),
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
     }
-    return dirs;
 }
-async function assertStudioRuntimeRoot(root) {
-    if (!(await isStudioRuntimeRoot(root))) {
-        throw new Error(`Invalid PostPlus Studio runtime root: ${root}`);
+async function findAvailablePort(startPort, host) {
+    for (let port = startPort; port < startPort + 50; port += 1) {
+        if (await isPortAvailable(port, host)) {
+            return port;
+        }
     }
-    return root;
+    throw new Error(`No available Studio port found from ${startPort} to ${startPort + 49}.`);
 }
-async function isStudioRuntimeRoot(root) {
-    return pathExists(join(root, 'skills/00-core/postplus-workspace-dashboard/scripts/launch_workspace_dashboard.mjs'));
+function isPortAvailable(port, host) {
+    return new Promise((resolveAvailable) => {
+        const server = net.createServer();
+        server.once('error', () => resolveAvailable(false));
+        server.once('listening', () => {
+            server.close(() => resolveAvailable(true));
+        });
+        server.listen(port, host);
+    });
 }
 async function pathExists(path) {
     try {

package/build/update-check.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { readCurrentCliVersion } from './client-compatibility.js';
 import { runInteractiveCommand as runDefaultInteractiveCommand, } from './command-runner.js';
@@ -88,6 +88,11 @@ export async function refreshUpdateCheckCache() {
         force: true,
     });
 }
+export async function clearUpdateCheckCache() {
+    await rm(getUpdateCheckCachePath(), {
+        force: true,
+    });
+}
 export async function runCliSelfUpdateIfOutdated(dependencies = {}) {
     const fetchFn = dependencies.fetchFn ?? fetch;
     const runInteractiveCommand = dependencies.runInteractiveCommand ?? runDefaultInteractiveCommand;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@postplus/cli",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "packageManager": "pnpm@10.30.3+sha512.c961d1e0a2d8e354ecaa5166b822516668b7f44cb5bd95122d590dd81922f606f5473b6d23ec4a5be05e7fcd18e8488d47d978bbe981872f1145d06e9a740017",
   "type": "module",
   "description": "PostPlus CLI for PostPlus Cloud auth, status, and diagnostics.",
@@ -23,6 +23,7 @@
     "build/skill-management.js",
     "build/status.js",
     "build/studio.js",
+    "build/studio-server.js",
     "build/subscription-status.js",
     "build/update-check.js",
     "LICENSE",