@ductape/cli 0.2.0

package/src/commands/generate.ts

@@ -0,0 +1,74 @@
+import fs from 'node:fs';
+import { requireSession } from '../lib/proxy/context.js';
+import { generateExecutablePayload } from '../lib/integrations.js';
+import {
+  buildSnippet,
+  ensureSupportedSnippetOperation,
+} from '../lib/snippets.js';
+import { printJson } from '../lib/output.js';
+
+export async function runGeneratePayload(opts: {
+  family: string;
+  method: string;
+  file?: string;
+  json?: boolean;
+}): Promise<void> {
+  const session = requireSession();
+  let targets: Record<string, unknown> | undefined;
+  if (opts.file) {
+    targets = JSON.parse(fs.readFileSync(opts.file, 'utf8')) as Record<string, unknown>;
+  }
+
+  const result = await generateExecutablePayload(session.apiUrl, session.credentials, {
+    workspace_id: session.project.workspace_id,
+    user_id: session.credentials.user_id,
+    public_key: session.credentials.public_key,
+    product_tag: session.project.product_tag,
+    env_slug: session.project.env_slug,
+    operation_family: opts.family,
+    method: opts.method,
+    targets,
+    include_session: true,
+    include_cache: true,
+    schema_mode: 'best_effort',
+  });
+
+  printJson(result, Boolean(opts.json));
+}
+
+export async function runGenerateSnippet(opts: {
+  family: string;
+  method: string;
+  language: 'typescript' | 'python' | 'go' | 'dotnet';
+  file?: string;
+  json?: boolean;
+  out?: string;
+}): Promise<void> {
+  ensureSupportedSnippetOperation(opts.family, opts.method);
+  const session = requireSession();
+  let targets: Record<string, unknown> | undefined;
+  if (opts.file) {
+    targets = JSON.parse(fs.readFileSync(opts.file, 'utf8')) as Record<string, unknown>;
+  }
+
+  const generated = await generateExecutablePayload(session.apiUrl, session.credentials, {
+    workspace_id: session.project.workspace_id,
+    user_id: session.credentials.user_id,
+    public_key: session.credentials.public_key,
+    product_tag: session.project.product_tag,
+    env_slug: session.project.env_slug,
+    operation_family: opts.family,
+    method: opts.method,
+    targets,
+  });
+
+  const payload = generated.payload ?? {};
+  const snippet = buildSnippet(opts.language, payload, opts.family, opts.method);
+  const output = { payload: generated, snippet };
+
+  if (opts.out) {
+    fs.writeFileSync(opts.out, snippet);
+    console.log(`Wrote snippet to ${opts.out}`);
+  }
+  printJson(output, Boolean(opts.json));
+}

package/src/commands/graph.ts

@@ -0,0 +1,51 @@
+import { readJsonBody } from '../lib/read-body.js';
+import { setGraphContext } from '../lib/context-store.js';
+import { GRAPH_PROXY_METHODS } from '../lib/db-methods.js';
+import { getGraphProxy, requireSession } from '../lib/proxy/context.js';
+import { printJson } from '../lib/output.js';
+
+export async function runGraph(
+  method: string,
+  opts: { file?: string; json?: boolean },
+): Promise<void> {
+  const session = requireSession();
+  const proxy = getGraphProxy(session);
+  const body = readJsonBody(opts.file) as Record<string, unknown>;
+
+  const m = method.includes('.') ? method : method.toLowerCase();
+  if (!GRAPH_PROXY_METHODS.includes(m as (typeof GRAPH_PROXY_METHODS)[number]) && !m.includes('.')) {
+    console.warn(`Method "${m}" not in known list; sending anyway. Known: ${GRAPH_PROXY_METHODS.join(', ')}`);
+  }
+
+  const params: unknown[] = [];
+  if (m === 'connect') {
+    const cfg = {
+      product: session.project.product_tag,
+      env: session.project.env_slug,
+      graph: body.graph ?? body.tag,
+      ...body,
+    };
+    params.push(cfg);
+  } else if (Object.keys(body).length > 0) {
+    params.push({
+      product: session.project.product_tag,
+      env: session.project.env_slug,
+      ...body,
+    });
+  } else if (m === 'fetchAll' || m === 'list') {
+    params.push(session.project.product_tag);
+  }
+
+  const result = await proxy.execute(m === 'list' ? 'fetchAll' : m, params);
+
+  if (m === 'connect' && params[0] && typeof params[0] === 'object') {
+    const cfg = params[0] as { graph: string; env: string; product: string };
+    setGraphContext(session.project.workspace_id, session.project.product_tag, session.project.env_slug, {
+      graph: String(cfg.graph),
+      env: String(cfg.env),
+      product: String(cfg.product),
+    });
+  }
+
+  printJson(result, Boolean(opts.json));
+}

