@ductape/cli 0.3.11 → 0.3.13

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/commands/resources.d.ts

@@ -16,6 +16,9 @@ export declare function runEventTopicCrud(verb: string, opts: {
     file?: string;
     dir?: string;
     json?: boolean;
+    resume?: boolean;
+    concurrency?: string;
+    timeout?: string;
 } & CommandInteractiveFlags, extraArgs: string[]): Promise<void>;
 export declare function runNotificationMessageCrud(verb: string, opts: {
     tag?: string;

package/dist/commands/resources.js

@@ -5,6 +5,7 @@ import { toInteractiveOpts } from '../lib/interactive-opts.js';
 import { bodyRequiredHint, resolveBody } from '../lib/read-body.js';
 import { requireSession, getSdkProxy } from '../lib/proxy/context.js';
 import { printJson } from '../lib/output.js';
+import { DuctapeOperationError } from '../lib/operation-error.js';
 import { readCanonicalTopicFile, topicBodyForTransport, validateEventTopicsProject, } from '../lib/event-topics.js';
 const CRUD_VERBS = ['create', 'list', 'get', 'update', 'delete', 'connect'];
 export function resolveResourceProductTag(override, linkedProductTag) {
@@ -67,20 +68,55 @@ export async function runEventTopicCrud(verb, opts, extraArgs) {
     const proxy = getSdkProxy(session);
     if (verb === 'create-all') {
         const validation = await validateEventTopicsProject(process.cwd(), opts.dir);
-        const created = [];
-        // Validation of the complete directory deliberately finishes before the first mutation.
-        for (const topic of validation.topics) {
-            await proxy.execute('messageBrokers', 'topics.create', [
-                productTag,
-                topicBodyForTransport(topic.definition),
-            ]);
-            const verified = await proxy.execute('messageBrokers', 'topics.fetch', [productTag, topic.definition.tag]);
-            if (!verified) {
-                throw new Error(`Topic creation returned without an error, but "${topic.definition.tag}" was not found during verification`);
+        const concurrency = positiveInteger(opts.concurrency, 1, '--concurrency');
+        const timeoutMs = positiveInteger(opts.timeout, 120_000, '--timeout');
+        const deadline = Date.now() + timeoutMs;
+        const items = new Array(validation.topics.length);
+        let cursor = 0;
+        const worker = async () => {
+            while (true) {
+                const index = cursor++;
+                const asset = validation.topics[index];
+                if (!asset)
+                    return;
+                const tag = asset.definition.tag;
+                if (Date.now() >= deadline) {
+                    items[index] = { tag, status: 'not_attempted', error: `Total timeout of ${timeoutMs}ms reached` };
+                    continue;
+                }
+                try {
+                    const existing = await fetchTopicIfPresent(proxy, productTag, tag);
+                    if (existing) {
+                        items[index] = { tag, status: 'already_exists', topic: existing };
+                        continue;
+                    }
+                    try {
+                        await proxy.execute('messageBrokers', 'topics.create', [productTag, topicBodyForTransport(asset.definition)]);
+                    }
+                    catch (error) {
+                        const reconciled = await fetchTopicIfPresent(proxy, productTag, tag);
+                        if (reconciled) {
+                            items[index] = { tag, status: 'created_after_reconciliation', topic: reconciled };
+                            continue;
+                        }
+                        throw error;
+                    }
+                    const verified = await fetchTopicIfPresent(proxy, productTag, tag);
+                    if (!verified)
+                        throw new Error(`Creation returned without an error, but the topic was not found during verification`);
+                    items[index] = { tag, status: 'created', topic: verified };
+                }
+                catch (error) {
+                    items[index] = { tag, status: 'failed', error: error instanceof Error ? error.message : String(error) };
+                }
             }
-            created.push({ tag: topic.definition.tag, topic: verified });
-        }
-        printJson({ created: created.length, topics: created }, Boolean(opts.json));
+        };
+        await Promise.all(Array.from({ length: Math.min(concurrency, validation.topics.length) }, worker));
+        const counts = items.reduce((result, item) => {
+            result[item.status] = (result[item.status] ?? 0) + 1;
+            return result;
+        }, {});
+        printJson({ complete: !counts.failed && !counts.not_attempted, resume: Boolean(opts.resume), counts, topics: items }, Boolean(opts.json));
         return;
     }
     const interactive = toInteractiveOpts(opts);
@@ -149,6 +185,24 @@ export async function runEventTopicCrud(verb, opts, extraArgs) {
     }
     printJson(result, Boolean(opts.json));
 }
+function positiveInteger(value, fallback, option) {
+    if (value === undefined)
+        return fallback;
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed < 1)
+        throw new Error(`${option} must be a positive integer`);
+    return parsed;
+}
+async function fetchTopicIfPresent(proxy, productTag, tag) {
+    try {
+        return await proxy.execute('messageBrokers', 'topics.fetch', [productTag, tag]) ?? null;
+    }
+    catch (error) {
+        if (/not[ -]?found|does not exist|404/i.test(error instanceof Error ? error.message : String(error)))
+            return null;
+        throw error;
+    }
+}
 export async function runNotificationMessageCrud(verb, opts) {
     const crud = verb.toLowerCase();
     if (!['create', 'list', 'get', 'update'].includes(crud)) {
@@ -215,6 +269,7 @@ export async function runResourceCrud(typeName, verb, opts, extraArgs) {
         }
     }
     const method = proxyMethodForVerb(crud);
+    const proxyMethod = module === 'models' && method === 'list' ? 'fetchAll' : method;
     const interactive = toInteractiveOpts(opts);
     let tag = opts.tag ?? extraArgs[0];
     if (!tag && ['get', 'update', 'delete'].includes(crud) && isInteractive(interactive)) {
@@ -251,7 +306,28 @@ export async function runResourceCrud(typeName, verb, opts, extraArgs) {
         printJson(await listSessionsWithProductFallback(proxy, productTag), Boolean(opts.json));
         return;
     }
-    const result = await proxy.execute(module, method, params);
+    let result;
+    try {
+        result = await proxy.execute(module, proxyMethod, params);
+    }
+    catch (error) {
+        const createdTag = String(body?.tag ?? '').trim();
+        if (crud !== 'create' || !createdTag || !(error instanceof DuctapeOperationError) || error.details.mutationState !== 'unknown') {
+            throw error;
+        }
+        try {
+            const reconciled = await proxy.execute(module, 'fetch', buildCrudParams(module, 'fetch', productTag, { tag: createdTag }));
+            if (!reconciled)
+                throw error;
+            printJson({ created: true, reconciled: true, outcome: 'succeeded_after_reconciliation', resource: reconciled }, Boolean(opts.json));
+            return;
+        }
+        catch (reconcileError) {
+            if (reconcileError === error)
+                throw error;
+            throw new DuctapeOperationError(`${error.message} Reconciliation could not confirm whether "${createdTag}" exists.`, { ...error.details, code: 'MUTATION_OUTCOME_UNKNOWN', mutationState: 'unknown' }, { cause: reconcileError });
+        }
+    }
     if (crud === 'create' && module === 'sessions') {
         const createdTag = String(body?.tag ?? '').trim();
         if (!createdTag) {

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';
@@ -42,6 +42,7 @@ import { runMigrationVerificationValidate } from './commands/migration-verificat
 import { runMigrationArtifactMigrate, runMigrationArtifactRecover, runMigrationArtifactSchemas, runMigrationArtifactValidate, } from './commands/migration-artifact.js';
 import { runMigrationCapabilities } from './commands/migration-capabilities.js';
 import { structuredMigrationError } from './lib/migration-artifact.js';
+import { DuctapeOperationError } from './lib/operation-error.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(path.join(__dirname, '../package.json'), 'utf8'));
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -51,7 +52,9 @@ function wrap(fn) {
             const command = process.argv[2] ?? '';
             console.error(command === 'migrate-codebase' || command.startsWith('migration-')
                 ? structuredMigrationError(err)
-                : err instanceof Error ? err.message : err);
+                : err instanceof DuctapeOperationError && process.argv.includes('--json')
+                    ? JSON.stringify(err.toJSON())
+                    : err instanceof Error ? err.message : err);
             process.exit(1);
         });
     };
@@ -530,12 +533,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 +666,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)');
@@ -644,6 +676,9 @@ eventTopics
     .option('-t, --tag <tag>', 'Broker tag (list) or topic tag in broker:topic form (get, update, delete)')
     .option('-f, --file <path>', 'JSON body (create, update)')
     .option('--dir <path>', 'Events asset directory (must resolve to ductape/events)', 'ductape/events')
+    .option('--resume', 'Reconcile live topic state and continue incomplete imports')
+    .option('--concurrency <count>', 'Maximum concurrent topic operations', '1')
+    .option('--timeout <ms>', 'Total create-all deadline in milliseconds', '120000')
     .option('-i, --interactive', 'Prompt for fields (default in TTY when -f omitted)')
     .option('--no-interactive', 'Require -f JSON for create/update')
     .option('--json', 'JSON output')

package/dist/lib/api-client.js

@@ -1,4 +1,6 @@
 import { getApiUrl } from './config.js';
+import { parseJsonResponse } from './http.js';
+import { DuctapeOperationError, safeEndpoint } from './operation-error.js';
 export class ApiClient {
     apiUrl;
     token;
@@ -23,22 +25,32 @@ export class ApiClient {
             headers,
             body: body !== undefined ? JSON.stringify(body) : undefined,
         });
-        const text = await res.text();
-        let parsed;
-        try {
-            parsed = text ? JSON.parse(text) : {};
-        }
-        catch {
-            throw new Error(`Invalid JSON from ${url}: ${text.slice(0, 200)}`);
-        }
+        const mutating = !['GET', 'HEAD', 'OPTIONS'].includes(method.toUpperCase());
+        const parsed = await parseJsonResponse(res, url, {
+            operation: `${method.toUpperCase()} ${path.split('?')[0]}`,
+            mutationState: mutating ? 'unknown' : 'not_attempted',
+        });
         if (!res.ok) {
             const msg = parsed.message ??
                 parsed.error ??
                 `HTTP ${res.status}`;
-            throw new Error(msg);
+            throw new DuctapeOperationError(msg, {
+                code: 'HTTP_ERROR', operation: `${method.toUpperCase()} ${path.split('?')[0]}`,
+                endpoint: safeEndpoint(url), httpStatus: res.status,
+                requestId: res.headers.get('x-request-id') ?? res.headers.get('x-correlation-id') ?? undefined,
+                retryable: res.status === 408 || res.status === 429 || res.status >= 500,
+                mutationState: mutating ? 'unknown' : 'not_attempted',
+                contentType: res.headers.get('content-type') ?? undefined,
+            });
         }
         if (typeof parsed.status === 'boolean' && !parsed.status) {
-            throw new Error(parsed.message ?? 'Request failed');
+            throw new DuctapeOperationError(parsed.message ?? 'Request failed', {
+                code: 'OPERATION_FAILED', operation: `${method.toUpperCase()} ${path.split('?')[0]}`,
+                endpoint: safeEndpoint(url), httpStatus: res.status,
+                requestId: res.headers.get('x-request-id') ?? res.headers.get('x-correlation-id') ?? undefined,
+                retryable: false, mutationState: mutating ? 'confirmed_failed' : 'not_attempted',
+                contentType: res.headers.get('content-type') ?? undefined,
+            });
         }
         const data = parsed.data;
         if (data && typeof data === 'object' && 'result' in data) {

package/dist/lib/http.d.ts

@@ -1,5 +1,9 @@
+import { type MutationState } from './operation-error.js';
 /** Parse fetch body as JSON; surface HTML/misconfigured api_url clearly. */
-export declare function parseJsonResponse<T = Record<string, unknown>>(res: Response, url: string): Promise<T>;
+export declare function parseJsonResponse<T = Record<string, unknown>>(res: Response, url: string, context?: {
+    operation?: string;
+    mutationState?: MutationState;
+}): Promise<T>;
 export interface ProxyJsonResponse<T> {
     status?: boolean;
     data?: {
@@ -7,4 +11,7 @@ export interface ProxyJsonResponse<T> {
     };
     message?: string;
 }
-export declare function postProxyJson<T>(url: string, body: Record<string, unknown>, headers: Record<string, string>): Promise<T>;
+export declare function postProxyJson<T>(url: string, body: Record<string, unknown>, headers: Record<string, string>, context?: {
+    operation?: string;
+    mutationState?: MutationState;
+}): Promise<T>;

package/dist/lib/http.js

@@ -1,12 +1,14 @@
 import { gzipSync } from 'node:zlib';
+import { DuctapeOperationError, safeEndpoint } from './operation-error.js';
 const GZIP_THRESHOLD = 200 * 1024;
 /** Parse fetch body as JSON; surface HTML/misconfigured api_url clearly. */
-export async function parseJsonResponse(res, url) {
+export async function parseJsonResponse(res, url, context = {}) {
+    const endpoint = safeEndpoint(url);
     const text = await res.text();
     const contentType = res.headers.get('content-type') ?? '';
     if (!text.trim()) {
         if (!res.ok)
-            throw new Error(`Empty response from ${url} (HTTP ${res.status})`);
+            throw responseError(`Empty response (HTTP ${res.status})`, res, url, context, 'EMPTY_RESPONSE');
         return {};
     }
     try {
@@ -14,8 +16,8 @@ export async function parseJsonResponse(res, url) {
     }
     catch {
         if (res.status === 504) {
-            throw new Error(`Ductape proxy gateway timeout (HTTP 504) for ${url}. The operation did not return a ` +
-                'verifiable result; retry only after checking whether the asset was created.');
+            throw responseError(`Ductape proxy gateway timeout (HTTP 504) for ${endpoint}. The operation did not return a ` +
+                'verifiable result; retry only after checking whether the asset was created.', res, url, context, 'GATEWAY_TIMEOUT');
         }
         const htmlHint = text.trimStart().startsWith('<')
             ? [
@@ -27,10 +29,22 @@ export async function parseJsonResponse(res, url) {
                 'Then: ductape login --profile local',
             ].join('\n')
             : '';
-        throw new Error(`Invalid JSON from ${url} (HTTP ${res.status}, Content-Type: ${contentType}): ${text.slice(0, 200)}${htmlHint}`);
+        throw responseError(`Invalid JSON from ${endpoint} (HTTP ${res.status}, Content-Type: ${contentType}): ${text.slice(0, 200)}${htmlHint}`, res, url, context, 'INVALID_JSON_RESPONSE');
     }
 }
-export async function postProxyJson(url, body, headers) {
+function responseError(message, res, url, context, code) {
+    return new DuctapeOperationError(message, {
+        code,
+        operation: context.operation ?? 'http.request',
+        endpoint: safeEndpoint(url),
+        httpStatus: res.status,
+        requestId: res.headers.get('x-request-id') ?? res.headers.get('x-correlation-id') ?? undefined,
+        retryable: res.status === 408 || res.status === 429 || res.status >= 500,
+        mutationState: context.mutationState ?? 'not_attempted',
+        contentType: res.headers.get('content-type') ?? undefined,
+    });
+}
+export async function postProxyJson(url, body, headers, context = {}) {
     const json = JSON.stringify(body);
     const reqHeaders = { ...headers, 'Content-Type': 'application/json' };
     let bodyInit = json;
@@ -44,12 +58,12 @@ export async function postProxyJson(url, body, headers) {
         headers: reqHeaders,
         body: bodyInit,
     });
-    const parsed = await parseJsonResponse(res, url);
+    const parsed = await parseJsonResponse(res, url, context);
     if (!res.ok) {
-        throw new Error(parsed.message ?? `Request failed: ${res.status}`);
+        throw responseError(parsed.message ?? `Request failed: ${res.status}`, res, url, context, 'HTTP_ERROR');
     }
     if (typeof parsed.status === 'boolean' && !parsed.status) {
-        throw new Error(parsed.message ?? 'Proxy operation failed');
+        throw responseError(parsed.message ?? 'Proxy operation failed', res, url, context, 'OPERATION_FAILED');
     }
     return parsed.data?.data;
 }

package/dist/lib/operation-error.d.ts

@@ -0,0 +1,17 @@
+export type MutationState = 'not_attempted' | 'unknown' | 'confirmed_failed';
+export interface OperationErrorDetails {
+    code: string;
+    operation: string;
+    endpoint: string;
+    httpStatus?: number;
+    requestId?: string;
+    retryable: boolean;
+    mutationState: MutationState;
+    contentType?: string;
+}
+export declare class DuctapeOperationError extends Error {
+    readonly details: OperationErrorDetails;
+    constructor(message: string, details: OperationErrorDetails, options?: ErrorOptions);
+    toJSON(): Record<string, unknown>;
+}
+export declare function safeEndpoint(value: string): string;

package/dist/lib/operation-error.js

@@ -0,0 +1,20 @@
+export class DuctapeOperationError extends Error {
+    details;
+    constructor(message, details, options) {
+        super(message, options);
+        this.name = 'DuctapeOperationError';
+        this.details = details;
+    }
+    toJSON() {
+        return { error: this.message, ...this.details };
+    }
+}
+export function safeEndpoint(value) {
+    try {
+        const url = new URL(value);
+        return `${url.origin}${url.pathname}`;
+    }
+    catch {
+        return value.split('?')[0];
+    }
+}

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/dist/lib/proxy/sdk-proxy.d.ts

@@ -1,4 +1,4 @@
-export type SDKModule = 'product' | 'app' | 'databases' | 'graph' | 'webhooks' | 'notifications' | 'messageBrokers' | 'storage' | 'vector' | 'caches' | 'sessions' | 'quotas' | 'actions' | 'features' | 'jobs' | 'logs' | 'resilience' | 'health' | 'fallback' | 'secrets' | 'cloud';
+export type SDKModule = 'product' | 'app' | 'databases' | 'graph' | 'webhooks' | 'notifications' | 'messageBrokers' | 'storage' | 'vector' | 'caches' | 'sessions' | 'quotas' | 'actions' | 'features' | 'jobs' | 'logs' | 'resilience' | 'health' | 'fallback' | 'secrets' | 'models' | 'cloud';
 export interface SdkProxyContext {
     apiUrl: string;
     workspaceId: string;

package/dist/lib/proxy/sdk-proxy.js

@@ -14,7 +14,12 @@ export class SdkProxyClient {
             workspace_id: this.ctx.workspaceId,
             user_id: this.ctx.userId,
             public_key: this.ctx.publicKey,
-        }, { 'x-access-token': this.ctx.token });
+        }, { 'x-access-token': this.ctx.token }, {
+            operation: `${module}.${method}`,
+            mutationState: /(^|\.)(create|update|delete|connect|import|provision|complete)$/.test(method)
+                ? 'unknown'
+                : 'not_attempted',
+        });
     }
 }
 export function createSdkProxyClient(ctx) {

package/dist/lib/resources.js

@@ -32,6 +32,8 @@ export const RESOURCE_MODULES = {
     health: 'health',
     healthcheck: 'health',
     fallback: 'fallback',
+    model: 'models',
+    models: 'models',
     product: 'product',
     app: 'app',
 };
@@ -45,6 +47,8 @@ export function resolveResourceType(name) {
 export function proxyMethodForVerb(verb) {
     if (verb === 'get')
         return 'fetch';
+    if (verb === 'list')
+        return 'list';
     return verb;
 }
 /** Build params array matching Workbench sdkProxy.ts conventions */
@@ -65,6 +69,22 @@ export function buildCrudParams(module, method, productTag, args) {
             return [payload];
         }
     }
+    if (module === 'models') {
+        if (method === 'list')
+            return [{ product: productTag }];
+        if (method === 'create')
+            return [{ product: productTag, ...(body ?? {}) }];
+        if (method === 'fetch' || method === 'delete') {
+            if (!tag)
+                throw new Error('tag is required');
+            return [{ product: productTag, tag }];
+        }
+        if (method === 'update') {
+            if (!tag)
+                throw new Error('tag is required');
+            return [{ product: productTag, tag, ...(body ?? {}) }];
+        }
+    }
     if ((module === 'storage' || module === 'databases') && method === 'create') {
         // databases.create and storage.create expect a single config object with product embedded,
         // not the default (productTag, data) two-argument form.
@@ -145,6 +165,7 @@ export function listResourceTypes() {
         'quotas',
         'health',
         'fallback',
+        'models',
         'product',
         'app',
     ];

package/package.json

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