@ductape/cli 0.2.0

package/dist/lib/forms/schemas.js

@@ -0,0 +1,253 @@
+import { DATABASE_TYPES, GRAPH_TYPES, HTTP_METHODS, JOB_EVENT_TYPES, NOTIFIERS, VECTOR_DB_TYPES, VECTOR_DISTANCE_METRICS, } from './enums.js';
+const TAG = { key: 'tag', label: 'Tag (no spaces)', kind: 'text', required: true };
+const NAME = { key: 'name', label: 'Name', kind: 'text', required: true };
+const DESC = { key: 'description', label: 'Description', kind: 'text' };
+function fields(...items) {
+    return items;
+}
+function optional(fields) {
+    return fields.map((f) => ({ ...f, required: false }));
+}
+const PRODUCT_CREATE = {
+    fields: fields({ key: 'name', label: 'Product name', kind: 'text', required: true }, { key: 'description', label: 'Description', kind: 'text', required: true }, TAG),
+};
+const APP_CREATE = {
+    fields: fields({ key: 'app_name', label: 'App name', kind: 'text', required: true }, { key: 'description', label: 'Description', kind: 'text', required: true }, TAG),
+};
+const COMPONENT_BASE = [NAME, DESC, TAG];
+const SCHEMAS = {
+    'products:create': PRODUCT_CREATE,
+    'products:update': { fields: optional(PRODUCT_CREATE.fields) },
+    'apps:create': APP_CREATE,
+    'apps:update': {
+        fields: optional([
+            { key: 'app_name', label: 'App name', kind: 'text' },
+            { key: 'description', label: 'Description', kind: 'text' },
+            TAG,
+        ]),
+    },
+    'storage:create': {
+        fields: [
+            ...COMPONENT_BASE,
+            { key: 'envs', label: 'Environments', kind: 'envs', required: true, envsVariant: 'storage' },
+        ],
+    },
+    'storage:update': {
+        fields: [
+            ...optional(COMPONENT_BASE),
+            { key: 'envs', label: 'Environments', kind: 'envs', envsVariant: 'storage' },
+        ],
+        allowExtraJson: true,
+    },
+    'databases:create': {
+        fields: [
+            ...COMPONENT_BASE,
+            {
+                key: 'type',
+                label: 'Database type',
+                kind: 'enum',
+                required: true,
+                choices: DATABASE_TYPES,
+            },
+            { key: 'envs', label: 'Environments', kind: 'envs', required: true, envsVariant: 'database' },
+        ],
+    },
+    'databases:update': {
+        fields: [
+            ...optional(COMPONENT_BASE),
+            { key: 'type', label: 'Database type', kind: 'enum', choices: DATABASE_TYPES },
+            { key: 'envs', label: 'Environments', kind: 'envs', envsVariant: 'database' },
+        ],
+        allowExtraJson: true,
+    },
+    'databases:connect': { fields: [TAG] },
+    'graph:create': {
+        fields: [
+            ...COMPONENT_BASE,
+            { key: 'type', label: 'Graph type', kind: 'enum', required: true, choices: GRAPH_TYPES },
+            { key: 'envs', label: 'Environments', kind: 'envs', required: true, envsVariant: 'graph' },
+        ],
+    },
+    'graph:update': {
+        fields: [
+            ...optional(COMPONENT_BASE),
+            { key: 'type', label: 'Graph type', kind: 'enum', choices: GRAPH_TYPES },
+            { key: 'envs', label: 'Environments', kind: 'envs', envsVariant: 'graph' },
+        ],
+        allowExtraJson: true,
+    },
+    'graph:connect': { fields: [TAG] },
+    'caches:create': {
+        fields: [
+            ...COMPONENT_BASE,
+            { key: 'expiry', label: 'Expiry (seconds)', kind: 'number', required: true },
+        ],
+    },
+    'caches:update': {
+        fields: optional([...COMPONENT_BASE, { key: 'expiry', label: 'Expiry (seconds)', kind: 'number' }]),
+        allowExtraJson: true,
+    },
+    'jobs:create': {
+        fields: [
+            TAG,
+            NAME,
+            { key: 'description', label: 'Description', kind: 'text', required: true },
+            { key: 'type', label: 'Job type', kind: 'enum', choices: JOB_EVENT_TYPES },
+            { key: 'event', label: 'Event tag', kind: 'text', required: true },
+            { key: 'executions', label: 'Max executions', kind: 'number', required: true },
+            { key: 'intervals', label: 'Interval (seconds)', kind: 'number', required: true },
+            { key: 'app', label: 'App tag (required for action jobs)', kind: 'text' },
+        ],
+        allowExtraJson: true,
+    },
+    'jobs:update': {
+        fields: optional([
+            TAG,
+            NAME,
+            { key: 'description', label: 'Description', kind: 'text' },
+            { key: 'type', label: 'Job type', kind: 'enum', choices: JOB_EVENT_TYPES },
+            { key: 'event', label: 'Event tag', kind: 'text' },
+            { key: 'executions', label: 'Max executions', kind: 'number' },
+            { key: 'intervals', label: 'Interval (seconds)', kind: 'number' },
+            { key: 'app', label: 'App tag', kind: 'text' },
+        ]),
+        allowExtraJson: true,
+    },
+    'vector:create': {
+        fields: [
+            ...COMPONENT_BASE,
+            {
+                key: 'type',
+                label: 'Vector DB type',
+                kind: 'enum',
+                required: true,
+                choices: VECTOR_DB_TYPES,
+            },
+            { key: 'dimensions', label: 'Dimensions', kind: 'number', required: true },
+            {
+                key: 'metric',
+                label: 'Distance metric',
+                kind: 'enum',
+                choices: VECTOR_DISTANCE_METRICS,
+                default: 'cosine',
+            },
+            { key: 'envs', label: 'Environments', kind: 'envs', required: true, envsVariant: 'vector' },
+        ],
+    },
+    'vector:update': {
+        fields: [
+            ...optional(COMPONENT_BASE),
+            { key: 'type', label: 'Vector DB type', kind: 'enum', choices: VECTOR_DB_TYPES },
+            { key: 'dimensions', label: 'Dimensions', kind: 'number' },
+            { key: 'metric', label: 'Distance metric', kind: 'enum', choices: VECTOR_DISTANCE_METRICS },
+            { key: 'envs', label: 'Environments', kind: 'envs', envsVariant: 'vector' },
+        ],
+        allowExtraJson: true,
+    },
+    'vector:connect': { fields: [TAG] },
+    'messageBrokers:create': {
+        fields: [
+            ...COMPONENT_BASE,
+            { key: 'envs', label: 'Environments', kind: 'envs', required: true, envsVariant: 'broker' },
+        ],
+    },
+    'messageBrokers:update': {
+        fields: [
+            ...optional(COMPONENT_BASE),
+            { key: 'envs', label: 'Environments', kind: 'envs', envsVariant: 'broker' },
+        ],
+        allowExtraJson: true,
+    },
+    'notifications:create': {
+        fields: [
+            ...COMPONENT_BASE,
+            { key: 'notifier', label: 'Notifier', kind: 'enum', required: true, choices: NOTIFIERS },
+        ],
+        allowExtraJson: true,
+    },
+    'notifications:update': {
+        fields: optional([
+            ...COMPONENT_BASE,
+            { key: 'notifier', label: 'Notifier', kind: 'enum', choices: NOTIFIERS },
+        ]),
+        allowExtraJson: true,
+    },
+    'actions:create': {
+        fields: [
+            TAG,
+            NAME,
+            DESC,
+            { key: 'method', label: 'HTTP method', kind: 'enum', choices: HTTP_METHODS },
+        ],
+        allowExtraJson: true,
+    },
+    'actions:update': {
+        fields: optional([
+            TAG,
+            NAME,
+            DESC,
+            { key: 'method', label: 'HTTP method', kind: 'enum', choices: HTTP_METHODS },
+        ]),
+        allowExtraJson: true,
+    },
+    'features:create': {
+        fields: [...COMPONENT_BASE],
+        allowExtraJson: true,
+    },
+    'features:update': { fields: optional(COMPONENT_BASE), allowExtraJson: true },
+    'secrets:create': {
+        fields: [
+            { key: 'key', label: 'Secret key', kind: 'text', required: true },
+            { key: 'value', label: 'Secret value', kind: 'text', required: true },
+            DESC,
+        ],
+    },
+    'secrets:update': {
+        fields: optional([
+            { key: 'value', label: 'Secret value', kind: 'text' },
+            DESC,
+        ]),
+    },
+    'quotas:create': { fields: [...COMPONENT_BASE], allowExtraJson: true },
+    'quotas:update': { fields: optional(COMPONENT_BASE), allowExtraJson: true },
+    'health:create': { fields: [...COMPONENT_BASE], allowExtraJson: true },
+    'health:update': { fields: optional(COMPONENT_BASE), allowExtraJson: true },
+    'fallback:create': { fields: [...COMPONENT_BASE], allowExtraJson: true },
+    'fallback:update': { fields: optional(COMPONENT_BASE), allowExtraJson: true },
+    'sessions:create': { fields: [...COMPONENT_BASE], allowExtraJson: true },
+    'sessions:update': { fields: optional(COMPONENT_BASE), allowExtraJson: true },
+};
+const GENERIC_COMPONENT = {
+    fields: [...COMPONENT_BASE],
+    allowExtraJson: true,
+};
+const CONNECT_MODULES = new Set(['databases', 'graph', 'vector', 'storage']);
+export function getFormSchema(schemaKey) {
+    return SCHEMAS[schemaKey] ?? undefined;
+}
+export function schemaKeyForResource(module, verb) {
+    if (verb === 'connect' && CONNECT_MODULES.has(module)) {
+        return `${module}:connect`;
+    }
+    if (verb === 'create' || verb === 'update') {
+        return `${module}:${verb}`;
+    }
+    return undefined;
+}
+export function schemaKeyForEntity(entity, verb) {
+    if (verb === 'create' || verb === 'update')
+        return `${entity}:${verb}`;
+    return undefined;
+}
+/** Fallback schema for component types without a dedicated form */
+export function genericComponentSchema(verb) {
+    if (verb === 'create')
+        return GENERIC_COMPONENT;
+    return { fields: optional(COMPONENT_BASE), allowExtraJson: true };
+}
+export function resolveResourceSchema(module, verb) {
+    const key = schemaKeyForResource(module, verb);
+    if (!key)
+        return undefined;
+    return getFormSchema(key) ?? (verb === 'create' || verb === 'update' ? genericComponentSchema(verb) : undefined);
+}