package/src/commands/init.ts

@@ -0,0 +1,39 @@
+import { saveProjectConfig, type ProjectConfig } from '../lib/config.js';
+import { detectLanguage, writeInitArtifacts } from '../lib/templates.js';
+import { success } from '../lib/output.js';
+import { runLink } from './link.js';
+
+export async function runInit(opts: {
+  link?: boolean;
+  workspace?: string;
+  product?: string;
+  env?: string;
+  language?: string;
+}): Promise<void> {
+  const dir = process.cwd();
+  const lang =
+    opts.language && ['typescript', 'python', 'go', 'dotnet'].includes(opts.language)
+      ? (opts.language as 'typescript' | 'python' | 'go' | 'dotnet')
+      : detectLanguage(dir);
+
+  writeInitArtifacts(dir, lang);
+
+  if (!opts.link) {
+    const stub: ProjectConfig = {
+      workspace_tag: '',
+      product_tag: '',
+      env_slug: opts.env ?? 'dev',
+    };
+    saveProjectConfig(dir, stub);
+    success(`Initialized Ductape (${lang}). Run \`ductape link\` to connect workspace/product.`);
+    return;
+  }
+
+  await runLink({
+    workspace: opts.workspace,
+    product: opts.product,
+    env: opts.env,
+    dir,
+  });
+  success(`Initialized and linked Ductape project (${lang})`);
+}

package/src/commands/install.ts

@@ -0,0 +1,48 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolvePlatformDir } from '../lib/config.js';
+import { success } from '../lib/output.js';
+
+function checkCommand(cmd: string, args: string[]): boolean {
+  const r = spawnSync(cmd, args, { stdio: 'ignore' });
+  return r.status === 0;
+}
+
+export function runInstall(): void {
+  const issues: string[] = [];
+
+  if (!checkCommand('docker', ['--version'])) {
+    issues.push('Docker is not installed or not on PATH');
+  } else if (!checkCommand('docker', ['compose', 'version'])) {
+    issues.push('Docker Compose v2 is required (docker compose)');
+  }
+
+  if (!checkCommand('node', ['--version'])) {
+    issues.push('Node.js 18+ is recommended for running the CLI');
+  }
+
+  let platformDir: string;
+  try {
+    platformDir = resolvePlatformDir();
+  } catch (e) {
+    issues.push(e instanceof Error ? e.message : String(e));
+    platformDir = '';
+  }
+
+  if (platformDir) {
+    const envExample = path.join(platformDir, '.env.example');
+    const envFile = path.join(platformDir, '.env');
+    if (fs.existsSync(envExample) && !fs.existsSync(envFile)) {
+      fs.copyFileSync(envExample, envFile);
+      success(`Created ${envFile} from .env.example`);
+    }
+  }
+
+  if (issues.length > 0) {
+    console.error('Install check failed:\n' + issues.map((i) => `  - ${i}`).join('\n'));
+    process.exit(1);
+  }
+
+  success('Prerequisites OK. Run `ductape start` to launch the local platform.');
+}

