@ductape/cli 0.2.0

package/dist/commands/workspaces.d.ts

@@ -0,0 +1,16 @@
+export declare function runWorkspacesList(opts: {
+    profile?: string;
+    json?: boolean;
+    refresh?: boolean;
+}): Promise<void>;
+export declare function runWorkspacesCurrent(json: boolean): void;
+export declare function runWorkspacesUse(selector: string | undefined, opts: {
+    profile?: string;
+    dir?: string;
+    json?: boolean;
+}): Promise<void>;
+/** Refresh workspace list from API and update login cache */
+export declare function runWorkspacesRefresh(opts: {
+    profile?: string;
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/workspaces.js

@@ -0,0 +1,72 @@
+import { applyActiveWorkspace, fetchWorkspaces, getActiveWorkspace, printWorkspaceTable, promptWorkspaceSelection, selectAndApplyWorkspace, workspaceId, workspaceLabel, } from '../lib/workspaces.js';
+import { printJson, success } from '../lib/output.js';
+export async function runWorkspacesList(opts) {
+    const workspaces = await fetchWorkspaces(opts.profile);
+    const active = getActiveWorkspace();
+    if (opts.json) {
+        printJson({
+            active_workspace_id: active?.id ?? null,
+            active_workspace_name: active?.name ?? null,
+            workspaces,
+        }, true);
+        return;
+    }
+    if (active) {
+        console.log(`Active workspace: ${active.name ?? active.id}`);
+        console.log(`  ${active.id}\n`);
+    }
+    printWorkspaceTable(workspaces, active?.id);
+}
+export function runWorkspacesCurrent(json) {
+    const active = getActiveWorkspace();
+    if (!active) {
+        if (json) {
+            printJson({ active: null }, true);
+            return;
+        }
+        console.log('No active workspace. Run: ductape login or ductape workspaces use');
+        return;
+    }
+    if (json) {
+        printJson({ active_workspace_id: active.id, active_workspace_name: active.name }, true);
+        return;
+    }
+    console.log(`Active workspace: ${active.name ?? active.id}`);
+    console.log(`  ${active.id}`);
+}
+export async function runWorkspacesUse(selector, opts) {
+    const workspaces = await fetchWorkspaces(opts.profile);
+    let chosen;
+    if (!selector) {
+        chosen = await promptWorkspaceSelection(workspaces, {
+            message: 'Switch workspace:',
+        });
+        await applyActiveWorkspace(chosen, { syncProject: true, dir: opts.dir });
+    }
+    else {
+        chosen = await selectAndApplyWorkspace({
+            profile: opts.profile,
+            selector,
+            skipPrompt: true,
+            syncProject: true,
+            dir: opts.dir,
+        });
+    }
+    const id = workspaceId(chosen);
+    const name = workspaceLabel(chosen);
+    if (opts.json) {
+        printJson({ active_workspace_id: id, active_workspace_name: name }, true);
+        return;
+    }
+    success(`Switched to workspace: ${name} (${id})`);
+}
+/** Refresh workspace list from API and update login cache */
+export async function runWorkspacesRefresh(opts) {
+    const workspaces = await fetchWorkspaces(opts.profile);
+    if (opts.json) {
+        printJson({ workspaces, count: workspaces.length }, true);
+        return;
+    }
+    success(`Refreshed ${workspaces.length} workspace(s) from API`);
+    await runWorkspacesList({ profile: opts.profile, json: false });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { runLogin } from './commands/login.js';
+import { runLogout } from './commands/logout.js';
+import { runWhoami } from './commands/whoami.js';
+import { runProfilesList, runProfilesUse } from './commands/profiles.js';
+import { runLink } from './commands/link.js';
+import { runUnlink } from './commands/unlink.js';
+import { runInit } from './commands/init.js';
+import { runInstall } from './commands/install.js';
+import { runStart, runStop, runStatus } from './commands/platform.js';
+import { runResourceCrud, runResourcesList } from './commands/resources.js';
+import { runCloud } from './commands/cloud.js';
+import { runDb, runDbContext } from './commands/db.js';
+import { runGraph } from './commands/graph.js';
+import { runSecrets } from './commands/secrets.js';
+import { runWorkspacesCurrent, runWorkspacesList, runWorkspacesRefresh, runWorkspacesUse, } from './commands/workspaces.js';
+import { runGeneratePayload, runGenerateSnippet } from './commands/generate.js';
+import { runCompletion } from './commands/completion.js';
+import { runProducts, runProductApps } from './commands/products.js';
+import { runApps } from './commands/apps.js';
+import { runAppsImport } from './commands/apps-import.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(path.join(__dirname, '../package.json'), 'utf8'));
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function wrap(fn) {
+    return (...args) => {
+        Promise.resolve(fn(...args)).catch((err) => {
+            console.error(err instanceof Error ? err.message : err);
+            process.exit(1);
+        });
+    };
+}
+const program = new Command();
+program
+    .name('ductape')
+    .description('Ductape CLI — local platform, auth, project linking, and resource CRUD via Workbench-compatible encrypted proxy')
+    .version(pkg.version);
+program
+    .command('login')
+    .description('Log in (email/password, OAuth token, or browser OAuth)')
+    .option('-e, --email <email>')
+    .option('-p, --password <password>')
+    .option('--token <token>', 'OAuth callback token from browser redirect URL')
+    .option('--browser [provider]', 'Open browser for Google OAuth (google|github)')
+    .option('--profile <name>', 'API profile', 'cloud')
+    .option('-w, --workspace <id>', 'Workspace index, name, or id (skips interactive picker)')
+    .option('--skip-workspace-select', 'Keep prior active workspace or default without prompting')
+    .action(wrap((opts) => runLogin({
+    email: opts.email,
+    password: opts.password,
+    profile: opts.profile,
+    token: opts.token,
+    browser: opts.browser === true ? 'google' : opts.browser,
+    workspace: opts.workspace,
+    skipWorkspaceSelect: Boolean(opts.skipWorkspaceSelect),
+})));
+program.command('logout').description('Clear local credentials').action(wrap(runLogout));
+program
+    .command('whoami')
+    .description('Show login and linked project')
+    .option('--json', 'JSON output')
+    .action(wrap((opts) => runWhoami(Boolean(opts.json))));
+program
+    .command('install')
+    .description('Check Docker/Node prerequisites and prepare platform .env')
+    .action(wrap(runInstall));
+const profiles = program.command('profiles').description('Manage API profiles (cloud / local)');
+profiles
+    .command('list')
+    .option('--json', 'JSON output')
+    .action(wrap((opts) => runProfilesList(Boolean(opts.json))));
+profiles.command('use <name>').action(wrap((name) => runProfilesUse(name)));
+const workspaces = program
+    .command('workspaces')
+    .description('List and switch active workspace (workspace_id is stored globally at login)');
+workspaces
+    .command('list')
+    .description('List workspaces (marks active)')
+    .option('--profile <name>')
+    .option('--json', 'JSON output')
+    .action(wrap((opts) => runWorkspacesList({ profile: opts.profile, json: opts.json })));
+workspaces
+    .command('current')
+    .description('Show active workspace')
+    .option('--json', 'JSON output')
+    .action(wrap((opts) => runWorkspacesCurrent(Boolean(opts.json))));
+workspaces
+    .command('use [selector]')
+    .description('Switch active workspace (interactive picker). Updates linked .ductape/config.json if present')
+    .option('--profile <name>')
+    .option('-C, --dir <path>', 'Project directory to sync', process.cwd())
+    .option('--json', 'JSON output')
+    .action(wrap((selector, opts) => runWorkspacesUse(selector, opts)));
+workspaces
+    .command('switch [selector]')
+    .description('Alias for workspaces use')
+    .option('--profile <name>')
+    .option('-C, --dir <path>', 'Project directory to sync', process.cwd())
+    .option('--json', 'JSON output')
+    .action(wrap((selector, opts) => runWorkspacesUse(selector, opts)));
+workspaces
+    .command('refresh')
+    .description('Refresh workspace list from API')
+    .option('--profile <name>')
+    .option('--json', 'JSON output')
+    .action(wrap((opts) => runWorkspacesRefresh(opts)));
+program
+    .command('link')
+    .option('-w, --workspace <id>')
+    .option('--product <tag>')
+    .option('--env <slug>')
+    .option('--profile <name>')
+    .option('-C, --dir <path>', 'Project directory', process.cwd())
+    .action(wrap((opts) => runLink({
+    workspace: opts.workspace,
+    product: opts.product,
+    env: opts.env,
+    profile: opts.profile,
+    dir: opts.dir,
+})));
+program
+    .command('unlink')
+    .option('-C, --dir <path>', 'Project directory', process.cwd())
+    .action(wrap((opts) => runUnlink({ dir: opts.dir })));
+program
+    .command('init')
+    .option('--link', 'Run link after init')
+    .option('-w, --workspace <id>')
+    .option('--product <tag>')
+    .option('--env <slug>')
+    .option('--language <lang>', 'typescript|python|go|dotnet')
+    .action(wrap((opts) => runInit({
+    link: Boolean(opts.link),
+    workspace: opts.workspace,
+    product: opts.product,
+    env: opts.env,
+    language: opts.language,
+})));
+program
+    .command('start')
+    .description('Start platform via docker compose')
+    .option('--backend-only', 'Backend without workbench UI')
+    .option('--remote', 'Workbench UI only, built against cloud API (no local Nest/Mongo/Kafka)')
+    .option('--build', 'Build images before start')
+    .action(wrap((opts) => runStart({
+    backendOnly: Boolean(opts.backendOnly),
+    remote: Boolean(opts.remote),
+    build: Boolean(opts.build),
+})));
+program.command('stop').action(wrap(runStop));
+program.command('status').option('--json', 'JSON output').action(wrap((opts) => runStatus(Boolean(opts.json))));
+const products = program
+    .command('products')
+    .description('Workspace products CRUD (REST + sdk-proxy update)');
+products
+    .command('<verb>')
+    .description('list | get | create | update | delete')
+    .option('--profile <name>')
+    .option('--status <status>', 'Filter for list: all, active, draft, …', 'all')
+    .option('--id <id>', 'Product _id (get, delete)')
+    .option('-t, --tag <tag>', 'Product tag (get, update)')
+    .option('-f, --file <path>', 'JSON body (create, update)')
+    .option('-i, --interactive', 'Prompt for fields (default in TTY when -f omitted)')
+    .option('--no-interactive', 'Require -f JSON for create/update')
+    .option('--json', 'JSON output')
+    .action(wrap((verb, opts) => runProducts(verb, opts, [])));
+const productApps = products.command('apps').description('Apps connected to a product');
+productApps
+    .command('list')
+    .option('--profile <name>')
+    .option('--product <id>', 'Product _id')
+    .option('--json', 'JSON output')
+    .action(wrap((opts) => runProductApps('list', opts, [])));
+const apps = program.command('apps').description('Workspace integration apps CRUD (REST)');
+apps
+    .command('<verb>')
+    .description('list | get | create | update | delete')
+    .option('--profile <name>')
+    .option('--status <status>', 'Filter for list', 'all')
+    .option('--id <id>', 'App _id')
+    .option('-t, --tag <tag>', 'App tag (get; update with --proxy)')
+    .option('--proxy', 'Update via sdk-proxy (use with --tag)')
+    .option('-f, --file <path>', 'JSON body')
+    .option('-i, --interactive', 'Prompt for fields (default in TTY when -f omitted)')
+    .option('--no-interactive', 'Require -f JSON for create/update')
+    .option('--json', 'JSON output')
+    .action(wrap((verb, opts) => runApps(verb, opts, [])));
+apps
+    .command('import <file>')
+    .description('Import Postman v2.1 or OpenAPI 3.0 into a new or existing app')
+    .requiredOption('-t, --type <format>', 'postman | openapi (Postman Collection v2.1 or OpenAPI 3.0)')
+    .option('--profile <name>')
+    .option('--app-id <id>', 'Update existing app by _id')
+    .option('--app-tag <tag>', 'Update existing app by tag')
+    .option('--update', 'Replace/update if app already exists')
+    .option('--version <tag>', 'App version tag', '0.0.1')
+    .option('--json', 'JSON output')
+    .action(wrap((file, opts) => runAppsImport(file, {
+    profile: opts.profile,
+    type: opts.type,
+    appId: opts.appId,
+    appTag: opts.appTag,
+    update: Boolean(opts.update),
+    version: opts.version,
+    json: opts.json,
+})));
+const resources = program.command('resources').description('Component CRUD (sdk-proxy)');
+resources.command('types').option('--json', 'JSON output').action(wrap((opts) => runResourcesList(Boolean(opts.json))));
+resources
+    .command('<type> <verb>')
+    .option('-t, --tag <tag>')
+    .option('-f, --file <path>', 'JSON body (or use interactive prompts)')
+    .option('-i, --interactive', 'Prompt for fields (default in TTY when -f omitted)')
+    .option('--no-interactive', 'Require -f JSON for create/update/connect')
+    .option('--json', 'JSON output')
+    .action(wrap((type, verb, opts) => runResourceCrud(type, verb, opts, [])));
+const cloud = program.command('cloud').description('Cloud connections & resources');
+cloud
+    .command('connections <verb> [id]')
+    .option('-f, --file <path>')
+    .option('--json', 'JSON output')
+    .action(wrap((verb, id, opts) => runCloud('connections', verb, { id, file: opts.file, json: opts.json }, [])));
+cloud
+    .command('resources <verb>')
+    .option('-f, --file <path>')
+    .option('--json', 'JSON output')
+    .action(wrap((verb, opts) => runCloud('resources', verb, { file: opts.file, json: opts.json }, [])));
+const db = program.command('db').description('Database runtime (db-proxy)');
+db.command('context').option('--json', 'JSON output').action(wrap((opts) => runDbContext(Boolean(opts.json))));
+db
+    .command('<verb>')
+    .option('-f, --file <path>')
+    .option('--json', 'JSON output')
+    .action(wrap((verb, opts) => runDb(verb, { file: opts.file, json: opts.json })));
+const graph = program.command('graph').description('Graph runtime (graph-proxy)');
+graph
+    .command('<verb>')
+    .option('-f, --file <path>')
+    .option('--json', 'JSON output')
+    .action(wrap((verb, opts) => runGraph(verb, { file: opts.file, json: opts.json })));
+program
+    .command('secrets <verb>')
+    .description('Workspace secrets CRUD')
+    .option('-k, --key <key>')
+    .option('-f, --file <path>')
+    .option('-i, --interactive', 'Prompt for fields (default in TTY when -f omitted)')
+    .option('--no-interactive', 'Require -f JSON for create/update')
+    .option('--json', 'JSON output')
+    .action(wrap((verb, opts) => runSecrets(verb, opts)));
+const generate = program.command('generate').description('Payload templates & code snippets');
+generate
+    .command('payload <family> <method>')
+    .option('-f, --file <path>', 'targets JSON')
+    .option('--json', 'JSON output')
+    .action(wrap((family, method, opts) => runGeneratePayload({ family, method, file: opts.file, json: opts.json })));
+generate
+    .command('snippet <family> <method>')
+    .requiredOption('-l, --language <lang>', 'typescript|python|go|dotnet')
+    .option('-f, --file <path>')
+    .option('-o, --out <path>', 'Write snippet to file')
+    .option('--json', 'JSON output')
+    .action(wrap((family, method, opts) => runGenerateSnippet({
+    family,
+    method,
+    language: opts.language,
+    file: opts.file,
+    json: opts.json,
+    out: opts.out,
+})));
+program
+    .command('completion <shell>')
+    .description('Print shell completions (bash|zsh)')
+    .action(wrap((shell) => {
+    if (shell !== 'bash' && shell !== 'zsh' && shell !== 'fish') {
+        throw new Error('Shell must be bash, zsh, or fish');
+    }
+    runCompletion(shell);
+}));
+program.parse();

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

@@ -0,0 +1,18 @@
+import type { Credentials } from './config.js';
+export interface ApiEnvelope<T> {
+    status?: boolean;
+    data?: T;
+    message?: string;
+}
+export declare class ApiClient {
+    private readonly apiUrl;
+    private readonly token?;
+    constructor(apiUrl: string, token?: string | undefined);
+    static forProfile(profileName?: string, creds?: Credentials | null): ApiClient;
+    request<T>(method: string, path: string, body?: unknown, extraHeaders?: Record<string, string>): Promise<T>;
+    post<T>(path: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    put<T>(path: string, body?: unknown, headers?: Record<string, string>): Promise<T>;
+    delete<T>(path: string, headers?: Record<string, string>): Promise<T>;
+    get<T>(path: string, headers?: Record<string, string>): Promise<T>;
+    getPath<T>(path: string, query?: Record<string, string>): Promise<T>;
+}

package/dist/lib/api-client.js

@@ -0,0 +1,65 @@
+import { getApiUrl } from './config.js';
+export class ApiClient {
+    apiUrl;
+    token;
+    constructor(apiUrl, token) {
+        this.apiUrl = apiUrl;
+        this.token = token;
+    }
+    static forProfile(profileName, creds) {
+        return new ApiClient(getApiUrl(profileName), creds?.auth_token);
+    }
+    async request(method, path, body, extraHeaders) {
+        const url = `${this.apiUrl}${path.startsWith('/') ? path : `/${path}`}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            ...extraHeaders,
+        };
+        if (this.token) {
+            headers.Authorization = `Bearer ${this.token}`;
+        }
+        const res = await fetch(url, {
+            method,
+            headers,
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        const text = await res.text();
+        let parsed;
+        try {
+            parsed = text ? JSON.parse(text) : {};
+        }
+        catch {
+            throw new Error(`Invalid JSON from ${url}: ${text.slice(0, 200)}`);
+        }
+        if (!res.ok) {
+            const msg = parsed.message ??
+                parsed.error ??
+                `HTTP ${res.status}`;
+            throw new Error(msg);
+        }
+        if (typeof parsed.status === 'boolean' && !parsed.status) {
+            throw new Error(parsed.message ?? 'Request failed');
+        }
+        const data = parsed.data;
+        if (data && typeof data === 'object' && 'result' in data) {
+            return data.result;
+        }
+        return (data ?? parsed);
+    }
+    post(path, body, headers) {
+        return this.request('POST', path, body, headers);
+    }
+    put(path, body, headers) {
+        return this.request('PUT', path, body, headers);
+    }
+    delete(path, headers) {
+        return this.request('DELETE', path, undefined, headers);
+    }
+    get(path, headers) {
+        return this.request('GET', path, undefined, headers);
+    }
+    getPath(path, query) {
+        const qs = query ? `?${new URLSearchParams(query).toString()}` : '';
+        return this.get(`${path}${qs}`);
+    }
+}

package/dist/lib/app-import.d.ts

@@ -0,0 +1,15 @@
+import type { WorkspaceContext } from './workspace-context.js';
+/** Values accepted by POST /apps/v1/import `type` field */
+export declare const IMPORT_DOC_TYPES: {
+    readonly postman: "PostmanV2.1";
+    readonly openapi: "OpenApiV3.0";
+};
+export type ImportFormat = keyof typeof IMPORT_DOC_TYPES;
+export declare function parseImportFormat(value: string): ImportFormat;
+export declare function importAppFromFile(ctx: WorkspaceContext, opts: {
+    filePath: string;
+    format: ImportFormat;
+    appId?: string;
+    update?: boolean;
+    version?: string;
+}): Promise<unknown>;

package/dist/lib/app-import.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+import path from 'node:path';
+/** Values accepted by POST /apps/v1/import `type` field */
+export const IMPORT_DOC_TYPES = {
+    postman: 'PostmanV2.1',
+    openapi: 'OpenApiV3.0',
+};
+export function parseImportFormat(value) {
+    const v = value.toLowerCase().replace(/[_\s]/g, '');
+    if (v === 'postman' || v === 'postmanv21' || v === 'postman2.1' || v === 'postmanv2.1') {
+        return 'postman';
+    }
+    if (v === 'openapi' || v === 'openapiv30' || v === 'openapi3.0' || v === 'openapi3') {
+        return 'openapi';
+    }
+    throw new Error(`Unknown import type "${value}". Use: postman (Postman Collection v2.1) or openapi (OpenAPI 3.0)`);
+}
+function uploadFilename(filePath) {
+    const base = path.basename(filePath);
+    if (base.endsWith('.yaml') || base.endsWith('.yml'))
+        return base;
+    if (base.endsWith('.json'))
+        return base;
+    return `${base}.json`;
+}
+export async function importAppFromFile(ctx, opts) {
+    const abs = path.resolve(opts.filePath);
+    if (!fs.existsSync(abs))
+        throw new Error(`File not found: ${abs}`);
+    const buffer = fs.readFileSync(abs);
+    const filename = uploadFilename(abs);
+    const form = new FormData();
+    form.append('file', new Blob([buffer]), filename);
+    form.append('workspace_id', ctx.workspaceId);
+    form.append('public_key', ctx.credentials.public_key);
+    form.append('user_id', ctx.credentials.user_id);
+    form.append('type', IMPORT_DOC_TYPES[opts.format]);
+    form.append('version', opts.version ?? '0.0.1');
+    form.append('update', opts.update ? 'true' : 'false');
+    if (opts.appId)
+        form.append('app_id', opts.appId);
+    const url = `${ctx.apiUrl}/apps/v1/import`;
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${ctx.credentials.auth_token}` },
+        body: form,
+    });
+    const text = await res.text();
+    let parsed;
+    try {
+        parsed = text ? JSON.parse(text) : {};
+    }
+    catch {
+        throw new Error(`Invalid JSON from import API: ${text.slice(0, 200)}`);
+    }
+    if (!res.ok) {
+        throw new Error(parsed.message ?? `Import failed (HTTP ${res.status})`);
+    }
+    if (parsed.status === false) {
+        throw new Error(parsed.message ?? 'Import failed');
+    }
+    return parsed.data ?? parsed;
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,63 @@
+export declare const GLOBAL_DIR: string;
+export declare const CREDENTIALS_PATH: string;
+export declare const GLOBAL_CONFIG_PATH: string;
+export declare const PROJECT_CONFIG_DIR = ".ductape";
+export declare const PROJECT_CONFIG_PATH: string;
+export interface Credentials {
+    user_id: string;
+    email: string;
+    auth_token: string;
+    public_key: string;
+    firstname?: string;
+    lastname?: string;
+    workspaces?: Array<{
+        workspace_id?: string;
+        workspace_name?: string;
+        _id?: string;
+        name?: string;
+        tag?: string;
+        default?: boolean;
+    }>;
+}
+export interface Profile {
+    api_url: string;
+}
+export interface GlobalConfig {
+    default_profile: string;
+    profiles: Record<string, Profile>;
+    /** Set at login or via `ductape workspaces use` */
+    active_workspace_id?: string;
+    active_workspace_name?: string;
+    active_workspace_tag?: string;
+}
+/** Linked project config — use workspace_tag (human-readable); workspace_id is resolved by the CLI. */
+export interface ProjectConfig {
+    workspace_tag?: string;
+    /** Resolved automatically; do not edit unless debugging */
+    workspace_id?: string;
+    product_tag: string;
+    env_slug: string;
+    linked_profile?: string;
+    project_id?: string;
+}
+export interface ResolvedProjectConfig extends ProjectConfig {
+    workspace_id: string;
+}
+export declare function ensureGlobalDir(): void;
+export declare function loadCredentials(): Credentials | null;
+export declare function saveCredentials(creds: Credentials): void;
+export declare function clearCredentials(): void;
+export declare function getActiveWorkspaceId(): string | null;
+export declare function loadGlobalConfig(): GlobalConfig;
+export declare function saveGlobalConfig(config: GlobalConfig): void;
+export declare function getActiveProfileName(project?: ProjectConfig | null): string;
+export declare function getApiUrl(profileName?: string): string;
+/** Resolve workspace_id from tag (cached workspaces), explicit id, or global active workspace. */
+export declare function resolveWorkspaceId(cfg: ProjectConfig, creds?: Credentials | null): string | null;
+export declare function findProjectConfig(startDir?: string): {
+    dir: string;
+    config: ProjectConfig;
+} | null;
+export declare function loadProjectConfig(): ResolvedProjectConfig;
+export declare function saveProjectConfig(dir: string, config: ProjectConfig): void;
+export declare function resolvePlatformDir(): string;