@ductape/cli 0.2.0

package/src/lib/api-client.ts

@@ -0,0 +1,88 @@
+import type { Credentials } from './config.js';
+import { getApiUrl } from './config.js';
+
+export interface ApiEnvelope<T> {
+  status?: boolean;
+  data?: T;
+  message?: string;
+}
+
+export class ApiClient {
+  constructor(
+    private readonly apiUrl: string,
+    private readonly token?: string,
+  ) {}
+
+  static forProfile(profileName?: string, creds?: Credentials | null): ApiClient {
+    return new ApiClient(getApiUrl(profileName), creds?.auth_token);
+  }
+
+  async request<T>(
+    method: string,
+    path: string,
+    body?: unknown,
+    extraHeaders?: Record<string, string>,
+  ): Promise<T> {
+    const url = `${this.apiUrl}${path.startsWith('/') ? path : `/${path}`}`;
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      ...extraHeaders,
+    };
+    if (this.token) {
+      headers.Authorization = `Bearer ${this.token}`;
+    }
+
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body !== undefined ? JSON.stringify(body) : undefined,
+    });
+
+    const text = await res.text();
+    let parsed: ApiEnvelope<T> & T;
+    try {
+      parsed = text ? JSON.parse(text) : {};
+    } catch {
+      throw new Error(`Invalid JSON from ${url}: ${text.slice(0, 200)}`);
+    }
+
+    if (!res.ok) {
+      const msg =
+        (parsed as ApiEnvelope<T>).message ??
+        (parsed as { error?: string }).error ??
+        `HTTP ${res.status}`;
+      throw new Error(msg);
+    }
+
+    if (typeof (parsed as ApiEnvelope<T>).status === 'boolean' && !(parsed as ApiEnvelope<T>).status) {
+      throw new Error((parsed as ApiEnvelope<T>).message ?? 'Request failed');
+    }
+
+    const data = (parsed as ApiEnvelope<{ result?: T }>).data;
+    if (data && typeof data === 'object' && 'result' in data) {
+      return (data as { result: T }).result;
+    }
+    return (data ?? parsed) as T;
+  }
+
+  post<T>(path: string, body?: unknown, headers?: Record<string, string>): Promise<T> {
+    return this.request<T>('POST', path, body, headers);
+  }
+
+  put<T>(path: string, body?: unknown, headers?: Record<string, string>): Promise<T> {
+    return this.request<T>('PUT', path, body, headers);
+  }
+
+  delete<T>(path: string, headers?: Record<string, string>): Promise<T> {
+    return this.request<T>('DELETE', path, undefined, headers);
+  }
+
+  get<T>(path: string, headers?: Record<string, string>): Promise<T> {
+    return this.request<T>('GET', path, undefined, headers);
+  }
+
+  getPath<T>(path: string, query?: Record<string, string>): Promise<T> {
+    const qs = query ? `?${new URLSearchParams(query).toString()}` : '';
+    return this.get<T>(`${path}${qs}`);
+  }
+}

package/src/lib/app-import.ts