package/src/commands/link.ts

@@ -0,0 +1,84 @@
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import path from 'node:path';
+import {
+  loadCredentials,
+  saveProjectConfig,
+  type ProjectConfig,
+} from '../lib/config.js';
+import {
+  fetchWorkspaces,
+  findWorkspace,
+  getActiveWorkspace,
+  promptWorkspaceSelection,
+  setActiveWorkspace,
+  workspaceId,
+  workspaceLabel,
+  workspaceTag,
+  type WorkspaceSummary,
+} from '../lib/workspaces.js';
+import { success } from '../lib/output.js';
+
+export async function runLink(opts: {
+  workspace?: string;
+  product?: string;
+  env?: string;
+  profile?: string;
+  dir?: string;
+}): Promise<void> {
+  const creds = loadCredentials();
+  if (!creds) throw new Error('Not logged in. Run: ductape login');
+
+  const rl = readline.createInterface({ input, output });
+
+  let workspaceSummary: WorkspaceSummary;
+  const selector = opts.workspace?.trim();
+  if (!selector) {
+    const active = getActiveWorkspace();
+    if (active?.id) {
+      console.log(`Using active workspace: ${active.name ?? active.tag ?? active.id}`);
+      workspaceSummary = {
+        workspace_id: active.id,
+        workspace_name: active.name,
+        tag: active.tag,
+      };
+    } else {
+      const workspaces = await fetchWorkspaces(opts.profile);
+      if (workspaces.length === 0) {
+        throw new Error('No workspaces on this account. Create one in the Workbench first.');
+      } else {
+        workspaceSummary = await promptWorkspaceSelection(workspaces, {
+          message: 'Link project to workspace:',
+        });
+      }
+    }
+  } else {
+    const workspaces = await fetchWorkspaces(opts.profile);
+    const match = findWorkspace(workspaces, selector);
+    if (!match) {
+      throw new Error(`Workspace not found: ${selector}`);
+    }
+    workspaceSummary = match;
+    setActiveWorkspace(workspaceId(match), workspaceLabel(match), workspaceTag(match));
+  }
+
+  const workspaceIdValue = workspaceId(workspaceSummary);
+  const workspaceTagValue = workspaceTag(workspaceSummary);
+
+  const productTag = opts.product ?? (await rl.question('Product tag: '));
+  const envSlug = opts.env ?? (await rl.question('Environment slug (e.g. dev): '));
+  rl.close();
+
+  const targetDir = path.resolve(opts.dir ?? process.cwd());
+  const config: ProjectConfig = {
+    workspace_tag: workspaceTagValue,
+    workspace_id: workspaceIdValue,
+    product_tag: productTag.trim(),
+    env_slug: envSlug.trim(),
+    linked_profile: opts.profile,
+  };
+
+  saveProjectConfig(targetDir, config);
+  setActiveWorkspace(workspaceIdValue, workspaceLabel(workspaceSummary), workspaceTagValue);
+  success(`Linked project in ${path.join(targetDir, '.ductape/config.json')}`);
+}

package/src/commands/login.ts

