@ductape/cli 0.2.0

package/dist/commands/init.js

@@ -0,0 +1,28 @@
+import { saveProjectConfig } from '../lib/config.js';
+import { detectLanguage, writeInitArtifacts } from '../lib/templates.js';
+import { success } from '../lib/output.js';
+import { runLink } from './link.js';
+export async function runInit(opts) {
+    const dir = process.cwd();
+    const lang = opts.language && ['typescript', 'python', 'go', 'dotnet'].includes(opts.language)
+        ? opts.language
+        : detectLanguage(dir);
+    writeInitArtifacts(dir, lang);
+    if (!opts.link) {
+        const stub = {
+            workspace_tag: '',
+            product_tag: '',
+            env_slug: opts.env ?? 'dev',
+        };
+        saveProjectConfig(dir, stub);
+        success(`Initialized Ductape (${lang}). Run \`ductape link\` to connect workspace/product.`);
+        return;
+    }
+    await runLink({
+        workspace: opts.workspace,
+        product: opts.product,
+        env: opts.env,
+        dir,
+    });
+    success(`Initialized and linked Ductape project (${lang})`);
+}

package/dist/commands/install.d.ts

@@ -0,0 +1 @@
+export declare function runInstall(): void;

package/dist/commands/install.js

@@ -0,0 +1,42 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolvePlatformDir } from '../lib/config.js';
+import { success } from '../lib/output.js';
+function checkCommand(cmd, args) {
+    const r = spawnSync(cmd, args, { stdio: 'ignore' });
+    return r.status === 0;
+}
+export function runInstall() {
+    const issues = [];
+    if (!checkCommand('docker', ['--version'])) {
+        issues.push('Docker is not installed or not on PATH');
+    }
+    else if (!checkCommand('docker', ['compose', 'version'])) {
+        issues.push('Docker Compose v2 is required (docker compose)');
+    }
+    if (!checkCommand('node', ['--version'])) {
+        issues.push('Node.js 18+ is recommended for running the CLI');
+    }
+    let platformDir;
+    try {
+        platformDir = resolvePlatformDir();
+    }
+    catch (e) {
+        issues.push(e instanceof Error ? e.message : String(e));
+        platformDir = '';
+    }
+    if (platformDir) {
+        const envExample = path.join(platformDir, '.env.example');
+        const envFile = path.join(platformDir, '.env');
+        if (fs.existsSync(envExample) && !fs.existsSync(envFile)) {
+            fs.copyFileSync(envExample, envFile);
+            success(`Created ${envFile} from .env.example`);
+        }
+    }
+    if (issues.length > 0) {
+        console.error('Install check failed:\n' + issues.map((i) => `  - ${i}`).join('\n'));
+        process.exit(1);
+    }
+    success('Prerequisites OK. Run `ductape start` to launch the local platform.');
+}

package/dist/commands/link.d.ts

@@ -0,0 +1,7 @@
+export declare function runLink(opts: {
+    workspace?: string;
+    product?: string;
+    env?: string;
+    profile?: string;
+    dir?: string;
+}): Promise<void>;

package/dist/commands/link.js

