@crouton-kit/crouter 0.1.1 → 0.1.2

package/dist/core/artifact.js

@@ -0,0 +1,187 @@
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { spawn, spawnSync } from 'node:child_process';
+import { writeFileSync } from 'node:fs';
+import { CRTR_DIR_NAME } from '../types.js';
+import { ensureDir, pathExists, readText, walkFiles } from './fs-utils.js';
+import { usage, notFound, general } from './errors.js';
+import { out, hint, jsonOut, handleError } from './output.js';
+export function mangleCwd(cwd = process.cwd()) {
+    return cwd.replace(/\//g, '-');
+}
+export function artifactsRoot(kind, cwd) {
+    return join(homedir(), CRTR_DIR_NAME, mangleCwd(cwd), kind);
+}
+export function sanitizeName(raw) {
+    const trimmed = raw.trim().replace(/^\/+|\/+$/g, '');
+    if (trimmed === '')
+        throw usage('name must not be empty');
+    if (trimmed.split('/').some((seg) => seg === '..' || seg === '.')) {
+        throw usage(`name must not contain "." or ".." segments: ${raw}`);
+    }
+    if (trimmed.startsWith('/') || /^[A-Za-z]:[\\/]/.test(trimmed)) {
+        throw usage(`name must not be absolute: ${raw}`);
+    }
+    return trimmed;
+}
+export function artifactPath(kind, name, cwd) {
+    return join(artifactsRoot(kind, cwd), `${sanitizeName(name)}.md`);
+}
+export function inTmux() {
+    return Boolean(process.env.TMUX);
+}
+export function openInTmuxPane(path) {
+    const result = spawnSync('termrender', ['--tmux', path], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (result.error) {
+        const code = result.error.code;
+        if (code === 'ENOENT') {
+            hint('termrender not found on $PATH — install it to auto-open in tmux');
+        }
+        else {
+            hint(`termrender failed: ${result.error.message}`);
+        }
+        return;
+    }
+    if (result.status !== 0) {
+        const stderrText = result.stderr.toString().trim();
+        hint(`termrender exited with ${result.status}${stderrText ? `: ${stderrText}` : ''}`);
+        return;
+    }
+    const paneId = result.stdout.toString().trim();
+    if (paneId)
+        hint(`opened in tmux pane ${paneId}`);
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+function listArtifactNames(kind) {
+    const root = artifactsRoot(kind);
+    if (!pathExists(root))
+        return [];
+    return walkFiles(root, (n) => n.endsWith('.md'))
+        .map((abs) => abs.substring(root.length + 1).replace(/\.md$/, ''))
+        .sort();
+}
+export function registerArtifactCommand(program, opts) {
+    const { command, kind, promptFn } = opts;
+    const cmd = program
+        .command(`${command} [content]`)
+        .description(`print the ${command} prompt, or save a ${command} with --name`)
+        .option('--name <name>', `save the ${command} under this name`)
+        .action(async (content, options) => {
+        try {
+            if (options.name === undefined) {
+                if (content !== undefined) {
+                    throw usage(`positional content requires --name (try \`crtr ${command} --name <name> ...\`)`);
+                }
+                out(promptFn(artifactsRoot(kind)));
+                return;
+            }
+            let body;
+            if (content !== undefined) {
+                body = content;
+            }
+            else if (!process.stdin.isTTY) {
+                body = await readStdin();
+            }
+            else {
+                throw usage(`no content provided. Pipe via stdin (heredoc) or pass as a positional arg:\n` +
+                    `  crtr ${command} --name <name> <<'EOF'\n  <content>\n  EOF`);
+            }
+            if (body.trim() === '') {
+                throw usage('content is empty');
+            }
+            const filePath = artifactPath(kind, options.name);
+            ensureDir(dirname(filePath));
+            writeFileSync(filePath, body.endsWith('\n') ? body : body + '\n', 'utf8');
+            out(filePath);
+            if (inTmux())
+                openInTmuxPane(filePath);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    cmd
+        .command('list')
+        .description(`list ${kind} for the current directory`)
+        .option('--json', 'emit JSON')
+        .action(async (options) => {
+        try {
+            const names = listArtifactNames(kind);
+            if (options.json) {
+                jsonOut({
+                    [kind]: names.map((name) => ({ name, path: artifactPath(kind, name) })),
+                });
+                return;
+            }
+            for (const n of names)
+                out(n);
+        }
+        catch (e) {
+            handleError(e, { json: options.json });
+        }
+    });
+    cmd
+        .command('show <name>')
+        .description(`print the body of a ${command}`)
+        .action(async (name) => {
+        try {
+            const filePath = artifactPath(kind, name);
+            if (!pathExists(filePath)) {
+                throw notFound(`${command} not found: ${name} (looked at ${filePath})`);
+            }
+            out(readText(filePath));
+            hint(`crtr: edit with \`crtr ${command} edit ${name}\` (${filePath})`);
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    cmd
+        .command('path [name]')
+        .description(`print the absolute path of a ${command} or the ${kind} directory`)
+        .action(async (name) => {
+        try {
+            out(name === undefined ? artifactsRoot(kind) : artifactPath(kind, name));
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+    cmd
+        .command('edit <name>')
+        .description(`open the ${command} in $EDITOR`)
+        .action(async (name) => {
+        try {
+            const filePath = artifactPath(kind, name);
+            if (!pathExists(filePath)) {
+                throw notFound(`${command} not found: ${name} (looked at ${filePath})`);
+            }
+            const editor = process.env.EDITOR !== undefined && process.env.EDITOR !== ''
+                ? process.env.EDITOR
+                : 'vi';
+            await new Promise((resolve, reject) => {
+                const child = spawn(editor, [filePath], { stdio: 'inherit' });
+                child.on('error', (e) => reject(general(`failed to launch editor: ${e.message}`)));
+                child.on('close', (code) => {
+                    if (code !== 0 && code !== null) {
+                        reject(general(`editor exited with code ${code}`));
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        }
+        catch (e) {
+            handleError(e);
+        }
+    });
+}

package/dist/core/config.d.ts

@@ -0,0 +1,10 @@
+import type { Scope, ScopeConfig, ScopeState } from '../types.js';
+export declare function configPath(scope: Scope): string | null;
+export declare function statePath(scope: Scope): string | null;
+export declare function readConfig(scope: Scope): ScopeConfig;
+export declare function readState(scope: Scope): ScopeState;
+export declare function writeConfig(scope: Scope, config: ScopeConfig): void;
+export declare function writeState(scope: Scope, state: ScopeState): void;
+export declare function ensureScopeInitialized(scope: Scope, root: string): void;
+export declare function updateConfig(scope: Scope, mutate: (cfg: ScopeConfig) => void): ScopeConfig;
+export declare function updateState(scope: Scope, mutate: (s: ScopeState) => void): ScopeState;

package/dist/core/config.js

@@ -0,0 +1,83 @@
+import { join } from 'node:path';
+import { CONFIG_FILE, STATE_FILE, defaultScopeConfig, defaultScopeState } from '../types.js';
+import { readJsonIfExists, writeJson, ensureDir } from './fs-utils.js';
+import { scopeRoot, requireScopeRoot } from './scope.js';
+function configPathFor(root) {
+    return join(root, CONFIG_FILE);
+}
+function statePathFor(root) {
+    return join(root, STATE_FILE);
+}
+export function configPath(scope) {
+    const root = scopeRoot(scope);
+    return root ? configPathFor(root) : null;
+}
+export function statePath(scope) {
+    const root = scopeRoot(scope);
+    return root ? statePathFor(root) : null;
+}
+export function readConfig(scope) {
+    const root = scopeRoot(scope);
+    if (!root)
+        return defaultScopeConfig();
+    const existing = readJsonIfExists(configPathFor(root));
+    if (!existing)
+        return defaultScopeConfig();
+    return mergeConfig(existing);
+}
+export function readState(scope) {
+    const root = scopeRoot(scope);
+    if (!root)
+        return defaultScopeState();
+    const existing = readJsonIfExists(statePathFor(root));
+    if (!existing)
+        return defaultScopeState();
+    return {
+        marketplaces: existing.marketplaces ?? {},
+        plugins: existing.plugins ?? {},
+        last_self_check: existing.last_self_check,
+    };
+}
+export function writeConfig(scope, config) {
+    const root = requireScopeRoot(scope);
+    ensureDir(root);
+    writeJson(configPathFor(root), config);
+}
+export function writeState(scope, state) {
+    const root = requireScopeRoot(scope);
+    ensureDir(root);
+    writeJson(statePathFor(root), state);
+}
+export function ensureScopeInitialized(scope, root) {
+    ensureDir(root);
+    const cfgPath = configPathFor(root);
+    if (!readJsonIfExists(cfgPath)) {
+        writeJson(cfgPath, defaultScopeConfig());
+    }
+}
+function mergeConfig(partial) {
+    const defaults = defaultScopeConfig();
+    const schema_version = partial.schema_version === undefined ? defaults.schema_version : partial.schema_version;
+    const marketplaces = partial.marketplaces === undefined ? {} : partial.marketplaces;
+    const plugins = partial.plugins === undefined ? {} : partial.plugins;
+    const skills = partial.skills === undefined ? {} : partial.skills;
+    const au = partial.auto_update;
+    const auto_update = {
+        crtr: au && au.crtr !== undefined ? au.crtr : defaults.auto_update.crtr,
+        content: au && au.content !== undefined ? au.content : defaults.auto_update.content,
+        interval_hours: au && au.interval_hours !== undefined ? au.interval_hours : defaults.auto_update.interval_hours,
+    };
+    return { schema_version, marketplaces, plugins, skills, auto_update };
+}
+export function updateConfig(scope, mutate) {
+    const cfg = readConfig(scope);
+    mutate(cfg);
+    writeConfig(scope, cfg);
+    return cfg;
+}
+export function updateState(scope, mutate) {
+    const s = readState(scope);
+    mutate(s);
+    writeState(scope, s);
+    return s;
+}

package/dist/core/errors.d.ts

@@ -0,0 +1,12 @@
+import { type ExitCodeValue } from '../types.js';
+export declare class CrtrError extends Error {
+    code: string;
+    exitCode: ExitCodeValue;
+    details?: Record<string, unknown>;
+    constructor(code: string, message: string, exitCode?: ExitCodeValue, details?: Record<string, unknown>);
+}
+export declare function notFound(message: string, details?: Record<string, unknown>): CrtrError;
+export declare function usage(message: string, details?: Record<string, unknown>): CrtrError;
+export declare function ambiguous(message: string, details?: Record<string, unknown>): CrtrError;
+export declare function network(message: string, details?: Record<string, unknown>): CrtrError;
+export declare function general(message: string, details?: Record<string, unknown>): CrtrError;

package/dist/core/errors.js

@@ -0,0 +1,28 @@
+import { ExitCode } from '../types.js';
+export class CrtrError extends Error {
+    code;
+    exitCode;
+    details;
+    constructor(code, message, exitCode = ExitCode.GENERAL, details) {
+        super(message);
+        this.name = 'CrtrError';
+        this.code = code;
+        this.exitCode = exitCode;
+        this.details = details;
+    }
+}
+export function notFound(message, details) {
+    return new CrtrError('not_found', message, ExitCode.NOT_FOUND, details);
+}
+export function usage(message, details) {
+    return new CrtrError('usage', message, ExitCode.USAGE, details);
+}
+export function ambiguous(message, details) {
+    return new CrtrError('ambiguous', message, ExitCode.AMBIGUOUS, details);
+}
+export function network(message, details) {
+    return new CrtrError('network', message, ExitCode.NETWORK, details);
+}
+export function general(message, details) {
+    return new CrtrError('error', message, ExitCode.GENERAL, details);
+}

package/dist/core/frontmatter.d.ts

@@ -0,0 +1,8 @@
+import type { SkillFrontmatter } from '../types.js';
+export interface ParsedFrontmatter {
+    data: SkillFrontmatter | null;
+    body: string;
+    raw: string;
+}
+export declare function parseFrontmatter(source: string): ParsedFrontmatter;
+export declare function serializeFrontmatter(data: SkillFrontmatter): string;

package/dist/core/frontmatter.js

@@ -0,0 +1,84 @@
+const FRONTMATTER_RE = /^---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?/;
+export function parseFrontmatter(source) {
+    const match = source.match(FRONTMATTER_RE);
+    if (!match) {
+        return { data: null, body: source, raw: '' };
+    }
+    const raw = match[1];
+    const body = source.slice(match[0].length);
+    return { data: parseSimpleYaml(raw), body, raw };
+}
+function parseSimpleYaml(yaml) {
+    const lines = yaml.split(/\r?\n/);
+    const out = {};
+    let currentKey = null;
+    let listBuffer = null;
+    for (const raw of lines) {
+        if (!raw.trim())
+            continue;
+        if (raw.startsWith('  - ') || raw.startsWith('- ')) {
+            const value = raw.replace(/^\s*-\s+/, '').trim();
+            if (currentKey && listBuffer)
+                listBuffer.push(stripQuotes(value));
+            continue;
+        }
+        const idx = raw.indexOf(':');
+        if (idx === -1)
+            continue;
+        if (currentKey && listBuffer) {
+            out[currentKey] = listBuffer;
+            listBuffer = null;
+        }
+        const key = raw.slice(0, idx).trim();
+        const rest = raw.slice(idx + 1).trim();
+        currentKey = key;
+        if (rest === '') {
+            listBuffer = [];
+            continue;
+        }
+        if (rest.startsWith('[') && rest.endsWith(']')) {
+            out[key] = rest
+                .slice(1, -1)
+                .split(',')
+                .map((s) => stripQuotes(s.trim()))
+                .filter(Boolean);
+            currentKey = null;
+            continue;
+        }
+        out[key] = stripQuotes(rest);
+        currentKey = null;
+    }
+    if (currentKey && listBuffer)
+        out[currentKey] = listBuffer;
+    const fm = {
+        name: typeof out.name === 'string' ? out.name : '',
+        description: typeof out.description === 'string' ? out.description : undefined,
+        keywords: Array.isArray(out.keywords) ? out.keywords : undefined,
+    };
+    return fm;
+}
+function stripQuotes(s) {
+    if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+        return s.slice(1, -1);
+    }
+    return s;
+}
+export function serializeFrontmatter(data) {
+    const lines = ['---'];
+    lines.push(`name: ${quoteIfNeeded(data.name)}`);
+    if (data.description !== undefined) {
+        lines.push(`description: ${quoteIfNeeded(data.description)}`);
+    }
+    if (data.keywords && data.keywords.length) {
+        const inline = `[${data.keywords.map(quoteIfNeeded).join(', ')}]`;
+        lines.push(`keywords: ${inline}`);
+    }
+    lines.push('---');
+    return lines.join('\n') + '\n';
+}
+function quoteIfNeeded(s) {
+    if (/[:#\-\[\]{},&*?|<>=!%@`]/.test(s) || /^\s/.test(s) || /\s$/.test(s)) {
+        return `"${s.replace(/"/g, '\\"')}"`;
+    }
+    return s;
+}

package/dist/core/fs-utils.d.ts

@@ -0,0 +1,18 @@
+export declare function ensureDir(dir: string): void;
+export declare function writeJson(path: string, data: unknown): void;
+export declare function readJson<T = unknown>(path: string): T;
+export declare function readJsonIfExists<T = unknown>(path: string): T | null;
+export declare function readTextIfExists(path: string): string | null;
+export declare function readText(path: string): string;
+export declare function isDir(path: string): boolean;
+export declare function isSymlink(path: string): boolean;
+export declare function pathExists(path: string): boolean;
+export declare function listDirs(path: string): string[];
+export declare function listEntries(path: string): string[];
+export declare function removePath(path: string): void;
+export declare function linkOrCopy(target: string, linkPath: string, opts?: {
+    noSymlink?: boolean;
+}): 'symlink' | 'copy';
+export declare function readSymlinkTarget(path: string): string | null;
+export declare function walkFiles(root: string, predicate?: (name: string) => boolean): string[];
+export declare function nowIso(): string;

package/dist/core/fs-utils.js

@@ -0,0 +1,115 @@
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, symlinkSync, writeFileSync, cpSync, readlinkSync, } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { platform } from 'node:os';
+export function ensureDir(dir) {
+    mkdirSync(dir, { recursive: true });
+}
+export function writeJson(path, data) {
+    ensureDir(dirname(path));
+    writeFileSync(path, JSON.stringify(data, null, 2) + '\n', 'utf8');
+}
+export function readJson(path) {
+    return JSON.parse(readFileSync(path, 'utf8'));
+}
+export function readJsonIfExists(path) {
+    if (!existsSync(path))
+        return null;
+    return readJson(path);
+}
+export function readTextIfExists(path) {
+    if (!existsSync(path))
+        return null;
+    return readFileSync(path, 'utf8');
+}
+export function readText(path) {
+    return readFileSync(path, 'utf8');
+}
+export function isDir(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export function isSymlink(path) {
+    try {
+        return lstatSync(path).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+export function pathExists(path) {
+    return existsSync(path);
+}
+export function listDirs(path) {
+    if (!existsSync(path))
+        return [];
+    return readdirSync(path, { withFileTypes: true })
+        .filter((d) => d.isDirectory() || d.isSymbolicLink())
+        .map((d) => d.name);
+}
+export function listEntries(path) {
+    if (!existsSync(path))
+        return [];
+    return readdirSync(path);
+}
+export function removePath(path) {
+    if (!existsSync(path) && !isSymlink(path))
+        return;
+    rmSync(path, { recursive: true, force: true });
+}
+export function linkOrCopy(target, linkPath, opts = {}) {
+    ensureDir(dirname(linkPath));
+    removePath(linkPath);
+    const isWindows = platform() === 'win32';
+    if (!opts.noSymlink && !isWindows) {
+        const rel = relative(dirname(linkPath), target);
+        try {
+            symlinkSync(rel, linkPath, isDir(target) ? 'dir' : 'file');
+            return 'symlink';
+        }
+        catch {
+            cpSync(target, linkPath, { recursive: true });
+            return 'copy';
+        }
+    }
+    cpSync(target, linkPath, { recursive: true });
+    return 'copy';
+}
+export function readSymlinkTarget(path) {
+    try {
+        return readlinkSync(path);
+    }
+    catch {
+        return null;
+    }
+}
+export function walkFiles(root, predicate = () => true) {
+    const out = [];
+    if (!existsSync(root))
+        return out;
+    const stack = [root];
+    while (stack.length) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            const full = join(dir, e.name);
+            if (e.isDirectory())
+                stack.push(full);
+            else if (e.isFile() && predicate(e.name))
+                out.push(full);
+        }
+    }
+    return out;
+}
+export function nowIso() {
+    return new Date().toISOString();
+}

package/dist/core/git.d.ts

@@ -0,0 +1,18 @@
+export interface GitResult {
+    status: number;
+    stdout: string;
+    stderr: string;
+}
+export declare function gitSync(args: string[], cwd?: string): GitResult;
+export declare function gitAsync(args: string[], cwd?: string): Promise<GitResult>;
+export declare function clone(url: string, dest: string, opts?: {
+    ref?: string;
+    depth?: number;
+}): GitResult;
+export declare function pull(cwd: string): GitResult;
+export declare function fetch(cwd: string, ref?: string): GitResult;
+export declare function lsRemote(url: string): GitResult;
+export declare function currentSha(cwd: string): string | null;
+export declare function remoteSha(cwd: string, ref: string): string | null;
+export declare function isGitRepo(cwd: string): boolean;
+export declare function deriveNameFromUrl(url: string): string;

package/dist/core/git.js

@@ -0,0 +1,71 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { network } from './errors.js';
+export function gitSync(args, cwd) {
+    const res = spawnSync('git', args, { cwd, encoding: 'utf8' });
+    const status = typeof res.status === 'number' ? res.status : 1;
+    const stdout = typeof res.stdout === 'string' ? res.stdout : '';
+    const stderr = typeof res.stderr === 'string' ? res.stderr : '';
+    return { status, stdout, stderr };
+}
+export async function gitAsync(args, cwd) {
+    return new Promise((resolve) => {
+        const child = spawn('git', args, { cwd });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (d) => (stdout += d.toString()));
+        child.stderr.on('data', (d) => (stderr += d.toString()));
+        child.on('close', (status) => {
+            const code = typeof status === 'number' ? status : 1;
+            resolve({ status: code, stdout, stderr });
+        });
+        child.on('error', (e) => resolve({ status: 1, stdout: '', stderr: String(e) }));
+    });
+}
+export function clone(url, dest, opts = {}) {
+    const args = ['clone'];
+    if (opts.depth)
+        args.push('--depth', String(opts.depth));
+    if (opts.ref)
+        args.push('--branch', opts.ref);
+    args.push(url, dest);
+    const res = gitSync(args);
+    if (res.status !== 0) {
+        throw network(`git clone failed: ${url}\n${res.stderr.trim()}`);
+    }
+    return res;
+}
+export function pull(cwd) {
+    return gitSync(['pull', '--ff-only'], cwd);
+}
+export function fetch(cwd, ref) {
+    const args = ['fetch', 'origin'];
+    if (ref)
+        args.push(ref);
+    return gitSync(args, cwd);
+}
+export function lsRemote(url) {
+    return gitSync(['ls-remote', url]);
+}
+export function currentSha(cwd) {
+    const res = gitSync(['rev-parse', 'HEAD'], cwd);
+    if (res.status !== 0)
+        return null;
+    return res.stdout.trim();
+}
+export function remoteSha(cwd, ref) {
+    const res = gitSync(['rev-parse', `origin/${ref}`], cwd);
+    if (res.status !== 0)
+        return null;
+    return res.stdout.trim();
+}
+export function isGitRepo(cwd) {
+    const res = gitSync(['rev-parse', '--is-inside-work-tree'], cwd);
+    return res.status === 0 && res.stdout.trim() === 'true';
+}
+export function deriveNameFromUrl(url) {
+    const trimmed = url.replace(/\.git\/?$/, '').replace(/\/$/, '');
+    const last = trimmed.split('/').pop();
+    if (!last)
+        return url;
+    return last;
+}

package/dist/core/manifest.d.ts

@@ -0,0 +1,5 @@
+import type { MarketplaceManifest, PluginManifest } from '../types.js';
+export declare function pluginManifestPath(pluginRoot: string): string;
+export declare function marketplaceManifestPath(mktRoot: string): string;
+export declare function readPluginManifest(pluginRoot: string): PluginManifest | null;
+export declare function readMarketplaceManifest(mktRoot: string): MarketplaceManifest | null;

package/dist/core/manifest.js

@@ -0,0 +1,15 @@
+import { join } from 'node:path';
+import { MARKETPLACE_MANIFEST_DIR, MARKETPLACE_MANIFEST_FILE, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE, } from '../types.js';
+import { readJsonIfExists } from './fs-utils.js';
+export function pluginManifestPath(pluginRoot) {
+    return join(pluginRoot, PLUGIN_MANIFEST_DIR, PLUGIN_MANIFEST_FILE);
+}
+export function marketplaceManifestPath(mktRoot) {
+    return join(mktRoot, MARKETPLACE_MANIFEST_DIR, MARKETPLACE_MANIFEST_FILE);
+}
+export function readPluginManifest(pluginRoot) {
+    return readJsonIfExists(pluginManifestPath(pluginRoot));
+}
+export function readMarketplaceManifest(mktRoot) {
+    return readJsonIfExists(marketplaceManifestPath(mktRoot));
+}