@ductape/cli 0.2.0

package/API_PARITY.md

@@ -0,0 +1,58 @@
+# CLI ↔ API parity (Nest / Workbench)
+
+The CLI uses the **same REST paths as the Workbench and TypeScript SDK**.
+
+| Profile | `api_url` | Example login URL |
+|---------|-----------|-------------------|
+| `cloud` | `https://api.ductape.app` | `https://api.ductape.app/users/v1/login` |
+| `local` | `http://localhost:4311/api` | `http://localhost:4311/api/users/v1/login` |
+
+Production does **not** use an `/api` prefix; the local docker gateway does.
+
+## Gateway routing
+
+| Client calls | Gateway (`/api/...`) | Nest service receives |
+|--------------|----------------------|------------------------|
+| `{api}/users/v1/login` | `/api/users/` → users:8002 | `/users/v1/login` |
+| `{api}/workspaces/v1/fetch/...` | `/api/workspaces/` → workspaces:8001 | `/workspaces/v1/...` |
+| `{api}/apps/v1/import` | `/api/apps/` → apps:8004 | `/apps/v1/import` |
+| `{api}/integrations/v1/create` | `/api/integrations/` → integrations:8009 | `/integrations/v1/create` |
+| `{api}/proxy/v1/sdk-proxy/execute` | `/api/proxy/` → proxy:8020 | encrypted sdk-proxy |
+
+Legacy Express services are **not** called by the CLI. All commands target Nest controllers under `platform/nest/apps/*/src/**/controllers/`.
+
+## Command → endpoint map
+
+| CLI | Method | Path (after `{api_url}`) | Workbench equivalent |
+|-----|--------|---------------------------|-------------------|
+| `ductape login` | POST | `/users/v1/login` | Login modal |
+| `ductape workspaces list` | GET | `/workspaces/v1/fetch/:user_id` | Workspace list |
+| `ductape products list` | GET | `/integrations/v1/workspace/:id/:status` | Products sidebar |
+| `ductape products create` | POST | `/integrations/v1/create` | Create product |
+| `ductape products update` | sdk-proxy | `product.update` | Product settings |
+| `ductape products delete` | DELETE | `/integrations/v1/:id` | Delete product |
+| `ductape apps list` | GET | `/apps/v1/workspace/:id/:status` | Apps sidebar |
+| `ductape apps create` | POST | `/apps/v1/create` | Create app |
+| `ductape apps import` | POST multipart | `/apps/v1/import` | App import dialog |
+| `ductape apps update` | PUT | `/apps/v1/:app_id` | App settings |
+| `ductape apps delete` | DELETE | `/apps/v1/:app_id` | Delete app |
+| `ductape resources *` | POST | `/proxy/v1/sdk-proxy/execute` | SDK proxy (encrypted) |
+| `ductape db *` | POST | `/proxy/v1/db-proxy/...` | Database proxy |
+| `ductape graph *` | POST | `/proxy/v1/graph-proxy/...` | Graph proxy |
+
+## Import body fields (`apps import`)
+
+Matches `AppsImportController` and `@ductape/sdk` `AppApiService.importApp`:
+
+| Field | CLI / SDK value |
+|-------|-----------------|
+| `type` | `PostmanV2.1` or `OpenApiV3.0` |
+| `version` | default `0.0.1` |
+| `update` | `true` / `false` |
+| `workspace_id`, `user_id`, `public_key` | from session |
+| `app_id` | optional (`--app-id` / `--app-tag`) |
+| `file` | multipart upload |
+
+## SDK base URL note
+
+The TS SDK client uses host `https://api.ductape.app` with paths like `/apps/v1/...` (no `/api` segment). Production routing may terminate TLS at a layer that forwards directly to services. **CLI and Workbench** use `{host}/api` as `api_url` — always set `ductape profiles use local` to `http://localhost:4311/api` for local parity.