@@ -0,0 +1,61 @@
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import path from 'node:path';
+import { loadCredentials, saveProjectConfig, } from '../lib/config.js';
+import { fetchWorkspaces, findWorkspace, getActiveWorkspace, promptWorkspaceSelection, setActiveWorkspace, workspaceId, workspaceLabel, workspaceTag, } from '../lib/workspaces.js';
+import { success } from '../lib/output.js';
+export async function runLink(opts) {
+    const creds = loadCredentials();
+    if (!creds)
+        throw new Error('Not logged in. Run: ductape login');
+    const rl = readline.createInterface({ input, output });
+    let workspaceSummary;
+    const selector = opts.workspace?.trim();
+    if (!selector) {
+        const active = getActiveWorkspace();
+        if (active?.id) {
+            console.log(`Using active workspace: ${active.name ?? active.tag ?? active.id}`);
+            workspaceSummary = {
+                workspace_id: active.id,
+                workspace_name: active.name,
+                tag: active.tag,
+            };
+        }
+        else {
+            const workspaces = await fetchWorkspaces(opts.profile);
+            if (workspaces.length === 0) {
+                throw new Error('No workspaces on this account. Create one in the Workbench first.');
+            }
+            else {
+                workspaceSummary = await promptWorkspaceSelection(workspaces, {
+                    message: 'Link project to workspace:',
+                });
+            }
+        }
+    }
+    else {
+        const workspaces = await fetchWorkspaces(opts.profile);
+        const match = findWorkspace(workspaces, selector);
+        if (!match) {
+            throw new Error(`Workspace not found: ${selector}`);
+        }
+        workspaceSummary = match;
+        setActiveWorkspace(workspaceId(match), workspaceLabel(match), workspaceTag(match));
+    }
+    const workspaceIdValue = workspaceId(workspaceSummary);
+    const workspaceTagValue = workspaceTag(workspaceSummary);
+    const productTag = opts.product ?? (await rl.question('Product tag: '));
+    const envSlug = opts.env ?? (await rl.question('Environment slug (e.g. dev): '));
+    rl.close();
+    const targetDir = path.resolve(opts.dir ?? process.cwd());
+    const config = {
+        workspace_tag: workspaceTagValue,
+        workspace_id: workspaceIdValue,
+        product_tag: productTag.trim(),
+        env_slug: envSlug.trim(),
+        linked_profile: opts.profile,
+    };
+    saveProjectConfig(targetDir, config);
+    setActiveWorkspace(workspaceIdValue, workspaceLabel(workspaceSummary), workspaceTagValue);
+    success(`Linked project in ${path.join(targetDir, '.ductape/config.json')}`);
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,9 @@
+export declare function runLogin(opts: {
+    email?: string;
+    password?: string;
+    profile?: string;
+    token?: string;
+    browser?: 'google' | 'github';
+    workspace?: string;
+    skipWorkspaceSelect?: boolean;
+}): Promise<void>;

package/dist/commands/login.js

@@ -0,0 +1,103 @@
+import inputPrompt from '@inquirer/input';
+import passwordPrompt from '@inquirer/password';
+import { spawn } from 'node:child_process';
+import { getApiUrl, getActiveProfileName, saveCredentials } from '../lib/config.js';
+import { parseJsonResponse } from '../lib/http.js';
+import { finalizeLoginWorkspace } from '../lib/workspaces.js';
+import { success } from '../lib/output.js';
+function saveFromResult(user) {
+    saveCredentials({
+        user_id: user._id,
+        email: user.email,
+        auth_token: user.auth_token,
+        public_key: user.public_key,
+        firstname: user.firstname,
+        lastname: user.lastname,
+        workspaces: user.workspaces,
+    });
+}
+async function exchangeOAuthToken(apiUrl, token) {
+    const res = await fetch(`${apiUrl}/users/v1/auth/oauth-session`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ token }),
+    });
+    const body = await parseJsonResponse(res, `${apiUrl}/users/v1/auth/oauth-session`);
+    if (!res.ok)
+        throw new Error(body.message ?? `OAuth exchange failed (${res.status})`);
+    const user = (body.data?.result ?? body.data);
+    if (!user?.auth_token)
+        throw new Error(body.message ?? 'Invalid OAuth token');
+    return user;
+}
+function openBrowser(url) {
+    const cmd = process.platform === 'darwin'
+        ? 'open'
+        : process.platform === 'win32'
+            ? 'start'
+            : 'xdg-open';
+    spawn(cmd, [url], { detached: true, stdio: 'ignore' }).unref();
+}
+export async function runLogin(opts) {
+    const profileName = opts.profile ?? getActiveProfileName();
+    const apiUrl = getApiUrl(opts.profile);
+    if (opts.token) {
+        const user = await exchangeOAuthToken(apiUrl, opts.token);
+        saveFromResult(user);
+        success(`Logged in as ${user.email} (OAuth)`);
+        await finalizeLoginWorkspace({
+            profile: opts.profile,
+            workspace: opts.workspace,
+            skipPrompt: opts.skipWorkspaceSelect,
+        });
+        return;
+    }
+    if (opts.browser) {
+        const path = opts.browser === 'github' ? '/users/v1/auth/github' : '/users/v1/auth/google';
+        const authUrl = `${apiUrl}${path}`;
+        console.log('Opening browser for OAuth login…');
+        console.log(`If the browser does not open, visit:\n  ${authUrl}\n`);
+        console.log('After sign-in you will be redirected with ?loggedIn=true&token=… in the URL.\n' +
+            'Copy the token value and run:\n' +
+            '  ductape login --token "<paste-token-here>"\n');
+        openBrowser(authUrl);
+        return;
+    }
+    let email = opts.email;
+    let password = opts.password;
+    if (!email || !password) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            throw new Error('Interactive login requires a TTY. Pass --email and --password, or use --token / --browser.');
+        }
+        email = email ?? (await inputPrompt({ message: 'Email' }));
+        password =
+            password ??
+                (await passwordPrompt({
+                    message: 'Password',
+                    mask: '*',
+                }));
+    }
+    const loginUrl = `${apiUrl}/users/v1/login`;
+    const res = await fetch(loginUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email, password }),
+    });
+    const body = await parseJsonResponse(res, loginUrl);
+    if (!res.ok) {
+        throw new Error(body.message ?? `Login failed (HTTP ${res.status}) — profile "${profileName}", ${loginUrl}`);
+    }
+    const user = (body.data?.result ?? body.data);
+    if (!user?.auth_token)
+        throw new Error(body.message ?? 'Login failed');
+    if (user.requires_verification) {
+        throw new Error('Account requires email verification. Complete verification in the Workbench first.');
+    }
+    saveFromResult(user);
+    success(`Logged in as ${user.email}`);
+    await finalizeLoginWorkspace({
+        profile: opts.profile,
+        workspace: opts.workspace,
+        skipPrompt: opts.skipWorkspaceSelect,
+    });
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1 @@
+export declare function runLogout(): void;

