@ductape/cli 0.2.22 → 0.3.0

package/src/lib/forms/prompt.ts

@@ -1,209 +0,0 @@
-import input from '@inquirer/input';
-import select from '@inquirer/select';
-import { MESSAGE_BROKER_TYPES, STORAGE_PROVIDERS } from './enums.js';
-import type { EnvsVariant, FormField, FormSchema } from './types.js';
-
-export type InteractiveOpts = {
-  interactive?: boolean;
-  noInteractive?: boolean;
-};
-
-export function isInteractive(opts?: InteractiveOpts): boolean {
-  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: string, defaultYes = true): Promise<boolean> {
-  return select({
-    message,
-    choices: [
-      { name: 'Yes', value: true },
-      { name: 'No', value: false },
-    ],
-    default: defaultYes,
-  });
-}
-
-async function promptJsonObject(message: string, required = true): Promise<Record<string, unknown>> {
-  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) as unknown;
-  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-    throw new Error('Expected a JSON object');
-  }
-  return parsed as Record<string, unknown>;
-}
-
-async function promptStorageConfig(provider: string): Promise<Record<string, unknown>> {
-  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: EnvsVariant, context?: { vectorType?: string }): Promise<unknown[]> {
-  const envs: unknown[] = [];
-  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: Record<string, unknown> = { 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: Record<string, unknown> = { 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: FormField, patch: boolean): Promise<unknown> {
-  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 as string | undefined,
-    });
-    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: FormSchema, opts?: { patch?: boolean }): Promise<Record<string, unknown>> {
-  const patch = Boolean(opts?.patch);
-  const body: Record<string, unknown> = {};
-  let vectorType: string | undefined;
-
-  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'): Promise<string> {
-  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'): Promise<string> {
-  return promptTag(label);
-}

package/src/lib/forms/schemas.ts

