@ductape/cli 0.2.0

package/dist/lib/proxy/db-proxy.js

@@ -0,0 +1,28 @@
+import { encryptProxyPayload } from '../encryption.js';
+import { postProxyJson } from '../http.js';
+export class DbProxyClient {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    async execute(method, params, databaseContext) {
+        const sensitive = {
+            method,
+            params,
+            user_id: this.ctx.userId,
+        };
+        if (databaseContext)
+            sensitive.database_context = databaseContext;
+        const encrypted_payload = encryptProxyPayload(sensitive, this.ctx.publicKey);
+        const body = {
+            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(url, body, { 'x-access-token': this.ctx.token });
+    }
+}

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

@@ -0,0 +1,19 @@
+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 declare class GraphProxyClient {
+    private readonly ctx;
+    constructor(ctx: GraphProxyContext);
+    setGraphContext(context: GraphContext | null): void;
+    execute<T>(method: string, params?: unknown[], graphContext?: GraphContext | null): Promise<T>;
+}

package/dist/lib/proxy/graph-proxy.js

@@ -0,0 +1,43 @@
+import { encryptProxyPayload } from '../encryption.js';
+import { postProxyJson } from '../http.js';
+export class GraphProxyClient {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    setGraphContext(context) {
+        this.ctx.graphContext = context;
+    }
+    async execute(method, params = [], graphContext) {
+        const ctx = graphContext ?? this.ctx.graphContext;
+        const sensitive = {
+            method,
+            params,
+            user_id: this.ctx.userId,
+        };
+        if (ctx)
+            sensitive.graph_context = ctx;
+        const encrypted_payload = encryptProxyPayload(sensitive, this.ctx.publicKey);
+        const body = {
+            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(url, body, {
+            'x-access-token': this.ctx.token,
+        });
+        if (method === 'connect' && params[0] && typeof params[0] === 'object') {
+            const cfg = params[0];
+            this.setGraphContext({
+                graph: cfg.graph,
+                env: cfg.env,
+                product: cfg.product,
+            });
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,14 @@
+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 declare class SdkProxyClient {
+    private readonly ctx;
+    constructor(ctx: SdkProxyContext);
+    execute<T>(module: SDKModule, method: string, params?: unknown[]): Promise<T>;
+}
+export declare function createSdkProxyClient(ctx: SdkProxyContext): SdkProxyClient;

package/dist/lib/proxy/sdk-proxy.js

@@ -0,0 +1,22 @@
+import { encryptProxyPayload } from '../encryption.js';
+import { postProxyJson } from '../http.js';
+export class SdkProxyClient {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    async execute(module, method, params = []) {
+        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(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) {
+    return new SdkProxyClient(ctx);
+}

package/dist/lib/read-body.d.ts

@@ -0,0 +1,11 @@
+import { type InteractiveOpts } from './forms/index.js';
+import type { FormSchema } from './forms/types.js';
+export declare function readJsonBody(filePath?: string): unknown;
+export declare function resolveBody(opts: InteractiveOpts & {
+    file?: string;
+    schemaKey?: string;
+    schema?: FormSchema;
+    patch?: boolean;
+    requireBody?: boolean;
+}): Promise<Record<string, unknown> | undefined>;
+export declare function bodyRequiredHint(schemaKey?: string): string;

package/dist/lib/read-body.js

@@ -0,0 +1,38 @@
+import fs from 'node:fs';
+import { getFormSchema, isInteractive, promptForm, } from './forms/index.js';
+export function readJsonBody(filePath) {
+    if (!filePath)
+        return undefined;
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+}
+function asRecord(value) {
+    if (value === undefined)
+        return undefined;
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    throw new Error('Body must be a JSON object');
+}
+export async function resolveBody(opts) {
+    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) {
+    const json = 'Pass -f <file.json> or run interactively (TTY)';
+    if (schemaKey)
+        return `${json} — schema: ${schemaKey}`;
+    return json;
+}

package/dist/lib/resources.d.ts

@@ -0,0 +1,12 @@
+import type { SDKModule } from './proxy/sdk-proxy.js';
+/** CLI resource type → sdk-proxy module */
+export declare const RESOURCE_MODULES: Record<string, SDKModule>;
+export type CrudVerb = 'create' | 'list' | 'get' | 'update' | 'delete' | 'connect';
+export declare function resolveResourceType(name: string): SDKModule;
+export declare function proxyMethodForVerb(verb: CrudVerb): string;
+/** Build params array matching Workbench sdkProxy.ts conventions */
+export declare function buildCrudParams(module: SDKModule, method: string, productTag: string, args: {
+    tag?: string;
+    body?: unknown;
+}): unknown[];
+export declare function listResourceTypes(): string[];

package/dist/lib/resources.js

@@ -0,0 +1,147 @@
+/** CLI resource type → sdk-proxy module */
+export const RESOURCE_MODULES = {
+    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 function resolveResourceType(name) {
+    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) {
+    if (verb === 'get')
+        return 'fetch';
+    return verb;
+}
+/** Build params array matching Workbench sdkProxy.ts conventions */
+export function buildCrudParams(module, method, productTag, args) {
+    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 }
+                : { product: productTag };
+            return [payload];
+        }
+    }
+    if (module === 'storage' && method === 'create') {
+        const payload = body && typeof body === 'object'
+            ? { product: productTag, ...body }
+            : { 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 }
+            : { product: productTag };
+        return [payload];
+    }
+    throw new Error(`Unsupported operation ${module}.${method}`);
+}
+export function listResourceTypes() {
+    return [
+        'storage',
+        'databases',
+        'graph',
+        'vector',
+        'caches',
+        'jobs',
+        'features',
+        'actions',
+        'notifications',
+        'message-brokers',
+        'sessions',
+        'secrets',
+        'quotas',
+        'health',
+        'fallback',
+        'product',
+        'app',
+    ];
+}

package/dist/lib/snippets.d.ts

@@ -0,0 +1,6 @@
+export declare function ensureSupportedSnippetOperation(operationFamily: string, method: string): void;
+export declare function buildTypeScriptSnippet(payload: Record<string, unknown>, operationFamily: string, method: string): string;
+export declare function buildPythonSnippet(payload: Record<string, unknown>, operationFamily: string, method: string): string;
+export declare function buildGoSnippet(payload: Record<string, unknown>, operationFamily: string, method: string): string;
+export declare function buildDotnetSnippet(payload: Record<string, unknown>, operationFamily: string, method: string): string;
+export declare function buildSnippet(language: 'typescript' | 'python' | 'go' | 'dotnet', payload: Record<string, unknown>, operationFamily: string, method: string): string;

package/dist/lib/snippets.js

@@ -0,0 +1,146 @@
+const ALLOWED_SNIPPET_METHODS = {
+    action: ['run', 'dispatch', 'execute'],
+    workflow: ['run', 'dispatch', 'execute'],
+    database: ['dispatch', 'find', 'insert', 'update', 'delete', 'query', 'upsert', 'count', 'aggregate'],
+    graph: ['dispatch', 'find', 'insert', 'update', 'delete', 'query', 'execute'],
+    vector: ['query', 'find', 'findSimilar', 'upsert', 'insert', 'delete', 'dispatch'],
+    storage: ['dispatch', 'upload', 'download', 'remove', 'listFiles', 'getSignedUrl', 'stats'],
+    notification: ['dispatch', 'send', 'email.send', 'push.send', 'sms.send', 'callback.send'],
+    messaging: ['dispatch', 'send', 'publish', 'produce', 'consume'],
+    broker: ['dispatch', 'send', 'publish', 'produce', 'consume'],
+    quota: ['run', 'dispatch', 'check', 'consume'],
+    fallback: ['run', 'dispatch'],
+    healthcheck: ['run', 'check', 'status'],
+    health: ['run', 'check', 'status'],
+    session: ['start', 'verify', 'refresh', 'revoke', 'listActive'],
+    cache: ['get', 'set', 'clear', 'clearAll', 'dispatch', 'fetchValues'],
+};
+export function ensureSupportedSnippetOperation(operationFamily, method) {
+    const family = operationFamily.toLowerCase();
+    const allowed = ALLOWED_SNIPPET_METHODS[family] ?? [];
+    if (!allowed.includes(method)) {
+        throw new Error(`Unsupported snippet operation "${family}.${method}". Allowed: ${allowed.join(', ') || '(none)'}`);
+    }
+}
+function resolveSdkCallPath(operationFamily, method) {
+    const family = operationFamily.toLowerCase();
+    const m = method.toLowerCase();
+    if (family === 'action')
+        return `actions.${m}`;
+    if (family === 'workflow')
+        return `workflows.${m}`;
+    if (family === 'database')
+        return m === 'dispatch' ? 'databases.dispatch' : `databases.${m}`;
+    if (family === 'graph')
+        return m === 'dispatch' ? 'graph.dispatch' : `graph.${m}`;
+    if (family === 'vector')
+        return `vector.${m}`;
+    if (family === 'storage')
+        return m === 'dispatch' ? 'storage.dispatch' : `storage.${m}`;
+    if (family === 'notification')
+        return m === 'dispatch' ? 'notifications.dispatch' : `notifications.${m}`;
+    if (family === 'messaging' || family === 'broker') {
+        if (m === 'dispatch')
+            return 'messageBrokers.dispatch';
+        if (m === 'send' || m === 'publish' || m === 'produce')
+            return 'messageBrokers.produce';
+        return `messageBrokers.${m}`;
+    }
+    if (family === 'quota')
+        return `quotas.${m}`;
+    if (family === 'fallback')
+        return `fallback.${m}`;
+    if (family === 'healthcheck' || family === 'health')
+        return `health.${m}`;
+    if (family === 'session')
+        return `sessions.${m}`;
+    if (family === 'cache')
+        return (m === 'dispatch' ? 'caches.dispatch' : `caches.${m}`);
+    return `${family}.${m}`;
+}
+function buildInvocationArgs(payload) {
+    const input = payload.input ?? {};
+    return {
+        product: payload.product_tag,
+        env: payload.env,
+        ...input,
+        ...(payload.session ? { session: payload.session } : {}),
+        ...(payload.cache ? { cache: payload.cache } : {}),
+    };
+}
+function prettyJson(v) {
+    return JSON.stringify(v ?? {}, null, 2);
+}
+export function buildTypeScriptSnippet(payload, operationFamily, method) {
+    const callPath = resolveSdkCallPath(operationFamily, method);
+    const args = buildInvocationArgs(payload);
+    return `import Ductape from '@ductape/sdk';
+
+const ductape = new Ductape({
+  publishableKey: process.env.DUCTAPE_PUBLISHABLE_KEY!,
+  product: process.env.DUCTAPE_PRODUCT!,
+  env: process.env.DUCTAPE_ENV!,
+});
+
+async function main() {
+  const result = await ductape.${callPath}(${prettyJson(args)});
+  console.log(JSON.stringify(result, null, 2));
+}
+
+main().catch(console.error);
+`;
+}
+export function buildPythonSnippet(payload, operationFamily, method) {
+    const callPath = resolveSdkCallPath(operationFamily, method).replace(/\./g, '_');
+    const args = buildInvocationArgs(payload);
+    return `import os
+import json
+from ductape import Ductape
+
+ductape = Ductape(
+    publishable_key=os.environ["DUCTAPE_PUBLISHABLE_KEY"],
+    product=os.environ["DUCTAPE_PRODUCT"],
+    env=os.environ["DUCTAPE_ENV"],
+)
+
+def main():
+    args = ${prettyJson(args)}
+    result = ductape.${callPath}(args)
+    print(json.dumps(result, indent=2))
+
+if __name__ == "__main__":
+    main()
+`;
+}
+export function buildGoSnippet(payload, operationFamily, method) {
+    const callPath = resolveSdkCallPath(operationFamily, method);
+    return `package main
+
+// go get github.com/ductape/ductape/sdk/go
+// See https://docs.ductape.app for ${operationFamily}.${method}
+// Payload preview:
+// ${prettyJson(payload).split('\n').join('\n// ')}
+func main() {
+    // ductape.${callPath}(...)
+}
+`;
+}
+export function buildDotnetSnippet(payload, operationFamily, method) {
+    const callPath = resolveSdkCallPath(operationFamily, method);
+    return `// dotnet add package Ductape.Sdk
+// Operation: ${operationFamily}.${method} -> ${callPath}
+// Payload: ${JSON.stringify(payload)}
+`;
+}
+export function buildSnippet(language, payload, operationFamily, method) {
+    switch (language) {
+        case 'python':
+            return buildPythonSnippet(payload, operationFamily, method);
+        case 'go':
+            return buildGoSnippet(payload, operationFamily, method);
+        case 'dotnet':
+            return buildDotnetSnippet(payload, operationFamily, method);
+        default:
+            return buildTypeScriptSnippet(payload, operationFamily, method);
+    }
+}

package/dist/lib/templates.d.ts

@@ -0,0 +1,3 @@
+export type InitLanguage = 'typescript' | 'python' | 'go' | 'dotnet' | 'unknown';
+export declare function detectLanguage(dir: string): InitLanguage;
+export declare function writeInitArtifacts(dir: string, lang: InitLanguage): void;

package/dist/lib/templates.js

@@ -0,0 +1,74 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_ROOT = path.resolve(__dirname, '../../templates');
+export function detectLanguage(dir) {
+    if (fs.existsSync(path.join(dir, 'package.json')))
+        return 'typescript';
+    if (fs.existsSync(path.join(dir, 'pyproject.toml')) || fs.existsSync(path.join(dir, 'requirements.txt'))) {
+        return 'python';
+    }
+    if (fs.existsSync(path.join(dir, 'go.mod')))
+        return 'go';
+    try {
+        if (fs.readdirSync(dir).some((f) => f.endsWith('.csproj')))
+            return 'dotnet';
+    }
+    catch {
+        /* ignore */
+    }
+    return 'unknown';
+}
+function copyTemplate(lang, targetDir) {
+    const map = {
+        typescript: { src: 'typescript/ductape.example.ts', dest: 'ductape.example.ts' },
+        python: { src: 'python/ductape_example.py', dest: 'ductape_example.py' },
+        go: { src: 'go/main.go', dest: 'ductape_example.go' },
+        dotnet: { src: 'dotnet/Program.cs', dest: 'DuctapeExample.cs' },
+        unknown: null,
+    };
+    const entry = map[lang];
+    if (!entry)
+        return;
+    const srcPath = path.join(TEMPLATES_ROOT, entry.src);
+    const destPath = path.join(targetDir, entry.dest);
+    if (!fs.existsSync(destPath) && fs.existsSync(srcPath)) {
+        fs.copyFileSync(srcPath, destPath);
+    }
+}
+export function writeInitArtifacts(dir, lang) {
+    const envContent = `# Ductape — credentials from Workbench → SDK Access
+DUCTAPE_ACCESS_KEY=
+# Passed to new Ductape({ accessKey, product, env }) — constructor is the only place for product/env defaults
+DUCTAPE_PRODUCT=
+DUCTAPE_ENV=dev
+`;
+    const envPath = path.join(dir, '.env.ductape.example');
+    if (!fs.existsSync(envPath))
+        fs.writeFileSync(envPath, envContent);
+    const ductapeDir = path.join(dir, '.ductape');
+    fs.mkdirSync(ductapeDir, { recursive: true });
+    const readme = `# Ductape project
+
+Linked via \`ductape link\`. Manage resources with:
+
+\`\`\`bash
+ductape resources storage list
+ductape resources databases create -f database.json
+\`\`\`
+
+Docs: https://docs.ductape.app/docs/cli/
+`;
+    const readmePath = path.join(ductapeDir, 'README.md');
+    if (!fs.existsSync(readmePath))
+        fs.writeFileSync(readmePath, readme);
+    copyTemplate(lang, dir);
+    const gitignorePath = path.join(dir, '.gitignore');
+    if (fs.existsSync(gitignorePath)) {
+        const gi = fs.readFileSync(gitignorePath, 'utf8');
+        if (!gi.includes('.env') && !gi.includes('.env.local')) {
+            fs.appendFileSync(gitignorePath, '\n.env\n.env.local\n');
+        }
+    }
+}

package/dist/lib/workspace-context.d.ts

@@ -0,0 +1,12 @@
+import { type Credentials } from './config.js';
+export interface WorkspaceContext {
+    credentials: Credentials;
+    workspaceId: string;
+    apiUrl: string;
+    profile: string;
+}
+export declare function requireWorkspaceContext(opts?: {
+    profile?: string;
+}): WorkspaceContext;
+/** Query params required by integrations/apps REST endpoints (matches Workbench). */
+export declare function workspaceAuthQuery(ctx: WorkspaceContext, extra?: Record<string, string>): Record<string, string>;

package/dist/lib/workspace-context.js

@@ -0,0 +1,25 @@
+import { getActiveProfileName, getActiveWorkspaceId, getApiUrl, } from './config.js';
+import { requireCredentials } from './proxy/context.js';
+export function requireWorkspaceContext(opts) {
+    const credentials = requireCredentials();
+    const workspaceId = getActiveWorkspaceId();
+    if (!workspaceId) {
+        throw new Error('No active workspace. Run: ductape login or ductape workspaces use');
+    }
+    const profile = opts?.profile ?? getActiveProfileName(null);
+    return {
+        credentials,
+        workspaceId,
+        apiUrl: getApiUrl(profile),
+        profile,
+    };
+}
+/** Query params required by integrations/apps REST endpoints (matches Workbench). */
+export function workspaceAuthQuery(ctx, extra) {
+    return {
+        user_id: ctx.credentials.user_id,
+        public_key: ctx.credentials.public_key,
+        workspace_id: ctx.workspaceId,
+        ...extra,
+    };
+}

package/dist/lib/workspaces.d.ts

@@ -0,0 +1,45 @@
+/** Workspace entry from login or workspaces API (field names vary). */
+export interface WorkspaceSummary {
+    workspace_id?: string;
+    workspace_name?: string;
+    _id?: string;
+    name?: string;
+    tag?: string;
+    default?: boolean;
+    accepted?: boolean;
+}
+export declare function workspaceId(w: WorkspaceSummary): string;
+export declare function workspaceLabel(w: WorkspaceSummary): string;
+/** Human-readable workspace tag for .ductape/config.json (slug of name, or explicit tag). */
+export declare function workspaceTag(w: WorkspaceSummary): string;
+export declare function slugifyTag(value: string): string;
+export declare function normalizeWorkspaces(raw: unknown[]): WorkspaceSummary[];
+export declare function getActiveWorkspace(): {
+    id: string;
+    name?: string;
+    tag?: string;
+} | null;
+export declare function setActiveWorkspace(id: string, name?: string, tag?: string): void;
+export declare function clearActiveWorkspace(): void;
+export declare function fetchWorkspaces(profile?: string): Promise<WorkspaceSummary[]>;
+export declare function findWorkspace(workspaces: WorkspaceSummary[], selector: string): WorkspaceSummary | undefined;
+export declare function printWorkspaceTable(workspaces: WorkspaceSummary[], activeId?: string | null): void;
+export declare function promptWorkspaceSelection(workspaces: WorkspaceSummary[], opts?: {
+    message?: string;
+}): Promise<WorkspaceSummary>;
+export declare function applyActiveWorkspace(workspace: WorkspaceSummary, opts?: {
+    syncProject?: boolean;
+    dir?: string;
+}): Promise<void>;
+export declare function selectAndApplyWorkspace(opts?: {
+    profile?: string;
+    selector?: string;
+    skipPrompt?: boolean;
+    syncProject?: boolean;
+    dir?: string;
+}): Promise<WorkspaceSummary>;
+export declare function finalizeLoginWorkspace(opts?: {
+    profile?: string;
+    workspace?: string;
+    skipPrompt?: boolean;
+}): Promise<void>;