@@ -0,0 +1,145 @@
+import inputPrompt from '@inquirer/input';
+import passwordPrompt from '@inquirer/password';
+import { spawn } from 'node:child_process';
+import { getApiUrl, getActiveProfileName, saveCredentials, type Credentials } from '../lib/config.js';
+import { parseJsonResponse } from '../lib/http.js';
+import { finalizeLoginWorkspace } from '../lib/workspaces.js';
+import { success } from '../lib/output.js';
+
+interface LoginResult {
+  _id: string;
+  email: string;
+  firstname?: string;
+  lastname?: string;
+  auth_token: string;
+  public_key: string;
+  workspaces?: Credentials['workspaces'];
+  requires_verification?: boolean;
+}
+
+function saveFromResult(user: LoginResult): void {
+  saveCredentials({
+    user_id: user._id,
+    email: user.email,
+    auth_token: user.auth_token,
+    public_key: user.public_key,
+    firstname: user.firstname,
+    lastname: user.lastname,
+    workspaces: user.workspaces,
+  });
+}
+
+async function exchangeOAuthToken(apiUrl: string, token: string): Promise<LoginResult> {
+  const res = await fetch(`${apiUrl}/users/v1/auth/oauth-session`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ token }),
+  });
+  const body = await parseJsonResponse<{ message?: string; data?: { result?: LoginResult } & LoginResult }>(
+    res,
+    `${apiUrl}/users/v1/auth/oauth-session`,
+  );
+  if (!res.ok) throw new Error(body.message ?? `OAuth exchange failed (${res.status})`);
+  const user = (body.data?.result ?? body.data) as LoginResult;
+  if (!user?.auth_token) throw new Error(body.message ?? 'Invalid OAuth token');
+  return user;
+}
+
+function openBrowser(url: string): void {
+  const cmd =
+    process.platform === 'darwin'
+      ? 'open'
+      : process.platform === 'win32'
+        ? 'start'
+        : 'xdg-open';
+  spawn(cmd, [url], { detached: true, stdio: 'ignore' }).unref();
+}
+
+export async function runLogin(opts: {
+  email?: string;
+  password?: string;
+  profile?: string;
+  token?: string;
+  browser?: 'google' | 'github';
+  workspace?: string;
+  skipWorkspaceSelect?: boolean;
+}): Promise<void> {
+  const profileName = opts.profile ?? getActiveProfileName();
+  const apiUrl = getApiUrl(opts.profile);
+
+  if (opts.token) {
+    const user = await exchangeOAuthToken(apiUrl, opts.token);
+    saveFromResult(user);
+    success(`Logged in as ${user.email} (OAuth)`);
+    await finalizeLoginWorkspace({
+      profile: opts.profile,
+      workspace: opts.workspace,
+      skipPrompt: opts.skipWorkspaceSelect,
+    });
+    return;
+  }
+
+  if (opts.browser) {
+    const path =
+      opts.browser === 'github' ? '/users/v1/auth/github' : '/users/v1/auth/google';
+    const authUrl = `${apiUrl}${path}`;
+    console.log('Opening browser for OAuth login…');
+    console.log(`If the browser does not open, visit:\n  ${authUrl}\n`);
+    console.log(
+      'After sign-in you will be redirected with ?loggedIn=true&token=… in the URL.\n' +
+        'Copy the token value and run:\n' +
+        '  ductape login --token "<paste-token-here>"\n',
+    );
+    openBrowser(authUrl);
+    return;
+  }
+
+  let email = opts.email;
+  let password = opts.password;
+
+  if (!email || !password) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+      throw new Error(
+        'Interactive login requires a TTY. Pass --email and --password, or use --token / --browser.',
+      );
+    }
+    email = email ?? (await inputPrompt({ message: 'Email' }));
+    password =
+      password ??
+      (await passwordPrompt({
+        message: 'Password',
+        mask: '*',
+      }));
+  }
+
+  const loginUrl = `${apiUrl}/users/v1/login`;
+  const res = await fetch(loginUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ email, password }),
+  });
+
+  const body = await parseJsonResponse<{ message?: string; data?: { result?: LoginResult } & LoginResult }>(
+    res,
+    loginUrl,
+  );
+  if (!res.ok) {
+    throw new Error(
+      body.message ?? `Login failed (HTTP ${res.status}) — profile "${profileName}", ${loginUrl}`,
+    );
+  }
+
+  const user = (body.data?.result ?? body.data) as LoginResult;
+  if (!user?.auth_token) throw new Error(body.message ?? 'Login failed');
+  if (user.requires_verification) {
+    throw new Error('Account requires email verification. Complete verification in the Workbench first.');
+  }
+
+  saveFromResult(user);
+  success(`Logged in as ${user.email}`);
+  await finalizeLoginWorkspace({
+    profile: opts.profile,
+    workspace: opts.workspace,
+    skipPrompt: opts.skipWorkspaceSelect,
+  });
+}