package/dist/commands/logout.js

@@ -0,0 +1,6 @@
+import { clearCredentials } from '../lib/config.js';
+import { success } from '../lib/output.js';
+export function runLogout() {
+    clearCredentials();
+    success('Logged out');
+}

package/dist/commands/platform.d.ts

@@ -0,0 +1,7 @@
+export declare function runStart(opts: {
+    backendOnly?: boolean;
+    build?: boolean;
+    remote?: boolean;
+}): Promise<void>;
+export declare function runStop(): Promise<void>;
+export declare function runStatus(json: boolean): Promise<void>;

package/dist/commands/platform.js

@@ -0,0 +1,99 @@
+import { spawn } from 'node:child_process';
+import { getApiUrl, loadGlobalConfig, resolvePlatformDir } from '../lib/config.js';
+import { printJson, success } from '../lib/output.js';
+const WORKBENCH_ONLY_COMPOSE = [
+    '-f',
+    'docker-compose.yml',
+    '-f',
+    'docker-compose.workbench.yml',
+];
+function normalizeViteApiBase(url) {
+    return url.endsWith('/') ? url : `${url}/`;
+}
+function runCompose(args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('docker', ['compose', ...args], {
+            cwd,
+            stdio: 'inherit',
+            shell: process.platform === 'win32',
+        });
+        child.on('error', reject);
+        child.on('close', (code) => resolve(code ?? 1));
+    });
+}
+export async function runStart(opts) {
+    const platformDir = resolvePlatformDir();
+    if (opts.remote) {
+        const apiBase = normalizeViteApiBase(getApiUrl('cloud'));
+        const composeArgs = [...WORKBENCH_ONLY_COMPOSE];
+        if (opts.build) {
+            const buildCode = await runCompose([
+                ...composeArgs,
+                'build',
+                '--build-arg',
+                `VITE_API_BASE_URL=${apiBase}`,
+                '--build-arg',
+                'VITE_APP_ENV=development',
+                'workbench',
+            ], platformDir);
+            if (buildCode !== 0)
+                throw new Error(`docker compose build exited with ${buildCode}`);
+        }
+        const code = await runCompose([...composeArgs, 'up', '-d', 'workbench'], platformDir);
+        if (code !== 0)
+            throw new Error(`docker compose exited with ${code}`);
+        success(`Workbench UI: http://localhost:4310 (API → ${apiBase})`);
+        return;
+    }
+    const composeArgs = opts.backendOnly
+        ? ['-f', 'docker-compose.yml', '-f', 'docker-compose.backend.yml', 'up', '-d']
+        : ['up', '-d'];
+    if (opts.build) {
+        const upIdx = composeArgs.indexOf('up');
+        composeArgs.splice(upIdx + 1, 0, '--build');
+    }
+    const code = await runCompose(composeArgs, platformDir);
+    if (code !== 0)
+        throw new Error(`docker compose exited with ${code}`);
+    success('Ductape platform started (see platform/README.md for URLs)');
+}
+export async function runStop() {
+    const platformDir = resolvePlatformDir();
+    const code = await runCompose(['down'], platformDir);
+    if (code !== 0)
+        throw new Error(`docker compose exited with ${code}`);
+    success('Ductape platform stopped');
+}
+async function probeHealth(url) {
+    try {
+        const res = await fetch(url, { signal: AbortSignal.timeout(5000) });
+        const hint = res.status === 502
+            ? 'nginx returned 502 Bad Gateway — the proxy container is usually not running or not listening yet. Try: docker compose ps proxy && docker compose logs proxy --tail 50'
+            : res.status === 404
+                ? 'route not found — check api-gateway nginx config vs Nest proxy routes'
+                : undefined;
+        return { url, ok: res.ok, status: res.status, hint };
+    }
+    catch (e) {
+        return {
+            url,
+            ok: false,
+            error: e instanceof Error ? e.message : String(e),
+            hint: 'cannot reach host — run `ductape start` (full stack) or ensure port 4311 / 8020 is up',
+        };
+    }
+}
+export async function runStatus(json) {
+    const global = loadGlobalConfig();
+    const localUrl = global.profiles.local?.api_url ?? 'http://localhost:4311/api';
+    const localBase = localUrl.replace(/\/$/, '');
+    const checks = {
+        profiles: global.profiles,
+        platform_dir: resolvePlatformDir(),
+        workbench_ui: 'http://localhost:4310',
+    };
+    checks.local_proxy_health = await probeHealth(`${localBase}/proxy/v1/sdk-proxy/health`);
+    checks.local_proxy_direct = await probeHealth('http://localhost:8020/proxy/v1/sdk-proxy/health');
+    checks.cloud_api = getApiUrl('cloud');
+    printJson(checks, json);
+}

