@ductape/cli 0.3.1 → 0.3.3

package/README.md

@@ -77,6 +77,8 @@ ductape cloud resources list|import|provision …
 ductape db <verb>                 # db-proxy runtime
 ductape graph <verb>              # graph-proxy runtime
 ductape secrets <verb>
+ductape marketplace search payments --json
+ductape marketplace get paystack --json
 ductape generate payload|snippet …
 ductape completion bash|zsh
 ```

package/dist/commands/apps-curate-postman.d.ts

@@ -0,0 +1,25 @@
+interface PostmanCandidate {
+    uid: string;
+    name: string;
+    description: string;
+    publisher: string;
+    publisherUrl?: string;
+    collectionUrl?: string;
+    logo?: string;
+    forkCount: number;
+    verified: boolean;
+    official: boolean;
+}
+export declare function parseExplorePage(html: string): PostmanCandidate[];
+export declare function reputation(candidate: PostmanCandidate): {
+    score: number;
+    reasons: string[];
+};
+export declare function runAppsCuratePostman(opts: {
+    profile?: string;
+    maxPages?: string;
+    minScore?: string;
+    state?: string;
+    apiKey?: string;
+}): Promise<void>;
+export {};

package/dist/commands/apps-curate-postman.js

@@ -0,0 +1,328 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import input from '@inquirer/input';
+import select from '@inquirer/select';
+import { importAppFromFile } from '../lib/app-import.js';
+import { getApp, listApps, listMarketplaceCategories, updateApp, } from '../lib/platform-api.js';
+import { success } from '../lib/output.js';
+import { requireWorkspaceContext } from '../lib/workspace-context.js';
+const EXPLORE_URL = 'https://www.postman.com/explore/collections';
+const DEFAULT_STATE = '.ductape/postman-marketplace-curator.json';
+function text(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function number(value) {
+    return typeof value === 'number' ? value : Number(value) || 0;
+}
+function slugify(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+}
+function walk(value, visit) {
+    if (Array.isArray(value)) {
+        value.forEach((item) => walk(item, visit));
+        return;
+    }
+    if (!value || typeof value !== 'object')
+        return;
+    const object = value;
+    visit(object);
+    Object.values(object).forEach((item) => walk(item, visit));
+}
+function candidateFromObject(item) {
+    const kind = text(item.entityType || item.type || item.elementType).toLowerCase();
+    const uid = text(item.uid || item.collectionUid || item.collectionId || item.id);
+    const name = text(item.name || item.title);
+    const hasCollectionIdentity = Boolean(item.collectionUid || item.collectionId);
+    if (!uid || !name || (kind ? !kind.includes('collection') : !hasCollectionIdentity))
+        return null;
+    const publisherObject = (item.publisher || item.organization || item.team || item.owner || {});
+    const publisher = text(item.publisherName || item.teamName || publisherObject.name || publisherObject.username);
+    const collectionUrl = text(item.url || item.href || item.publicUrl);
+    return {
+        uid,
+        name,
+        description: text(item.description || item.summary),
+        publisher,
+        publisherUrl: text(publisherObject.url || publisherObject.profileUrl) || undefined,
+        collectionUrl: collectionUrl || undefined,
+        logo: text(item.logo || item.icon || publisherObject.logo) || undefined,
+        forkCount: number(item.forkCount || item.forks || item.fork_count),
+        verified: Boolean(item.verified || item.isVerified || publisherObject.verified),
+        official: Boolean(item.official || item.isOfficial || item.publisherType === 'official'),
+    };
+}
+export function parseExplorePage(html) {
+    const found = new Map();
+    const scriptPattern = /<script[^>]*>([\s\S]*?)<\/script>/gi;
+    for (const match of html.matchAll(scriptPattern)) {
+        const raw = match[1]?.trim();
+        if (!raw || (!raw.startsWith('{') && !raw.startsWith('[')))
+            continue;
+        try {
+            walk(JSON.parse(raw), (item) => {
+                const candidate = candidateFromObject(item);
+                if (candidate)
+                    found.set(candidate.uid, candidate);
+            });
+        }
+        catch {
+            // Framework payloads that are not plain JSON are covered by the URL fallback below.
+        }
+    }
+    const linkPattern = /https?:\/\/www\.postman\.com\/([^/"'?#]+)\/([^/"'?#]+)\/(?:collection|documentation)\/([a-zA-Z0-9-]+)(?:\/([^"'?#<]+))?/g;
+    for (const match of html.matchAll(linkPattern)) {
+        const uid = match[3];
+        if (!uid || found.has(uid))
+            continue;
+        found.set(uid, {
+            uid,
+            name: (match[4] || uid).split('/')[0].replace(/-/g, ' '),
+            description: '',
+            publisher: match[1],
+            collectionUrl: match[0],
+            forkCount: 0,
+            verified: false,
+            official: false,
+        });
+    }
+    return [...found.values()];
+}
+export function reputation(candidate) {
+    let score = 0;
+    const reasons = [];
+    if (candidate.official) {
+        score += 5;
+        reasons.push('official publisher');
+    }
+    if (candidate.verified) {
+        score += 4;
+        reasons.push('verified publisher');
+    }
+    if (candidate.forkCount >= 10_000) {
+        score += 4;
+        reasons.push(`${candidate.forkCount.toLocaleString()} forks`);
+    }
+    else if (candidate.forkCount >= 1_000) {
+        score += 3;
+        reasons.push(`${candidate.forkCount.toLocaleString()} forks`);
+    }
+    else if (candidate.forkCount >= 100) {
+        score += 2;
+        reasons.push(`${candidate.forkCount.toLocaleString()} forks`);
+    }
+    const publisher = slugify(candidate.publisher);
+    const name = slugify(candidate.name);
+    if (publisher && name && (name.includes(publisher) || publisher.includes(name.split('-')[0]))) {
+        score += 2;
+        reasons.push('publisher/API identity match');
+    }
+    if (candidate.publisherUrl) {
+        score += 1;
+        reasons.push('publisher profile');
+    }
+    return { score, reasons };
+}
+async function fetchJson(url, apiKey) {
+    const response = await fetch(url, {
+        headers: {
+            Accept: 'application/json',
+            ...(apiKey ? { 'X-Api-Key': apiKey } : {}),
+        },
+    });
+    if (!response.ok)
+        throw new Error(`${url} returned HTTP ${response.status}`);
+    return await response.json();
+}
+async function downloadCollection(candidate, apiKey) {
+    const urls = [
+        `https://api.postman.com/collections/${encodeURIComponent(candidate.uid)}`,
+        `https://api.getpostman.com/collections/${encodeURIComponent(candidate.uid)}`,
+        `https://www.postman.com/collections/${encodeURIComponent(candidate.uid)}`,
+    ];
+    let lastError;
+    for (const url of urls) {
+        try {
+            const result = await fetchJson(url, apiKey);
+            const collection = result.collection;
+            if (collection && typeof collection === 'object')
+                return collection;
+            if (result.info && result.item)
+                return result;
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw new Error(`Unable to download ${candidate.uid}. Set POSTMAN_API_KEY to use the official Postman API. ${String(lastError)}`);
+}
+function loadState(file) {
+    if (!fs.existsSync(file))
+        return { processed: {} };
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+function saveState(file, state) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(state, null, 2)}\n`);
+}
+function suggestDomains(candidate, domains) {
+    const haystack = `${candidate.name} ${candidate.description}`.toLowerCase();
+    const aliases = {
+        payments: ['payment', 'checkout', 'payout', 'fintech'],
+        'subscriptions-billing': ['subscription', 'billing', 'invoice'],
+        'crm-sales': ['crm', 'sales', 'customer support'],
+        messaging: ['sms', 'message', 'chat', 'push'],
+        email: ['email'],
+        'ai-machine-learning': [' ai ', 'machine learning', 'model'],
+        'developer-tools': ['developer', 'api', 'cloud', 'code'],
+        'maps-location': ['map', 'location', 'geocod'],
+        'shipping-delivery': ['shipping', 'delivery', 'logistics'],
+    };
+    return domains
+        .filter((domain) => {
+        const slug = text(domain.slug);
+        return (aliases[slug] || []).some((term) => ` ${haystack} `.includes(term));
+    })
+        .map((domain) => text(domain.slug));
+}
+function domainIds(slugs, domains) {
+    return domains
+        .filter((domain) => slugs.includes(text(domain.slug)))
+        .map((domain) => text(domain._id))
+        .filter(Boolean);
+}
+function marketplaceMetadata(candidate, collection) {
+    const info = (collection.info || {});
+    const description = text(info.description) || candidate.description ||
+        `${candidate.name} API collection published by ${candidate.publisher}.`;
+    const requestCount = JSON.stringify(collection).match(/"request"\s*:/g)?.length ?? 0;
+    const source = candidate.collectionUrl || `https://www.postman.com/explore/collections`;
+    const aboutText = [
+        description,
+        `Imported from the public Postman API Network collection maintained by ${candidate.publisher || 'its publisher'}.`,
+        `This version contains approximately ${requestCount} documented requests. Review authentication, environment variables, and provider terms before production use.`,
+        `Source: ${source}`,
+    ].join('\n\n').slice(0, 5000);
+    const aboutHTML = `<p>${aboutText
+        .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+        .replace(/\n\n/g, '</p><p>')}</p>`.slice(0, 5000);
+    return {
+        app_name: candidate.name.slice(0, 100),
+        description: description.slice(0, 1000),
+        aboutText,
+        aboutHTML,
+        website: candidate.publisherUrl || candidate.collectionUrl,
+        ...(candidate.logo?.startsWith('http') ? { logo: candidate.logo } : {}),
+        require_whitelist: false,
+    };
+}
+async function findImportedApp(ctx, beforeIds, collectionName) {
+    const apps = await listApps(ctx, 'all');
+    const created = apps.find((app) => !beforeIds.has(text(app._id)));
+    const named = apps.find((app) => text(app.app_name) === collectionName);
+    const result = created || named;
+    if (!result?._id)
+        throw new Error(`Import completed but app "${collectionName}" could not be located`);
+    return result;
+}
+export async function runAppsCuratePostman(opts) {
+    const ctx = requireWorkspaceContext({ profile: opts.profile });
+    const maxPages = Math.max(1, Number(opts.maxPages || 250));
+    const minScore = Math.max(0, Number(opts.minScore || 5));
+    const stateFile = path.resolve(opts.state || DEFAULT_STATE);
+    const state = loadState(stateFile);
+    const domains = await listMarketplaceCategories(ctx);
+    const apiKey = opts.apiKey || process.env.POSTMAN_API_KEY;
+    let emptyPages = 0;
+    for (let page = 1; page <= maxPages && emptyPages < 2; page++) {
+        const url = `${EXPLORE_URL}?sort=forkCount&page=${page}&filter=this_week`;
+        const response = await fetch(url, { headers: { Accept: 'text/html' } });
+        if (!response.ok)
+            throw new Error(`Postman Explore page ${page} returned HTTP ${response.status}`);
+        const candidates = parseExplorePage(await response.text());
+        if (candidates.length === 0) {
+            emptyPages++;
+            continue;
+        }
+        emptyPages = 0;
+        for (const candidate of candidates) {
+            if (state.processed[candidate.uid])
+                continue;
+            const trust = reputation(candidate);
+            if (trust.score < minScore)
+                continue;
+            console.log(`\n${candidate.name} by ${candidate.publisher || 'unknown publisher'}`);
+            console.log(`Reputation ${trust.score}: ${trust.reasons.join(', ') || 'limited evidence'}`);
+            if (candidate.collectionUrl)
+                console.log(candidate.collectionUrl);
+            const decision = await select({
+                message: 'Add or update this Ductape app?',
+                choices: [
+                    { name: 'Skip', value: 'skip' },
+                    { name: 'Add as new app', value: 'add' },
+                    { name: 'Update existing app/version', value: 'update' },
+                    { name: 'Stop and save progress', value: 'stop' },
+                ],
+            });
+            if (decision === 'stop') {
+                saveState(stateFile, state);
+                return;
+            }
+            if (decision === 'skip') {
+                state.processed[candidate.uid] = 'skipped';
+                saveState(stateFile, state);
+                continue;
+            }
+            const defaultTag = `${slugify(candidate.publisher || candidate.name)}:${slugify(candidate.name)}`;
+            const appTag = await input({ message: 'Ductape app tag', default: defaultTag });
+            const version = await input({
+                message: 'App version',
+                default: new Date().toISOString().slice(0, 10).replace(/-/g, '.'),
+            });
+            const suggested = suggestDomains(candidate, domains);
+            const selectedSlugs = (await input({
+                message: 'Domain slugs (comma-separated)',
+                default: suggested.join(','),
+            })).split(',').map((item) => item.trim()).filter(Boolean);
+            const selectedDomainIds = domainIds(selectedSlugs, domains);
+            if (selectedDomainIds.length !== selectedSlugs.length) {
+                const known = new Set(domains.map((domain) => text(domain.slug)));
+                const unknown = selectedSlugs.filter((slug) => !known.has(slug));
+                throw new Error(`Unknown marketplace domain slug(s): ${unknown.join(', ')}`);
+            }
+            const collection = await downloadCollection(candidate, apiKey);
+            const tempFile = path.join(path.dirname(stateFile), `${slugify(candidate.uid)}.postman_collection.json`);
+            fs.mkdirSync(path.dirname(tempFile), { recursive: true });
+            fs.writeFileSync(tempFile, `${JSON.stringify(collection, null, 2)}\n`);
+            const before = await listApps(ctx, 'all');
+            const beforeIds = new Set(before.map((app) => text(app._id)));
+            let target;
+            if (decision === 'update') {
+                target = await getApp(ctx, { tag: appTag });
+                if (!target?._id)
+                    throw new Error(`Existing app not found: ${appTag}`);
+            }
+            await importAppFromFile(ctx, {
+                filePath: tempFile,
+                format: 'postman',
+                appId: target ? text(target._id) : undefined,
+                update: decision === 'update',
+                version,
+            });
+            target = target || await findImportedApp(ctx, beforeIds, text(collection.info?.name) || candidate.name);
+            await updateApp(ctx, text(target._id), {
+                component: 'app',
+                tag: appTag,
+                version,
+                domains: selectedDomainIds,
+                status: 'pending_review',
+                workspace_id: ctx.workspaceId,
+                ...marketplaceMetadata(candidate, collection),
+            });
+            fs.unlinkSync(tempFile);
+            state.processed[candidate.uid] = decision === 'update' ? 'updated' : 'imported';
+            saveState(stateFile, state);
+            success(`${candidate.name} submitted for marketplace review as ${appTag}@${version}`);
+        }
+    }
+    saveState(stateFile, state);
+}

