@ductape/cli 0.2.23 → 0.3.0

package/src/lib/integrations.ts

@@ -1,110 +0,0 @@
-import type { Credentials } from './config.js';
-
-export interface TableColumnRecord {
-  name: string;
-  type: string;
-  nullable: boolean;
-  primaryKey: boolean;
-  unique: boolean;
-  autoIncrement: boolean;
-  defaultValue?: unknown;
-}
-
-export interface TableSchemaRecord {
-  table: string;
-  columns: TableColumnRecord[];
-  updated_at: string;
-}
-
-export interface GeneratePayloadRequest {
-  workspace_id: string;
-  user_id: string;
-  public_key: string;
-  product_tag: string;
-  env_slug: string;
-  operation_family: string;
-  method: string;
-  targets?: Record<string, unknown>;
-  include_session?: boolean;
-  include_cache?: boolean;
-  schema_mode?: 'strict' | 'best_effort';
-  input_hint?: Record<string, unknown>;
-}
-
-export interface GeneratePayloadResponse {
-  payload: Record<string, unknown>;
-  meta: Record<string, unknown>;
-}
-
-export async function generateExecutablePayload(
-  apiUrl: string,
-  creds: Credentials,
-  request: GeneratePayloadRequest,
-): Promise<GeneratePayloadResponse> {
-  const url = `${apiUrl}/integrations/v1/payloads/generate`;
-  const res = await fetch(url, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${creds.auth_token}`,
-      'x-access-key': creds.public_key,
-    },
-    body: JSON.stringify({
-      ...request,
-      operation_family: request.operation_family.toLowerCase() === 'features'
-        ? 'feature'
-        : request.operation_family,
-    }),
-  });
-
-  const body = await res.json();
-  if (!res.ok) {
-    throw new Error(body.message ?? `Payload generation failed (${res.status})`);
-  }
-  if (body.status === false) {
-    throw new Error(body.message ?? 'Payload generation failed');
-  }
-  return (body.data ?? body) as GeneratePayloadResponse;
-}
-
-export async function pushDatabaseSchema(
-  apiUrl: string,
-  creds: Credentials,
-  opts: {
-    workspace_id: string;
-    product_tag: string;
-    database_tag: string;
-    env_slug: string;
-    table_schemas: TableSchemaRecord[];
-  },
-): Promise<{ synced: number; tables: string[] }> {
-  const url = `${apiUrl}/integrations/v1/databases/schema-sync`;
-  const res = await fetch(url, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${creds.auth_token}`,
-      'x-access-key': creds.public_key,
-    },
-    body: JSON.stringify({
-      user_id: creds.user_id,
-      public_key: creds.public_key,
-      workspace_id: opts.workspace_id,
-      product_tag: opts.product_tag,
-      database_tag: opts.database_tag,
-      env_slug: opts.env_slug,
-      table_schemas: opts.table_schemas,
-    }),
-  });
-
-  const body = await res.json() as Record<string, unknown>;
-  if (!res.ok) {
-    const msg = (body as any).errors ?? (body as any).message;
-    throw new Error(typeof msg === 'string' ? msg : `Schema sync failed (${res.status})`);
-  }
-  if (body.status === false) {
-    const msg = (body as any).errors ?? (body as any).message;
-    throw new Error(typeof msg === 'string' ? msg : 'Schema sync failed');
-  }
-  return (body.data ?? body) as { synced: number; tables: string[] };
-}

package/src/lib/interactive-opts.ts

@@ -1,13 +0,0 @@
-import type { InteractiveOpts } from './forms/index.js';
-
-export type CommandInteractiveFlags = {
-  interactive?: boolean;
-  noInteractive?: boolean;
-};
-
-export function toInteractiveOpts(flags: CommandInteractiveFlags): InteractiveOpts {
-  return {
-    interactive: flags.noInteractive ? false : flags.interactive,
-    noInteractive: flags.noInteractive,
-  };
-}

package/src/lib/migration-files.ts

