@north-light/api 0.3.579 → 0.3.587

package/dist/commands/pkg/market-inspect.js

@@ -0,0 +1,141 @@
+import { defineLeaf } from '../../core/command.js';
+import { notFound } from '../../core/errors.js';
+import { paginate } from '../../core/pagination.js';
+import { listInstalledPlugins, listInstalledMarketplaces, listAllMarketplaces, findMarketplaceByName, } from '../../core/resolver.js';
+import { resolveScopeArg, projectScopeRoot } from '../../core/scope.js';
+export const marketList = defineLeaf({
+    name: 'list',
+    description: 'list registered marketplaces',
+    whenToUse: 'listing registered marketplace sources with their git URL, ref, scope, and clone path',
+    help: {
+        name: 'pkg market list',
+        summary: 'list registered marketplaces',
+        params: [
+            { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project', 'all'], required: false, constraint: 'Default: all.' },
+            { kind: 'flag', name: 'limit', type: 'int', required: false, default: 50, constraint: 'Default 50, max 200.' },
+            { kind: 'flag', name: 'cursor', type: 'string', required: false, constraint: 'Opaque token from next_cursor. Omit on first call.' },
+        ],
+        output: [
+            { name: 'items', type: 'object[]', required: true, constraint: 'Each: {name, scope, url, ref, path}. Sorted by scope then name ascending.' },
+            { name: 'next_cursor', type: 'string | null', required: true, constraint: 'null means no more items.' },
+            { name: 'total', type: 'integer | null', required: true, constraint: 'Total count.' },
+        ],
+        outputKind: 'object',
+        effects: ['None. Read-only.'],
+    },
+    run: async (input) => {
+        const scopeInput = input['scope'];
+        const limitRaw = input['limit'];
+        const limit = limitRaw !== undefined ? Math.min(Math.max(1, limitRaw), 200) : 50;
+        const cursor = input['cursor'];
+        let all;
+        if (scopeInput !== undefined) {
+            const resolved = resolveScopeArg(scopeInput);
+            if (resolved === 'all') {
+                all = listAllMarketplaces();
+            }
+            else if (resolved === 'builtin') {
+                all = [];
+            }
+            else {
+                all = listInstalledMarketplaces(resolved);
+            }
+        }
+        else {
+            all = listAllMarketplaces();
+        }
+        const sorted = [...all].sort((a, b) => {
+            if (a.scope === 'project' && b.scope !== 'project')
+                return -1;
+            if (a.scope !== 'project' && b.scope === 'project')
+                return 1;
+            return a.name.localeCompare(b.name);
+        });
+        const result = paginate(sorted, { limit, cursor: cursor !== undefined ? cursor : undefined }, {
+            defaultLimit: 50,
+            maxLimit: 200,
+            keyOf: (m) => `${m.scope}:${m.name}`,
+            total: 'count',
+        });
+        return {
+            items: result.items.map((m) => ({
+                name: m.name,
+                scope: m.scope,
+                url: m.url,
+                ref: m.ref,
+                path: m.root,
+            })),
+            next_cursor: result.next_cursor,
+            total: result.total,
+        };
+    },
+});
+export const marketBrowse = defineLeaf({
+    name: 'browse',
+    description: 'list plugins available in a marketplace',
+    whenToUse: 'browsing one registered marketplace source to choose a plugin install ref; each item includes ref=marketplace/plugin for `pkg plugin install`',
+    help: {
+        name: 'pkg market browse',
+        summary: 'list plugins available in a marketplace',
+        params: [
+            { kind: 'positional', name: 'name', type: 'string', required: true, constraint: 'Marketplace name.' },
+            { kind: 'flag', name: 'limit', type: 'int', required: false, default: 50, constraint: 'Default 50, max 200.' },
+            { kind: 'flag', name: 'cursor', type: 'string', required: false, constraint: 'Opaque token from next_cursor. Omit on first call.' },
+        ],
+        output: [
+            { name: 'marketplace', type: 'string', required: true, constraint: 'Echo of the input marketplace name.' },
+            { name: 'items', type: 'object[]', required: true, constraint: 'Each: {name, ref, source, version?, description?, keywords?, installed, installed_scope?}. ref is marketplace/plugin. Sorted by name ascending.' },
+            { name: 'next_cursor', type: 'string | null', required: true, constraint: 'null means no more items.' },
+            { name: 'total', type: 'integer | null', required: true, constraint: 'Total plugins in the marketplace; null if unavailable.' },
+        ],
+        outputKind: 'object',
+        effects: ['None. Read-only.'],
+    },
+    run: async (input) => {
+        const mktName = input['name'];
+        const limitRaw = input['limit'];
+        const limit = limitRaw !== undefined ? Math.min(Math.max(1, limitRaw), 200) : 50;
+        const cursor = input['cursor'];
+        const mkt = findMarketplaceByName(mktName);
+        if (!mkt)
+            throw notFound(`marketplace not found: ${mktName}`);
+        const allScopes = ['project', 'user'].filter((s) => s !== 'project' || projectScopeRoot() !== null);
+        const installedMap = new Map();
+        for (const scope of allScopes) {
+            for (const p of listInstalledPlugins(scope)) {
+                if (!installedMap.has(p.name)) {
+                    installedMap.set(p.name, p.scope);
+                }
+            }
+        }
+        const pluginsSorted = [...mkt.manifest.plugins].sort((a, b) => a.name.localeCompare(b.name));
+        const result = paginate(pluginsSorted, { limit, cursor: cursor !== undefined ? cursor : undefined }, {
+            defaultLimit: 50,
+            maxLimit: 200,
+            keyOf: (p) => p.name,
+            total: 'count',
+        });
+        return {
+            marketplace: mkt.name,
+            items: result.items.map((entry) => {
+                const installedScope = installedMap.get(entry.name);
+                const installed = installedScope !== undefined;
+                const item = {
+                    name: entry.name,
+                    ref: `${mkt.name}/${entry.name}`,
+                    source: entry.source,
+                    version: entry.version,
+                    description: entry.description,
+                    keywords: entry.keywords,
+                    installed,
+                };
+                if (installed) {
+                    item.installed_scope = installedScope;
+                }
+                return item;
+            }),
+            next_cursor: result.next_cursor,
+            total: result.total,
+        };
+    },
+});

package/dist/commands/pkg/market-manage.d.ts

@@ -0,0 +1,16 @@
+import type { Scope } from '../../types.js';
+/** Clone a marketplace repo into `scope` and register it in that scope's
+ *  config. Shared by the `pkg market add` leaf and `crtr sys setup`, which
+ *  offers the official marketplace as a checked-by-default entry. */
+export declare function addMarketplace(opts: {
+    url: string;
+    ref?: string;
+    scope: Scope;
+}): Promise<{
+    name: string;
+    scope: Scope;
+    path: string;
+}>;
+export declare const marketAdd: import("../../core/command.js").LeafDef;
+export declare const marketRemove: import("../../core/command.js").LeafDef;
+export declare const marketUpdate: import("../../core/command.js").LeafDef;

package/dist/commands/pkg/market-manage.js

@@ -0,0 +1,327 @@
+import { dirname, join, relative, resolve } from 'node:path';
+import { renameSync } from 'node:fs';
+import { defineLeaf } from '../../core/command.js';
+import { general, notFound } from '../../core/errors.js';
+import { listAllMarketplaces, listAllPlugins, findMarketplaceByName } from '../../core/resolver.js';
+import { resolveScopeArg, requireScopeRoot, marketplacesDir, pluginsDir } from '../../core/scope.js';
+import { updateConfig, updateState, ensureScopeInitialized, readConfig } from '../../core/config.js';
+import { pathExists, ensureDir, removePath, isSymlink, nowIso, readSymlinkTarget } from '../../core/fs-utils.js';
+import { clone, deriveNameFromUrl, currentSha, gitSync, isGitRepo } from '../../core/git.js';
+import { readMarketplaceManifest, readPluginManifest } from '../../core/manifest.js';
+import { assertPluginCandidateValid, isMarketplaceRelativeSource } from './plugin-manage.js';
+import { resolveInstallScope } from './shared.js';
+/** Clone a marketplace repo into `scope` and register it in that scope's
+ *  config. Shared by the `pkg market add` leaf and `crtr sys setup`, which
+ *  offers the official marketplace as a checked-by-default entry. */
+export async function addMarketplace(opts) {
+    const { url, ref, scope } = opts;
+    const root = requireScopeRoot(scope);
+    await ensureScopeInitialized(scope, root);
+    const tempName = deriveNameFromUrl(url);
+    const mktsDir = marketplacesDir(scope);
+    ensureDir(mktsDir);
+    const tempDest = join(mktsDir, tempName);
+    if (pathExists(tempDest)) {
+        removePath(tempDest);
+    }
+    clone(url, tempDest, { depth: 1, ref: ref !== undefined ? ref : undefined });
+    const manifest = readMarketplaceManifest(tempDest);
+    if (!manifest) {
+        removePath(tempDest);
+        throw notFound(`marketplace manifest not found at ${tempDest}/.crouter-marketplace/marketplace.json — not a valid marketplace`);
+    }
+    const finalName = manifest.name;
+    const finalDest = join(mktsDir, finalName);
+    if (finalName !== tempName) {
+        if (pathExists(finalDest)) {
+            removePath(finalDest);
+        }
+        renameSync(tempDest, finalDest);
+    }
+    const effectiveRef = ref !== undefined ? ref : 'main';
+    await updateConfig(scope, (cfg) => {
+        cfg.marketplaces[finalName] = {
+            url,
+            ref: effectiveRef,
+            installed_at: nowIso(),
+        };
+    });
+    return { name: finalName, scope, path: finalDest };
+}
+export const marketAdd = defineLeaf({
+    name: 'add',
+    description: 'add a marketplace by git URL',
+    whenToUse: 'registering a new marketplace source repo so its plugins appear in marketplace browse output and become installable by marketplace/plugin ref',
+    help: {
+        name: 'pkg market add',
+        summary: 'add a marketplace by git URL',
+        params: [
+            { kind: 'positional', name: 'url', type: 'string', required: true, constraint: 'Git URL of the marketplace repo.' },
+            { kind: 'flag', name: 'ref', type: 'string', required: false, constraint: 'Git ref to track. Default: main.' },
+            { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Default: project if available, else user.' },
+        ],
+        output: [
+            { name: 'name', type: 'string', required: true, constraint: 'Marketplace name as declared in marketplace.json.' },
+            { name: 'scope', type: 'string', required: true, constraint: 'Scope the marketplace was added into.' },
+            { name: 'path', type: 'string', required: true, constraint: 'Absolute path to the cloned marketplace directory.' },
+        ],
+        outputKind: 'object',
+        effects: ['Clones the marketplace repo. Registers the marketplace in config.json.'],
+    },
+    run: async (input) => {
+        const url = input['url'];
+        const ref = input['ref'];
+        const scopeInput = input['scope'];
+        return addMarketplace({ url, ref, scope: resolveInstallScope(scopeInput) });
+    },
+});
+export const marketRemove = defineLeaf({
+    name: 'remove',
+    description: 'remove a marketplace',
+    whenToUse: 'unregistering a marketplace source: deletes the source clone and any plugins installed from it in the same scope',
+    help: {
+        name: 'pkg market remove',
+        summary: 'remove a marketplace and its directory',
+        params: [
+            { kind: 'positional', name: 'name', type: 'string', required: true, constraint: 'Marketplace name to remove.' },
+            { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Narrows resolution.' },
+        ],
+        output: [],
+        outputKind: 'object',
+        effects: ['Deletes the marketplace directory. Removes the entry from config.json. Removes plugin files and config entries sourced from that marketplace in the same scope.'],
+    },
+    run: async (input) => {
+        const name = input['name'];
+        const scopeInput = input['scope'];
+        let targetScope;
+        let mktRoot;
+        if (scopeInput !== undefined) {
+            const resolved = resolveScopeArg(scopeInput);
+            if (resolved !== 'all' && resolved !== 'builtin') {
+                const s = resolved;
+                const found = findMarketplaceByName(name, s);
+                if (!found)
+                    throw notFound(`marketplace not found: ${name} (scope: ${s})`);
+                targetScope = s;
+                mktRoot = found.root;
+            }
+            else {
+                const found = findMarketplaceByName(name);
+                if (!found)
+                    throw notFound(`marketplace not found: ${name}`);
+                targetScope = found.scope;
+                mktRoot = found.root;
+            }
+        }
+        else {
+            const found = findMarketplaceByName(name);
+            if (!found)
+                throw notFound(`marketplace not found: ${name}`);
+            targetScope = found.scope;
+            mktRoot = found.root;
+        }
+        const scope = targetScope;
+        const scopeRootPath = requireScopeRoot(scope);
+        const plgDir = pluginsDir(scope);
+        const cfg = readConfig(scope);
+        const pluginsToRemove = [];
+        for (const [pluginName, entry] of Object.entries(cfg.plugins)) {
+            if (entry.source_marketplace === name) {
+                pluginsToRemove.push(pluginName);
+            }
+        }
+        for (const pluginName of pluginsToRemove) {
+            const pluginPath = join(plgDir, pluginName);
+            removePath(pluginPath);
+        }
+        removePath(mktRoot);
+        await updateConfig(scope, (c) => {
+            delete c.marketplaces[name];
+            for (const pluginName of pluginsToRemove) {
+                delete c.plugins[pluginName];
+            }
+        });
+        return {};
+    },
+});
+/** Stage a fresh checkout beside the active root. A clone that fails throws
+ *  the git error: reporting the active revision as current would present a
+ *  failed refresh as an up-to-date one, which is how a checkout stays pinned
+ *  to a stale revision with nothing on screen to say so. */
+function stageGitRoot(url, ref, active, candidate) {
+    try {
+        clone(url, candidate, { depth: 1, ref });
+    }
+    catch (error) {
+        removePath(candidate);
+        throw error;
+    }
+    return { active, candidate, previous: `${candidate}.previous` };
+}
+function activateStagedRoots(staged) {
+    const moved = [];
+    const activated = [];
+    try {
+        for (const root of staged) {
+            if (pathExists(root.previous))
+                throw general(`prior staged backup remains at ${root.previous}`);
+            renameSync(root.active, root.previous);
+            moved.push(root);
+        }
+        for (const root of staged) {
+            renameSync(root.candidate, root.active);
+            activated.push(root);
+        }
+    }
+    catch (error) {
+        for (const root of [...activated].reverse())
+            renameSync(root.active, root.candidate);
+        for (const root of [...moved].reverse())
+            renameSync(root.previous, root.active);
+        throw error;
+    }
+    for (const root of staged)
+        removePath(root.previous);
+}
+function candidatePlugin(plugin, root, manifest) {
+    return { plugin: { ...plugin, root, manifest }, scopeRoot: dirname(dirname(plugin.root)) };
+}
+async function updateMarketplaceTarget(target) {
+    const activeSha = currentSha(target.root) ?? '';
+    const sourcedPlugins = listAllPlugins().filter((plugin) => plugin.scope === target.scope && plugin.sourceMarketplace === target.name);
+    const stagedRoots = [];
+    const cleanupRoots = [];
+    let manifest;
+    let marketplaceCandidate;
+    const candidates = [];
+    try {
+        if (isGitRepo(target.root)) {
+            const candidate = join(dirname(target.root), `.${target.name}.${process.pid}.${Date.now()}.candidate`);
+            marketplaceCandidate = stageGitRoot(target.url, target.ref, target.root, candidate);
+            cleanupRoots.push(candidate);
+            const candidateManifest = readMarketplaceManifest(candidate);
+            if (candidateManifest === null)
+                throw notFound(`marketplace manifest not found in candidate checkout: ${candidate}/.crouter-marketplace/marketplace.json`);
+            manifest = candidateManifest;
+            // The staged checkout replaces the active root even at an unchanged
+            // revision. The tree is package-owned content, not a working copy: an
+            // in-place edit to it (a memory migration reaching a plugin through its
+            // symlink, a hand edit) otherwise survives every update, and a revision
+            // comparison would call that drifted tree current.
+            stagedRoots.push(marketplaceCandidate);
+        }
+        else {
+            const activeManifest = readMarketplaceManifest(target.root);
+            if (activeManifest === null)
+                throw notFound(`marketplace manifest not found after refresh: ${target.root}/.crouter-marketplace/marketplace.json`);
+            manifest = activeManifest;
+        }
+        for (const plugin of sourcedPlugins) {
+            if (isSymlink(plugin.root)) {
+                if (marketplaceCandidate === undefined)
+                    continue;
+                // A symlinked plugin resolves through the marketplace root, so the root
+                // swap above already replaced its content.
+                const entry = manifest.plugins.find((candidate) => candidate.name === plugin.name);
+                if (entry === undefined || !isMarketplaceRelativeSource(entry.source)) {
+                    throw general(`marketplace candidate removes relative-source plugin "${plugin.name}" while it is installed`);
+                }
+                const symlinkTarget = readSymlinkTarget(plugin.root);
+                if (symlinkTarget === null)
+                    throw general(`installed marketplace plugin "${plugin.name}" has no readable symlink target`);
+                const observedSource = relative(target.root, resolve(dirname(plugin.root), symlinkTarget));
+                const candidateRoot = resolve(marketplaceCandidate.candidate, entry.source);
+                if (candidateRoot !== resolve(marketplaceCandidate.candidate, observedSource)) {
+                    throw general(`marketplace candidate moves installed relative-source plugin "${plugin.name}" from ${observedSource} to ${entry.source}`);
+                }
+                if (!pathExists(candidateRoot))
+                    throw notFound(`marketplace candidate source path does not exist for plugin "${plugin.name}": ${candidateRoot}`);
+                const candidateManifest = readPluginManifest(candidateRoot);
+                if (candidateManifest === null)
+                    throw notFound(`plugin manifest not found in marketplace candidate: ${candidateRoot}/.crouter-plugin/plugin.json`);
+                candidates.push(candidatePlugin(plugin, candidateRoot, candidateManifest));
+                continue;
+            }
+            if (!pathExists(plugin.root) || !isGitRepo(plugin.root))
+                continue;
+            const remote = gitSync(['config', '--get', 'remote.origin.url'], plugin.root).stdout.trim();
+            const branch = gitSync(['symbolic-ref', '--short', 'HEAD'], plugin.root).stdout.trim();
+            if (remote === '' || branch === '')
+                continue;
+            const scopeRoot = plugin.scope === 'project' ? requireScopeRoot('project') : requireScopeRoot('user');
+            const candidate = join(scopeRoot, 'tmp', `${plugin.name}.${process.pid}.${Date.now()}.candidate`);
+            ensureDir(join(scopeRoot, 'tmp'));
+            const staged = stageGitRoot(remote, branch, plugin.root, candidate);
+            cleanupRoots.push(candidate);
+            const candidateManifest = readPluginManifest(candidate);
+            if (candidateManifest === null)
+                throw notFound(`plugin manifest not found in update candidate: ${candidate}/.crouter-plugin/plugin.json`);
+            candidates.push(candidatePlugin(plugin, candidate, candidateManifest));
+            stagedRoots.push(staged);
+        }
+        for (const candidate of candidates) {
+            await assertPluginCandidateValid(candidate.plugin.manifest, candidate.plugin.root, candidate.plugin.scope, candidate.scopeRoot, `${candidate.plugin.root}/.crouter-plugin/plugin.json`, candidates);
+        }
+        activateStagedRoots(stagedRoots);
+        await updateState(target.scope, (state) => {
+            if (state.marketplaces[target.name] === undefined)
+                state.marketplaces[target.name] = {};
+            state.marketplaces[target.name].last_updated = nowIso();
+        });
+        for (const plugin of sourcedPlugins) {
+            const entry = manifest.plugins.find((candidate) => candidate.name === plugin.name);
+            if (entry?.version !== undefined) {
+                await updateConfig(plugin.scope, (config) => {
+                    if (config.plugins[plugin.name] !== undefined)
+                        config.plugins[plugin.name].version = entry.version;
+                });
+            }
+            await updateState(plugin.scope, (state) => {
+                if (state.plugins[plugin.name] === undefined)
+                    state.plugins[plugin.name] = {};
+                state.plugins[plugin.name].last_updated = nowIso();
+            });
+        }
+        const sha = currentSha(target.root) ?? '';
+        return { name: target.name, updated: activeSha !== sha, sha };
+    }
+    finally {
+        for (const root of cleanupRoots)
+            removePath(root);
+    }
+}
+export const marketUpdate = defineLeaf({
+    name: 'update',
+    description: 'replace marketplace source with its latest revision',
+    whenToUse: 'refreshing one named marketplace source from git, or all registered marketplace sources when no name is given; also updates installed plugins sourced from refreshed marketplaces',
+    help: {
+        name: 'pkg market update',
+        summary: 'refresh one or all registered marketplaces',
+        params: [
+            { kind: 'flag', name: 'name', type: 'string', required: false, constraint: 'Marketplace name to update. Omit to update all registered marketplaces.' },
+            { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Narrows resolution.' },
+        ],
+        output: [
+            { name: 'updated', type: 'object[]', required: true, constraint: 'One entry per marketplace processed: {name, updated, sha}.' },
+        ],
+        outputKind: 'object',
+        effects: ['Stages and validates marketplace and sourced-plugin revisions before atomically activating them, replacing each checkout even at an unchanged revision — local modifications inside those directories are discarded. `updated` reports whether the revision moved, not whether the checkout was replaced. Updates installed plugin content/version for plugins sourced from refreshed marketplaces.'],
+    },
+    run: async (input) => {
+        const name = input['name'];
+        const scopeInput = input['scope'];
+        const scope = scopeInput === undefined ? undefined : resolveScopeArg(scopeInput);
+        const targets = name === undefined
+            ? (scope === undefined || scope === 'all' ? listAllMarketplaces() : scope === 'builtin' ? [] : listAllMarketplaces().filter((marketplace) => marketplace.scope === scope))
+            : (() => {
+                const found = scope === undefined || scope === 'all' || scope === 'builtin' ? findMarketplaceByName(name) : findMarketplaceByName(name, scope);
+                if (found === null)
+                    throw notFound(`marketplace not found: ${name}${scope === undefined || scope === 'all' || scope === 'builtin' ? '' : ` (scope: ${scope})`}`);
+                return [found];
+            })();
+        const updated = [];
+        for (const target of targets)
+            updated.push(await updateMarketplaceTarget(target));
+        return { updated };
+    },
+});

package/dist/commands/pkg/market.d.ts

@@ -0,0 +1 @@
+export declare const marketBranch: import("../../core/command.js").BranchDef;

package/dist/commands/pkg/market.js

@@ -0,0 +1,14 @@
+import { defineBranch } from '../../core/command.js';
+import { marketAdd, marketRemove, marketUpdate } from './market-manage.js';
+import { marketBrowse, marketList } from './market-inspect.js';
+export const marketBranch = defineBranch({
+    name: 'market',
+    description: 'manage and browse marketplace sources',
+    whenToUse: 'working with marketplace sources: add or remove a marketplace repo, refresh registered sources, list them, or browse one source for plugin install refs. Use `pkg plugin install marketplace/plugin` to install a plugin from a marketplace.',
+    help: {
+        name: 'pkg market',
+        summary: 'marketplace source management and browsing',
+        model: 'Marketplaces are git repos containing a .crouter-marketplace/marketplace.json index. This branch owns sources only; plugin lifecycle is under `pkg plugin`.',
+    },
+    children: [marketAdd, marketRemove, marketUpdate, marketList, marketBrowse],
+});

package/dist/commands/pkg/plugin-env.d.ts

@@ -0,0 +1,3 @@
+import type { PluginManifest } from '../../types.js';
+/** Collect only missing declared names. The daemon decides which app owns this CLI's request. */
+export declare function collectPluginEnv(manifest: PluginManifest): Promise<string[]>;

package/dist/commands/pkg/plugin-env.js

@@ -0,0 +1,65 @@
+import { cliClient } from '../api-client.js';
+import { requiredPluginEnv } from '../../core/plugin-env.js';
+/** Collect only missing declared names. The daemon decides which app owns this CLI's request. */
+export async function collectPluginEnv(manifest) {
+    const names = requiredPluginEnv(manifest.env);
+    if (!names.length)
+        return [];
+    const present = new Set((await cliClient().listAppEnv()).names);
+    const warnings = [];
+    for (const name of names) {
+        if (present.has(name))
+            continue;
+        const declaration = manifest.env[name];
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            warnings.push(`Warning: plugin "${manifest.name}" needs ${name}; set it with crtr sys env set --name ${name}`);
+            continue;
+        }
+        process.stderr.write(`${manifest.name}: ${declaration.description}${declaration.url ? ` (${declaration.url})` : ''}\n${name} (Enter to skip): `);
+        const value = await readPrompt(declaration.secret !== false);
+        if (value) {
+            await cliClient().setAppEnv(name, value);
+            present.add(name);
+        }
+        else
+            warnings.push(`Warning: plugin "${manifest.name}" needs ${name}; set it with crtr sys env set --name ${name}`);
+    }
+    return warnings;
+}
+function readPrompt(secret) {
+    return new Promise((resolve) => {
+        const input = process.stdin;
+        const wasRaw = input.isRaw;
+        let value = '';
+        if (secret)
+            input.setRawMode(true);
+        input.resume();
+        const finish = () => {
+            input.off('data', onData);
+            if (secret)
+                input.setRawMode(wasRaw);
+            input.pause();
+            process.stderr.write('\n');
+            resolve(value);
+        };
+        const onData = (chunk) => {
+            for (const character of chunk.toString('utf8')) {
+                if (character === '\r' || character === '\n') {
+                    finish();
+                    return;
+                }
+                if (character === '\u0003') {
+                    value = '';
+                    finish();
+                    return;
+                }
+                if (character === '\u007f') {
+                    value = value.slice(0, -1);
+                    continue;
+                }
+                value += character;
+            }
+        };
+        input.on('data', onData);
+    });
+}

package/dist/commands/pkg/plugin-inspect.d.ts

@@ -0,0 +1,2 @@
+export declare const pluginList: import("../../core/command.js").LeafDef;
+export declare const pluginShow: import("../../core/command.js").LeafDef;