@ductape/cli 0.2.0

package/dist/lib/workspaces.js

@@ -0,0 +1,219 @@
+import select from '@inquirer/select';
+import { ApiClient } from './api-client.js';
+import { findProjectConfig, getApiUrl, loadCredentials, loadGlobalConfig, saveCredentials, saveGlobalConfig, saveProjectConfig, } from './config.js';
+import { success } from './output.js';
+export function workspaceId(w) {
+    const id = w.workspace_id ?? w._id;
+    if (!id)
+        throw new Error('Workspace entry missing id');
+    return id;
+}
+export function workspaceLabel(w) {
+    return w.workspace_name ?? w.name ?? w.tag ?? workspaceId(w);
+}
+/** Human-readable workspace tag for .ductape/config.json (slug of name, or explicit tag). */
+export function workspaceTag(w) {
+    if (w.tag?.trim())
+        return w.tag.trim();
+    return slugifyTag(workspaceLabel(w));
+}
+export function slugifyTag(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+export function normalizeWorkspaces(raw) {
+    return raw
+        .filter((w) => Boolean(w) && typeof w === 'object')
+        .map((w) => ({
+        workspace_id: String(w.workspace_id ?? w._id ?? ''),
+        workspace_name: (w.workspace_name ?? w.name ?? w.tag),
+        _id: w._id,
+        name: w.name,
+        tag: w.tag,
+        default: Boolean(w.default),
+        accepted: w.accepted,
+    }))
+        .filter((w) => w.workspace_id.length > 0);
+}
+export function getActiveWorkspace() {
+    const global = loadGlobalConfig();
+    if (global.active_workspace_id) {
+        return {
+            id: global.active_workspace_id,
+            name: global.active_workspace_name,
+            tag: global.active_workspace_tag,
+        };
+    }
+    return null;
+}
+export function setActiveWorkspace(id, name, tag) {
+    const global = loadGlobalConfig();
+    global.active_workspace_id = id;
+    global.active_workspace_name = name;
+    if (tag)
+        global.active_workspace_tag = tag;
+    saveGlobalConfig(global);
+}
+export function clearActiveWorkspace() {
+    const global = loadGlobalConfig();
+    delete global.active_workspace_id;
+    delete global.active_workspace_name;
+    delete global.active_workspace_tag;
+    saveGlobalConfig(global);
+}
+export async function fetchWorkspaces(profile) {
+    const creds = loadCredentials();
+    if (!creds)
+        throw new Error('Not logged in. Run: ductape login');
+    const cached = normalizeWorkspaces(creds.workspaces ?? []);
+    const api = ApiClient.forProfile(profile, creds);
+    const apiUrl = getApiUrl(profile);
+    try {
+        const res = await fetch(`${apiUrl}/workspaces/v1/fetch/${creds.user_id}?user_id=${encodeURIComponent(creds.user_id)}&public_key=${encodeURIComponent(creds.public_key)}`, { headers: { Authorization: `Bearer ${creds.auth_token}` } });
+        const body = await res.json();
+        if (!res.ok)
+            throw new Error(body.message ?? `Failed to list workspaces (${res.status})`);
+        const data = body.data ?? body;
+        const list = Array.isArray(data) ? data : (data?.result ?? data?.workspaces ?? []);
+        const normalized = normalizeWorkspaces(list);
+        if (normalized.length > 0) {
+            saveCredentials({ ...creds, workspaces: normalized });
+            return normalized;
+        }
+    }
+    catch {
+        // fall through to cache / api client
+    }
+    try {
+        const list = await api.get(`/workspaces/v1/fetch/${creds.user_id}?user_id=${encodeURIComponent(creds.user_id)}&public_key=${encodeURIComponent(creds.public_key)}`);
+        const normalized = normalizeWorkspaces(list);
+        if (normalized.length > 0) {
+            saveCredentials({ ...creds, workspaces: normalized });
+            return normalized;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return cached;
+}
+export function findWorkspace(workspaces, selector) {
+    const trimmed = selector.trim();
+    const idx = Number(trimmed);
+    if (!Number.isNaN(idx) && workspaces[idx])
+        return workspaces[idx];
+    return workspaces.find((w) => workspaceId(w) === trimmed ||
+        workspaceLabel(w).toLowerCase() === trimmed.toLowerCase() ||
+        w.tag?.toLowerCase() === trimmed.toLowerCase());
+}
+export function printWorkspaceTable(workspaces, activeId) {
+    if (workspaces.length === 0) {
+        console.log('No workspaces found for this account.');
+        return;
+    }
+    workspaces.forEach((w, i) => {
+        const id = workspaceId(w);
+        const label = workspaceLabel(w);
+        const markers = [];
+        if (activeId && id === activeId)
+            markers.push('active');
+        if (w.default)
+            markers.push('default');
+        const suffix = markers.length ? ` (${markers.join(', ')})` : '';
+        console.log(`  [${i}] ${label}${suffix}`);
+        console.log(`      ${id}`);
+    });
+}
+export async function promptWorkspaceSelection(workspaces, opts) {
+    if (workspaces.length === 0) {
+        throw new Error('No workspaces available. Create one in the Workbench first.');
+    }
+    if (workspaces.length === 1) {
+        const only = workspaces[0];
+        setActiveWorkspace(workspaceId(only), workspaceLabel(only), workspaceTag(only));
+        return only;
+    }
+    const active = getActiveWorkspace();
+    const activeId = active?.id ?? null;
+    const defaultWs = workspaces.find((w) => active && workspaceId(w) === active.id) ??
+        workspaces.find((w) => w.default) ??
+        workspaces[0];
+    const defaultIdx = workspaces.indexOf(defaultWs);
+    // Non-interactive (CI, pipes): keep default without prompting.
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return defaultWs;
+    }
+    const choiceIndex = await select({
+        message: opts?.message ?? 'Select a workspace',
+        pageSize: Math.min(12, workspaces.length),
+        default: defaultIdx >= 0 ? defaultIdx : 0,
+        choices: workspaces.map((w, i) => {
+            const id = workspaceId(w);
+            const label = workspaceLabel(w);
+            const markers = [];
+            if (activeId && id === activeId)
+                markers.push('active');
+            if (w.default)
+                markers.push('default');
+            const suffix = markers.length ? ` · ${markers.join(', ')}` : '';
+            return {
+                name: label + suffix,
+                value: i,
+                description: id,
+            };
+        }),
+    });
+    return workspaces[choiceIndex];
+}
+export async function applyActiveWorkspace(workspace, opts) {
+    const id = workspaceId(workspace);
+    const name = workspaceLabel(workspace);
+    const tag = workspaceTag(workspace);
+    setActiveWorkspace(id, name, tag);
+    if (opts?.syncProject !== false) {
+        const found = findProjectConfig(opts?.dir);
+        if (found) {
+            saveProjectConfig(found.dir, {
+                ...found.config,
+                workspace_tag: tag,
+                workspace_id: id,
+            });
+        }
+    }
+}
+export async function selectAndApplyWorkspace(opts) {
+    const workspaces = await fetchWorkspaces(opts?.profile);
+    let chosen;
+    if (opts?.selector) {
+        const match = findWorkspace(workspaces, opts.selector);
+        if (!match)
+            throw new Error(`Workspace not found: ${opts.selector}`);
+        chosen = match;
+    }
+    else if (opts?.skipPrompt) {
+        const active = getActiveWorkspace();
+        const match = active ? findWorkspace(workspaces, active.id) : undefined;
+        chosen = match ?? workspaces.find((w) => w.default) ?? workspaces[0];
+        if (!chosen)
+            throw new Error('No workspace to select');
+    }
+    else {
+        chosen = await promptWorkspaceSelection(workspaces);
+    }
+    await applyActiveWorkspace(chosen, { syncProject: opts?.syncProject, dir: opts?.dir });
+    return chosen;
+}
+export async function finalizeLoginWorkspace(opts) {
+    const chosen = await selectAndApplyWorkspace({
+        profile: opts?.profile,
+        selector: opts?.workspace,
+        skipPrompt: opts?.skipPrompt,
+        syncProject: true,
+    });
+    const workspaces = await fetchWorkspaces(opts?.profile);
+    const hint = workspaces.length > 1 ? '\nSwitch anytime: ductape workspaces use' : '';
+    success(`Active workspace: ${workspaceLabel(chosen)} (${workspaceId(chosen)})${hint}`);
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@ductape/cli",
+  "version": "0.2.0",
+  "description": "Ductape CLI — local platform, login, link projects, and manage resources via the proxy (Workbench-compatible)",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "ductape": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "test": "npm run build && node --import tsx --test test/**/*.test.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ductape",
+    "cli"
+  ],
+  "license": "UNLICENSED",
+  "dependencies": {
+    "@inquirer/input": "^5.0.13",
+    "@inquirer/password": "^5.0.13",
+    "@inquirer/select": "^5.1.5",
+    "commander": "^13.1.0",
+    "crypto-js": "^4.2.0"
+  },
+  "devDependencies": {
+    "@types/crypto-js": "^4.2.0",
+    "@types/node": "^22.12.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/commands/apps-import.ts

@@ -0,0 +1,43 @@
+import path from 'node:path';
+import { getApp } from '../lib/platform-api.js';
+import { importAppFromFile, parseImportFormat } from '../lib/app-import.js';
+import { printJson, success } from '../lib/output.js';
+import { requireWorkspaceContext } from '../lib/workspace-context.js';
+
+export async function runAppsImport(
+  file: string,
+  opts: {
+    profile?: string;
+    type: string;
+    appId?: string;
+    appTag?: string;
+    update?: boolean;
+    version?: string;
+    json?: boolean;
+  },
+): Promise<void> {
+  const ctx = requireWorkspaceContext({ profile: opts.profile });
+  const format = parseImportFormat(opts.type);
+
+  let appId = opts.appId;
+  if (!appId && opts.appTag) {
+    const app = (await getApp(ctx, { tag: opts.appTag })) as { _id?: string };
+    appId = app._id;
+    if (!appId) throw new Error(`App not found for tag: ${opts.appTag}`);
+  }
+
+  const result = await importAppFromFile(ctx, {
+    filePath: path.resolve(file),
+    format,
+    appId,
+    update: Boolean(opts.update),
+    version: opts.version,
+  });
+
+  if (opts.json) {
+    printJson(result, true);
+    return;
+  }
+  const label = format === 'postman' ? 'Postman v2.1' : 'OpenAPI 3.0';
+  success(`Imported ${label} collection from ${path.basename(file)}`);
+}

package/src/commands/apps.ts

@@ -0,0 +1,92 @@
+import { schemaKeyForEntity } from '../lib/forms/index.js';
+import { isInteractive, promptTag } from '../lib/forms/prompt.js';
+import { toInteractiveOpts, type CommandInteractiveFlags } from '../lib/interactive-opts.js';
+import { bodyRequiredHint, resolveBody } from '../lib/read-body.js';
+import {
+  createApp,
+  deleteApp,
+  getApp,
+  listApps,
+  updateApp,
+  updateAppViaProxy,
+} from '../lib/platform-api.js';
+import { printJson } from '../lib/output.js';
+import { requireWorkspaceContext } from '../lib/workspace-context.js';
+
+const VERBS = ['list', 'get', 'create', 'update', 'delete'] as const;
+type Verb = (typeof VERBS)[number];
+
+export async function runApps(
+  verb: string,
+  opts: {
+    profile?: string;
+    status?: string;
+    id?: string;
+    tag?: string;
+    file?: string;
+    json?: boolean;
+    proxy?: boolean;
+  } & CommandInteractiveFlags,
+  extraArgs: string[],
+): Promise<void> {
+  const v = verb.toLowerCase() as Verb;
+  if (!VERBS.includes(v)) {
+    throw new Error(`Unknown apps verb "${verb}". Use: ${VERBS.join(', ')}`);
+  }
+
+  const ctx = requireWorkspaceContext({ profile: opts.profile });
+  const status = opts.status ?? 'all';
+  const interactive = toInteractiveOpts(opts);
+  const schemaKey = schemaKeyForEntity('apps', v);
+  const body =
+    v === 'create' || v === 'update'
+      ? await resolveBody({
+          ...interactive,
+          file: opts.file,
+          schemaKey,
+          patch: v === 'update',
+          requireBody: v === 'create',
+        })
+      : undefined;
+  const id = opts.id ?? extraArgs[0];
+  let tag = opts.tag ?? (extraArgs[0] && !opts.id ? extraArgs[0] : undefined);
+  if (v === 'update' && (opts.proxy || !id) && !tag && isInteractive(interactive)) {
+    tag = await promptTag('App tag');
+  }
+
+  let result: unknown;
+
+  switch (v) {
+    case 'list':
+      result = await listApps(ctx, status);
+      break;
+    case 'get':
+      result = await getApp(ctx, { id, tag });
+      break;
+    case 'create':
+      if (!body || Object.keys(body).length === 0) {
+        throw new Error(`create requires a body. ${bodyRequiredHint('apps:create')}`);
+      }
+      result = await createApp(ctx, body);
+      break;
+    case 'update': {
+      if (opts.proxy || tag) {
+        const appTag = tag ?? (body?.tag as string | undefined);
+        if (!appTag) throw new Error('update via proxy requires --tag <app_tag>');
+        result = await updateAppViaProxy(ctx, appTag, body ?? {});
+        break;
+      }
+      if (!id) throw new Error('update requires --id <app_id> or --tag with --proxy');
+      result = await updateApp(ctx, id, body ?? {});
+      break;
+    }
+    case 'delete':
+      if (!id) throw new Error('delete requires --id <app_id>');
+      result = await deleteApp(ctx, id);
+      break;
+    default:
+      throw new Error(`Unsupported: apps ${v}`);
+  }
+
+  printJson(result, Boolean(opts.json));
+}

package/src/commands/cloud.ts

@@ -0,0 +1,50 @@
+import { readJsonBody } from '../lib/read-body.js';
+import { getSdkProxy, requireSession } from '../lib/proxy/context.js';
+import { printJson } from '../lib/output.js';
+
+type CloudTarget = 'connections' | 'resources';
+
+export async function runCloud(
+  target: CloudTarget,
+  verb: string,
+  opts: { id?: string; file?: string; json?: boolean },
+  extraArgs: string[],
+): Promise<void> {
+  requireSession();
+  const proxy = getSdkProxy();
+  const body = readJsonBody(opts.file);
+  const id = opts.id ?? extraArgs[0];
+
+  let method: string;
+  let params: unknown[];
+
+  if (target === 'connections') {
+    const map: Record<string, [string, unknown[]]> = {
+      create: ['connections.create', [body]],
+      list: ['connections.list', []],
+      get: ['connections.fetch', [id]],
+      fetch: ['connections.fetch', [id]],
+      delete: ['connections.delete', [id]],
+      update: ['connections.update', [id, body]],
+      complete: ['connections.complete', [id, body]],
+      validate: ['connections.validate', [id]],
+    };
+    const entry = map[verb.toLowerCase()];
+    if (!entry) throw new Error(`Unknown cloud connections verb: ${verb}`);
+    [method, params] = entry;
+  } else {
+    const map: Record<string, [string, unknown[]]> = {
+      list: ['resources.list', [body]],
+      import: ['resources.import', [body]],
+      provision: ['resources.provision', [body]],
+      'import-persist': ['resources.importAndPersist', [body]],
+      'provision-persist': ['resources.provisionAndPersist', [body]],
+    };
+    const entry = map[verb.toLowerCase()];
+    if (!entry) throw new Error(`Unknown cloud resources verb: ${verb}`);
+    [method, params] = entry;
+  }
+
+  const result = await proxy.execute('cloud', method, params);
+  printJson(result, Boolean(opts.json));
+}

package/src/commands/completion.ts

@@ -0,0 +1,119 @@
+import { listResourceTypes } from '../lib/resources.js';
+import { DB_PROXY_METHODS, GRAPH_PROXY_METHODS } from '../lib/db-methods.js';
+
+const TOP_LEVEL = [
+  'login',
+  'logout',
+  'whoami',
+  'profiles',
+  'workspaces',
+  'link',
+  'unlink',
+  'init',
+  'install',
+  'start',
+  'stop',
+  'status',
+  'products',
+  'apps',
+  'resources',
+  'cloud',
+  'db',
+  'graph',
+  'secrets',
+  'generate',
+  'completion',
+];
+
+const ENTITY_CRUD = 'list get create update delete';
+
+export function runCompletion(shell: 'bash' | 'zsh' | 'fish'): void {
+  const resources = listResourceTypes();
+  const crud = 'create list get update delete connect';
+
+  if (shell === 'bash') {
+    console.log(`
+_ductape_completions() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  local cmd="\${COMP_WORDS[1]}"
+
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "${TOP_LEVEL.join(' ')}" -- "$cur") )
+    return
+  fi
+
+  case "$cmd" in
+    products)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "${ENTITY_CRUD}" -- "$cur") )
+      fi
+      ;;
+    apps)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "import ${ENTITY_CRUD}" -- "$cur") )
+      elif [[ \${COMP_CWORD} -eq 3 && "\${COMP_WORDS[2]}" == "import" ]]; then
+        COMPREPLY=( $(compgen -f -- "$cur") )
+      fi
+      ;;
+    resources)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "types ${resources.join(' ')}" -- "$cur") )
+      elif [[ \${COMP_CWORD} -eq 3 ]]; then
+        COMPREPLY=( $(compgen -W "${crud}" -- "$cur") )
+      fi
+      ;;
+    db)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "${DB_PROXY_METHODS.join(' ')}" -- "$cur") )
+      fi
+      ;;
+    graph)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "${GRAPH_PROXY_METHODS.join(' ')}" -- "$cur") )
+      fi
+      ;;
+    profiles|workspaces)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "list use" -- "$cur") )
+      fi
+      ;;
+    generate)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "payload snippet" -- "$cur") )
+      fi
+      ;;
+  esac
+}
+complete -F _ductape_completions ductape
+`);
+    return;
+  }
+
+  if (shell === 'zsh') {
+    console.log(`
+#compdef ductape
+_ductape() {
+  local -a commands
+  commands=(
+    ${TOP_LEVEL.map((c) => `'${c}:command'`).join('\n    ')}
+  )
+  _arguments '1: :->cmd' '*: :->args'
+  case $state in
+    cmd) _describe 'command' commands ;;
+    args)
+      case $words[1] in
+        resources) _arguments '2: :(types ${resources.join(' ')})' '3: :(${crud.split(' ').join(' ')})' ;;
+        db) _arguments '2: :(${DB_PROXY_METHODS.join(' ')})' ;;
+        graph) _arguments '2: :(${GRAPH_PROXY_METHODS.join(' ')})' ;;
+      esac
+      ;;
+  esac
+}
+_ductape
+`);
+    return;
+  }
+
+  console.log(`# Fish: use ductape completion bash | source`);
+}

package/src/commands/db.ts

@@ -0,0 +1,63 @@
+import { readJsonBody } from '../lib/read-body.js';
+import { setDatabaseContext } from '../lib/context-store.js';
+import { DB_PROXY_METHODS } from '../lib/db-methods.js';
+import { getDbContext, getDbProxy, requireSession } from '../lib/proxy/context.js';
+import { loadRuntimeContext } from '../lib/context-store.js';
+import { printJson } from '../lib/output.js';
+
+export async function runDb(
+  method: string,
+  opts: { file?: string; json?: boolean },
+): Promise<void> {
+  const session = requireSession();
+  const proxy = getDbProxy(session);
+  const runtime = loadRuntimeContext(session.project.workspace_id, session.project.product_tag);
+  const dbContext = runtime?.database_context ?? null;
+  const body = readJsonBody(opts.file) as Record<string, unknown>;
+
+  const m = method.toLowerCase();
+  if (!DB_PROXY_METHODS.includes(m as (typeof DB_PROXY_METHODS)[number]) && !m.includes('.')) {
+    console.warn(`Method "${m}" not in known list; sending anyway.`);
+  }
+
+  let params: unknown[] = [];
+  if (m === 'connect') {
+    const cfg = {
+      product: session.project.product_tag,
+      env: session.project.env_slug,
+      database: body.database ?? body.tag,
+      ...body,
+    };
+    params = [cfg];
+  } else if (m === 'list') {
+    params = [session.project.product_tag];
+  } else if (Object.keys(body).length > 0) {
+    params = [
+      {
+        product: session.project.product_tag,
+        env: session.project.env_slug,
+        ...body,
+      },
+    ];
+  }
+
+  const result = await proxy.execute(m, params, dbContext);
+
+  if (m === 'connect' && params[0] && typeof params[0] === 'object') {
+    const cfg = params[0] as { database: string; env: string; product: string };
+    setDatabaseContext(session.project.workspace_id, session.project.product_tag, session.project.env_slug, {
+      database: String(cfg.database),
+      env: String(cfg.env),
+      product: String(cfg.product),
+    });
+  }
+
+  printJson(result, Boolean(opts.json));
+}
+
+export function runDbContext(json: boolean): void {
+  const session = requireSession();
+  const ctx = getDbContext(session);
+  const runtime = loadRuntimeContext(session.project.workspace_id, session.project.product_tag);
+  printJson({ database_context: runtime?.database_context ?? ctx }, json);
+}