@@ -1,58 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { PROJECT_CONFIG_DIR } from './config.js';
-import type { IMigration } from './db-types.js';
-
-export function getMigrationsDir(projectDir: string, dbTag: string): string {
-  return path.join(projectDir, PROJECT_CONFIG_DIR, 'database', 'migrations', dbTag);
-}
-
-export function loadMigrationFiles(projectDir: string, dbTag: string): IMigration[] {
-  const dir = getMigrationsDir(projectDir, dbTag);
-  if (!fs.existsSync(dir)) return [];
-
-  const files = fs
-    .readdirSync(dir)
-    .filter((f) => f.endsWith('.json'))
-    .sort();
-
-  return files.map((file) => {
-    const raw = JSON.parse(
-      fs.readFileSync(path.join(dir, file), 'utf8'),
-    ) as IMigration;
-    return raw;
-  });
-}
-
-function makeTimestamp(counter: number): string {
-  const now = new Date();
-  const pad = (n: number, len = 2) => String(n).padStart(len, '0');
-  const ts =
-    String(now.getFullYear()) +
-    pad(now.getMonth() + 1) +
-    pad(now.getDate()) +
-    pad(now.getHours()) +
-    pad(now.getMinutes()) +
-    pad(now.getSeconds());
-  return `${ts}_${pad(counter, 3)}`;
-}
-
-export function writeMigrationFile(
-  projectDir: string,
-  dbTag: string,
-  migration: IMigration,
-  counter: number,
-): string {
-  const dir = getMigrationsDir(projectDir, dbTag);
-  fs.mkdirSync(dir, { recursive: true });
-
-  const safeName = migration.name
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '_')
-    .replace(/^_|_$/g, '');
-  const ts = makeTimestamp(counter);
-  const filename = `${ts}_${safeName}.json`;
-  const filePath = path.join(dir, filename);
-  fs.writeFileSync(filePath, JSON.stringify(migration, null, 2) + '\n');
-  return filePath;
-}

package/src/lib/output.ts

@@ -1,39 +0,0 @@
-const REDACTED_KEYS = new Set(['private_key']);
-
-function redactSensitiveFields(data: unknown): unknown {
-  if (Array.isArray(data)) return data.map(redactSensitiveFields);
-  if (data !== null && typeof data === 'object') {
-    const result: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(data as Record<string, unknown>)) {
-      result[key] = REDACTED_KEYS.has(key) ? '[REDACTED]' : redactSensitiveFields(value);
-    }
-    return result;
-  }
-  return data;
-}
-
-export function printJson(data: unknown, jsonMode: boolean): void {
-  const safe = redactSensitiveFields(data);
-  if (jsonMode) {
-    console.log(JSON.stringify(safe, null, 2));
-    return;
-  }
-  if (safe === undefined || safe === null) {
-    console.log('(no data)');
-    return;
-  }
-  if (typeof safe === 'object') {
-    console.log(JSON.stringify(safe, null, 2));
-    return;
-  }
-  console.log(String(safe));
-}
-
-export function success(message: string): void {
-  console.log(`✓ ${message}`);
-}
-
-export function fail(message: string): never {
-  console.error(`✗ ${message}`);
-  process.exit(1);
-}

package/src/lib/platform-api.ts