@@ -0,0 +1,82 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { WorkspaceContext } from './workspace-context.js';
+
+/** Values accepted by POST /apps/v1/import `type` field */
+export const IMPORT_DOC_TYPES = {
+  postman: 'PostmanV2.1',
+  openapi: 'OpenApiV3.0',
+} as const;
+
+export type ImportFormat = keyof typeof IMPORT_DOC_TYPES;
+
+export function parseImportFormat(value: string): ImportFormat {
+  const v = value.toLowerCase().replace(/[_\s]/g, '');
+  if (v === 'postman' || v === 'postmanv21' || v === 'postman2.1' || v === 'postmanv2.1') {
+    return 'postman';
+  }
+  if (v === 'openapi' || v === 'openapiv30' || v === 'openapi3.0' || v === 'openapi3') {
+    return 'openapi';
+  }
+  throw new Error(
+    `Unknown import type "${value}". Use: postman (Postman Collection v2.1) or openapi (OpenAPI 3.0)`,
+  );
+}
+
+function uploadFilename(filePath: string): string {
+  const base = path.basename(filePath);
+  if (base.endsWith('.yaml') || base.endsWith('.yml')) return base;
+  if (base.endsWith('.json')) return base;
+  return `${base}.json`;
+}
+
+export async function importAppFromFile(
+  ctx: WorkspaceContext,
+  opts: {
+    filePath: string;
+    format: ImportFormat;
+    appId?: string;
+    update?: boolean;
+    version?: string;
+  },
+): Promise<unknown> {
+  const abs = path.resolve(opts.filePath);
+  if (!fs.existsSync(abs)) throw new Error(`File not found: ${abs}`);
+
+  const buffer = fs.readFileSync(abs);
+  const filename = uploadFilename(abs);
+  const form = new FormData();
+
+  form.append('file', new Blob([buffer]), filename);
+  form.append('workspace_id', ctx.workspaceId);
+  form.append('public_key', ctx.credentials.public_key);
+  form.append('user_id', ctx.credentials.user_id);
+  form.append('type', IMPORT_DOC_TYPES[opts.format]);
+  form.append('version', opts.version ?? '0.0.1');
+  form.append('update', opts.update ? 'true' : 'false');
+  if (opts.appId) form.append('app_id', opts.appId);
+
+  const url = `${ctx.apiUrl}/apps/v1/import`;
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${ctx.credentials.auth_token}` },
+    body: form,
+  });
+
+  const text = await res.text();
+  let parsed: { status?: boolean; data?: unknown; message?: string };
+  try {
+    parsed = text ? JSON.parse(text) : {};
+  } catch {
+    throw new Error(`Invalid JSON from import API: ${text.slice(0, 200)}`);
+  }
+
+  if (!res.ok) {
+    throw new Error(parsed.message ?? `Import failed (HTTP ${res.status})`);
+  }
+  if (parsed.status === false) {
+    throw new Error(parsed.message ?? 'Import failed');
+  }
+
+  return parsed.data ?? parsed;
+}

package/src/lib/config.ts

@@ -0,0 +1,225 @@
+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');
+
+export interface Credentials {
+  user_id: string;
+  email: string;
+  auth_token: string;
+  public_key: string;
+  firstname?: string;
+  lastname?: string;
+  workspaces?: Array<{
+    workspace_id?: string;
+    workspace_name?: string;
+    _id?: string;
+    name?: string;
+    tag?: string;
+    default?: boolean;
+  }>;
+}
+
+export interface Profile {
+  api_url: string;
+}
+
+export interface GlobalConfig {
+  default_profile: string;
+  profiles: Record<string, Profile>;
+  /** Set at login or via `ductape workspaces use` */
+  active_workspace_id?: string;
+  active_workspace_name?: string;
+  active_workspace_tag?: string;
+}
+
+/** Linked project config — use workspace_tag (human-readable); workspace_id is resolved by the CLI. */
+export interface ProjectConfig {
+  workspace_tag?: string;
+  /** Resolved automatically; do not edit unless debugging */
+  workspace_id?: string;
+  product_tag: string;
+  env_slug: string;
+  linked_profile?: string;
+  project_id?: string;
+}
+
+export interface ResolvedProjectConfig extends ProjectConfig {
+  workspace_id: string;
+}
+
+const DEFAULT_GLOBAL: GlobalConfig = {
+  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<T>(filePath: string): T | null {
+  if (!fs.existsSync(filePath)) return null;
+  return JSON.parse(fs.readFileSync(filePath, 'utf8')) as T;
+}
+
+function writeJson(filePath: string, data: unknown, mode = 0o644): void {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', { mode });
+}
+
+export function ensureGlobalDir(): void {
+  fs.mkdirSync(GLOBAL_DIR, { recursive: true });
+}
+
+export function loadCredentials(): Credentials | null {
+  return readJson<Credentials>(CREDENTIALS_PATH);
+}
+
+export function saveCredentials(creds: Credentials): void {
+  ensureGlobalDir();
+  writeJson(CREDENTIALS_PATH, creds, 0o600);
+}
+
+export function clearCredentials(): void {
+  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(): string | null {
+  const global = loadGlobalConfig();
+  return global.active_workspace_id ?? null;
+}
+
+export function loadGlobalConfig(): GlobalConfig {
+  const cfg = readJson<GlobalConfig>(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: GlobalConfig): void {
+  ensureGlobalDir();
+  writeJson(GLOBAL_CONFIG_PATH, config);
+}
+
+export function getActiveProfileName(project?: ProjectConfig | null): string {
+  if (project?.linked_profile) return project.linked_profile;
+  return loadGlobalConfig().default_profile;
+}
+
+export function getApiUrl(profileName?: string): string {
+  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: NonNullable<Credentials['workspaces']>,
+  selector: string,
+): string | null {
+  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: ProjectConfig, creds?: Credentials | null): string | null {
+  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()): { dir: string; config: ProjectConfig } | null {
+  let dir = startDir;
+  const root = path.parse(dir).root;
+  while (true) {
+    const candidate = path.join(dir, PROJECT_CONFIG_PATH);
+    const cfg = readJson<ProjectConfig>(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(): ResolvedProjectConfig {
+  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: string, config: ProjectConfig): void {
+  const configDir = path.join(dir, PROJECT_CONFIG_DIR);
+  fs.mkdirSync(configDir, { recursive: true });
+  writeJson(path.join(configDir, 'config.json'), config);
+}
+
+export function resolvePlatformDir(): string {
+  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/src/lib/context-store.ts

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

package/src/lib/db-methods.ts

@@ -0,0 +1,56 @@
+/** 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',
+] as const;
+
+export const GRAPH_PROXY_METHODS = [
+  'connect',
+  'disconnect',
+  'disconnectAll',
+  'testConnection',
+  'getCurrentContext',
+  'create',
+  'fetchAll',
+  'fetch',
+  'update',
+  'delete',
+  'createNode',
+  'findNodes',
+  'query',
+  'traverse',
+  'shortestPath',
+  'countNodes',
+  'dispatch',
+  'execute',
+  'executeTransaction',
+] as const;

package/src/lib/encryption.ts

@@ -0,0 +1,12 @@
+/**
+ * Proxy payload encryption — matches platform/workbench/src/utils/proxyEncryption.ts
+ */
+import CryptoJS from 'crypto-js';
+
+export function encryptProxyPayload(data: object, publicKey: string): string {
+  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/src/lib/forms/enums.ts

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

package/src/lib/forms/index.ts

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