@ductape/cli 0.2.0

package/dist/lib/config.js

@@ -0,0 +1,155 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export const GLOBAL_DIR = path.join(os.homedir(), '.ductape');
+export const CREDENTIALS_PATH = path.join(GLOBAL_DIR, 'credentials.json');
+export const GLOBAL_CONFIG_PATH = path.join(GLOBAL_DIR, 'config.json');
+export const PROJECT_CONFIG_DIR = '.ductape';
+export const PROJECT_CONFIG_PATH = path.join(PROJECT_CONFIG_DIR, 'config.json');
+const DEFAULT_GLOBAL = {
+    default_profile: 'cloud',
+    profiles: {
+        /** Production gateway — paths are /users/v1/…, /proxy/v1/… (no /api prefix). */
+        cloud: { api_url: 'https://api.ductape.app' },
+        /** Local docker api-gateway — paths are /api/users/v1/…, /api/proxy/v1/… */
+        local: { api_url: 'http://localhost:4311/api' },
+    },
+};
+function readJson(filePath) {
+    if (!fs.existsSync(filePath))
+        return null;
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+function writeJson(filePath, data, mode = 0o644) {
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', { mode });
+}
+export function ensureGlobalDir() {
+    fs.mkdirSync(GLOBAL_DIR, { recursive: true });
+}
+export function loadCredentials() {
+    return readJson(CREDENTIALS_PATH);
+}
+export function saveCredentials(creds) {
+    ensureGlobalDir();
+    writeJson(CREDENTIALS_PATH, creds, 0o600);
+}
+export function clearCredentials() {
+    if (fs.existsSync(CREDENTIALS_PATH))
+        fs.unlinkSync(CREDENTIALS_PATH);
+    const global = loadGlobalConfig();
+    delete global.active_workspace_id;
+    delete global.active_workspace_name;
+    delete global.active_workspace_tag;
+    saveGlobalConfig(global);
+}
+export function getActiveWorkspaceId() {
+    const global = loadGlobalConfig();
+    return global.active_workspace_id ?? null;
+}
+export function loadGlobalConfig() {
+    const cfg = readJson(GLOBAL_CONFIG_PATH) ?? {
+        ...DEFAULT_GLOBAL,
+        profiles: { ...DEFAULT_GLOBAL.profiles },
+    };
+    // Migrate older configs that used /api on production (returns HTML 404).
+    if (cfg.profiles.cloud?.api_url?.replace(/\/$/, '') === 'https://api.ductape.app/api') {
+        cfg.profiles.cloud.api_url = DEFAULT_GLOBAL.profiles.cloud.api_url;
+    }
+    return cfg;
+}
+export function saveGlobalConfig(config) {
+    ensureGlobalDir();
+    writeJson(GLOBAL_CONFIG_PATH, config);
+}
+export function getActiveProfileName(project) {
+    if (project?.linked_profile)
+        return project.linked_profile;
+    return loadGlobalConfig().default_profile;
+}
+export function getApiUrl(profileName) {
+    const global = loadGlobalConfig();
+    const name = profileName ?? global.default_profile;
+    const profile = global.profiles[name];
+    if (!profile) {
+        throw new Error(`Unknown profile "${name}". Run: ductape profiles list`);
+    }
+    return profile.api_url.replace(/\/$/, '');
+}
+function matchWorkspaceFromCredentials(workspaces, selector) {
+    const trimmed = selector.trim();
+    const idx = Number(trimmed);
+    if (!Number.isNaN(idx) && workspaces[idx]) {
+        const w = workspaces[idx];
+        return w.workspace_id ?? w._id ?? null;
+    }
+    for (const w of workspaces) {
+        const id = w.workspace_id ?? w._id;
+        const name = w.workspace_name ?? w.name ?? '';
+        const tag = w.tag ?? '';
+        if (id === trimmed ||
+            name.toLowerCase() === trimmed.toLowerCase() ||
+            tag.toLowerCase() === trimmed.toLowerCase()) {
+            return id ?? null;
+        }
+    }
+    return null;
+}
+/** Resolve workspace_id from tag (cached workspaces), explicit id, or global active workspace. */
+export function resolveWorkspaceId(cfg, creds) {
+    if (cfg.workspace_id?.trim())
+        return cfg.workspace_id.trim();
+    if (cfg.workspace_tag?.trim() && creds?.workspaces?.length) {
+        const id = matchWorkspaceFromCredentials(creds.workspaces, cfg.workspace_tag);
+        if (id)
+            return id;
+    }
+    return getActiveWorkspaceId();
+}
+export function findProjectConfig(startDir = process.cwd()) {
+    let dir = startDir;
+    const root = path.parse(dir).root;
+    while (true) {
+        const candidate = path.join(dir, PROJECT_CONFIG_PATH);
+        const cfg = readJson(candidate);
+        if (cfg?.product_tag && (cfg.workspace_tag || cfg.workspace_id)) {
+            return { dir, config: cfg };
+        }
+        if (dir === root)
+            break;
+        dir = path.dirname(dir);
+    }
+    return null;
+}
+export function loadProjectConfig() {
+    const found = findProjectConfig();
+    if (!found) {
+        throw new Error('No linked project. Run `ductape link` from your project directory (or `ductape init`).');
+    }
+    const creds = loadCredentials();
+    const cfg = { ...found.config };
+    const workspace_id = resolveWorkspaceId(cfg, creds);
+    if (!workspace_id) {
+        throw new Error('No workspace resolved. Set workspace_tag in .ductape/config.json or run `ductape workspaces use`.');
+    }
+    return { ...cfg, workspace_id };
+}
+export function saveProjectConfig(dir, config) {
+    const configDir = path.join(dir, PROJECT_CONFIG_DIR);
+    fs.mkdirSync(configDir, { recursive: true });
+    writeJson(path.join(configDir, 'config.json'), config);
+}
+export function resolvePlatformDir() {
+    if (process.env.DUCTAPE_PLATFORM_DIR) {
+        return path.resolve(process.env.DUCTAPE_PLATFORM_DIR);
+    }
+    // cli/ -> repo root -> platform/
+    const fromPackage = path.resolve(__dirname, '../../../platform');
+    if (fs.existsSync(path.join(fromPackage, 'docker-compose.yml'))) {
+        return fromPackage;
+    }
+    throw new Error('Platform directory not found. Set DUCTAPE_PLATFORM_DIR to the folder containing docker-compose.yml');
+}

package/dist/lib/context-store.d.ts

@@ -0,0 +1,17 @@
+import type { GraphContext } from './proxy/graph-proxy.js';
+export interface DatabaseContext {
+    database: string;
+    env: string;
+    product: string;
+}
+export interface ProjectRuntimeContext {
+    workspace_id: string;
+    product_tag: string;
+    env_slug: string;
+    database_context?: DatabaseContext | null;
+    graph_context?: GraphContext | null;
+}
+export declare function loadRuntimeContext(workspaceId: string, productTag: string): ProjectRuntimeContext | null;
+export declare function saveRuntimeContext(ctx: ProjectRuntimeContext): void;
+export declare function setDatabaseContext(workspaceId: string, productTag: string, envSlug: string, db: DatabaseContext | null): void;
+export declare function setGraphContext(workspaceId: string, productTag: string, envSlug: string, graph: GraphContext | null): void;

package/dist/lib/context-store.js

@@ -0,0 +1,43 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { GLOBAL_DIR } from './config.js';
+const RUNTIME_PATH = path.join(GLOBAL_DIR, 'runtime-context.json');
+function readAll() {
+    if (!fs.existsSync(RUNTIME_PATH))
+        return {};
+    return JSON.parse(fs.readFileSync(RUNTIME_PATH, 'utf8'));
+}
+function writeAll(data) {
+    fs.mkdirSync(GLOBAL_DIR, { recursive: true });
+    fs.writeFileSync(RUNTIME_PATH, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
+}
+function projectKey(workspaceId, productTag) {
+    return `${workspaceId}:${productTag}`;
+}
+export function loadRuntimeContext(workspaceId, productTag) {
+    const all = readAll();
+    return all[projectKey(workspaceId, productTag)] ?? null;
+}
+export function saveRuntimeContext(ctx) {
+    const all = readAll();
+    all[projectKey(ctx.workspace_id, ctx.product_tag)] = ctx;
+    writeAll(all);
+}
+export function setDatabaseContext(workspaceId, productTag, envSlug, db) {
+    const existing = loadRuntimeContext(workspaceId, productTag) ?? {
+        workspace_id: workspaceId,
+        product_tag: productTag,
+        env_slug: envSlug,
+    };
+    existing.database_context = db;
+    saveRuntimeContext(existing);
+}
+export function setGraphContext(workspaceId, productTag, envSlug, graph) {
+    const existing = loadRuntimeContext(workspaceId, productTag) ?? {
+        workspace_id: workspaceId,
+        product_tag: productTag,
+        env_slug: envSlug,
+    };
+    existing.graph_context = graph;
+    saveRuntimeContext(existing);
+}

package/dist/lib/db-methods.d.ts

@@ -0,0 +1,3 @@
+/** db-proxy methods (runtime). Dot notation supported: schema.list */
+export declare const DB_PROXY_METHODS: readonly ["connect", "disconnect", "closeAll", "testConnection", "getCurrentContext", "connection", "query", "execute", "insert", "update", "delete", "upsert", "count", "sum", "avg", "min", "max", "aggregate", "listTables", "listTablesWithInfo", "describe", "getSchema", "beginTransaction", "schema.create", "schema.drop", "schema.list", "schema.describe", "schema.addField", "schema.dropField", "migration.list", "migration.run"];
+export declare const GRAPH_PROXY_METHODS: readonly ["connect", "disconnect", "disconnectAll", "testConnection", "getCurrentContext", "create", "fetchAll", "fetch", "update", "delete", "createNode", "findNodes", "query", "traverse", "shortestPath", "countNodes", "dispatch", "execute", "executeTransaction"];

package/dist/lib/db-methods.js

@@ -0,0 +1,55 @@
+/** db-proxy methods (runtime). Dot notation supported: schema.list */
+export const DB_PROXY_METHODS = [
+    'connect',
+    'disconnect',
+    'closeAll',
+    'testConnection',
+    'getCurrentContext',
+    'connection',
+    'query',
+    'execute',
+    'insert',
+    'update',
+    'delete',
+    'upsert',
+    'count',
+    'sum',
+    'avg',
+    'min',
+    'max',
+    'aggregate',
+    'listTables',
+    'listTablesWithInfo',
+    'describe',
+    'getSchema',
+    'beginTransaction',
+    'schema.create',
+    'schema.drop',
+    'schema.list',
+    'schema.describe',
+    'schema.addField',
+    'schema.dropField',
+    'migration.list',
+    'migration.run',
+];
+export const GRAPH_PROXY_METHODS = [
+    'connect',
+    'disconnect',
+    'disconnectAll',
+    'testConnection',
+    'getCurrentContext',
+    'create',
+    'fetchAll',
+    'fetch',
+    'update',
+    'delete',
+    'createNode',
+    'findNodes',
+    'query',
+    'traverse',
+    'shortestPath',
+    'countNodes',
+    'dispatch',
+    'execute',
+    'executeTransaction',
+];

package/dist/lib/encryption.d.ts

@@ -0,0 +1 @@
+export declare function encryptProxyPayload(data: object, publicKey: string): string;

package/dist/lib/encryption.js

@@ -0,0 +1,11 @@
+/**
+ * Proxy payload encryption — matches platform/workbench/src/utils/proxyEncryption.ts
+ */
+import CryptoJS from 'crypto-js';
+export function encryptProxyPayload(data, publicKey) {
+    const jsonString = JSON.stringify(data);
+    const iv = CryptoJS.lib.WordArray.random(16);
+    const hashedKey = CryptoJS.SHA256(publicKey);
+    const encrypted = CryptoJS.AES.encrypt(jsonString, hashedKey, { iv });
+    return iv.toString(CryptoJS.enc.Hex) + ':' + encrypted.toString();
+}

package/dist/lib/forms/enums.d.ts

@@ -0,0 +1,11 @@
+/** Enum values aligned with @ductape/sdk — used for CLI dropdowns */
+export declare const STORAGE_PROVIDERS: readonly ["aws", "gcp", "azure"];
+export declare const DATABASE_TYPES: readonly ["postgresql", "mongodb", "mysql"];
+export declare const GRAPH_TYPES: readonly ["neo4j", "neptune", "arangodb", "memgraph"];
+export declare const VECTOR_DB_TYPES: readonly ["pinecone", "qdrant", "weaviate", "chroma", "milvus", "pgvector", "memory"];
+export declare const VECTOR_DISTANCE_METRICS: readonly ["cosine", "euclidean", "dotproduct"];
+export declare const MESSAGE_BROKER_TYPES: readonly ["rabbitmq", "kafka", "aws_sqs", "redis", "google_pubsub", "nats"];
+export declare const JOB_EVENT_TYPES: readonly ["action", "notification", "database_action", "database_operation", "graph_action", "graph_operation", "workflow", "storage"];
+export declare const DATABASE_ACTION_TYPES: readonly ["read", "count", "create", "update", "delete", "aggregate"];
+export declare const HTTP_METHODS: readonly ["GET", "POST", "PUT", "PATCH", "DELETE"];
+export declare const NOTIFIERS: readonly ["email", "sms", "push", "callback"];

package/dist/lib/forms/enums.js

@@ -0,0 +1,42 @@
+/** Enum values aligned with @ductape/sdk — used for CLI dropdowns */
+export const STORAGE_PROVIDERS = ['aws', 'gcp', 'azure'];
+export const DATABASE_TYPES = ['postgresql', 'mongodb', 'mysql'];
+export const GRAPH_TYPES = ['neo4j', 'neptune', 'arangodb', 'memgraph'];
+export const VECTOR_DB_TYPES = [
+    'pinecone',
+    'qdrant',
+    'weaviate',
+    'chroma',
+    'milvus',
+    'pgvector',
+    'memory',
+];
+export const VECTOR_DISTANCE_METRICS = ['cosine', 'euclidean', 'dotproduct'];
+export const MESSAGE_BROKER_TYPES = [
+    'rabbitmq',
+    'kafka',
+    'aws_sqs',
+    'redis',
+    'google_pubsub',
+    'nats',
+];
+export const JOB_EVENT_TYPES = [
+    'action',
+    'notification',
+    'database_action',
+    'database_operation',
+    'graph_action',
+    'graph_operation',
+    'workflow',
+    'storage',
+];
+export const DATABASE_ACTION_TYPES = [
+    'read',
+    'count',
+    'create',
+    'update',
+    'delete',
+    'aggregate',
+];
+export const HTTP_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'];
+export const NOTIFIERS = ['email', 'sms', 'push', 'callback'];

package/dist/lib/forms/index.d.ts

@@ -0,0 +1,2 @@
+export { isInteractive, promptForm, promptKey, promptTag, type InteractiveOpts } from './prompt.js';
+export { genericComponentSchema, getFormSchema, resolveResourceSchema, schemaKeyForEntity, schemaKeyForResource, } from './schemas.js';

package/dist/lib/forms/index.js

@@ -0,0 +1,2 @@
+export { isInteractive, promptForm, promptKey, promptTag } from './prompt.js';
+export { genericComponentSchema, getFormSchema, resolveResourceSchema, schemaKeyForEntity, schemaKeyForResource, } from './schemas.js';

package/dist/lib/forms/prompt.d.ts

@@ -0,0 +1,11 @@
+import type { FormSchema } from './types.js';
+export type InteractiveOpts = {
+    interactive?: boolean;
+    noInteractive?: boolean;
+};
+export declare function isInteractive(opts?: InteractiveOpts): boolean;
+export declare function promptForm(schema: FormSchema, opts?: {
+    patch?: boolean;
+}): Promise<Record<string, unknown>>;
+export declare function promptTag(label?: string): Promise<string>;
+export declare function promptKey(label?: string): Promise<string>;

package/dist/lib/forms/prompt.js

@@ -0,0 +1,203 @@
+import input from '@inquirer/input';
+import select from '@inquirer/select';
+import { MESSAGE_BROKER_TYPES, STORAGE_PROVIDERS } from './enums.js';
+export function isInteractive(opts) {
+    if (opts?.noInteractive)
+        return false;
+    if (opts?.interactive === true)
+        return true;
+    if (opts?.interactive === false)
+        return false;
+    return Boolean(process.stdin.isTTY && !process.env.CI && process.env.DUCTAPE_NO_INTERACTIVE !== '1');
+}
+async function askYesNo(message, defaultYes = true) {
+    return select({
+        message,
+        choices: [
+            { name: 'Yes', value: true },
+            { name: 'No', value: false },
+        ],
+        default: defaultYes,
+    });
+}
+async function promptJsonObject(message, required = true) {
+    const raw = await input({
+        message: `${message} (JSON object${required ? '' : ', optional'})`,
+    });
+    if (!raw.trim()) {
+        if (required)
+            throw new Error('JSON object is required');
+        return {};
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('Expected a JSON object');
+    }
+    return parsed;
+}
+async function promptStorageConfig(provider) {
+    if (provider === 'aws') {
+        return {
+            bucketName: await input({ message: 'S3 bucket name' }),
+            accessKeyId: await input({ message: 'AWS access key ID' }),
+            secretAccessKey: await input({ message: 'AWS secret access key' }),
+            region: await input({ message: 'AWS region' }),
+        };
+    }
+    if (provider === 'azure') {
+        return {
+            containerName: await input({ message: 'Container name' }),
+            connectionString: await input({ message: 'Connection string' }),
+        };
+    }
+    if (provider === 'gcp') {
+        return {
+            bucketName: await input({ message: 'GCS bucket name' }),
+            config: await promptJsonObject('GCP service account config'),
+        };
+    }
+    return promptJsonObject(`Config for ${provider}`);
+}
+async function promptEnvs(variant, context) {
+    const envs = [];
+    let addMore = true;
+    while (addMore) {
+        const slug = await input({
+            message: `Environment slug #${envs.length + 1} (3 letters)`,
+            validate: (v) => (v.length >= 1 && v.length <= 3 ? true : 'Use 1–3 characters'),
+        });
+        if (variant === 'database' || variant === 'graph') {
+            const connection_url = await input({
+                message: 'Connection URL',
+            });
+            const description = await input({ message: 'Description (optional)', default: '' });
+            const row = { slug, connection_url };
+            if (description.trim())
+                row.description = description.trim();
+            envs.push(row);
+        }
+        else if (variant === 'storage') {
+            const type = await select({
+                message: 'Storage provider',
+                choices: STORAGE_PROVIDERS.map((p) => ({ name: p, value: p })),
+            });
+            const config = await promptStorageConfig(type);
+            envs.push({ slug, type, config });
+        }
+        else if (variant === 'broker') {
+            const type = await select({
+                message: 'Broker type',
+                choices: MESSAGE_BROKER_TYPES.map((p) => ({ name: p, value: p })),
+            });
+            const config = await promptJsonObject('Broker config');
+            envs.push({ slug, type, config });
+        }
+        else if (variant === 'vector') {
+            const vectorType = context?.vectorType ?? 'pinecone';
+            const row = { slug };
+            if (vectorType === 'memory') {
+                const index = await input({ message: 'Index name (optional)', default: '' });
+                if (index.trim())
+                    row.index = index.trim();
+            }
+            else {
+                row.endpoint = await input({ message: 'Endpoint URL' });
+                const apiKey = await input({ message: 'API key (optional)', default: '' });
+                const index = await input({ message: 'Index / collection (optional)', default: '' });
+                if (apiKey.trim())
+                    row.apiKey = apiKey.trim();
+                if (index.trim())
+                    row.index = index.trim();
+            }
+            envs.push(row);
+        }
+        else {
+            envs.push({ slug });
+        }
+        addMore = await askYesNo('Add another environment?', false);
+    }
+    return envs;
+}
+async function promptField(field, patch) {
+    const required = patch ? field.required : field.required !== false;
+    if (field.kind === 'enum' && field.choices?.length) {
+        const value = await select({
+            message: field.label,
+            choices: field.choices.map((c) => ({ name: c, value: c })),
+            default: field.default,
+        });
+        return value;
+    }
+    if (field.kind === 'number') {
+        const raw = await input({
+            message: field.label,
+            default: field.default !== undefined ? String(field.default) : undefined,
+        });
+        if (!raw.trim() && !required)
+            return undefined;
+        const n = Number(raw);
+        if (Number.isNaN(n))
+            throw new Error(`${field.label} must be a number`);
+        return n;
+    }
+    if (field.kind === 'envs') {
+        if (!field.envsVariant)
+            throw new Error('envs field missing envsVariant');
+        return promptEnvs(field.envsVariant);
+    }
+    const value = await input({
+        message: field.label,
+        default: field.default !== undefined ? String(field.default) : undefined,
+    });
+    if (!value.trim() && !required)
+        return undefined;
+    if (!value.trim() && required)
+        throw new Error(`${field.label} is required`);
+    return value.trim();
+}
+export async function promptForm(schema, opts) {
+    const patch = Boolean(opts?.patch);
+    const body = {};
+    let vectorType;
+    for (const field of schema.fields) {
+        if (patch && !field.required) {
+            const set = await askYesNo(`Set ${field.label}?`, false);
+            if (!set)
+                continue;
+        }
+        if (field.key === 'type' && field.kind === 'enum') {
+            const value = await promptField(field, patch);
+            if (value !== undefined) {
+                body.type = value;
+                vectorType = String(value);
+            }
+            continue;
+        }
+        if (field.kind === 'envs' && field.envsVariant === 'vector') {
+            const envs = await promptEnvs('vector', { vectorType });
+            if (envs.length)
+                body.envs = envs;
+            continue;
+        }
+        const value = await promptField(field, patch);
+        if (value !== undefined && value !== '') {
+            body[field.key] = value;
+        }
+    }
+    if (schema.allowExtraJson) {
+        const useExtra = await askYesNo('Add extra fields as JSON?', false);
+        if (useExtra) {
+            Object.assign(body, await promptJsonObject('Extra fields', false));
+        }
+    }
+    return body;
+}
+export async function promptTag(label = 'Tag') {
+    const value = await input({ message: label });
+    if (!value.trim())
+        throw new Error(`${label} is required`);
+    return value.trim();
+}
+export async function promptKey(label = 'Secret key') {
+    return promptTag(label);
+}

package/dist/lib/forms/schemas.d.ts

@@ -0,0 +1,9 @@
+import type { SDKModule } from '../proxy/sdk-proxy.js';
+import type { CrudVerb } from '../resources.js';
+import type { FormSchema } from './types.js';
+export declare function getFormSchema(schemaKey: string): FormSchema | undefined;
+export declare function schemaKeyForResource(module: SDKModule, verb: CrudVerb): string | undefined;
+export declare function schemaKeyForEntity(entity: 'products' | 'apps', verb: string): string | undefined;
+/** Fallback schema for component types without a dedicated form */
+export declare function genericComponentSchema(verb: 'create' | 'update'): FormSchema;
+export declare function resolveResourceSchema(module: SDKModule, verb: CrudVerb): FormSchema | undefined;