package/dist/lib/forms/types.d.ts

@@ -0,0 +1,18 @@
+export type FieldKind = 'text' | 'number' | 'enum' | 'envs';
+export type EnvsVariant = 'database' | 'graph' | 'storage' | 'broker' | 'vector' | 'simple';
+export interface FormField {
+    key: string;
+    label: string;
+    kind: FieldKind;
+    required?: boolean;
+    default?: string | number;
+    /** enum */
+    choices?: readonly string[];
+    /** envs */
+    envsVariant?: EnvsVariant;
+}
+export interface FormSchema {
+    fields: FormField[];
+    /** Merge optional JSON object after prompts */
+    allowExtraJson?: boolean;
+}

package/dist/lib/forms/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/http.d.ts

@@ -0,0 +1,10 @@
+/** Parse fetch body as JSON; surface HTML/misconfigured api_url clearly. */
+export declare function parseJsonResponse<T = Record<string, unknown>>(res: Response, url: string): Promise<T>;
+export interface ProxyJsonResponse<T> {
+    status?: boolean;
+    data?: {
+        data: T;
+    };
+    message?: string;
+}
+export declare function postProxyJson<T>(url: string, body: Record<string, unknown>, headers: Record<string, string>): Promise<T>;

package/dist/lib/http.js

@@ -0,0 +1,51 @@
+import { gzipSync } from 'node:zlib';
+const GZIP_THRESHOLD = 200 * 1024;
+/** Parse fetch body as JSON; surface HTML/misconfigured api_url clearly. */
+export async function parseJsonResponse(res, url) {
+    const text = await res.text();
+    const contentType = res.headers.get('content-type') ?? '';
+    if (!text.trim()) {
+        if (!res.ok)
+            throw new Error(`Empty response from ${url} (HTTP ${res.status})`);
+        return {};
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        const htmlHint = text.trimStart().startsWith('<')
+            ? [
+                '',
+                'The server returned HTML instead of JSON. Check your API profile:',
+                '  ductape profiles list',
+                '  ductape profiles use local   → http://localhost:4311/api (run `ductape start` first)',
+                '  ductape profiles use cloud  → https://api.ductape.app/api',
+                'Then: ductape login --profile local',
+            ].join('\n')
+            : '';
+        throw new Error(`Invalid JSON from ${url} (HTTP ${res.status}, Content-Type: ${contentType}): ${text.slice(0, 200)}${htmlHint}`);
+    }
+}
+export async function postProxyJson(url, body, headers) {
+    const json = JSON.stringify(body);
+    const reqHeaders = { ...headers, 'Content-Type': 'application/json' };
+    let bodyInit = json;
+    if (json.length > GZIP_THRESHOLD) {
+        const gz = gzipSync(json);
+        bodyInit = new Uint8Array(gz);
+        reqHeaders['Content-Encoding'] = 'gzip';
+    }
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: reqHeaders,
+        body: bodyInit,
+    });
+    const parsed = await parseJsonResponse(res, url);
+    if (!res.ok) {
+        throw new Error(parsed.message ?? `Request failed: ${res.status}`);
+    }
+    if (typeof parsed.status === 'boolean' && !parsed.status) {
+        throw new Error(parsed.message ?? 'Proxy operation failed');
+    }
+    return parsed.data?.data;
+}