package/dist/commands/products.d.ts

@@ -0,0 +1,14 @@
+import { type CommandInteractiveFlags } from '../lib/interactive-opts.js';
+export declare function runProducts(verb: string, opts: {
+    profile?: string;
+    status?: string;
+    id?: string;
+    tag?: string;
+    file?: string;
+    json?: boolean;
+} & CommandInteractiveFlags, extraArgs: string[]): Promise<void>;
+export declare function runProductApps(verb: string, opts: {
+    profile?: string;
+    product?: string;
+    json?: boolean;
+}, extraArgs: string[]): Promise<void>;

package/dist/commands/products.js

@@ -0,0 +1,74 @@
+import { schemaKeyForEntity } from '../lib/forms/index.js';
+import { isInteractive, promptTag } from '../lib/forms/prompt.js';
+import { toInteractiveOpts } from '../lib/interactive-opts.js';
+import { bodyRequiredHint, resolveBody } from '../lib/read-body.js';
+import { createProduct, deleteProduct, getProduct, listProductApps, listProducts, updateProduct, } from '../lib/platform-api.js';
+import { printJson } from '../lib/output.js';
+import { requireWorkspaceContext } from '../lib/workspace-context.js';
+const VERBS = ['list', 'get', 'create', 'update', 'delete'];
+export async function runProducts(verb, opts, extraArgs) {
+    const v = verb.toLowerCase();
+    if (!VERBS.includes(v)) {
+        throw new Error(`Unknown products verb "${verb}". Use: ${VERBS.join(', ')}`);
+    }
+    const ctx = requireWorkspaceContext({ profile: opts.profile });
+    const status = opts.status ?? 'all';
+    const interactive = toInteractiveOpts(opts);
+    const schemaKey = schemaKeyForEntity('products', v);
+    const body = v === 'create' || v === 'update'
+        ? await resolveBody({
+            ...interactive,
+            file: opts.file,
+            schemaKey,
+            patch: v === 'update',
+            requireBody: v === 'create',
+        })
+        : undefined;
+    const id = opts.id ?? extraArgs[0];
+    let tag = opts.tag ?? (extraArgs[0] && !opts.id ? extraArgs[0] : undefined);
+    if (v === 'update' && !tag && isInteractive(interactive)) {
+        tag = await promptTag('Product tag');
+    }
+    let result;
+    switch (v) {
+        case 'list':
+            result = await listProducts(ctx, status);
+            break;
+        case 'get':
+            result = await getProduct(ctx, { id, tag });
+            break;
+        case 'create':
+            if (!body || Object.keys(body).length === 0) {
+                throw new Error(`create requires a body. ${bodyRequiredHint('products:create')}`);
+            }
+            result = await createProduct(ctx, body);
+            break;
+        case 'update': {
+            const productTag = tag ?? body?.tag;
+            if (!productTag)
+                throw new Error('update requires --tag <product_tag> (or tag in body)');
+            const patch = body ?? {};
+            result = await updateProduct(ctx, productTag, patch);
+            break;
+        }
+        case 'delete':
+            if (!id)
+                throw new Error('delete requires --id <product_id>');
+            result = await deleteProduct(ctx, id);
+            break;
+        default:
+            throw new Error(`Unsupported: products ${v}`);
+    }
+    printJson(result, Boolean(opts.json));
+}
+export async function runProductApps(verb, opts, extraArgs) {
+    if (verb.toLowerCase() !== 'list') {
+        throw new Error('Only supported: ductape products apps list --product <id>');
+    }
+    const ctx = requireWorkspaceContext({ profile: opts.profile });
+    const productId = opts.product ?? extraArgs[0];
+    if (!productId)
+        throw new Error('Provide --product <product_id>');
+    const result = await listProductApps(ctx, productId);
+    printJson(result, Boolean(opts.json));
+}

