@ductape/cli 0.3.12 → 0.3.14

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

@@ -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);
         });
     };
@@ -673,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/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.12",
+  "version": "0.3.14",
   "description": "Ductape CLI — local platform, login, link projects, and manage resources via the proxy (Workbench-compatible)",
   "type": "module",
   "main": "dist/index.js",