package/dist/lib/integrations.d.ts

@@ -0,0 +1,20 @@
+import type { Credentials } from './config.js';
+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 declare function generateExecutablePayload(apiUrl: string, creds: Credentials, request: GeneratePayloadRequest): Promise<GeneratePayloadResponse>;

package/dist/lib/integrations.js

@@ -0,0 +1,20 @@
+export async function generateExecutablePayload(apiUrl, creds, request) {
+    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),
+    });
+    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);
+}

package/dist/lib/interactive-opts.d.ts

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

package/dist/lib/interactive-opts.js

@@ -0,0 +1,6 @@
+export function toInteractiveOpts(flags) {
+    return {
+        interactive: flags.noInteractive ? false : flags.interactive,
+        noInteractive: flags.noInteractive,
+    };
+}

package/dist/lib/output.d.ts

@@ -0,0 +1,3 @@
+export declare function printJson(data: unknown, jsonMode: boolean): void;
+export declare function success(message: string): void;
+export declare function fail(message: string): never;

package/dist/lib/output.js

@@ -0,0 +1,22 @@
+export function printJson(data, jsonMode) {
+    if (jsonMode) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    if (data === undefined || data === null) {
+        console.log('(no data)');
+        return;
+    }
+    if (typeof data === 'object') {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+    }
+    console.log(String(data));
+}
+export function success(message) {
+    console.log(`✓ ${message}`);
+}
+export function fail(message) {
+    console.error(`✗ ${message}`);
+    process.exit(1);
+}