package/dist/commands/profiles.d.ts

@@ -0,0 +1,2 @@
+export declare function runProfilesList(json: boolean): void;
+export declare function runProfilesUse(name: string): void;

package/dist/commands/profiles.js

@@ -0,0 +1,18 @@
+import { loadGlobalConfig, saveGlobalConfig } from '../lib/config.js';
+import { printJson, success } from '../lib/output.js';
+export function runProfilesList(json) {
+    const cfg = loadGlobalConfig();
+    printJson({
+        default_profile: cfg.default_profile,
+        profiles: cfg.profiles,
+    }, json);
+}
+export function runProfilesUse(name) {
+    const cfg = loadGlobalConfig();
+    if (!cfg.profiles[name]) {
+        throw new Error(`Unknown profile "${name}"`);
+    }
+    cfg.default_profile = name;
+    saveGlobalConfig(cfg);
+    success(`Default profile set to "${name}" (${cfg.profiles[name].api_url})`);
+}

package/dist/commands/resources.d.ts

@@ -0,0 +1,7 @@
+import { type CommandInteractiveFlags } from '../lib/interactive-opts.js';
+export declare function runResourcesList(json: boolean): void;
+export declare function runResourceCrud(typeName: string, verb: string, opts: {
+    tag?: string;
+    file?: string;
+    json?: boolean;
+} & CommandInteractiveFlags, extraArgs: string[]): Promise<void>;

package/dist/commands/resources.js

@@ -0,0 +1,61 @@
+import { buildCrudParams, listResourceTypes, proxyMethodForVerb, resolveResourceType, } from '../lib/resources.js';
+import { resolveResourceSchema } from '../lib/forms/index.js';
+import { isInteractive, promptTag } from '../lib/forms/prompt.js';
+import { toInteractiveOpts } from '../lib/interactive-opts.js';
+import { bodyRequiredHint, resolveBody } from '../lib/read-body.js';
+import { requireSession, getSdkProxy } from '../lib/proxy/context.js';
+import { printJson } from '../lib/output.js';
+const CRUD_VERBS = ['create', 'list', 'get', 'update', 'delete', 'connect'];
+export function runResourcesList(json) {
+    printJson({ resource_types: listResourceTypes() }, json);
+}
+export async function runResourceCrud(typeName, verb, opts, extraArgs) {
+    const crud = verb.toLowerCase();
+    if (!CRUD_VERBS.includes(crud)) {
+        throw new Error(`Unknown verb "${verb}". Use: ${CRUD_VERBS.join(', ')}`);
+    }
+    const session = requireSession();
+    const module = resolveResourceType(typeName);
+    if (module === 'product' || module === 'app') {
+        if (crud === 'list') {
+            throw new Error(`Use \`ductape ${module}s list\` — listing uses the workspace REST API (not sdk-proxy).`);
+        }
+        if (crud === 'delete') {
+            throw new Error(`Use \`ductape ${module}s delete --id <id>\`.`);
+        }
+    }
+    const method = proxyMethodForVerb(crud);
+    const interactive = toInteractiveOpts(opts);
+    let tag = opts.tag ?? extraArgs[0];
+    if (!tag && ['get', 'update', 'delete'].includes(crud) && isInteractive(interactive)) {
+        tag = await promptTag('Component tag');
+    }
+    const needsBody = crud === 'create' || crud === 'update' || crud === 'connect';
+    const schema = needsBody ? resolveResourceSchema(module, crud) : undefined;
+    const body = needsBody
+        ? await resolveBody({
+            ...interactive,
+            file: opts.file,
+            schema,
+            patch: crud === 'update',
+            requireBody: crud === 'create',
+        })
+        : undefined;
+    if (crud === 'create' && (!body || Object.keys(body).length === 0)) {
+        throw new Error(`create requires a body. ${bodyRequiredHint(`${module}:create`)}`);
+    }
+    let payload = body;
+    if (crud === 'connect' && tag) {
+        payload = {
+            ...(payload && typeof payload === 'object' ? payload : {}),
+            tag,
+        };
+    }
+    const params = buildCrudParams(module, method, session.project.product_tag, {
+        tag,
+        body: payload,
+    });
+    const proxy = getSdkProxy(session);
+    const result = await proxy.execute(module, method, params);
+    printJson(result, Boolean(opts.json));
+}