@@ -1,288 +0,0 @@
-import type { SDKModule } from '../proxy/sdk-proxy.js';
-import type { CrudVerb } from '../resources.js';
-import {
-  DATABASE_TYPES,
-  GRAPH_TYPES,
-  HTTP_METHODS,
-  JOB_EVENT_TYPES,
-  MESSAGE_BROKER_TYPES,
-  NOTIFIERS,
-  STORAGE_PROVIDERS,
-  VECTOR_DB_TYPES,
-  VECTOR_DISTANCE_METRICS,
-} from './enums.js';
-import type { FormField, FormSchema } from './types.js';
-
-const TAG: FormField = { key: 'tag', label: 'Tag (no spaces)', kind: 'text', required: true };
-const NAME: FormField = { key: 'name', label: 'Name', kind: 'text', required: true };
-const DESC: FormField = { key: 'description', label: 'Description', kind: 'text' };
-
-function fields(...items: FormField[]): FormField[] {
-  return items;
-}
-
-function optional(fields: FormField[]): FormField[] {
-  return fields.map((f) => ({ ...f, required: false }));
-}
-
-const PRODUCT_CREATE: FormSchema = {
-  fields: fields(
-    { key: 'name', label: 'Product name', kind: 'text', required: true },
-    { key: 'description', label: 'Description', kind: 'text', required: true },
-    TAG,
-  ),
-};
-
-const APP_CREATE: FormSchema = {
-  fields: fields(
-    { key: 'app_name', label: 'App name', kind: 'text', required: true },
-    { key: 'description', label: 'Description', kind: 'text', required: true },
-    TAG,
-  ),
-};
-
-const COMPONENT_BASE: FormField[] = [NAME, DESC, TAG];
-
-const SCHEMAS: Record<string, FormSchema> = {
-  'products:create': PRODUCT_CREATE,
-  'products:update': { fields: optional(PRODUCT_CREATE.fields) },
-  'apps:create': APP_CREATE,
-  'apps:update': {
-    fields: optional([
-      { key: 'app_name', label: 'App name', kind: 'text' },
-      { key: 'description', label: 'Description', kind: 'text' },
-      TAG,
-    ]),
-  },
-  'storage:create': {
-    fields: [
-      ...COMPONENT_BASE,
-      { key: 'envs', label: 'Environments', kind: 'envs', required: true, envsVariant: 'storage' },
-    ],
-  },
-  'storage:update': {
-    fields: [
-      ...optional(COMPONENT_BASE),
-      { key: 'envs', label: 'Environments', kind: 'envs', envsVariant: 'storage' },
-    ],
-    allowExtraJson: true,
-  },
-  'databases:create': {
-    fields: [
-      ...COMPONENT_BASE,
-      {
-        key: 'type',
-        label: 'Database type',
-        kind: 'enum',
-        required: true,
-        choices: DATABASE_TYPES,
-      },
-      { key: 'envs', label: 'Environments', kind: 'envs', required: true, envsVariant: 'database' },
-    ],
-  },
-  'databases:update': {
-    fields: [
-      ...optional(COMPONENT_BASE),
-      { key: 'type', label: 'Database type', kind: 'enum', choices: DATABASE_TYPES },
-      { key: 'envs', label: 'Environments', kind: 'envs', envsVariant: 'database' },
-    ],
-    allowExtraJson: true,
-  },
-  'databases:connect': { fields: [TAG] },
-  'graph:create': {
-    fields: [
-      ...COMPONENT_BASE,
-      { key: 'type', label: 'Graph type', kind: 'enum', required: true, choices: GRAPH_TYPES },
-      { key: 'envs', label: 'Environments', kind: 'envs', required: true, envsVariant: 'graph' },
-    ],
-  },
-  'graph:update': {
-    fields: [
-      ...optional(COMPONENT_BASE),
-      { key: 'type', label: 'Graph type', kind: 'enum', choices: GRAPH_TYPES },
-      { key: 'envs', label: 'Environments', kind: 'envs', envsVariant: 'graph' },
-    ],
-    allowExtraJson: true,
-  },
-  'graph:connect': { fields: [TAG] },
-  'caches:create': {
-    fields: [
-      ...COMPONENT_BASE,
-      { key: 'expiry', label: 'Expiry (seconds)', kind: 'number', required: true },
-    ],
-  },
-  'caches:update': {
-    fields: optional([...COMPONENT_BASE, { key: 'expiry', label: 'Expiry (seconds)', kind: 'number' }]),
-    allowExtraJson: true,
-  },
-  'jobs:create': {
-    fields: [
-      TAG,
-      NAME,
-      { key: 'description', label: 'Description', kind: 'text', required: true },
-      { key: 'type', label: 'Job type', kind: 'enum', choices: JOB_EVENT_TYPES },
-      { key: 'event', label: 'Event tag', kind: 'text', required: true },
-      { key: 'executions', label: 'Max executions', kind: 'number', required: true },
-      { key: 'intervals', label: 'Interval (seconds)', kind: 'number', required: true },
-      { key: 'app', label: 'App tag (required for action jobs)', kind: 'text' },
-    ],
-    allowExtraJson: true,
-  },
-  'jobs:update': {
-    fields: optional([
-      TAG,
-      NAME,
-      { key: 'description', label: 'Description', kind: 'text' },
-      { key: 'type', label: 'Job type', kind: 'enum', choices: JOB_EVENT_TYPES },
-      { key: 'event', label: 'Event tag', kind: 'text' },
-      { key: 'executions', label: 'Max executions', kind: 'number' },
-      { key: 'intervals', label: 'Interval (seconds)', kind: 'number' },
-      { key: 'app', label: 'App tag', kind: 'text' },
-    ]),
-    allowExtraJson: true,
-  },
-  'vector:create': {
-    fields: [
-      ...COMPONENT_BASE,
-      {
-        key: 'type',
-        label: 'Vector DB type',
-        kind: 'enum',
-        required: true,
-        choices: VECTOR_DB_TYPES,
-      },
-      { key: 'dimensions', label: 'Dimensions', kind: 'number', required: true },
-      {
-        key: 'metric',
-        label: 'Distance metric',
-        kind: 'enum',
-        choices: VECTOR_DISTANCE_METRICS,
-        default: 'cosine',
-      },
-      { key: 'envs', label: 'Environments', kind: 'envs', required: true, envsVariant: 'vector' },
-    ],
-  },
-  'vector:update': {
-    fields: [
-      ...optional(COMPONENT_BASE),
-      { key: 'type', label: 'Vector DB type', kind: 'enum', choices: VECTOR_DB_TYPES },
-      { key: 'dimensions', label: 'Dimensions', kind: 'number' },
-      { key: 'metric', label: 'Distance metric', kind: 'enum', choices: VECTOR_DISTANCE_METRICS },
-      { key: 'envs', label: 'Environments', kind: 'envs', envsVariant: 'vector' },
-    ],
-    allowExtraJson: true,
-  },
-  'vector:connect': { fields: [TAG] },
-  'messageBrokers:create': {
-    fields: [
-      ...COMPONENT_BASE,
-      { key: 'envs', label: 'Environments', kind: 'envs', required: true, envsVariant: 'broker' },
-    ],
-  },
-  'messageBrokers:update': {
-    fields: [
-      ...optional(COMPONENT_BASE),
-      { key: 'envs', label: 'Environments', kind: 'envs', envsVariant: 'broker' },
-    ],
-    allowExtraJson: true,
-  },
-  'notifications:create': {
-    fields: [
-      ...COMPONENT_BASE,
-      { key: 'notifier', label: 'Notifier', kind: 'enum', required: true, choices: NOTIFIERS },
-    ],
-    allowExtraJson: true,
-  },
-  'notifications:update': {
-    fields: optional([
-      ...COMPONENT_BASE,
-      { key: 'notifier', label: 'Notifier', kind: 'enum', choices: NOTIFIERS },
-    ]),
-    allowExtraJson: true,
-  },
-  'actions:create': {
-    fields: [
-      TAG,
-      NAME,
-      DESC,
-      { key: 'method', label: 'HTTP method', kind: 'enum', choices: HTTP_METHODS },
-    ],
-    allowExtraJson: true,
-  },
-  'actions:update': {
-    fields: optional([
-      TAG,
-      NAME,
-      DESC,
-      { key: 'method', label: 'HTTP method', kind: 'enum', choices: HTTP_METHODS },
-    ]),
-    allowExtraJson: true,
-  },
-  'features:create': {
-    fields: [...COMPONENT_BASE],
-    allowExtraJson: true,
-  },
-  'features:update': { fields: optional(COMPONENT_BASE), allowExtraJson: true },
-  'secrets:create': {
-    fields: [
-      { key: 'key', label: 'Secret key', kind: 'text', required: true },
-      { key: 'value', label: 'Secret value', kind: 'text', required: true },
-      DESC,
-    ],
-  },
-  'secrets:update': {
-    fields: optional([
-      { key: 'value', label: 'Secret value', kind: 'text' },
-      DESC,
-    ]),
-  },
-  'quotas:create': { fields: [...COMPONENT_BASE], allowExtraJson: true },
-  'quotas:update': { fields: optional(COMPONENT_BASE), allowExtraJson: true },
-  'health:create': { fields: [...COMPONENT_BASE], allowExtraJson: true },
-  'health:update': { fields: optional(COMPONENT_BASE), allowExtraJson: true },
-  'fallback:create': { fields: [...COMPONENT_BASE], allowExtraJson: true },
-  'fallback:update': { fields: optional(COMPONENT_BASE), allowExtraJson: true },
-  'sessions:create': { fields: [...COMPONENT_BASE], allowExtraJson: true },
-  'sessions:update': { fields: optional(COMPONENT_BASE), allowExtraJson: true },
-};
-
-const GENERIC_COMPONENT: FormSchema = {
-  fields: [...COMPONENT_BASE],
-  allowExtraJson: true,
-};
-
-const CONNECT_MODULES = new Set<SDKModule>(['databases', 'graph', 'vector', 'storage']);
-
-export function getFormSchema(schemaKey: string): FormSchema | undefined {
-  return SCHEMAS[schemaKey] ?? undefined;
-}
-
-export function schemaKeyForResource(module: SDKModule, verb: CrudVerb): string | undefined {
-  if (verb === 'connect' && CONNECT_MODULES.has(module)) {
-    return `${module}:connect`;
-  }
-  if (verb === 'create' || verb === 'update') {
-    return `${module}:${verb}`;
-  }
-  return undefined;
-}
-
-export function schemaKeyForEntity(entity: 'products' | 'apps', verb: string): string | undefined {
-  if (verb === 'create' || verb === 'update') return `${entity}:${verb}`;
-  return undefined;
-}
-
-/** Fallback schema for component types without a dedicated form */
-export function genericComponentSchema(verb: 'create' | 'update'): FormSchema {
-  if (verb === 'create') return GENERIC_COMPONENT;
-  return { fields: optional(COMPONENT_BASE), allowExtraJson: true };
-}
-
-export function resolveResourceSchema(
-  module: SDKModule,
-  verb: CrudVerb,
-): FormSchema | undefined {
-  const key = schemaKeyForResource(module, verb);
-  if (!key) return undefined;
-  return getFormSchema(key) ?? (verb === 'create' || verb === 'update' ? genericComponentSchema(verb) : undefined);
-}