@@ -1,209 +0,0 @@
-import { ApiClient } from './api-client.js';
-import { createSdkProxyClient } from './proxy/sdk-proxy.js';
-import type { WorkspaceContext } from './workspace-context.js';
-import { workspaceAuthQuery } from './workspace-context.js';
-
-function client(ctx: WorkspaceContext): ApiClient {
-  return ApiClient.forProfile(ctx.profile, ctx.credentials);
-}
-
-function proxy(ctx: WorkspaceContext) {
-  return createSdkProxyClient({
-    apiUrl: ctx.apiUrl,
-    workspaceId: ctx.workspaceId,
-    userId: ctx.credentials.user_id,
-    publicKey: ctx.credentials.public_key,
-    token: ctx.credentials.auth_token,
-  });
-}
-
-function unwrapList<T>(result: unknown): T[] {
-  if (Array.isArray(result)) return result;
-  if (result && typeof result === 'object' && Array.isArray((result as { data?: T[] }).data)) {
-    return (result as { data: T[] }).data;
-  }
-  return [];
-}
-
-function unwrapOne<T>(result: unknown): T {
-  if (result && typeof result === 'object' && 'data' in result) {
-    return (result as { data: T }).data;
-  }
-  return result as T;
-}
-
-// —— Products (integrations REST + sdk-proxy for update) ——
-
-const PRODUCT_LIST_ARRAY_FIELDS = [
-  'apps', 'caches', 'quota', 'fallback', 'storage', 'brokers',
-  'sessions', 'messageBrokers', 'functions', 'variables', 'auths',
-  'databases', 'graphs', 'jobs', 'healthchecks', 'notifications',
-  'features', 'vectors', 'agents', 'models', 'steps_data',
-];
-
-function summarizeProduct(p: unknown): unknown {
-  if (!p || typeof p !== 'object') return p;
-  const out: Record<string, unknown> = { ...(p as Record<string, unknown>) };
-  for (const field of PRODUCT_LIST_ARRAY_FIELDS) delete out[field];
-  return out;
-}
-
-export async function listProducts(
-  ctx: WorkspaceContext,
-  status = 'all',
-): Promise<unknown[]> {
-  const result = await client(ctx).getPath<unknown>(
-    `/integrations/v1/workspace/${ctx.workspaceId}/${status}`,
-    workspaceAuthQuery(ctx),
-  );
-  return unwrapList<unknown>(result).map(summarizeProduct);
-}
-
-export async function getProduct(
-  ctx: WorkspaceContext,
-  opts: { id?: string; tag?: string },
-): Promise<unknown> {
-  const q = workspaceAuthQuery(ctx);
-  if (opts.id) {
-    const result = await client(ctx).getPath<unknown>(`/integrations/v1/${opts.id}`, q);
-    return unwrapOne(result);
-  }
-  if (opts.tag) {
-    // The integrations REST fetch-by-tag route rejects current CLI login tokens with HTTP 401.
-    // Product inventory is an administrative read, so route it through the authenticated CLI
-    // SDK proxy (x-access-token), not the publishable-key runtime MCP proxy.
-    const result = await proxy(ctx).execute<unknown>('product', 'fetch', [opts.tag]);
-    return unwrapOne(result);
-  }
-  throw new Error('Provide --id <product_id> or --tag <product_tag>');
-}
-
-export async function createProduct(ctx: WorkspaceContext, body: Record<string, unknown>): Promise<unknown> {
-  const payload = {
-    workspace_id: ctx.workspaceId,
-    user_id: ctx.credentials.user_id,
-    public_key: ctx.credentials.public_key,
-    ...body,
-  };
-  const result = await client(ctx).post<unknown>('/integrations/v1/create', payload);
-  return unwrapOne(result);
-}
-
-export async function updateProduct(
-  ctx: WorkspaceContext,
-  tag: string,
-  body: Record<string, unknown>,
-): Promise<unknown> {
-  return proxy(ctx).execute('product', 'update', [tag, body]);
-}
-
-export async function deleteProduct(ctx: WorkspaceContext, productId: string): Promise<unknown> {
-  return client(ctx).delete<unknown>(
-    `/integrations/v1/${productId}?${new URLSearchParams(workspaceAuthQuery(ctx)).toString()}`,
-  );
-}
-
-export async function listProductApps(ctx: WorkspaceContext, productId: string): Promise<unknown[]> {
-  const result = await client(ctx).getPath<unknown>(
-    `/integrations/v1/fetch-product-apps/${productId}`,
-    workspaceAuthQuery(ctx),
-  );
-  return unwrapList(result);
-}
-
-// —— Apps (apps REST) ——
-
-export async function listApps(ctx: WorkspaceContext, status = 'all'): Promise<unknown[]> {
-  const result = await client(ctx).getPath<unknown>(
-    `/apps/v1/workspace/${ctx.workspaceId}/${status}`,
-    {
-      user_id: ctx.credentials.user_id,
-      public_key: ctx.credentials.public_key,
-    },
-  );
-  return unwrapList(result);
-}
-
-export async function getApp(
-  ctx: WorkspaceContext,
-  opts: { id?: string; tag?: string },
-): Promise<unknown> {
-  const q = {
-    user_id: ctx.credentials.user_id,
-    public_key: ctx.credentials.public_key,
-  };
-  if (opts.id) {
-    const result = await client(ctx).getPath<unknown>(`/apps/v1/${opts.id}`, q);
-    return unwrapOne(result);
-  }
-  if (opts.tag) {
-    const result = await client(ctx).getPath<unknown>(`/apps/v1/fetch/tag`, { ...q, tag: opts.tag });
-    return unwrapOne(result);
-  }
-  throw new Error('Provide --id <app_id> or --tag <app_tag>');
-}
-
-export async function createApp(ctx: WorkspaceContext, body: Record<string, unknown>): Promise<unknown> {
-  const payload = {
-    workspace_id: ctx.workspaceId,
-    user_id: ctx.credentials.user_id,
-    public_key: ctx.credentials.public_key,
-    version: '1.0.0',
-    logo: '',
-    envs: [],
-    ...body,
-  };
-  const result = await client(ctx).post<unknown>('/apps/v1/create', payload);
-  return unwrapOne(result);
-}
-
-export async function updateApp(
-  ctx: WorkspaceContext,
-  appId: string,
-  body: Record<string, unknown>,
-): Promise<unknown> {
-  const q = {
-    user_id: ctx.credentials.user_id,
-    public_key: ctx.credentials.public_key,
-  };
-  const result = await client(ctx).put<unknown>(
-    `/apps/v1/${appId}?${new URLSearchParams(q).toString()}`,
-    body,
-  );
-  return unwrapOne(result);
-}
-
-export async function updateAppViaProxy(
-  ctx: WorkspaceContext,
-  tag: string,
-  body: Record<string, unknown>,
-): Promise<unknown> {
-  return proxy(ctx).execute('app', 'update', [tag, body]);
-}
-
-export async function deleteApp(ctx: WorkspaceContext, appId: string): Promise<unknown> {
-  const q = {
-    user_id: ctx.credentials.user_id,
-    public_key: ctx.credentials.public_key,
-  };
-  return client(ctx).delete<unknown>(
-    `/apps/v1/${appId}?${new URLSearchParams(q).toString()}`,
-  );
-}
-
-// —— Cloud tiers ——
-
-export interface TierQuery {
-  provider?: string;
-  resource_type?: string;
-  db_type?: string;
-}
-
-export async function listCloudTiers(ctx: WorkspaceContext, q: TierQuery): Promise<unknown[]> {
-  const params: Record<string, string> = workspaceAuthQuery(ctx);
-  if (q.provider) params.provider = q.provider;
-  if (q.resource_type) params.resource_type = q.resource_type;
-  if (q.db_type) params.db_type = q.db_type;
-  const result = await client(ctx).getPath<unknown>('/integrations/v1/cloud/tiers', params);
-  return unwrapList<unknown>(result);
-}

