@ductape/cli 0.3.11 → 0.3.12

package/dist/commands/marketplace.d.ts

@@ -4,5 +4,6 @@ export declare function runMarketplace(verb: string, opts: {
     category?: string;
     limit?: string;
     tag?: string;
+    full?: boolean;
     json?: boolean;
 }, args: string[]): Promise<void>;

package/dist/commands/marketplace.js

@@ -17,7 +17,7 @@ export async function runMarketplace(verb, opts, args) {
             const tag = opts.tag ?? args[0];
             if (!tag)
                 throw new Error('marketplace get requires <tag> or --tag <tag>');
-            result = await getMarketplaceApp(ctx, tag);
+            result = await getMarketplaceApp(ctx, tag, Boolean(opts.full));
             break;
         }
         case 'categories':

package/dist/commands/products.d.ts

@@ -10,8 +10,18 @@ export declare function runProducts(verb: string, opts: {
 export declare function runProductApps(verb: string, opts: {
     profile?: string;
     product?: string;
+    app?: string;
+    envMap?: string[];
     json?: boolean;
+    full?: boolean;
 }, extraArgs: string[]): Promise<void>;
+export declare function runProductAppActions(verb: string, opts: {
+    profile?: string;
+    product?: string;
+    app?: string;
+    action?: string;
+    json?: boolean;
+}): Promise<void>;
 export declare function runProductComponents(verb: string, opts: {
     profile?: string;
     tag?: string;

package/dist/commands/products.js

@@ -2,7 +2,7 @@ import { schemaKeyForEntity } from '../lib/forms/index.js';
 import { isInteractive, promptTag } from '../lib/forms/prompt.js';
 import { toInteractiveOpts } from '../lib/interactive-opts.js';
 import { bodyRequiredHint, resolveBody } from '../lib/read-body.js';
-import { createProduct, deleteProduct, getProduct, listProductApps, listProducts, updateProduct, } from '../lib/platform-api.js';
+import { connectMarketplaceApp, createProduct, deleteProduct, getProduct, getProductAppAction, listProductAppActions, listProductApps, listProducts, updateProduct, } from '../lib/platform-api.js';
 import { printJson } from '../lib/output.js';
 import { requireWorkspaceContext } from '../lib/workspace-context.js';
 import { getSdkProxyForContext, getOptionalProject } from '../lib/proxy/context.js';
@@ -63,16 +63,49 @@ export async function runProducts(verb, opts, extraArgs) {
     printJson(result, Boolean(opts.json));
 }
 export async function runProductApps(verb, opts, extraArgs) {
-    if (verb.toLowerCase() !== 'list') {
-        throw new Error('Only supported: ductape products apps list --product <id>');
-    }
     const ctx = requireWorkspaceContext({ profile: opts.profile });
     const productId = opts.product ?? extraArgs[0];
     if (!productId)
-        throw new Error('Provide --product <product_id>');
-    const result = await listProductApps(ctx, productId);
+        throw new Error('Provide --product <product_id_or_tag>');
+    let result;
+    if (verb.toLowerCase() === 'list') {
+        result = await listProductApps(ctx, productId, Boolean(opts.full));
+    }
+    else if (verb.toLowerCase() === 'connect') {
+        if (!opts.app)
+            throw new Error('Provide --app <marketplace_app_tag>');
+        const envs = (opts.envMap ?? []).map((mapping) => {
+            const [appEnv, productEnv, ...extra] = mapping.split(':');
+            if (!appEnv || !productEnv || extra.length) {
+                throw new Error(`Invalid --env-map "${mapping}"; expected <app_env>:<product_env>`);
+            }
+            return { app_env_slug: appEnv, product_env_slug: productEnv };
+        });
+        result = await connectMarketplaceApp(ctx, productId, opts.app, envs);
+    }
+    else {
+        throw new Error('Supported verbs: list | connect');
+    }
     printJson(result, Boolean(opts.json));
 }
+export async function runProductAppActions(verb, opts) {
+    const ctx = requireWorkspaceContext({ profile: opts.profile });
+    if (!opts.product)
+        throw new Error('Provide --product <product_id_or_tag>');
+    if (!opts.app)
+        throw new Error('Provide --app <app_tag>');
+    if (verb === 'list') {
+        printJson(await listProductAppActions(ctx, opts.product, opts.app), Boolean(opts.json));
+        return;
+    }
+    if (verb === 'get') {
+        if (!opts.action)
+            throw new Error('Provide --action <action_tag>');
+        printJson(await getProductAppAction(ctx, opts.product, opts.app, opts.action), Boolean(opts.json));
+        return;
+    }
+    throw new Error('Supported verbs: list | get');
+}
 const COMPONENT_KEYS = {
     apps: ['apps'],
     databases: ['databases'],

package/dist/index.js

@@ -22,7 +22,7 @@ import { runSecretImportEnv, runSecrets } from './commands/secrets.js';
 import { runWorkspacesCurrent, runWorkspacesList, runWorkspacesRefresh, runWorkspacesUse, } from './commands/workspaces.js';
 import { runGeneratePayload, runGenerateSnippet } from './commands/generate.js';
 import { runCompletion } from './commands/completion.js';
-import { runProducts, runProductApps, runProductComponents, runProductEnvironments } from './commands/products.js';
+import { runProducts, runProductApps, runProductAppActions, 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';
@@ -530,12 +530,40 @@ const products = program
     return runProducts(verb, opts, []);
 }));
 const productApps = products.command('apps').description('Apps connected to a product');
+function collectOption(value, previous) {
+    return previous.concat(value);
+}
 productApps
     .command('list')
     .option('--profile <name>')
-    .option('--product <id>', 'Product _id')
+    .option('--product <id-or-tag>', 'Product _id or tag')
+    .option('--full', 'Include complete app versions, actions, schemas, and responses')
     .option('--json', 'JSON output')
     .action(wrap((opts) => runProductApps('list', opts, [])));
+productApps
+    .command('connect')
+    .requiredOption('--product <id-or-tag>', 'Product _id or tag')
+    .requiredOption('--app <tag>', 'Public marketplace app tag')
+    .requiredOption('--env-map <app-env:product-env>', 'Environment mapping; repeat for every product environment', collectOption, [])
+    .option('--profile <name>')
+    .option('--json', 'JSON output')
+    .action(wrap((opts) => runProductApps('connect', opts, [])));
+const productAppActions = productApps.command('actions').description('Actions exposed by an app linked to a product');
+productAppActions
+    .command('list')
+    .requiredOption('--product <id-or-tag>', 'Product _id or tag')
+    .requiredOption('--app <tag>', 'Linked app tag')
+    .option('--profile <name>')
+    .option('--json', 'JSON output')
+    .action(wrap((opts) => runProductAppActions('list', opts)));
+productAppActions
+    .command('get')
+    .requiredOption('--product <id-or-tag>', 'Product _id or tag')
+    .requiredOption('--app <tag>', 'Linked app tag')
+    .requiredOption('--action <tag>', 'Action tag')
+    .option('--profile <name>')
+    .option('--json', 'JSON output')
+    .action(wrap((opts) => runProductAppActions('get', opts)));
 const productComponents = products
     .command('components')
     .description('Compact, non-secret product component inventory');
@@ -635,6 +663,7 @@ program
     .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('--full', 'Return the complete marketplace app definition 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)');

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

@@ -7,7 +7,14 @@ export declare function getProduct(ctx: WorkspaceContext, opts: {
 export declare function createProduct(ctx: WorkspaceContext, body: Record<string, unknown>): Promise<unknown>;
 export declare function updateProduct(ctx: WorkspaceContext, tag: string, body: Record<string, unknown>): Promise<unknown>;
 export declare function deleteProduct(ctx: WorkspaceContext, productId: string): Promise<unknown>;
-export declare function listProductApps(ctx: WorkspaceContext, productId: string): Promise<unknown[]>;
+export declare function summarizeConnectedApp(value: unknown): unknown;
+export declare function listProductApps(ctx: WorkspaceContext, productIdOrTag: string, full?: boolean): Promise<unknown[]>;
+export declare function listProductAppActions(ctx: WorkspaceContext, product: string, appTag: string): Promise<unknown[]>;
+export declare function getProductAppAction(ctx: WorkspaceContext, product: string, appTag: string, actionTag: string): Promise<unknown>;
+export declare function connectMarketplaceApp(ctx: WorkspaceContext, product: string, appTag: string, envs: Array<{
+    app_env_slug: string;
+    product_env_slug: string;
+}>): Promise<unknown>;
 export declare function listApps(ctx: WorkspaceContext, status?: string): Promise<unknown[]>;
 export declare function getApp(ctx: WorkspaceContext, opts: {
     id?: string;
@@ -23,7 +30,7 @@ export interface MarketplaceSearchOptions {
     limit?: number;
 }
 export declare function listMarketplaceCategories(ctx: WorkspaceContext): Promise<unknown[]>;
-export declare function getMarketplaceApp(ctx: WorkspaceContext, tag: string): Promise<unknown>;
+export declare function getMarketplaceApp(ctx: WorkspaceContext, tag: string, full?: boolean): Promise<unknown>;
 export declare function searchMarketplaceApps(ctx: WorkspaceContext, opts: MarketplaceSearchOptions): Promise<unknown[]>;
 export interface TierQuery {
     provider?: string;

package/dist/lib/platform-api.js

@@ -56,8 +56,20 @@ export async function getProduct(ctx, opts) {
         // The integrations REST fetch-by-tag route rejects current CLI login tokens with HTTP 401.
         // Product inventory is an administrative read, so route it through the authenticated CLI
         // SDK proxy (x-access-token), not the publishable-key runtime MCP proxy.
-        const result = await proxy(ctx).execute('product', 'fetch', [opts.tag]);
-        return unwrapOne(result);
+        try {
+            const result = await proxy(ctx).execute('product', 'fetch', [opts.tag]);
+            return unwrapOne(result);
+        }
+        catch (proxyError) {
+            // Some deployed proxy versions fail product.fetch while the authenticated workspace
+            // inventory remains healthy. Resolve the exact tag from that inventory; never guess or
+            // turn a transport failure into an empty result.
+            const products = await listProducts(ctx, 'all');
+            const match = products.find((product) => product && typeof product === 'object' && product.tag === opts.tag);
+            if (match)
+                return match;
+            throw proxyError;
+        }
     }
     throw new Error('Provide --id <product_id> or --tag <product_tag>');
 }
@@ -77,9 +89,185 @@ export async function updateProduct(ctx, tag, body) {
 export async function deleteProduct(ctx, productId) {
     return client(ctx).delete(`/integrations/v1/${productId}?${new URLSearchParams(workspaceAuthQuery(ctx)).toString()}`);
 }
-export async function listProductApps(ctx, productId) {
-    const result = await client(ctx).getPath(`/integrations/v1/fetch-product-apps/${productId}`, workspaceAuthQuery(ctx));
-    return unwrapList(result);
+export function summarizeConnectedApp(value) {
+    if (!value || typeof value !== 'object')
+        return value;
+    const app = value;
+    const versions = Array.isArray(app.versions) ? app.versions : [];
+    const linkedEnvs = Array.isArray(app.envs) ? app.envs : [];
+    return {
+        _id: app._id ?? app.id,
+        tag: app.tag ?? app.app_tag,
+        access_tag: app.access_tag,
+        name: app.app_name ?? app.name,
+        description: app.description,
+        status: app.status,
+        active: app.active,
+        environments: linkedEnvs.map((item) => {
+            const env = item && typeof item === 'object' ? item : {};
+            return {
+                app_env_slug: env.app_env_slug,
+                product_env_slug: env.product_env_slug,
+            };
+        }),
+        versions: versions.map((item) => {
+            const version = item && typeof item === 'object' ? item : {};
+            return {
+                tag: version.tag,
+                latest: version.latest,
+                active: version.active,
+                environments: Array.isArray(version.envs) ? version.envs.length : 0,
+                actions: Array.isArray(version.actions) ? version.actions.length : 0,
+                webhooks: Array.isArray(version.webhooks) ? version.webhooks.length : 0,
+            };
+        }),
+    };
+}
+export async function listProductApps(ctx, productIdOrTag, full = false) {
+    const isObjectId = /^[a-f\d]{24}$/i.test(productIdOrTag);
+    // A tag is already sufficient for the compact SDK method; do not fetch the
+    // product catalogue merely to rediscover that same tag.
+    if (!full && !isObjectId) {
+        try {
+            const result = await proxy(ctx).execute('product', 'apps.list', [productIdOrTag]);
+            return unwrapList(result).map(summarizeConnectedApp);
+        }
+        catch {
+            // Older deployments may not expose product.apps.list reliably. The product
+            // record itself still contains compact link records and is the safe fallback.
+        }
+    }
+    const product = await getProduct(ctx, isObjectId ? { id: productIdOrTag } : { tag: productIdOrTag });
+    const row = product && typeof product === 'object' ? product : {};
+    const productId = String(row._id ?? row.id ?? (isObjectId ? productIdOrTag : ''));
+    const productTag = String(row.tag ?? (!isObjectId ? productIdOrTag : ''));
+    // The SDK proxy returns only the product's link records and avoids expanding every
+    // action contract. Prefer it for normal discovery; retain the expanded REST route
+    // solely for --full and compatibility with older deployed proxy versions.
+    if (!full && Array.isArray(row.apps)) {
+        return row.apps.map(summarizeConnectedApp);
+    }
+    if (!full && productTag) {
+        try {
+            const result = await proxy(ctx).execute('product', 'apps.list', [productTag]);
+            return unwrapList(result).map(summarizeConnectedApp);
+        }
+        catch {
+            // Fall through to the linked-app REST endpoint.
+        }
+    }
+    if (productId) {
+        try {
+            const result = await client(ctx).getPath(`/integrations/v1/fetch-product-apps/${productId}`, workspaceAuthQuery(ctx));
+            const apps = unwrapList(result);
+            return full ? apps : apps.map(summarizeConnectedApp);
+        }
+        catch (error) {
+            if (!productTag)
+                throw error;
+        }
+    }
+    if (!productTag)
+        throw new Error(`Could not resolve product tag for "${productIdOrTag}"`);
+    const result = await proxy(ctx).execute('product', 'apps.list', [productTag]);
+    const apps = unwrapList(result);
+    return full ? apps : apps.map(summarizeConnectedApp);
+}
+function actionSummary(value) {
+    if (!value || typeof value !== 'object')
+        return value;
+    const action = value;
+    return {
+        tag: action.tag,
+        name: action.name,
+        description: action.description,
+        method: action.method,
+        resource: action.resource,
+        request_type: action.request_type,
+    };
+}
+function actionsFromLinkedApp(app) {
+    const versions = Array.isArray(app.versions) ? app.versions : [];
+    const version = versions.find((item) => item.latest === true) ?? versions[0];
+    return Array.isArray(version?.actions) ? version.actions : [];
+}
+async function requireLinkedApp(ctx, product, appTag) {
+    const apps = await listProductApps(ctx, product);
+    const app = apps.find((item) => {
+        if (!item || typeof item !== 'object')
+            return false;
+        const row = item;
+        return row.tag === appTag || row.app_tag === appTag;
+    });
+    if (!app || typeof app !== 'object')
+        throw new Error(`App "${appTag}" is not linked to product "${product}"`);
+    return app;
+}
+export async function listProductAppActions(ctx, product, appTag) {
+    await requireLinkedApp(ctx, product, appTag);
+    try {
+        const result = await proxy(ctx).execute('app', 'actions.list', [appTag]);
+        return unwrapList(result).map(actionSummary);
+    }
+    catch {
+        const app = await getApp(ctx, { tag: appTag });
+        if (!app || typeof app !== 'object')
+            throw new Error(`App "${appTag}" could not be fetched`);
+        return actionsFromLinkedApp(app).map(actionSummary);
+    }
+}
+export async function getProductAppAction(ctx, product, appTag, actionTag) {
+    await requireLinkedApp(ctx, product, appTag);
+    try {
+        const result = unwrapOne(await proxy(ctx).execute('app', 'actions.fetch', [appTag, actionTag]));
+        if (result)
+            return result;
+    }
+    catch {
+        // Compatibility fallback for deployed SDKs predating app.actions.
+    }
+    const app = await getApp(ctx, { tag: appTag });
+    if (!app || typeof app !== 'object')
+        throw new Error(`App "${appTag}" could not be fetched`);
+    const action = actionsFromLinkedApp(app).find((item) => item && typeof item === 'object' && item.tag === actionTag);
+    if (!action)
+        throw new Error(`Action "${actionTag}" was not found on linked app "${appTag}"`);
+    return action;
+}
+export async function connectMarketplaceApp(ctx, product, appTag, envs) {
+    if (envs.length === 0)
+        throw new Error('At least one app-to-product environment mapping is required');
+    const marketplaceApp = await getMarketplaceApp(ctx, appTag, true);
+    if (!marketplaceApp || typeof marketplaceApp !== 'object')
+        throw new Error(`Marketplace app "${appTag}" was not found`);
+    const app = marketplaceApp;
+    if (app.status !== 'public')
+        throw new Error(`App "${appTag}" is not public in the marketplace`);
+    const versions = Array.isArray(app.versions) ? app.versions : [];
+    const latest = versions.find((version) => version.latest === true) ?? versions[0];
+    const availableAppEnvs = new Set((Array.isArray(latest?.envs) ? latest.envs : []).map((env) => String(env && typeof env === 'object' ? env.slug ?? '' : env)).filter(Boolean));
+    const productEnvs = unwrapList(await proxy(ctx).execute('product', 'environments.list', [product]));
+    const availableProductEnvs = new Set(productEnvs.map((env) => String(env.slug ?? '')).filter(Boolean));
+    for (const mapping of envs) {
+        if (!availableAppEnvs.has(mapping.app_env_slug)) {
+            throw new Error(`Marketplace app "${appTag}" has no environment "${mapping.app_env_slug}"`);
+        }
+        if (!availableProductEnvs.has(mapping.product_env_slug)) {
+            throw new Error(`Product "${product}" has no environment "${mapping.product_env_slug}"`);
+        }
+    }
+    const accessResult = unwrapOne(await proxy(ctx).execute('product', 'apps.connect', [product, appTag]));
+    const accessTag = String(accessResult?.access_tag ?? '');
+    if (!accessTag)
+        throw new Error(`Could not create or resolve access for marketplace app "${appTag}"`);
+    await proxy(ctx).execute('product', 'apps.add', [product, { access_tag: accessTag, envs }]);
+    return {
+        connected: true,
+        product,
+        app_tag: appTag,
+        access_tag: accessTag,
+        environments: envs,
+    };
 }
 // —— Apps (apps REST) ——
 export async function listApps(ctx, status = 'all') {
@@ -99,7 +287,9 @@ export async function getApp(ctx, opts) {
         return unwrapOne(result);
     }
     if (opts.tag) {
-        const result = await client(ctx).getPath(`/apps/v1/fetch/tag`, { ...q, tag: opts.tag });
+        // The REST tag route is not consistent for namespaced/private apps. The authenticated SDK
+        // proxy uses AppBuilder's canonical tag lookup and works for tags such as ductape:paystack.
+        const result = await proxy(ctx).execute('app', 'fetch', [opts.tag]);
         return unwrapOne(result);
     }
     throw new Error('Provide --id <app_id> or --tag <app_tag>');
@@ -164,13 +354,35 @@ function searchableMarketplaceText(app) {
         }),
     ].filter((item) => typeof item === 'string').join(' ').toLowerCase();
 }
+function summarizeMarketplaceApp(value) {
+    if (!value || typeof value !== 'object')
+        return value;
+    const app = value;
+    const versions = Array.isArray(app.versions) ? app.versions : [];
+    const current = app.currentVersion && typeof app.currentVersion === 'object'
+        ? app.currentVersion
+        : versions.find((version) => version.latest === true) ?? versions[0] ?? {};
+    const actions = Array.isArray(current.actions) ? current.actions : [];
+    return {
+        tag: app.tag,
+        name: app.app_name ?? app.name,
+        description: app.description,
+        categories: app.domains ?? [],
+        version: current.tag,
+        environments: Array.isArray(current.envs)
+            ? current.envs.map((env) => env && typeof env === 'object' ? env.slug : env)
+            : [],
+        actions: actions.map(actionSummary),
+    };
+}
 export async function listMarketplaceCategories(ctx) {
     const result = await client(ctx).getPath('/apps/v1/domains');
     return unwrapList(result);
 }
-export async function getMarketplaceApp(ctx, tag) {
+export async function getMarketplaceApp(ctx, tag, full = false) {
     const result = await client(ctx).getPath('/apps/v1/fetch/tag', { tag });
-    return unwrapOne(result);
+    const app = unwrapOne(result);
+    return full ? app : summarizeMarketplaceApp(app);
 }
 export async function searchMarketplaceApps(ctx, opts) {
     const result = await client(ctx).getPath('/apps/v1/domains/all');
@@ -188,7 +400,7 @@ export async function searchMarketplaceApps(ctx, opts) {
         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)));
+    return filtered.slice(0, Math.max(1, Math.min(opts.limit ?? 20, 100))).map(summarizeMarketplaceApp);
 }
 export async function listCloudTiers(ctx, q) {
     const params = workspaceAuthQuery(ctx);

package/package.json

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