package/dist/commands/secrets.d.ts

@@ -0,0 +1,6 @@
+import { type CommandInteractiveFlags } from '../lib/interactive-opts.js';
+export declare function runSecrets(verb: string, opts: {
+    key?: string;
+    file?: string;
+    json?: boolean;
+} & CommandInteractiveFlags): Promise<void>;

package/dist/commands/secrets.js

@@ -0,0 +1,38 @@
+import { isInteractive, promptKey } from '../lib/forms/prompt.js';
+import { toInteractiveOpts } from '../lib/interactive-opts.js';
+import { bodyRequiredHint, resolveBody } from '../lib/read-body.js';
+import { buildCrudParams, proxyMethodForVerb } from '../lib/resources.js';
+import { getSdkProxy, requireSession } from '../lib/proxy/context.js';
+import { printJson } from '../lib/output.js';
+const VERBS = ['create', 'list', 'get', 'update', 'delete'];
+export async function runSecrets(verb, opts) {
+    const crud = verb.toLowerCase();
+    if (!VERBS.includes(crud)) {
+        throw new Error(`Unknown secrets verb "${verb}". Use: ${VERBS.join(', ')}`);
+    }
+    const session = requireSession();
+    const method = proxyMethodForVerb(crud);
+    const interactive = toInteractiveOpts(opts);
+    let key = opts.key;
+    if (!key && ['fetch', 'delete', 'update'].includes(method) && isInteractive(interactive)) {
+        key = await promptKey();
+    }
+    const body = crud === 'create' || crud === 'update'
+        ? await resolveBody({
+            ...interactive,
+            file: opts.file,
+            schemaKey: `secrets:${crud}`,
+            patch: crud === 'update',
+            requireBody: crud === 'create',
+        })
+        : undefined;
+    if (crud === 'create' && (!body || Object.keys(body).length === 0)) {
+        throw new Error(`create requires a body. ${bodyRequiredHint('secrets:create')}`);
+    }
+    const params = buildCrudParams('secrets', method, session.project.product_tag, {
+        tag: key,
+        body,
+    });
+    const result = await getSdkProxy(session).execute('secrets', method, params);
+    printJson(result, Boolean(opts.json));
+}

package/dist/commands/unlink.d.ts

@@ -0,0 +1,3 @@
+export declare function runUnlink(opts: {
+    dir?: string;
+}): void;

package/dist/commands/unlink.js

@@ -0,0 +1,14 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { findProjectConfig, PROJECT_CONFIG_PATH } from '../lib/config.js';
+import { success } from '../lib/output.js';
+export function runUnlink(opts) {
+    const dir = path.resolve(opts.dir ?? process.cwd());
+    const found = findProjectConfig(dir);
+    if (!found) {
+        throw new Error('No linked project in this directory');
+    }
+    const configPath = path.join(found.dir, PROJECT_CONFIG_PATH);
+    fs.unlinkSync(configPath);
+    success(`Removed ${configPath}`);
+}

package/dist/commands/whoami.d.ts

@@ -0,0 +1 @@
+export declare function runWhoami(json: boolean): void;

package/dist/commands/whoami.js

@@ -0,0 +1,22 @@
+import { getActiveProfileName, getApiUrl, loadCredentials, loadGlobalConfig, findProjectConfig } from '../lib/config.js';
+import { getActiveWorkspace } from '../lib/workspaces.js';
+import { printJson } from '../lib/output.js';
+export function runWhoami(json) {
+    const creds = loadCredentials();
+    const project = findProjectConfig();
+    const active = getActiveWorkspace();
+    const profile = project?.config
+        ? getActiveProfileName(project.config)
+        : loadGlobalConfig().default_profile;
+    printJson({
+        logged_in: Boolean(creds),
+        email: creds?.email,
+        user_id: creds?.user_id,
+        profile,
+        api_url: getApiUrl(profile),
+        active_workspace: active
+            ? { id: active.id, name: active.name }
+            : null,
+        project: project?.config ?? null,
+    }, json);
+}