package/CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+## Unreleased
+
+### Added
+
+- `ductape apps import <file> --type postman|openapi` (Postman v2.1 / OpenAPI 3.0)
+- Project config uses `workspace_tag` (CLI resolves `workspace_id` automatically)
+- `ductape products` and `ductape apps` CRUD (workspace REST + sdk-proxy update)
+- `ductape products apps list --product <id>`
+- CLI docs split into `docs/docs/cli/` folder with per-topic pages
+- Interactive workspace selection after `ductape login` (stored in `~/.ductape/config.json`)
+- `ductape workspaces current`, `workspaces switch`, `workspaces refresh`
+- `ductape login --workspace`, `--skip-workspace-select`
+- `ductape link` defaults to active workspace; `whoami` shows `active_workspace`
+- Switching workspaces updates linked `.ductape/config.json` when present
+
+## 0.2.0
+
+### Added
+
+- OAuth login: `ductape login --browser`, `ductape login --token`
+- `ductape install`, `ductape unlink`, `ductape workspaces list|use`
+- `ductape graph <verb>` (graph-proxy, persisted graph context)
+- Expanded `ductape db` (db-proxy, `db context`, more methods)
+- `ductape secrets` CRUD
+- `ductape generate payload|snippet`
+- Shell completions: `ductape completion bash|zsh`
+- Language bootstrap templates (TypeScript, Python, Go, .NET)
+- Gzip support for large proxy payloads
+- Runtime context store (`~/.ductape/runtime-context.json`)
+- Unit tests (`npm test`)
+
+## 0.1.0
+
+- Initial CLI: login, profiles, link, init, start/stop/status, resources CRUD, cloud, db basics

package/README.md

@@ -0,0 +1,89 @@
+# @ductape/cli
+
+Terminal interface for Ductape — **same transport as the Workbench** (encrypted sdk-proxy / db-proxy / graph-proxy).
+
+## Install
+
+```bash
+cd cli
+npm install
+npm run build
+```
+
+### Global `ductape` command (optional)
+
+`npm link` installs into npm’s global prefix. If you see `EACCES` on `/usr/local/lib/node_modules`, that prefix is owned by root (common with the system Node installer). Use one of these:
+
+**Option A — run without linking (no sudo)**
+
+```bash
+npm exec ductape -- login
+npm exec ductape -- resources storage list
+# or: node dist/index.js login
+```
+
+**Option B — user-owned global prefix (recommended for `npm link`)**
+
+```bash
+mkdir -p ~/.npm-global
+npm config set prefix "$HOME/.npm-global"
+# Add to ~/.zshrc (or ~/.bashrc):
+#   export PATH="$HOME/.npm-global/bin:$PATH"
+source ~/.zshrc
+cd cli && npm link
+ductape --help
+```
+
+Do not use `sudo npm link`; it mixes root-owned globals with your normal user.
+
+## Quick start
+
+```bash
+ductape install
+ductape login                    # uses `cloud` profile (https://api.ductape.app)
+# Local platform (UI + API on your machine):
+ductape profiles use local
+ductape start
+ductape login --profile local
+
+# Workbench UI locally, cloud API (no local backend):
+ductape start --remote --build
+ductape login
+ductape init --link
+ductape resources storage list
+ductape generate snippet storage upload -l typescript -o upload.ts
+```
+
+## Command overview
+
+```
+ductape login|logout|whoami|install
+ductape profiles list|use <name>
+ductape workspaces list|current|use   # interactive picker on login/link/use
+ductape products list|get|create|update|delete
+ductape apps list|get|create|update|delete|import
+ductape init|link|unlink
+ductape start|stop|status   # status explains proxy 502 when backend is down
+ductape resources <type> <verb>   # CRUD via sdk-proxy (interactive prompts or -f JSON)
+ductape cloud connections list|create|get|update|complete|validate|delete
+ductape cloud resources list|import|provision …
+ductape db <verb>                 # db-proxy runtime
+ductape graph <verb>              # graph-proxy runtime
+ductape secrets <verb>
+ductape generate payload|snippet …
+ductape completion bash|zsh
+```
+
+## Documentation
+
+Full reference: [docs/docs/cli/](../docs/docs/cli/index.mdx)
+
+## Tests
+
+```bash
+npm test
+```
+
+## Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md).

package/dist/commands/apps-import.d.ts