package/dist/commands/marketplace.d.ts

@@ -0,0 +1,8 @@
+export declare function runMarketplace(verb: string, opts: {
+    profile?: string;
+    query?: string;
+    category?: string;
+    limit?: string;
+    tag?: string;
+    json?: boolean;
+}, args: string[]): Promise<void>;

package/dist/commands/marketplace.js

@@ -0,0 +1,30 @@
+import { getMarketplaceApp, listMarketplaceCategories, searchMarketplaceApps, } from '../lib/platform-api.js';
+import { printJson } from '../lib/output.js';
+import { requireWorkspaceContext } from '../lib/workspace-context.js';
+export async function runMarketplace(verb, opts, args) {
+    const ctx = requireWorkspaceContext({ profile: opts.profile });
+    let result;
+    switch (verb.toLowerCase()) {
+        case 'search':
+        case 'list':
+            result = await searchMarketplaceApps(ctx, {
+                query: opts.query ?? (args.join(' ') || undefined),
+                category: opts.category,
+                limit: opts.limit ? Number(opts.limit) : undefined,
+            });
+            break;
+        case 'get': {
+            const tag = opts.tag ?? args[0];
+            if (!tag)
+                throw new Error('marketplace get requires <tag> or --tag <tag>');
+            result = await getMarketplaceApp(ctx, tag);
+            break;
+        }
+        case 'categories':
+            result = await listMarketplaceCategories(ctx);
+            break;
+        default:
+            throw new Error('Unknown marketplace verb. Use: search, list, get, categories');
+    }
+    printJson(result, Boolean(opts.json));
+}