package/src/commands/logout.ts

@@ -0,0 +1,7 @@
+import { clearCredentials } from '../lib/config.js';
+import { success } from '../lib/output.js';
+
+export function runLogout(): void {
+  clearCredentials();
+  success('Logged out');
+}

package/src/commands/platform.ts

@@ -0,0 +1,123 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { getApiUrl, loadGlobalConfig, resolvePlatformDir } from '../lib/config.js';
+import { printJson, success } from '../lib/output.js';
+
+const WORKBENCH_ONLY_COMPOSE = [
+  '-f',
+  'docker-compose.yml',
+  '-f',
+  'docker-compose.workbench.yml',
+] as const;
+
+function normalizeViteApiBase(url: string): string {
+  return url.endsWith('/') ? url : `${url}/`;
+}
+
+function runCompose(args: string[], cwd: string): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const child = spawn('docker', ['compose', ...args], {
+      cwd,
+      stdio: 'inherit',
+      shell: process.platform === 'win32',
+    });
+    child.on('error', reject);
+    child.on('close', (code) => resolve(code ?? 1));
+  });
+}
+
+export async function runStart(opts: {
+  backendOnly?: boolean;
+  build?: boolean;
+  remote?: boolean;
+}): Promise<void> {
+  const platformDir = resolvePlatformDir();
+
+  if (opts.remote) {
+    const apiBase = normalizeViteApiBase(getApiUrl('cloud'));
+    const composeArgs = [...WORKBENCH_ONLY_COMPOSE];
+    if (opts.build) {
+      const buildCode = await runCompose(
+        [
+          ...composeArgs,
+          'build',
+          '--build-arg',
+          `VITE_API_BASE_URL=${apiBase}`,
+          '--build-arg',
+          'VITE_APP_ENV=development',
+          'workbench',
+        ],
+        platformDir,
+      );
+      if (buildCode !== 0) throw new Error(`docker compose build exited with ${buildCode}`);
+    }
+    const code = await runCompose([...composeArgs, 'up', '-d', 'workbench'], platformDir);
+    if (code !== 0) throw new Error(`docker compose exited with ${code}`);
+    success(`Workbench UI: http://localhost:4310 (API → ${apiBase})`);
+    return;
+  }
+
+  const composeArgs = opts.backendOnly
+    ? ['-f', 'docker-compose.yml', '-f', 'docker-compose.backend.yml', 'up', '-d']
+    : ['up', '-d'];
+  if (opts.build) {
+    const upIdx = composeArgs.indexOf('up');
+    composeArgs.splice(upIdx + 1, 0, '--build');
+  }
+  const code = await runCompose(composeArgs, platformDir);
+  if (code !== 0) throw new Error(`docker compose exited with ${code}`);
+  success('Ductape platform started (see platform/README.md for URLs)');
+}
+
+export async function runStop(): Promise<void> {
+  const platformDir = resolvePlatformDir();
+  const code = await runCompose(['down'], platformDir);
+  if (code !== 0) throw new Error(`docker compose exited with ${code}`);
+  success('Ductape platform stopped');
+}
+
+async function probeHealth(url: string): Promise<{
+  url: string;
+  ok: boolean;
+  status?: number;
+  error?: string;
+  hint?: string;
+}> {
+  try {
+    const res = await fetch(url, { signal: AbortSignal.timeout(5000) });
+    const hint =
+      res.status === 502
+        ? 'nginx returned 502 Bad Gateway — the proxy container is usually not running or not listening yet. Try: docker compose ps proxy && docker compose logs proxy --tail 50'
+        : res.status === 404
+          ? 'route not found — check api-gateway nginx config vs Nest proxy routes'
+          : undefined;
+    return { url, ok: res.ok, status: res.status, hint };
+  } catch (e) {
+    return {
+      url,
+      ok: false,
+      error: e instanceof Error ? e.message : String(e),
+      hint: 'cannot reach host — run `ductape start` (full stack) or ensure port 4311 / 8020 is up',
+    };
+  }
+}
+
+export async function runStatus(json: boolean): Promise<void> {
+  const global = loadGlobalConfig();
+  const localUrl = global.profiles.local?.api_url ?? 'http://localhost:4311/api';
+  const localBase = localUrl.replace(/\/$/, '');
+  const checks: Record<string, unknown> = {
+    profiles: global.profiles,
+    platform_dir: resolvePlatformDir(),
+    workbench_ui: 'http://localhost:4310',
+  };
+
+  checks.local_proxy_health = await probeHealth(`${localBase}/proxy/v1/sdk-proxy/health`);
+  checks.local_proxy_direct = await probeHealth(
+    'http://localhost:8020/proxy/v1/sdk-proxy/health',
+  );
+
+  checks.cloud_api = getApiUrl('cloud');
+
+  printJson(checks, json);
+}