@@ -0,0 +1,9 @@
+export declare function runAppsImport(file: string, opts: {
+    profile?: string;
+    type: string;
+    appId?: string;
+    appTag?: string;
+    update?: boolean;
+    version?: string;
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/apps-import.js

@@ -0,0 +1,29 @@
+import path from 'node:path';
+import { getApp } from '../lib/platform-api.js';
+import { importAppFromFile, parseImportFormat } from '../lib/app-import.js';
+import { printJson, success } from '../lib/output.js';
+import { requireWorkspaceContext } from '../lib/workspace-context.js';
+export async function runAppsImport(file, opts) {
+    const ctx = requireWorkspaceContext({ profile: opts.profile });
+    const format = parseImportFormat(opts.type);
+    let appId = opts.appId;
+    if (!appId && opts.appTag) {
+        const app = (await getApp(ctx, { tag: opts.appTag }));
+        appId = app._id;
+        if (!appId)
+            throw new Error(`App not found for tag: ${opts.appTag}`);
+    }
+    const result = await importAppFromFile(ctx, {
+        filePath: path.resolve(file),
+        format,
+        appId,
+        update: Boolean(opts.update),
+        version: opts.version,
+    });
+    if (opts.json) {
+        printJson(result, true);
+        return;
+    }
+    const label = format === 'postman' ? 'Postman v2.1' : 'OpenAPI 3.0';
+    success(`Imported ${label} collection from ${path.basename(file)}`);
+}

package/dist/commands/apps.d.ts

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

package/dist/commands/apps.js

@@ -0,0 +1,68 @@
+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 { createApp, deleteApp, getApp, listApps, updateApp, updateAppViaProxy, } 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 runApps(verb, opts, extraArgs) {
+    const v = verb.toLowerCase();
+    if (!VERBS.includes(v)) {
+        throw new Error(`Unknown apps verb "${verb}". Use: ${VERBS.join(', ')}`);
+    }
+    const ctx = requireWorkspaceContext({ profile: opts.profile });
+    const status = opts.status ?? 'all';
+    const interactive = toInteractiveOpts(opts);
+    const schemaKey = schemaKeyForEntity('apps', 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' && (opts.proxy || !id) && !tag && isInteractive(interactive)) {
+        tag = await promptTag('App tag');
+    }
+    let result;
+    switch (v) {
+        case 'list':
+            result = await listApps(ctx, status);
+            break;
+        case 'get':
+            result = await getApp(ctx, { id, tag });
+            break;
+        case 'create':
+            if (!body || Object.keys(body).length === 0) {
+                throw new Error(`create requires a body. ${bodyRequiredHint('apps:create')}`);
+            }
+            result = await createApp(ctx, body);
+            break;
+        case 'update': {
+            if (opts.proxy || tag) {
+                const appTag = tag ?? body?.tag;
+                if (!appTag)
+                    throw new Error('update via proxy requires --tag <app_tag>');
+                result = await updateAppViaProxy(ctx, appTag, body ?? {});
+                break;
+            }
+            if (!id)
+                throw new Error('update requires --id <app_id> or --tag with --proxy');
+            result = await updateApp(ctx, id, body ?? {});
+            break;
+        }
+        case 'delete':
+            if (!id)
+                throw new Error('delete requires --id <app_id>');
+            result = await deleteApp(ctx, id);
+            break;
+        default:
+            throw new Error(`Unsupported: apps ${v}`);
+    }
+    printJson(result, Boolean(opts.json));
+}

package/dist/commands/cloud.d.ts

@@ -0,0 +1,7 @@
+type CloudTarget = 'connections' | 'resources';
+export declare function runCloud(target: CloudTarget, verb: string, opts: {
+    id?: string;
+    file?: string;
+    json?: boolean;
+}, extraArgs: string[]): Promise<void>;
+export {};

package/dist/commands/cloud.js

@@ -0,0 +1,42 @@
+import { readJsonBody } from '../lib/read-body.js';
+import { getSdkProxy, requireSession } from '../lib/proxy/context.js';
+import { printJson } from '../lib/output.js';
+export async function runCloud(target, verb, opts, extraArgs) {
+    requireSession();
+    const proxy = getSdkProxy();
+    const body = readJsonBody(opts.file);
+    const id = opts.id ?? extraArgs[0];
+    let method;
+    let params;
+    if (target === 'connections') {
+        const map = {
+            create: ['connections.create', [body]],
+            list: ['connections.list', []],
+            get: ['connections.fetch', [id]],
+            fetch: ['connections.fetch', [id]],
+            delete: ['connections.delete', [id]],
+            update: ['connections.update', [id, body]],
+            complete: ['connections.complete', [id, body]],
+            validate: ['connections.validate', [id]],
+        };
+        const entry = map[verb.toLowerCase()];
+        if (!entry)
+            throw new Error(`Unknown cloud connections verb: ${verb}`);
+        [method, params] = entry;
+    }
+    else {
+        const map = {
+            list: ['resources.list', [body]],
+            import: ['resources.import', [body]],
+            provision: ['resources.provision', [body]],
+            'import-persist': ['resources.importAndPersist', [body]],
+            'provision-persist': ['resources.provisionAndPersist', [body]],
+        };
+        const entry = map[verb.toLowerCase()];
+        if (!entry)
+            throw new Error(`Unknown cloud resources verb: ${verb}`);
+        [method, params] = entry;
+    }
+    const result = await proxy.execute('cloud', method, params);
+    printJson(result, Boolean(opts.json));
+}

package/dist/commands/completion.d.ts

@@ -0,0 +1 @@
+export declare function runCompletion(shell: 'bash' | 'zsh' | 'fish'): void;

package/dist/commands/completion.js

@@ -0,0 +1,113 @@
+import { listResourceTypes } from '../lib/resources.js';
+import { DB_PROXY_METHODS, GRAPH_PROXY_METHODS } from '../lib/db-methods.js';
+const TOP_LEVEL = [
+    'login',
+    'logout',
+    'whoami',
+    'profiles',
+    'workspaces',
+    'link',
+    'unlink',
+    'init',
+    'install',
+    'start',
+    'stop',
+    'status',
+    'products',
+    'apps',
+    'resources',
+    'cloud',
+    'db',
+    'graph',
+    'secrets',
+    'generate',
+    'completion',
+];
+const ENTITY_CRUD = 'list get create update delete';
+export function runCompletion(shell) {
+    const resources = listResourceTypes();
+    const crud = 'create list get update delete connect';
+    if (shell === 'bash') {
+        console.log(`
+_ductape_completions() {
+  local cur="\${COMP_WORDS[COMP_CWORD]}"
+  local prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  local cmd="\${COMP_WORDS[1]}"
+
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=( $(compgen -W "${TOP_LEVEL.join(' ')}" -- "$cur") )
+    return
+  fi
+
+  case "$cmd" in
+    products)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "${ENTITY_CRUD}" -- "$cur") )
+      fi
+      ;;
+    apps)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "import ${ENTITY_CRUD}" -- "$cur") )
+      elif [[ \${COMP_CWORD} -eq 3 && "\${COMP_WORDS[2]}" == "import" ]]; then
+        COMPREPLY=( $(compgen -f -- "$cur") )
+      fi
+      ;;
+    resources)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "types ${resources.join(' ')}" -- "$cur") )
+      elif [[ \${COMP_CWORD} -eq 3 ]]; then
+        COMPREPLY=( $(compgen -W "${crud}" -- "$cur") )
+      fi
+      ;;
+    db)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "${DB_PROXY_METHODS.join(' ')}" -- "$cur") )
+      fi
+      ;;
+    graph)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "${GRAPH_PROXY_METHODS.join(' ')}" -- "$cur") )
+      fi
+      ;;
+    profiles|workspaces)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "list use" -- "$cur") )
+      fi
+      ;;
+    generate)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=( $(compgen -W "payload snippet" -- "$cur") )
+      fi
+      ;;
+  esac
+}
+complete -F _ductape_completions ductape
+`);
+        return;
+    }
+    if (shell === 'zsh') {
+        console.log(`
+#compdef ductape
+_ductape() {
+  local -a commands
+  commands=(
+    ${TOP_LEVEL.map((c) => `'${c}:command'`).join('\n    ')}
+  )
+  _arguments '1: :->cmd' '*: :->args'
+  case $state in
+    cmd) _describe 'command' commands ;;
+    args)
+      case $words[1] in
+        resources) _arguments '2: :(types ${resources.join(' ')})' '3: :(${crud.split(' ').join(' ')})' ;;
+        db) _arguments '2: :(${DB_PROXY_METHODS.join(' ')})' ;;
+        graph) _arguments '2: :(${GRAPH_PROXY_METHODS.join(' ')})' ;;
+      esac
+      ;;
+  esac
+}
+_ductape
+`);
+        return;
+    }
+    console.log(`# Fish: use ductape completion bash | source`);
+}

package/dist/commands/db.d.ts

@@ -0,0 +1,5 @@
+export declare function runDb(method: string, opts: {
+    file?: string;
+    json?: boolean;
+}): Promise<void>;
+export declare function runDbContext(json: boolean): void;

package/dist/commands/db.js

@@ -0,0 +1,55 @@
+import { readJsonBody } from '../lib/read-body.js';
+import { setDatabaseContext } from '../lib/context-store.js';
+import { DB_PROXY_METHODS } from '../lib/db-methods.js';
+import { getDbContext, getDbProxy, requireSession } from '../lib/proxy/context.js';
+import { loadRuntimeContext } from '../lib/context-store.js';
+import { printJson } from '../lib/output.js';
+export async function runDb(method, opts) {
+    const session = requireSession();
+    const proxy = getDbProxy(session);
+    const runtime = loadRuntimeContext(session.project.workspace_id, session.project.product_tag);
+    const dbContext = runtime?.database_context ?? null;
+    const body = readJsonBody(opts.file);
+    const m = method.toLowerCase();
+    if (!DB_PROXY_METHODS.includes(m) && !m.includes('.')) {
+        console.warn(`Method "${m}" not in known list; sending anyway.`);
+    }
+    let params = [];
+    if (m === 'connect') {
+        const cfg = {
+            product: session.project.product_tag,
+            env: session.project.env_slug,
+            database: body.database ?? body.tag,
+            ...body,
+        };
+        params = [cfg];
+    }
+    else if (m === 'list') {
+        params = [session.project.product_tag];
+    }
+    else if (Object.keys(body).length > 0) {
+        params = [
+            {
+                product: session.project.product_tag,
+                env: session.project.env_slug,
+                ...body,
+            },
+        ];
+    }
+    const result = await proxy.execute(m, params, dbContext);
+    if (m === 'connect' && params[0] && typeof params[0] === 'object') {
+        const cfg = params[0];
+        setDatabaseContext(session.project.workspace_id, session.project.product_tag, session.project.env_slug, {
+            database: String(cfg.database),
+            env: String(cfg.env),
+            product: String(cfg.product),
+        });
+    }
+    printJson(result, Boolean(opts.json));
+}
+export function runDbContext(json) {
+    const session = requireSession();
+    const ctx = getDbContext(session);
+    const runtime = loadRuntimeContext(session.project.workspace_id, session.project.product_tag);
+    printJson({ database_context: runtime?.database_context ?? ctx }, json);
+}

package/dist/commands/generate.d.ts

@@ -0,0 +1,14 @@
+export declare function runGeneratePayload(opts: {
+    family: string;
+    method: string;
+    file?: string;
+    json?: boolean;
+}): Promise<void>;
+export declare function runGenerateSnippet(opts: {
+    family: string;
+    method: string;
+    language: 'typescript' | 'python' | 'go' | 'dotnet';
+    file?: string;
+    json?: boolean;
+    out?: string;
+}): Promise<void>;

package/dist/commands/generate.js

@@ -0,0 +1,52 @@
+import fs from 'node:fs';
+import { requireSession } from '../lib/proxy/context.js';
+import { generateExecutablePayload } from '../lib/integrations.js';
+import { buildSnippet, ensureSupportedSnippetOperation, } from '../lib/snippets.js';
+import { printJson } from '../lib/output.js';
+export async function runGeneratePayload(opts) {
+    const session = requireSession();
+    let targets;
+    if (opts.file) {
+        targets = JSON.parse(fs.readFileSync(opts.file, 'utf8'));
+    }
+    const result = await generateExecutablePayload(session.apiUrl, session.credentials, {
+        workspace_id: session.project.workspace_id,
+        user_id: session.credentials.user_id,
+        public_key: session.credentials.public_key,
+        product_tag: session.project.product_tag,
+        env_slug: session.project.env_slug,
+        operation_family: opts.family,
+        method: opts.method,
+        targets,
+        include_session: true,
+        include_cache: true,
+        schema_mode: 'best_effort',
+    });
+    printJson(result, Boolean(opts.json));
+}
+export async function runGenerateSnippet(opts) {
+    ensureSupportedSnippetOperation(opts.family, opts.method);
+    const session = requireSession();
+    let targets;
+    if (opts.file) {
+        targets = JSON.parse(fs.readFileSync(opts.file, 'utf8'));
+    }
+    const generated = await generateExecutablePayload(session.apiUrl, session.credentials, {
+        workspace_id: session.project.workspace_id,
+        user_id: session.credentials.user_id,
+        public_key: session.credentials.public_key,
+        product_tag: session.project.product_tag,
+        env_slug: session.project.env_slug,
+        operation_family: opts.family,
+        method: opts.method,
+        targets,
+    });
+    const payload = generated.payload ?? {};
+    const snippet = buildSnippet(opts.language, payload, opts.family, opts.method);
+    const output = { payload: generated, snippet };
+    if (opts.out) {
+        fs.writeFileSync(opts.out, snippet);
+        console.log(`Wrote snippet to ${opts.out}`);
+    }
+    printJson(output, Boolean(opts.json));
+}

package/dist/commands/graph.d.ts

@@ -0,0 +1,4 @@
+export declare function runGraph(method: string, opts: {
+    file?: string;
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/graph.js

@@ -0,0 +1,44 @@
+import { readJsonBody } from '../lib/read-body.js';
+import { setGraphContext } from '../lib/context-store.js';
+import { GRAPH_PROXY_METHODS } from '../lib/db-methods.js';
+import { getGraphProxy, requireSession } from '../lib/proxy/context.js';
+import { printJson } from '../lib/output.js';
+export async function runGraph(method, opts) {
+    const session = requireSession();
+    const proxy = getGraphProxy(session);
+    const body = readJsonBody(opts.file);
+    const m = method.includes('.') ? method : method.toLowerCase();
+    if (!GRAPH_PROXY_METHODS.includes(m) && !m.includes('.')) {
+        console.warn(`Method "${m}" not in known list; sending anyway. Known: ${GRAPH_PROXY_METHODS.join(', ')}`);
+    }
+    const params = [];
+    if (m === 'connect') {
+        const cfg = {
+            product: session.project.product_tag,
+            env: session.project.env_slug,
+            graph: body.graph ?? body.tag,
+            ...body,
+        };
+        params.push(cfg);
+    }
+    else if (Object.keys(body).length > 0) {
+        params.push({
+            product: session.project.product_tag,
+            env: session.project.env_slug,
+            ...body,
+        });
+    }
+    else if (m === 'fetchAll' || m === 'list') {
+        params.push(session.project.product_tag);
+    }
+    const result = await proxy.execute(m === 'list' ? 'fetchAll' : m, params);
+    if (m === 'connect' && params[0] && typeof params[0] === 'object') {
+        const cfg = params[0];
+        setGraphContext(session.project.workspace_id, session.project.product_tag, session.project.env_slug, {
+            graph: String(cfg.graph),
+            env: String(cfg.env),
+            product: String(cfg.product),
+        });
+    }
+    printJson(result, Boolean(opts.json));
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,7 @@
+export declare function runInit(opts: {
+    link?: boolean;
+    workspace?: string;
+    product?: string;
+    env?: string;
+    language?: string;
+}): Promise<void>;