package/src/lib/proxy/context.ts

@@ -1,94 +0,0 @@
-import {
-  findProjectConfig,
-  getActiveProfileName,
-  getApiUrl,
-  loadCredentials,
-  loadProjectConfig,
-  type Credentials,
-  type ResolvedProjectConfig,
-} from '../config.js';
-import { loadRuntimeContext } from '../context-store.js';
-import { createSdkProxyClient, type SdkProxyClient } from './sdk-proxy.js';
-import { DbProxyClient } from './db-proxy.js';
-import { GraphProxyClient } from './graph-proxy.js';
-
-export interface SessionContext {
-  credentials: Credentials;
-  project: ResolvedProjectConfig;
-  apiUrl: string;
-}
-
-export function requireCredentials(): Credentials {
-  const creds = loadCredentials();
-  if (!creds?.auth_token || !creds.public_key || !creds.user_id) {
-    throw new Error('Not logged in. Run: ductape login');
-  }
-  return creds;
-}
-
-export function requireSession(): SessionContext {
-  const credentials = requireCredentials();
-  const project = loadProjectConfig();
-  const profile = getActiveProfileName(project);
-  const apiUrl = getApiUrl(profile);
-  return { credentials, project, apiUrl };
-}
-
-export function getSdkProxy(session?: SessionContext): SdkProxyClient {
-  const s = session ?? requireSession();
-  return createSdkProxyClient({
-    apiUrl: s.apiUrl,
-    workspaceId: s.project.workspace_id,
-    userId: s.credentials.user_id,
-    publicKey: s.credentials.public_key,
-    token: s.credentials.auth_token,
-  });
-}
-
-export function getDbProxy(session?: SessionContext): DbProxyClient {
-  const s = session ?? requireSession();
-  const runtime = loadRuntimeContext(s.project.workspace_id, s.project.product_tag);
-  const proxy = new DbProxyClient({
-    apiUrl: s.apiUrl,
-    workspaceId: s.project.workspace_id,
-    userId: s.credentials.user_id,
-    publicKey: s.credentials.public_key,
-    token: s.credentials.auth_token,
-  });
-  return proxy;
-}
-
-export function getDbContext(session?: SessionContext) {
-  const s = session ?? requireSession();
-  const runtime = loadRuntimeContext(s.project.workspace_id, s.project.product_tag);
-  return (
-    runtime?.database_context ?? {
-      database: '',
-      env: s.project.env_slug,
-      product: s.project.product_tag,
-    }
-  );
-}
-
-export function getGraphProxy(session?: SessionContext): GraphProxyClient {
-  const s = session ?? requireSession();
-  const runtime = loadRuntimeContext(s.project.workspace_id, s.project.product_tag);
-  return new GraphProxyClient({
-    apiUrl: s.apiUrl,
-    workspaceId: s.project.workspace_id,
-    userId: s.credentials.user_id,
-    publicKey: s.credentials.public_key,
-    token: s.credentials.auth_token,
-    graphContext: runtime?.graph_context ?? null,
-  });
-}
-
-export function getOptionalProject(): ResolvedProjectConfig | null {
-  const found = findProjectConfig();
-  if (!found) return null;
-  try {
-    return loadProjectConfig();
-  } catch {
-    return null;
-  }
-}