package/src/commands/products.ts

@@ -0,0 +1,104 @@
+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 {
+  createProduct,
+  deleteProduct,
+  getProduct,
+  listProductApps,
+  listProducts,
+  updateProduct,
+} 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 runProducts(
+  verb: string,
+  opts: {
+    profile?: string;
+    status?: string;
+    id?: string;
+    tag?: string;
+    file?: string;
+    json?: boolean;
+  } & CommandInteractiveFlags,
+  extraArgs: string[],
+): Promise<void> {
+  const v = verb.toLowerCase() as Verb;
+  if (!VERBS.includes(v)) {
+    throw new Error(`Unknown products verb "${verb}". Use: ${VERBS.join(', ')}`);
+  }
+
+  const ctx = requireWorkspaceContext({ profile: opts.profile });
+  const status = opts.status ?? 'all';
+  const interactive = toInteractiveOpts(opts);
+  const schemaKey = schemaKeyForEntity('products', 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' && !tag && isInteractive(interactive)) {
+    tag = await promptTag('Product tag');
+  }
+
+  let result: unknown;
+
+  switch (v) {
+    case 'list':
+      result = await listProducts(ctx, status);
+      break;
+    case 'get':
+      result = await getProduct(ctx, { id, tag });
+      break;
+    case 'create':
+      if (!body || Object.keys(body).length === 0) {
+        throw new Error(`create requires a body. ${bodyRequiredHint('products:create')}`);
+      }
+      result = await createProduct(ctx, body);
+      break;
+    case 'update': {
+      const productTag = tag ?? (body?.tag as string | undefined);
+      if (!productTag) throw new Error('update requires --tag <product_tag> (or tag in body)');
+      const patch = body ?? {};
+      result = await updateProduct(ctx, productTag, patch);
+      break;
+    }
+    case 'delete':
+      if (!id) throw new Error('delete requires --id <product_id>');
+      result = await deleteProduct(ctx, id);
+      break;
+    default:
+      throw new Error(`Unsupported: products ${v}`);
+  }
+
+  printJson(result, Boolean(opts.json));
+}
+
+export async function runProductApps(
+  verb: string,
+  opts: { profile?: string; product?: string; json?: boolean },
+  extraArgs: string[],
+): Promise<void> {
+  if (verb.toLowerCase() !== 'list') {
+    throw new Error('Only supported: ductape products apps list --product <id>');
+  }
+
+  const ctx = requireWorkspaceContext({ profile: opts.profile });
+  const productId = opts.product ?? extraArgs[0];
+  if (!productId) throw new Error('Provide --product <product_id>');
+
+  const result = await listProductApps(ctx, productId);
+  printJson(result, Boolean(opts.json));
+}