package/dist/commands/migrate-codebase.d.ts

@@ -149,6 +149,13 @@ interface MigrationPlan {
     ai_working_standards: {
         global: string[];
         languages: Record<Language, string[]>;
+        feature_classification: {
+            definition: string;
+            categories: Record<'FEATURE' | 'FEATURE_STEP' | 'DOMAIN_SERVICE' | 'UTILITY' | 'INFRASTRUCTURE_ADAPTER', string>;
+            discovery: string[];
+            required_output_fields: string[];
+            grouping_rule: string;
+        };
     };
     output_paths: {
         plan: string;

package/dist/commands/migrate-codebase.js

@@ -479,6 +479,8 @@ const FILE_REVIEW_CHECKLIST = [
     'configuration and secret-name references',
     'database reads, writes, transactions, schemas, and migrations',
     'internal events, queues, schedules, and background work',
+    'named capability candidates across exports, public methods, controllers, consumers, jobs, repeated orchestration, typed operations, documentation, and routes',
+    'whether related low-level operations collectively form one FEATURE, FEATURE_STEP, DOMAIN_SERVICE, UTILITY, or INFRASTRUCTURE_ADAPTER boundary',
     'external HTTP/API integrations and authentication',
     'sessions, actor propagation, authorization, and privacy',
     'cache, storage, notifications, graph, and vector usage',
@@ -630,6 +632,27 @@ function buildPlan(source, files, scanPolicy, mode, destination, productTag, pro
                     'Preserve request scope and dispose SDK-owned resources through the host lifecycle.',
                 ],
             },
+            feature_classification: {
+                definition: 'A named, reusable product capability with a stable input/output contract that benefits from managed execution, composition, observability, retries, versioning, policy enforcement, or explicit execution steps. It may be synchronous and local.',
+                categories: {
+                    FEATURE: 'Independently meaningful product capability; make it a standalone Ductape Feature.',
+                    FEATURE_STEP: 'Meaningful stage without a useful independent boundary; expose it as a named ctx.step inside another Feature.',
+                    DOMAIN_SERVICE: 'Reusable domain logic without a useful independent managed-execution boundary; keep it as domain logic called by a Feature.',
+                    UTILITY: 'Low-level hashing, formatting, redaction, normalization, conversion, or type-guard helper; keep it as a utility.',
+                    INFRASTRUCTURE_ADAPTER: 'Database, Event, HTTP, cache, storage, transport, provider, or framework integration; keep it as an infrastructure adapter.',
+                },
+                discovery: [
+                    'Exported functions and public service methods; export alone is neither sufficient nor necessary.',
+                    'Controller entry points, Event consumers, scheduled jobs, and repeated orchestration sequences.',
+                    'Domain operations reused from several locations and functions with substantial typed inputs and outputs.',
+                    'Functions composing several meaningful domain stages and product terminology in documentation and API routes.',
+                ],
+                required_output_fields: [
+                    'candidate', 'classification', 'executionStyle', 'evidence', 'suggestedSteps',
+                    'signalsRequired', 'eventsRequired', 'recommendation',
+                ],
+                grouping_rule: 'Group related low-level operations into one coherent capability candidate; never recommend one Feature per exported function.',
+            },
         },
         output_paths: {
             plan: planPath,
@@ -665,6 +688,20 @@ ${plan.ai_working_standards.global.map((rule) => `- ${rule}`).join('\n')}
 
 ${languageSections || 'No supported server language was detected. The AI must inspect the repository before proceeding.'}
 
+## Feature capability classification
+
+${plan.ai_working_standards.feature_classification.definition}
+
+${Object.entries(plan.ai_working_standards.feature_classification.categories)
+        .map(([category, rule]) => `- **${category}**: ${rule}`).join('\n')}
+
+Discovery must cover:
+${plan.ai_working_standards.feature_classification.discovery.map((item) => `- ${item}`).join('\n')}
+
+- ${plan.ai_working_standards.feature_classification.grouping_rule}
+- Every recommendation must include: ${plan.ai_working_standards.feature_classification.required_output_fields.join(', ')}.
+- Signals and Events are optional; synchronous multi-step capabilities remain valid Feature candidates.
+
 ## Workflow
 
 1. Before this plan, create missing project-level E2E tests, run them against the original codebase, and record a passing checksum-bound \`migration-e2e\` baseline.

package/dist/index.js

@@ -25,6 +25,7 @@ import { runCompletion } from './commands/completion.js';
 import { runProducts, runProductApps, runProductComponents, runProductEnvironments } from './commands/products.js';
 import { runApps } from './commands/apps.js';
 import { runAppsImport } from './commands/apps-import.js';
+import { runMarketplace } from './commands/marketplace.js';
 import { runApply } from './commands/apply.js';
 import { runMigrateCodebase } from './commands/migrate-codebase.js';
 import { runMigrationReviewInit, runMigrationReviewRecord, runMigrationReviewFollowUp, runMigrationReviewExclude, runMigrationReviewParity, runMigrationReviewReopen, runMigrationReviewMove, runMigrationReviewMerge, runMigrationReviewSign, runMigrationReviewSnapshot, runMigrationReviewVerifySignature, runMigrationReviewValidate, } from './commands/migration-review.js';
@@ -563,15 +564,20 @@ productEnvironments
 productEnvironments
     .command('create <product_tag>')
     .description('Idempotently create a product environment and verify persistence')
-    .requiredOption('-f, --file <path>', 'Environment JSON: env_name, description, slug, active?')
+    // NOTE: cannot use -f/--file here — it collides with the parent `products` command's own
+    // -f/--file option (used by `products create`/`products update`). Commander resolves a flag
+    // shared by an ancestor and a descendant command against the ancestor, so the value never
+    // reaches this subcommand's own opts, and requiredOption fails even when -f is supplied.
+    .requiredOption('--env-file <path>', 'Environment JSON: env_name, description, slug, active?')
     .option('--json', 'JSON output')
-    .action(wrap((productTag, opts) => runProductEnvironments('create', { product: productTag, file: opts.file, json: opts.json }, [])));
+    .action(wrap((productTag, opts) => runProductEnvironments('create', { product: productTag, file: opts.envFile, json: opts.json }, [])));
 productEnvironments
     .command('update <product_tag> <slug>')
     .description('Update a product environment and verify persistence')
-    .requiredOption('-f, --file <path>', 'Environment patch JSON')
+    // See NOTE above on `create` — same -f/--file collision with the parent `products` command.
+    .requiredOption('--env-file <path>', 'Environment patch JSON')
     .option('--json', 'JSON output')
-    .action(wrap((productTag, slug, opts) => runProductEnvironments('update', { product: productTag, slug, file: opts.file, json: opts.json }, [])));
+    .action(wrap((productTag, slug, opts) => runProductEnvironments('update', { product: productTag, slug, file: opts.envFile, json: opts.json }, [])));
 productEnvironments
     .command('get <product_tag> [slug]')
     .description('Fetch a single product environment by slug')
@@ -615,6 +621,18 @@ apps
     version: opts.version,
     json: opts.json,
 })));
+program
+    .command('marketplace')
+    .description('Discover public apps by capability and inspect their actions')
+    .argument('<verb>', 'search | list | get | categories')
+    .argument('[terms...]', 'Capability terms for search, or app tag for get')
+    .option('--profile <name>')
+    .option('-q, --query <query>', 'Capability search query')
+    .option('-c, --category <category>', 'Filter by category/domain name')
+    .option('-l, --limit <count>', 'Maximum results', '20')
+    .option('-t, --tag <tag>', 'Marketplace app tag for get')
+    .option('--json', 'JSON output')
+    .action(wrap((verb, terms, opts) => runMarketplace(verb, opts, terms)));
 const events = program.command('events').description('Message broker CRUD (sdk-proxy, requires access key login)');
 const eventTopics = events.command('topics').description('Topic CRUD for a message broker');
 eventTopics

package/dist/lib/platform-api.d.ts

@@ -17,6 +17,14 @@ export declare function createApp(ctx: WorkspaceContext, body: Record<string, un
 export declare function updateApp(ctx: WorkspaceContext, appId: string, body: Record<string, unknown>): Promise<unknown>;
 export declare function updateAppViaProxy(ctx: WorkspaceContext, tag: string, body: Record<string, unknown>): Promise<unknown>;
 export declare function deleteApp(ctx: WorkspaceContext, appId: string): Promise<unknown>;
+export interface MarketplaceSearchOptions {
+    query?: string;
+    category?: string;
+    limit?: number;
+}
+export declare function listMarketplaceCategories(ctx: WorkspaceContext): Promise<unknown[]>;
+export declare function getMarketplaceApp(ctx: WorkspaceContext, tag: string): Promise<unknown>;
+export declare function searchMarketplaceApps(ctx: WorkspaceContext, opts: MarketplaceSearchOptions): Promise<unknown[]>;
 export interface TierQuery {
     provider?: string;
     resource_type?: string;

package/dist/lib/platform-api.js

@@ -135,6 +135,61 @@ export async function deleteApp(ctx, appId) {
     };
     return client(ctx).delete(`/apps/v1/${appId}?${new URLSearchParams(q).toString()}`);
 }
+function searchableMarketplaceText(app) {
+    if (!app || typeof app !== 'object')
+        return '';
+    const value = app;
+    const version = value.currentVersion && typeof value.currentVersion === 'object'
+        ? value.currentVersion
+        : {};
+    const actions = Array.isArray(version.actions) ? version.actions : [];
+    const webhooks = Array.isArray(version.webhooks) ? version.webhooks : [];
+    return [
+        value.app_name,
+        value.tag,
+        value.description,
+        value.aboutText,
+        ...(Array.isArray(value.domains) ? value.domains : []),
+        ...actions.flatMap((action) => {
+            if (!action || typeof action !== 'object')
+                return [];
+            const item = action;
+            return [item.name, item.tag, item.description];
+        }),
+        ...webhooks.flatMap((webhook) => {
+            if (!webhook || typeof webhook !== 'object')
+                return [];
+            const item = webhook;
+            return [item.name, item.tag, item.description];
+        }),
+    ].filter((item) => typeof item === 'string').join(' ').toLowerCase();
+}
+export async function listMarketplaceCategories(ctx) {
+    const result = await client(ctx).getPath('/apps/v1/domains');
+    return unwrapList(result);
+}
+export async function getMarketplaceApp(ctx, tag) {
+    const result = await client(ctx).getPath('/apps/v1/fetch/tag', { tag });
+    return unwrapOne(result);
+}
+export async function searchMarketplaceApps(ctx, opts) {
+    const result = await client(ctx).getPath('/apps/v1/domains/all');
+    const apps = unwrapList(result);
+    const terms = (opts.query ?? '').toLowerCase().split(/\s+/).filter(Boolean);
+    const category = opts.category?.toLowerCase();
+    const filtered = apps.filter((app) => {
+        const text = searchableMarketplaceText(app);
+        if (terms.length > 0 && !terms.every((term) => text.includes(term)))
+            return false;
+        if (!category)
+            return true;
+        if (!app || typeof app !== 'object')
+            return false;
+        const domains = app.domains;
+        return Array.isArray(domains) && domains.some((domain) => typeof domain === 'string' && domain.toLowerCase().includes(category));
+    });
+    return filtered.slice(0, Math.max(1, Math.min(opts.limit ?? 20, 100)));
+}
 export async function listCloudTiers(ctx, q) {
     const params = workspaceAuthQuery(ctx);
     if (q.provider)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ductape/cli",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Ductape CLI — local platform, login, link projects, and manage resources via the proxy (Workbench-compatible)",
   "type": "module",
   "main": "dist/index.js",