package/src/lib/proxy/db-proxy.ts

@@ -1,40 +0,0 @@
-import { encryptProxyPayload } from '../encryption.js';
-import { postProxyJson } from '../http.js';
-import type { DatabaseContext } from '../context-store.js';
-
-export interface DbProxyContext {
-  apiUrl: string;
-  workspaceId: string;
-  userId: string;
-  publicKey: string;
-  token: string;
-}
-
-export class DbProxyClient {
-  constructor(private readonly ctx: DbProxyContext) {}
-
-  async execute<T>(
-    method: string,
-    params: unknown[],
-    databaseContext?: DatabaseContext | null,
-  ): Promise<T> {
-    const sensitive: Record<string, unknown> = {
-      method,
-      params,
-      user_id: this.ctx.userId,
-    };
-    if (databaseContext) sensitive.database_context = databaseContext;
-
-    const encrypted_payload = encryptProxyPayload(sensitive, this.ctx.publicKey);
-    const body: Record<string, unknown> = {
-      encrypted_payload,
-      workspace_id: this.ctx.workspaceId,
-      user_id: this.ctx.userId,
-      public_key: this.ctx.publicKey,
-    };
-    if (databaseContext) body.database_context = databaseContext;
-
-    const url = `${this.ctx.apiUrl}/proxy/v1/db-proxy/execute`;
-    return postProxyJson<T>(url, body, { 'x-access-token': this.ctx.token });
-  }
-}