package/dist/lib/platform-api.d.ts

@@ -0,0 +1,19 @@
+import type { WorkspaceContext } from './workspace-context.js';
+export declare function listProducts(ctx: WorkspaceContext, status?: string): Promise<unknown[]>;
+export declare function getProduct(ctx: WorkspaceContext, opts: {
+    id?: string;
+    tag?: string;
+}): Promise<unknown>;
+export declare function createProduct(ctx: WorkspaceContext, body: Record<string, unknown>): Promise<unknown>;
+export declare function updateProduct(ctx: WorkspaceContext, tag: string, body: Record<string, unknown>): Promise<unknown>;
+export declare function deleteProduct(ctx: WorkspaceContext, productId: string): Promise<unknown>;
+export declare function listProductApps(ctx: WorkspaceContext, productId: string): Promise<unknown[]>;
+export declare function listApps(ctx: WorkspaceContext, status?: string): Promise<unknown[]>;
+export declare function getApp(ctx: WorkspaceContext, opts: {
+    id?: string;
+    tag?: string;
+}): Promise<unknown>;
+export declare function createApp(ctx: WorkspaceContext, body: Record<string, unknown>): Promise<unknown>;
+export declare function updateApp(ctx: WorkspaceContext, appId: string, body: Record<string, unknown>): Promise<unknown>;
+export declare function updateAppViaProxy(ctx: WorkspaceContext, tag: string, body: Record<string, unknown>): Promise<unknown>;
+export declare function deleteApp(ctx: WorkspaceContext, appId: string): Promise<unknown>;

package/dist/lib/platform-api.js

