@ductape/cli 0.2.0

package/src/lib/platform-api.ts

@@ -0,0 +1,178 @@
+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) ——
+
+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(result);
+}
+
+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) {
+    const result = await client(ctx).getPath<unknown>(`/integrations/v1/fetch/tag`, {
+      ...q,
+      tag: 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()}`,
+  );
+}

package/src/lib/proxy/context.ts

@@ -0,0 +1,94 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,58 @@
+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);
+}

package/src/lib/read-body.ts

@@ -0,0 +1,57 @@
+import fs from 'node:fs';
+import {
+  getFormSchema,
+  isInteractive,
+  promptForm,
+  type InteractiveOpts,
+} from './forms/index.js';
+import type { FormSchema } from './forms/types.js';
+
+export function readJsonBody(filePath?: string): unknown {
+  if (!filePath) return undefined;
+  const raw = fs.readFileSync(filePath, 'utf8');
+  return JSON.parse(raw) as unknown;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  if (value === undefined) return undefined;
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    return value as Record<string, unknown>;
+  }
+  throw new Error('Body must be a JSON object');
+}
+
+export async function resolveBody(
+  opts: InteractiveOpts & {
+    file?: string;
+    schemaKey?: string;
+    schema?: FormSchema;
+    patch?: boolean;
+    requireBody?: boolean;
+  },
+): Promise<Record<string, unknown> | undefined> {
+  if (opts.file) {
+    return asRecord(readJsonBody(opts.file));
+  }
+
+  const schema = opts.schema ?? (opts.schemaKey ? getFormSchema(opts.schemaKey) : undefined);
+  if (schema && isInteractive(opts)) {
+    return promptForm(schema, { patch: opts.patch ?? opts.schemaKey?.endsWith(':update') });
+  }
+
+  if (opts.requireBody && isInteractive(opts) === false) {
+    return undefined;
+  }
+
+  if (opts.requireBody) {
+    return undefined;
+  }
+
+  return undefined;
+}
+
+export function bodyRequiredHint(schemaKey?: string): string {
+  const json = 'Pass -f <file.json> or run interactively (TTY)';
+  if (schemaKey) return `${json} — schema: ${schemaKey}`;
+  return json;
+}

package/src/lib/resources.ts

@@ -0,0 +1,156 @@
+import type { SDKModule } from './proxy/sdk-proxy.js';
+
+/** CLI resource type → sdk-proxy module */
+export const RESOURCE_MODULES: Record<string, SDKModule> = {
+  storage: 'storage',
+  databases: 'databases',
+  database: 'databases',
+  graph: 'graph',
+  graphs: 'graph',
+  vector: 'vector',
+  vectors: 'vector',
+  cache: 'caches',
+  caches: 'caches',
+  job: 'jobs',
+  jobs: 'jobs',
+  feature: 'features',
+  features: 'features',
+  action: 'actions',
+  actions: 'actions',
+  notification: 'notifications',
+  notifications: 'notifications',
+  broker: 'messageBrokers',
+  brokers: 'messageBrokers',
+  'message-brokers': 'messageBrokers',
+  messagebrokers: 'messageBrokers',
+  session: 'sessions',
+  sessions: 'sessions',
+  secret: 'secrets',
+  secrets: 'secrets',
+  quota: 'quotas',
+  quotas: 'quotas',
+  health: 'health',
+  healthcheck: 'health',
+  fallback: 'fallback',
+  product: 'product',
+  app: 'app',
+};
+
+export type CrudVerb = 'create' | 'list' | 'get' | 'update' | 'delete' | 'connect';
+
+export function resolveResourceType(name: string): SDKModule {
+  const mod = RESOURCE_MODULES[name.toLowerCase()];
+  if (!mod) {
+    throw new Error(
+      `Unknown resource type "${name}". Try: storage, databases, graph, product, app, … — or \`ductape products\` / \`ductape apps\` for workspace CRUD`,
+    );
+  }
+  return mod;
+}
+
+export function proxyMethodForVerb(verb: CrudVerb): string {
+  if (verb === 'get') return 'fetch';
+  return verb;
+}
+
+/** Build params array matching Workbench sdkProxy.ts conventions */
+export function buildCrudParams(
+  module: SDKModule,
+  method: string,
+  productTag: string,
+  args: { tag?: string; body?: unknown },
+): unknown[] {
+  const { tag, body } = args;
+
+  if (module === 'vector') {
+    if (method === 'list') return [{ product: productTag }];
+    if (method === 'fetch' || method === 'delete') {
+      if (!tag) throw new Error('tag is required');
+      return [{ product: productTag, tag }];
+    }
+    if (method === 'create' || method === 'update' || method === 'connect') {
+      const payload =
+        body && typeof body === 'object'
+          ? { product: productTag, ...(body as object) }
+          : { product: productTag };
+      return [payload];
+    }
+  }
+
+  if (module === 'storage' && method === 'create') {
+    const payload =
+      body && typeof body === 'object'
+        ? { product: productTag, ...(body as object) }
+        : { product: productTag };
+    return [payload];
+  }
+
+  if (module === 'secrets') {
+    if (method === 'list') return [];
+    if (method === 'fetch' || method === 'delete') {
+      if (!tag) throw new Error('key/tag is required');
+      return method === 'delete' ? [tag] : [tag];
+    }
+    if (method === 'create') return [body ?? {}];
+    if (method === 'update') {
+      if (!tag) throw new Error('key is required');
+      return [tag, body ?? {}];
+    }
+  }
+
+  if (module === 'product' || module === 'app') {
+    if (method === 'create') return [body ?? {}];
+    if (method === 'fetch') {
+      if (!tag) throw new Error('tag is required');
+      return [tag];
+    }
+    if (method === 'update') {
+      if (!tag) throw new Error('tag is required');
+      return [tag, body ?? {}];
+    }
+    if (method === 'list') return [];
+  }
+
+  // Default product-scoped components
+  if (method === 'create') return [productTag, body ?? {}];
+  if (method === 'list') return [productTag];
+  if (method === 'fetch' || method === 'delete') {
+    if (!tag) throw new Error('tag is required');
+    return [productTag, tag];
+  }
+  if (method === 'update') {
+    if (!tag) throw new Error('tag is required');
+    return [productTag, tag, body ?? {}];
+  }
+  if (method === 'connect') {
+    const payload =
+      body && typeof body === 'object'
+        ? { product: productTag, ...(body as object) }
+        : { product: productTag };
+    return [payload];
+  }
+
+  throw new Error(`Unsupported operation ${module}.${method}`);
+}
+
+export function listResourceTypes(): string[] {
+  return [
+    'storage',
+    'databases',
+    'graph',
+    'vector',
+    'caches',
+    'jobs',
+    'features',
+    'actions',
+    'notifications',
+    'message-brokers',
+    'sessions',
+    'secrets',
+    'quotas',
+    'health',
+    'fallback',
+    'product',
+    'app',
+  ];
+}