package/src/lib/proxy/graph-proxy.ts

@@ -1,64 +0,0 @@
-import { encryptProxyPayload } from '../encryption.js';
-import { postProxyJson } from '../http.js';
-
-export interface GraphContext {
-  graph: string;
-  env: string;
-  product: string;
-}
-
-export interface GraphProxyContext {
-  apiUrl: string;
-  workspaceId: string;
-  userId: string;
-  publicKey: string;
-  token: string;
-  graphContext?: GraphContext | null;
-}
-
-export class GraphProxyClient {
-  constructor(private readonly ctx: GraphProxyContext) {}
-
-  setGraphContext(context: GraphContext | null): void {
-    this.ctx.graphContext = context;
-  }
-
-  async execute<T>(
-    method: string,
-    params: unknown[] = [],
-    graphContext?: GraphContext | null,
-  ): Promise<T> {
-    const ctx = graphContext ?? this.ctx.graphContext;
-    const sensitive: Record<string, unknown> = {
-      method,
-      params,
-      user_id: this.ctx.userId,
-    };
-    if (ctx) sensitive.graph_context = ctx;
-
-    const encrypted_payload = encryptProxyPayload(sensitive, this.ctx.publicKey);
-    const body: Record<string, unknown> = {
-      encrypted_payload,
-      workspace_id: this.ctx.workspaceId,
-      user_id: this.ctx.userId,
-      public_key: this.ctx.publicKey,
-    };
-    if (ctx) body.graph_context = ctx;
-
-    const url = `${this.ctx.apiUrl}/proxy/v1/graph-proxy/execute`;
-    const result = await postProxyJson<T>(url, body, {
-      'x-access-token': this.ctx.token,
-    });
-
-    if (method === 'connect' && params[0] && typeof params[0] === 'object') {
-      const cfg = params[0] as GraphContext;
-      this.setGraphContext({
-        graph: cfg.graph,
-        env: cfg.env,
-        product: cfg.product,
-      });
-    }
-
-    return result;
-  }
-}

package/src/lib/proxy/sdk-proxy.ts

@@ -1,58 +0,0 @@
-import { encryptProxyPayload } from '../encryption.js';
-import { postProxyJson } from '../http.js';
-
-export type SDKModule =
-  | 'product'
-  | 'app'
-  | 'databases'
-  | 'graph'
-  | 'webhooks'
-  | 'notifications'
-  | 'messageBrokers'
-  | 'storage'
-  | 'vector'
-  | 'caches'
-  | 'sessions'
-  | 'quotas'
-  | 'actions'
-  | 'features'
-  | 'jobs'
-  | 'logs'
-  | 'resilience'
-  | 'health'
-  | 'fallback'
-  | 'secrets'
-  | 'cloud';
-
-export interface SdkProxyContext {
-  apiUrl: string;
-  workspaceId: string;
-  userId: string;
-  publicKey: string;
-  token: string;
-}
-
-export class SdkProxyClient {
-  constructor(private readonly ctx: SdkProxyContext) {}
-
-  async execute<T>(module: SDKModule, method: string, params: unknown[] = []): Promise<T> {
-    const sensitive = { module, method, params, user_id: this.ctx.userId };
-    const encrypted_payload = encryptProxyPayload(sensitive, this.ctx.publicKey);
-
-    const url = `${this.ctx.apiUrl}/proxy/v1/sdk-proxy/execute`;
-    return postProxyJson<T>(
-      url,
-      {
-        encrypted_payload,
-        workspace_id: this.ctx.workspaceId,
-        user_id: this.ctx.userId,
-        public_key: this.ctx.publicKey,
-      },
-      { 'x-access-token': this.ctx.token },
-    );
-  }
-}
-
-export function createSdkProxyClient(ctx: SdkProxyContext): SdkProxyClient {
-  return new SdkProxyClient(ctx);
-}