@@ -0,0 +1,123 @@
+import { ApiClient } from './api-client.js';
+import { createSdkProxyClient } from './proxy/sdk-proxy.js';
+import { workspaceAuthQuery } from './workspace-context.js';
+function client(ctx) {
+    return ApiClient.forProfile(ctx.profile, ctx.credentials);
+}
+function proxy(ctx) {
+    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(result) {
+    if (Array.isArray(result))
+        return result;
+    if (result && typeof result === 'object' && Array.isArray(result.data)) {
+        return result.data;
+    }
+    return [];
+}
+function unwrapOne(result) {
+    if (result && typeof result === 'object' && 'data' in result) {
+        return result.data;
+    }
+    return result;
+}
+// —— Products (integrations REST + sdk-proxy for update) ——
+export async function listProducts(ctx, status = 'all') {
+    const result = await client(ctx).getPath(`/integrations/v1/workspace/${ctx.workspaceId}/${status}`, workspaceAuthQuery(ctx));
+    return unwrapList(result);
+}
+export async function getProduct(ctx, opts) {
+    const q = workspaceAuthQuery(ctx);
+    if (opts.id) {
+        const result = await client(ctx).getPath(`/integrations/v1/${opts.id}`, q);
+        return unwrapOne(result);
+    }
+    if (opts.tag) {
+        const result = await client(ctx).getPath(`/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, body) {
+    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('/integrations/v1/create', payload);
+    return unwrapOne(result);
+}
+export async function updateProduct(ctx, tag, body) {
+    return proxy(ctx).execute('product', 'update', [tag, body]);
+}
+export async function deleteProduct(ctx, productId) {
+    return client(ctx).delete(`/integrations/v1/${productId}?${new URLSearchParams(workspaceAuthQuery(ctx)).toString()}`);
+}
+export async function listProductApps(ctx, productId) {
+    const result = await client(ctx).getPath(`/integrations/v1/fetch-product-apps/${productId}`, workspaceAuthQuery(ctx));
+    return unwrapList(result);
+}
+// —— Apps (apps REST) ——
+export async function listApps(ctx, status = 'all') {
+    const result = await client(ctx).getPath(`/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, opts) {
+    const q = {
+        user_id: ctx.credentials.user_id,
+        public_key: ctx.credentials.public_key,
+    };
+    if (opts.id) {
+        const result = await client(ctx).getPath(`/apps/v1/${opts.id}`, q);
+        return unwrapOne(result);
+    }
+    if (opts.tag) {
+        const result = await client(ctx).getPath(`/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, body) {
+    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('/apps/v1/create', payload);
+    return unwrapOne(result);
+}
+export async function updateApp(ctx, appId, body) {
+    const q = {
+        user_id: ctx.credentials.user_id,
+        public_key: ctx.credentials.public_key,
+    };
+    const result = await client(ctx).put(`/apps/v1/${appId}?${new URLSearchParams(q).toString()}`, body);
+    return unwrapOne(result);
+}
+export async function updateAppViaProxy(ctx, tag, body) {
+    return proxy(ctx).execute('app', 'update', [tag, body]);
+}
+export async function deleteApp(ctx, appId) {
+    const q = {
+        user_id: ctx.credentials.user_id,
+        public_key: ctx.credentials.public_key,
+    };
+    return client(ctx).delete(`/apps/v1/${appId}?${new URLSearchParams(q).toString()}`);
+}

package/dist/lib/proxy/context.d.ts

@@ -0,0 +1,16 @@
+import { type Credentials, type ResolvedProjectConfig } from '../config.js';
+import { 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 declare function requireCredentials(): Credentials;
+export declare function requireSession(): SessionContext;
+export declare function getSdkProxy(session?: SessionContext): SdkProxyClient;
+export declare function getDbProxy(session?: SessionContext): DbProxyClient;
+export declare function getDbContext(session?: SessionContext): import("../context-store.js").DatabaseContext;
+export declare function getGraphProxy(session?: SessionContext): GraphProxyClient;
+export declare function getOptionalProject(): ResolvedProjectConfig | null;

package/dist/lib/proxy/context.js

@@ -0,0 +1,73 @@
+import { findProjectConfig, getActiveProfileName, getApiUrl, loadCredentials, loadProjectConfig, } from '../config.js';
+import { loadRuntimeContext } from '../context-store.js';
+import { createSdkProxyClient } from './sdk-proxy.js';
+import { DbProxyClient } from './db-proxy.js';
+import { GraphProxyClient } from './graph-proxy.js';
+export function requireCredentials() {
+    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() {
+    const credentials = requireCredentials();
+    const project = loadProjectConfig();
+    const profile = getActiveProfileName(project);
+    const apiUrl = getApiUrl(profile);
+    return { credentials, project, apiUrl };
+}
+export function getSdkProxy(session) {
+    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) {
+    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) {
+    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) {
+    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() {
+    const found = findProjectConfig();
+    if (!found)
+        return null;
+    try {
+        return loadProjectConfig();
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/proxy/db-proxy.d.ts

@@ -0,0 +1,13 @@
+import type { DatabaseContext } from '../context-store.js';
+export interface DbProxyContext {
+    apiUrl: string;
+    workspaceId: string;
+    userId: string;
+    publicKey: string;
+    token: string;
+}
+export declare class DbProxyClient {
+    private readonly ctx;
+    constructor(ctx: DbProxyContext);
+    execute<T>(method: string, params: unknown[], databaseContext?: DatabaseContext | null): Promise<T>;
+}