package/src/lib/forms/types.ts

@@ -1,27 +0,0 @@
-export type FieldKind = 'text' | 'number' | 'enum' | 'envs';
-
-export type EnvsVariant =
-  | 'database'
-  | 'graph'
-  | 'storage'
-  | 'broker'
-  | 'vector'
-  | 'simple';
-
-export interface FormField {
-  key: string;
-  label: string;
-  kind: FieldKind;
-  required?: boolean;
-  default?: string | number;
-  /** enum */
-  choices?: readonly string[];
-  /** envs */
-  envsVariant?: EnvsVariant;
-}
-
-export interface FormSchema {
-  fields: FormField[];
-  /** Merge optional JSON object after prompts */
-  allowExtraJson?: boolean;
-}

package/src/lib/http.ts

@@ -1,76 +0,0 @@
-import { gzipSync } from 'node:zlib';
-
-const GZIP_THRESHOLD = 200 * 1024;
-
-/** Parse fetch body as JSON; surface HTML/misconfigured api_url clearly. */
-export async function parseJsonResponse<T = Record<string, unknown>>(
-  res: Response,
-  url: string,
-): Promise<T> {
-  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})`);
-    return {} as T;
-  }
-  try {
-    return JSON.parse(text) as T;
-  } 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.',
-      );
-    }
-    const htmlHint = text.trimStart().startsWith('<')
-      ? [
-          '',
-          'The server returned HTML instead of JSON. Check your API profile:',
-          '  ductape profiles list',
-          '  ductape profiles use local   → http://localhost:4311/api (run `ductape start` first)',
-          '  ductape profiles use cloud  → https://api.ductape.app/api',
-          '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}`,
-    );
-  }
-}
-
-export interface ProxyJsonResponse<T> {
-  status?: boolean;
-  data?: { data: T };
-  message?: string;
-}
-
-export async function postProxyJson<T>(
-  url: string,
-  body: Record<string, unknown>,
-  headers: Record<string, string>,
-): Promise<T> {
-  const json = JSON.stringify(body);
-  const reqHeaders: Record<string, string> = { ...headers, 'Content-Type': 'application/json' };
-  let bodyInit: BodyInit = json;
-
-  if (json.length > GZIP_THRESHOLD) {
-    const gz = gzipSync(json);
-    bodyInit = new Uint8Array(gz);
-    reqHeaders['Content-Encoding'] = 'gzip';
-  }
-
-  const res = await fetch(url, {
-    method: 'POST',
-    headers: reqHeaders,
-    body: bodyInit,
-  });
-
-  const parsed = await parseJsonResponse<ProxyJsonResponse<T>>(res, url);
-  if (!res.ok) {
-    throw new Error(parsed.message ?? `Request failed: ${res.status}`);
-  }
-  if (typeof parsed.status === 'boolean' && !parsed.status) {
-    throw new Error(parsed.message ?? 'Proxy operation failed');
-  }
-  return parsed.data?.data as T;
-}