@agenthippo-ai/agenthippo 0.1.0

package/out/spotlight/publish.js

@@ -0,0 +1,544 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveViewPublishVersionFromParsed = resolveViewPublishVersionFromParsed;
+exports.discoverPublishableViews = discoverPublishableViews;
+exports.validateViewForPublish = validateViewForPublish;
+exports.collectViewFiles = collectViewFiles;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const branding_1 = require("../branding");
+const publish_1 = require("../engines/publish");
+const utils_1 = require("../utils");
+const index_1 = require("../utils/index");
+const yaml_1 = require("./yaml");
+/**
+ * Resolve publish semver from view.yaml.
+ * Prefers string `version` (e.g. 1.0.0); falls back to legacy `semver` or numeric `version: 1` (no publish version).
+ */
+function resolveViewPublishVersionFromParsed(parsed) {
+    if (!parsed) {
+        return undefined;
+    }
+    if (typeof parsed.version === 'string' && parsed.version.trim()) {
+        const value = parsed.version.trim().replace(/^v/, '');
+        if ((0, publish_1.isValidPublishVersion)(value)) {
+            return value;
+        }
+    }
+    // Legacy publish field (prefer `version: 1.0.0` in new views).
+    if (typeof parsed.semver === 'string' && parsed.semver.trim()) {
+        const legacy = parsed.semver.trim().replace(/^v/, '');
+        if ((0, publish_1.isValidPublishVersion)(legacy)) {
+            return legacy;
+        }
+    }
+    return undefined;
+}
+// -----------------------------------------------------------------------------
+// Constants
+// -----------------------------------------------------------------------------
+const RESERVED_VIEW_IDS = new Set(['global', 'workspace', 'fleet', 'workflows', 'default']);
+const VIEW_MANIFEST_NAME = 'view.yaml';
+const PANEL_ENTRY_NAME = 'panel-entry.yaml';
+/** View subdirs excluded when walking scripts/ (scripts-only and full). */
+const SCRIPTS_TREE_EXCLUDED_DIRS = new Set([
+    'charts',
+    'reports',
+    'exports',
+    'panel-state',
+    'assets',
+    'images',
+]);
+/** Included in full bundle mode (scripts-only still ships scripts/ only). */
+const FULL_BUNDLE_DIRS = ['assets', 'images', 'charts', 'reports', 'exports'];
+const ARTIFACT_MANIFEST_NAME = 'manifest.json';
+const BINARY_EXTENSIONS = new Set([
+    '.png',
+    '.jpg',
+    '.jpeg',
+    '.gif',
+    '.webp',
+    '.pdf',
+    '.ico',
+    '.woff',
+    '.woff2',
+]);
+const EXCLUDED_DIR_NAMES = new Set([
+    ...SCRIPTS_TREE_EXCLUDED_DIRS,
+    'node_modules',
+    '.git',
+    '.hg',
+    '.svn',
+    '.DS_Store',
+    '__pycache__',
+    '.turbo',
+    '.cache',
+]);
+const EXCLUDED_FILE_NAMES = new Set([
+    '.DS_Store',
+    'Thumbs.db',
+]);
+const SECRET_PATTERNS = [
+    ['private key', /-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/],
+    ['OpenAI-style key', /\bsk-(?!dummy\b|ant-)[A-Za-z0-9_-]{20,}\b/],
+    ['Anthropic key', /\bsk-ant-[A-Za-z0-9_-]{20,}\b/],
+    ['Google API key', /\bAIza[0-9A-Za-z_-]{30,}\b/],
+    ['GitHub token', /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/],
+    ['Atlassian API token', /\bATATT[A-Za-z0-9_=+/\-]{20,}\b/],
+    ['AWS access key', /\bAKIA[0-9A-Z]{16}\b/],
+    ['JWT', /\beyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{10,}\b/],
+];
+const MAX_FILE_SIZE = 1024 * 1024;
+const MAX_BUNDLE_SIZE = 10 * 1024 * 1024;
+// -----------------------------------------------------------------------------
+// Helpers
+// -----------------------------------------------------------------------------
+function parseStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .filter((entry) => typeof entry === 'string' && entry.trim().length > 0)
+        .map(entry => path.basename(entry.trim()));
+}
+function dedupeBasenames(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        const basename = path.basename(value.trim());
+        if (!basename || seen.has(basename)) {
+            continue;
+        }
+        seen.add(basename);
+        result.push(basename);
+    }
+    return result;
+}
+function getAnalyticsRoots(workspaceRoot) {
+    const candidates = [];
+    if (workspaceRoot?.trim()) {
+        candidates.push({
+            root: path.join(workspaceRoot.trim(), branding_1.AGENTIDE_DIR_NAME, 'analytics'),
+            label: 'workspace',
+        });
+    }
+    candidates.push({
+        root: path.join((0, index_1.getAgentideHome)(), 'analytics'),
+        label: 'home',
+    });
+    return candidates;
+}
+function getViewsConfigPath(analyticsRoot) {
+    return path.join(analyticsRoot, 'panel', 'views.yaml');
+}
+async function readViewsConfig(viewsConfigPath) {
+    try {
+        const raw = await fs_1.promises.readFile(viewsConfigPath, 'utf-8');
+        const parsed = (0, yaml_1.parseSpotlightYamlRecord)(raw);
+        const views = Array.isArray(parsed?.views) ? parsed.views : [];
+        const result = [];
+        for (const item of views) {
+            if (!item || typeof item !== 'object') {
+                continue;
+            }
+            const candidate = item;
+            const id = (0, yaml_1.normalizeSpotlightViewId)(typeof candidate.id === 'string' ? candidate.id : undefined);
+            if (!id) {
+                continue;
+            }
+            const scope = candidate.scope === 'workspace' ? 'workspace' : 'global';
+            const name = typeof candidate.name === 'string' && candidate.name.trim() ? candidate.name.trim() : id;
+            const scripts = dedupeBasenames(parseStringArray(candidate.scripts));
+            const system = candidate.system === true;
+            result.push({ id, name, scope, scripts, system });
+        }
+        return result;
+    }
+    catch {
+        return [];
+    }
+}
+async function readViewMetadataFile(viewRoot) {
+    const metadataPath = path.join(viewRoot, VIEW_MANIFEST_NAME);
+    try {
+        const raw = await fs_1.promises.readFile(metadataPath, 'utf-8');
+        const parsed = (0, yaml_1.parseSpotlightYamlRecord)(raw);
+        if (!parsed) {
+            return undefined;
+        }
+        const id = (0, yaml_1.normalizeSpotlightViewId)(typeof parsed.id === 'string' ? parsed.id : undefined);
+        if (!id) {
+            return undefined;
+        }
+        const scope = parsed.scope === 'workspace' ? 'workspace' : 'global';
+        const name = typeof parsed.name === 'string' && parsed.name.trim() ? parsed.name.trim() : id;
+        return {
+            id,
+            name,
+            description: typeof parsed.description === 'string' ? parsed.description.trim() : undefined,
+            author: typeof parsed.author === 'string' ? parsed.author.trim() : undefined,
+            publishVersion: resolveViewPublishVersionFromParsed(parsed),
+            scope,
+            tags: Array.isArray(parsed.tags)
+                ? parsed.tags.filter((tag) => typeof tag === 'string')
+                : undefined,
+            scripts: dedupeBasenames(parseStringArray(parsed.scripts)),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function scanForSecrets(files) {
+    const findings = [];
+    for (const file of files) {
+        for (const [label, pattern] of SECRET_PATTERNS) {
+            if (pattern.test(file.content)) {
+                findings.push(`${file.rel}: possible ${label}`);
+            }
+        }
+    }
+    return findings;
+}
+function shouldExcludeEntry(name, isDirectory) {
+    if (EXCLUDED_FILE_NAMES.has(name)) {
+        return true;
+    }
+    if (name.startsWith('.') && name !== '.') {
+        return true;
+    }
+    if (isDirectory && EXCLUDED_DIR_NAMES.has(name)) {
+        return true;
+    }
+    if (/^\.env(?:\.|$)/.test(name)) {
+        return true;
+    }
+    if (/\.log$/i.test(name)) {
+        return true;
+    }
+    return false;
+}
+function shouldExcludeFullBundleEntry(name, isDirectory) {
+    if (EXCLUDED_FILE_NAMES.has(name)) {
+        return true;
+    }
+    if (name.startsWith('.')) {
+        return true;
+    }
+    if (isDirectory && (name === 'node_modules' || name === '__pycache__')) {
+        return true;
+    }
+    if (/^\.env(?:\.|$)/.test(name)) {
+        return true;
+    }
+    if (/\.log$/i.test(name)) {
+        return true;
+    }
+    return false;
+}
+function isBinaryAssetPath(relPath) {
+    const ext = path.extname(relPath).toLowerCase();
+    return BINARY_EXTENSIONS.has(ext);
+}
+async function readFileForBundle(fullPath, relPath) {
+    const buffer = await fs_1.promises.readFile(fullPath);
+    if (buffer.includes(0) || isBinaryAssetPath(relPath)) {
+        return {
+            path: relPath,
+            content: buffer.toString('base64'),
+            encoding: 'base64',
+        };
+    }
+    return {
+        path: relPath,
+        content: buffer.toString('utf-8'),
+        encoding: 'utf-8',
+    };
+}
+async function countFullBundleContentFiles(viewRoot) {
+    let count = 0;
+    for (const dirName of FULL_BUNDLE_DIRS) {
+        const dir = path.join(viewRoot, dirName);
+        if (!(await (0, utils_1.pathExists)(dir))) {
+            continue;
+        }
+        async function walk(current) {
+            const entries = await fs_1.promises.readdir(current, { withFileTypes: true });
+            for (const entry of entries) {
+                if (shouldExcludeFullBundleEntry(entry.name, entry.isDirectory())) {
+                    continue;
+                }
+                const fullPath = path.join(current, entry.name);
+                if (entry.isDirectory()) {
+                    await walk(fullPath);
+                    continue;
+                }
+                count++;
+            }
+        }
+        await walk(dir);
+    }
+    if (await (0, utils_1.pathExists)(path.join(viewRoot, ARTIFACT_MANIFEST_NAME))) {
+        count++;
+    }
+    return count;
+}
+async function walkFullBundleContent(viewRoot, onFile) {
+    for (const dirName of FULL_BUNDLE_DIRS) {
+        const dir = path.join(viewRoot, dirName);
+        if (await (0, utils_1.pathExists)(dir)) {
+            await walkBundleTree(dir, dirName, shouldExcludeFullBundleEntry, onFile);
+        }
+    }
+    const manifestPath = path.join(viewRoot, ARTIFACT_MANIFEST_NAME);
+    if (await (0, utils_1.pathExists)(manifestPath)) {
+        const stat = await fs_1.promises.stat(manifestPath);
+        await onFile(manifestPath, ARTIFACT_MANIFEST_NAME, stat.size);
+    }
+}
+async function walkBundleTree(dir, prefix, exclude, onFile) {
+    const entries = await fs_1.promises.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (exclude(entry.name, entry.isDirectory())) {
+            continue;
+        }
+        const fullPath = path.join(dir, entry.name);
+        const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            await walkBundleTree(fullPath, rel, exclude, onFile);
+            continue;
+        }
+        const stat = await fs_1.promises.stat(fullPath);
+        await onFile(fullPath, rel, stat.size);
+    }
+}
+// -----------------------------------------------------------------------------
+// Discovery
+// -----------------------------------------------------------------------------
+/**
+ * Find user-authored Spotlight views that can be published from workspace or home analytics.
+ */
+async function discoverPublishableViews(workspaceRoot) {
+    const byId = new Map();
+    for (const { root: analyticsRoot, label } of getAnalyticsRoots(workspaceRoot)) {
+        const viewsConfigPath = getViewsConfigPath(analyticsRoot);
+        if (!(await (0, utils_1.pathExists)(viewsConfigPath))) {
+            continue;
+        }
+        const configuredViews = await readViewsConfig(viewsConfigPath);
+        for (const view of configuredViews) {
+            if (view.system || RESERVED_VIEW_IDS.has(view.id)) {
+                continue;
+            }
+            if (byId.has(view.id)) {
+                continue;
+            }
+            const viewRoot = path.join(analyticsRoot, 'views', view.id);
+            const metadata = await readViewMetadataFile(viewRoot);
+            const scripts = dedupeBasenames(metadata?.scripts.length ? metadata.scripts : view.scripts);
+            byId.set(view.id, {
+                id: view.id,
+                name: metadata?.name ?? view.name,
+                scope: metadata?.scope ?? view.scope,
+                scripts,
+                viewRoot,
+                viewsConfigPath,
+                analyticsRoot,
+                sourceLabel: label,
+            });
+        }
+    }
+    return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+// -----------------------------------------------------------------------------
+// Validation
+// -----------------------------------------------------------------------------
+/**
+ * Validate a Spotlight view before publishing to the store.
+ */
+async function validateViewForPublish(summary, options) {
+    const mode = options?.mode ?? 'scripts-only';
+    const expectedId = options?.expectedId;
+    const errors = [];
+    const warnings = [];
+    if (expectedId && expectedId !== summary.id) {
+        errors.push(`View id "${expectedId}" does not match selected view "${summary.id}"`);
+    }
+    if (RESERVED_VIEW_IDS.has(summary.id)) {
+        errors.push(`View id "${summary.id}" is reserved for built-in Spotlight views`);
+    }
+    if (!(await (0, utils_1.pathExists)(summary.viewRoot))) {
+        errors.push(`View directory not found: ${summary.viewRoot}`);
+        return { valid: false, errors, warnings };
+    }
+    const metadata = await readViewMetadataFile(summary.viewRoot);
+    const scripts = dedupeBasenames(metadata?.scripts.length ? metadata.scripts : summary.scripts);
+    const fullBundleContentCount = mode === 'full' ? await countFullBundleContentFiles(summary.viewRoot) : 0;
+    if (!metadata) {
+        warnings.push('Missing view.yaml; publish will generate manifest from panel config');
+    }
+    if (!metadata?.description) {
+        warnings.push('Consider adding description to view.yaml for store discoverability');
+    }
+    if (!metadata?.tags || metadata.tags.length === 0) {
+        warnings.push('Consider adding tags to view.yaml for store discoverability');
+    }
+    if (mode === 'scripts-only') {
+        if (scripts.length === 0) {
+            errors.push('View has no scripts registered');
+        }
+    }
+    else if (scripts.length === 0 && fullBundleContentCount === 0) {
+        errors.push('Full bundle requires at least one script or content under assets/, images/, charts/, reports/, exports/, or manifest.json');
+    }
+    else if (scripts.length === 0) {
+        warnings.push('Publishing generated artifacts only (no widget scripts)');
+    }
+    const scriptsDir = path.join(summary.viewRoot, 'scripts');
+    for (const scriptName of scripts) {
+        const scriptPath = path.join(scriptsDir, scriptName);
+        if (!(await (0, utils_1.pathExists)(scriptPath))) {
+            errors.push(`Missing script file: scripts/${scriptName}`);
+        }
+    }
+    const rawFiles = [];
+    let bundleSize = 0;
+    async function trackFile(fullPath, rel, size) {
+        if (size === undefined) {
+            const stat = await fs_1.promises.stat(fullPath);
+            size = stat.size;
+        }
+        if (size > MAX_FILE_SIZE) {
+            errors.push(`File too large (>1MB): ${rel}`);
+            return;
+        }
+        bundleSize += size;
+        if (bundleSize > MAX_BUNDLE_SIZE) {
+            errors.push('Total bundle size exceeds 10MB');
+            return;
+        }
+        if (isBinaryAssetPath(rel)) {
+            return;
+        }
+        const buffer = await fs_1.promises.readFile(fullPath);
+        rawFiles.push({ rel, content: buffer.toString('utf-8') });
+    }
+    if (await (0, utils_1.pathExists)(scriptsDir)) {
+        await walkBundleTree(scriptsDir, 'scripts', shouldExcludeEntry, trackFile);
+    }
+    if (mode === 'full') {
+        await walkFullBundleContent(summary.viewRoot, trackFile);
+    }
+    const secretFindings = await scanForSecrets(rawFiles);
+    if (secretFindings.length > 0) {
+        errors.push(`Possible secrets found:\n${secretFindings.map(f => `  - ${f}`).join('\n')}`);
+    }
+    const resolvedMetadata = {
+        id: summary.id,
+        name: metadata?.name ?? summary.name,
+        description: metadata?.description,
+        author: metadata?.author,
+        publishVersion: metadata?.publishVersion,
+        scope: metadata?.scope ?? summary.scope,
+        tags: metadata?.tags,
+        scripts,
+        ...(mode === 'full' ? { publishBundle: 'full' } : {}),
+    };
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+        metadata: errors.length === 0 ? resolvedMetadata : undefined,
+    };
+}
+// -----------------------------------------------------------------------------
+// Publish bundle
+// -----------------------------------------------------------------------------
+/**
+ * Collect store files for a Spotlight view publish.
+ */
+async function collectViewFiles(summary, publishVersion, metadata, mode = 'scripts-only') {
+    if (!(0, publish_1.isValidPublishVersion)(publishVersion.replace(/^v/, ''))) {
+        throw new Error(`Invalid publish version: ${publishVersion}`);
+    }
+    const files = [];
+    const scriptsDir = path.join(summary.viewRoot, 'scripts');
+    const normalizedVersion = publishVersion.replace(/^v/, '');
+    const manifestForYaml = {
+        version: normalizedVersion,
+        id: summary.id,
+        name: metadata.name,
+        scope: metadata.scope,
+        scripts: metadata.scripts,
+        ...(metadata.description ? { description: metadata.description } : {}),
+        ...(metadata.author ? { author: metadata.author } : {}),
+        ...(metadata.tags?.length ? { tags: metadata.tags } : {}),
+        ...(mode === 'full' ? { publishBundle: 'full' } : {}),
+    };
+    files.push({
+        path: VIEW_MANIFEST_NAME,
+        content: (0, yaml_1.dumpSpotlightYaml)(manifestForYaml),
+        encoding: 'utf-8',
+    });
+    files.push({
+        path: PANEL_ENTRY_NAME,
+        content: (0, yaml_1.dumpSpotlightYaml)({
+            id: summary.id,
+            name: metadata.name,
+            scope: metadata.scope,
+            scripts: metadata.scripts,
+        }),
+        encoding: 'utf-8',
+    });
+    const readmePath = path.join(summary.viewRoot, 'README.md');
+    if (await (0, utils_1.pathExists)(readmePath)) {
+        files.push(await readFileForBundle(readmePath, 'README.md'));
+    }
+    if (await (0, utils_1.pathExists)(scriptsDir)) {
+        await walkBundleTree(scriptsDir, 'scripts', shouldExcludeEntry, async (fullPath, rel) => {
+            files.push(await readFileForBundle(fullPath, rel));
+        });
+    }
+    if (mode === 'full') {
+        await walkFullBundleContent(summary.viewRoot, async (fullPath, rel) => {
+            files.push(await readFileForBundle(fullPath, rel));
+        });
+    }
+    return files;
+}

package/out/spotlight/yaml.js

@@ -0,0 +1,31 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeSpotlightViewId = normalizeSpotlightViewId;
+exports.parseSpotlightYamlRecord = parseSpotlightYamlRecord;
+exports.dumpSpotlightYaml = dumpSpotlightYaml;
+/**
+ * Shared YAML and view-id helpers for Spotlight publish/install flows.
+ */
+const viewsConfigMerge_1 = require("../analytics/dashboard/viewsConfigMerge");
+/** Normalize a Spotlight view id (publish/install); dashboard code uses {@link normalizeDashboardViewId}. */
+function normalizeSpotlightViewId(raw, fallback = 'view') {
+    return (0, viewsConfigMerge_1.normalizeDashboardViewId)(raw, fallback);
+}
+/** Parse YAML object documents used by view.yaml, panel-entry.yaml, and views.yaml. */
+function parseSpotlightYamlRecord(content) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const yaml = require('js-yaml');
+    const parsed = yaml.load(content);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+        ? parsed
+        : undefined;
+}
+/** Serialize Spotlight panel/view config objects to YAML. */
+function dumpSpotlightYaml(content) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const yaml = require('js-yaml');
+    return yaml.dump(content, { lineWidth: 120, noRefs: true });
+}