@alvera-ai/platform-sdk 0.2.4 → 0.4.1

package/README.md

@@ -16,9 +16,9 @@ pnpm add @alvera-ai/platform-sdk
 ## Quick start
 
 ```ts
-import { createPlatformApi, createSession } from '@alvera-ai/platform-sdk';
+import { createPlatformApi, createSession, ENVIRONMENTS } from '@alvera-ai/platform-sdk';
 
-const baseUrl = 'https://admin.alvera.ai';
+const baseUrl = ENVIRONMENTS.prod.base_url; // or ENVIRONMENTS.local / ENVIRONMENTS.demo
 
 // 1. Exchange credentials for a session token
 const session = await createSession({
@@ -79,6 +79,36 @@ await revokeSession();
 `session.expiresAt` is an ISO-8601 timestamp — check it before long-running
 work and re-authenticate if needed.
 
+## Environments
+
+The base URLs ship with the package, derived at build time from the
+`servers[]` block of the committed OpenAPI spec (`spec/openapi.yaml`). The
+generated map is exported as `ENVIRONMENTS`:
+
+```ts
+import { ENVIRONMENTS, DEFAULT_ENVIRONMENT } from '@alvera-ai/platform-sdk';
+
+ENVIRONMENTS.local.base_url; // http://localhost:4000
+ENVIRONMENTS.demo.base_url;  // https://platform-hh.alvera.ai
+ENVIRONMENTS.prod.base_url;  // https://app.alvera.ai
+
+DEFAULT_ENVIRONMENT; // 'prod'
+```
+
+The CLI resolves a base URL with this precedence (highest first):
+
+1. `ALVERA_BASE_URL` env var (explicit URL override — useful for tunnels /
+   ephemeral servers)
+2. `base_url` pinned in the profile (written when the user passes a custom URL
+   to `alvera configure` or `alvera login --base-url …`)
+3. `ENVIRONMENTS[env].base_url` where `env` is the first of: `--env <name>`
+   flag, `ALVERA_ENV` env var, the profile's `environment` entry, or
+   `DEFAULT_ENVIRONMENT`
+
+Adding, renaming, or removing environments happens in the platform repo (the
+`servers/0` function in `lib/platform_api/api_spec.ex`); rerun
+`pnpm regen` in the SDK to pick up the change.
+
 ## Resources
 
 | Resource                | Operations                                  |
@@ -140,14 +170,16 @@ alvera --help
 Both files are INI. The default profile is `[default]`; additional profiles
 live under `[profile <name>]` in `config` and `[<name>]` in `credentials`.
 
-Every command accepts `--profile <name>`. Environment variables
-(`ALVERA_PROFILE`, `ALVERA_BASE_URL`, `ALVERA_TENANT`, `ALVERA_EMAIL`,
-`ALVERA_PASSWORD`, `ALVERA_SESSION_TOKEN`) take precedence over file values.
+Every command accepts `--profile <name>` and `--env <name>`. Environment
+variables (`ALVERA_PROFILE`, `ALVERA_ENV`, `ALVERA_BASE_URL`, `ALVERA_TENANT`,
+`ALVERA_EMAIL`, `ALVERA_PASSWORD`, `ALVERA_SESSION_TOKEN`) take precedence
+over file values.
 
 ### Getting started
 
 ```bash
-alvera configure                          # set base URL + default tenant
+alvera env list                           # show local / demo / prod
+alvera configure                          # pick environment + default tenant
 alvera login --email me@acme.com --tenant acme
 alvera ping
 alvera datalakes list
@@ -155,13 +187,26 @@ alvera tools create --body-file tool.json
 alvera logout
 ```
 
-Multiple environments via profiles:
+Per-command env switch (no profile edit):
 
 ```bash
-alvera --profile staging login --base-url https://admin.staging.alvera.ai --tenant acme
+alvera --env local ping
+ALVERA_ENV=demo alvera datalakes list
+```
+
+Pin an env into a profile:
+
+```bash
+alvera --profile staging env use demo
 alvera --profile staging datalakes list
 ```
 
+Override the base URL for an ad-hoc host (tunnels, local branches):
+
+```bash
+ALVERA_BASE_URL=https://pr-123.preview.alvera.ai alvera ping
+```
+
 ### Command surface
 
 ```
@@ -170,6 +215,7 @@ alvera login   [--email] [--password] [--tenant] [--base-url] [--expires-in]
 alvera logout
 alvera whoami
 alvera ping
+alvera env                    list | use <name>
 
 alvera datalakes              list | get <id> | create
 alvera data-sources           list <datalake> | create <datalake> | update <datalake> <id>
@@ -196,16 +242,39 @@ status messages and prompts go to stderr so responses stay pipeable.
 
 ## Regenerating the typed client
 
-The typed client is generated from the live OpenAPI spec at
-`https://admin.alvera.ai/api/openapi` using
-[`@hey-api/openapi-ts`](https://heyapi.dev/).
+The typed client is generated from `spec/openapi.yaml` using
+[`@hey-api/openapi-ts`](https://heyapi.dev/). The spec is produced by the
+platform repo and committed here, so this repo is fully self-contained at CI
+time.
+
+To pull a newer spec from the sibling platform repo:
 
 ```bash
-pnpm regen        # fetch latest spec + regenerate
-pnpm codegen      # regenerate from the pinned openapi.json
+# in the platform repo
+mix openapi.spec.yaml --spec PlatformApi.ApiSpec openapi.yaml
+git commit -am "feat(api): …"
+
+# in this repo
+cp ../platform/openapi.yaml spec/openapi.yaml
+pnpm regen        # gen-environments + codegen + check-coverage
 pnpm build        # compile to dist/
+git commit -am "chore: sync openapi spec"
 ```
 
+`pnpm regen` runs `gen-environments` (rebuilds
+`src/environments.generated.ts` from `servers[]`), then `codegen`, then
+`check-coverage`.
+
+## Releases
+
+This package uses
+[release-please](https://github.com/googleapis/release-please) plus
+[Conventional Commits](https://www.conventionalcommits.org/). Commits on
+`main` of the form `feat: …`, `fix: …`, `chore: …` feed into an automated
+"chore(main): release X.Y.Z" PR that bumps `package.json` and updates
+`CHANGELOG.md`. Merging that PR tags `vX.Y.Z`, which in turn triggers the
+existing npm publish workflow.
+
 ## License
 
 MIT

package/dist/cli.js

@@ -8,7 +8,8 @@ import { ValiError } from 'valibot';
 import { createPlatformApi, createSession, revokeSession } from './client.js';
 const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
 const { version: packageVersion } = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-import { CONFIG_PATHS, clearProfileCreds, getProfileName, resolveProfile, writeProfileConfig, writeProfileCreds, } from './config.js';
+import { CONFIG_PATHS, DEFAULT_ENVIRONMENT, ENVIRONMENTS, clearProfileCreds, getProfileName, readProfileConfig, resolveProfile, writeProfileConfig, writeProfileCreds, } from './config.js';
+const ENVIRONMENT_NAMES = Object.keys(ENVIRONMENTS);
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -123,18 +124,47 @@ program
     .description('Alvera platform CLI')
     .version(packageVersion, '-v, --version', 'print the installed version')
     .addOption(new Option('--profile <name>', 'config profile to use').default('default'))
-    .showHelpAfterError();
+    .addOption(new Option('--env <name>', `environment from spec/openapi.yaml (${ENVIRONMENT_NAMES.join(', ')})`))
+    .showHelpAfterError()
+    .hook('preAction', (thisCommand) => {
+    const env = thisCommand.optsWithGlobals().env;
+    if (env !== undefined)
+        process.env.ALVERA_ENV = env;
+    const candidate = process.env.ALVERA_ENV;
+    if (candidate !== undefined && !ENVIRONMENT_NAMES.includes(candidate)) {
+        die(`unknown environment "${candidate}". Valid: ${ENVIRONMENT_NAMES.join(', ')}`);
+    }
+});
 // -- configure --------------------------------------------------------------
 program
     .command('configure')
-    .description('Interactively set defaults (base URL, tenant) for a profile')
+    .description('Interactively set defaults (environment, tenant, email) for a profile')
     .action(async () => {
     const profile = getProfileName(program.opts().profile);
     const current = resolveProfile(profile);
-    const baseUrl = (await prompt(`Base URL [${current.baseUrl}]: `)) || current.baseUrl;
-    const tenantSlug = (await prompt(`Default tenant slug [${current.tenantSlug ?? ''}]: `)) || current.tenantSlug || '';
-    const email = (await prompt(`Email [${current.email ?? ''}]: `)) || current.email || '';
-    writeProfileConfig(profile, { base_url: baseUrl, tenant_slug: tenantSlug, email });
+    const currentCfg = readProfileConfig(profile);
+    const options = ENVIRONMENT_NAMES.map((name) => `${name} (${ENVIRONMENTS[name].base_url})`).join(', ');
+    const defaultChoice = currentCfg.environment ?? current.environment;
+    const envInput = (await prompt(`Environment [${defaultChoice}] — one of: ${options}, or a custom URL: `)) ||
+        defaultChoice;
+    const patch = {};
+    const unset = [];
+    if (ENVIRONMENT_NAMES.includes(envInput)) {
+        patch.environment = envInput;
+        unset.push('base_url');
+    }
+    else if (/^https?:\/\//.test(envInput)) {
+        patch.base_url = envInput;
+        unset.push('environment');
+    }
+    else {
+        die(`"${envInput}" is not a known environment or a URL. ` +
+            `Valid: ${ENVIRONMENT_NAMES.join(', ')} or http(s)://…`);
+    }
+    patch.tenant_slug =
+        (await prompt(`Default tenant slug [${current.tenantSlug ?? ''}]: `)) || current.tenantSlug || '';
+    patch.email = (await prompt(`Email [${current.email ?? ''}]: `)) || current.email || '';
+    writeProfileConfig(profile, patch, unset);
     process.stderr.write(`Saved profile "${profile}" → ${CONFIG_PATHS.config}\n`);
 });
 // -- login ------------------------------------------------------------------
@@ -163,7 +193,13 @@ program
             tenantSlug: tenant,
             expiresIn: opts.expiresIn ? Number(opts.expiresIn) : undefined,
         });
-        writeProfileConfig(profile, { base_url: baseUrl, tenant_slug: tenant, email });
+        // Only pin base_url into the profile when the user explicitly overrode it.
+        // Otherwise the environment selection (profile.environment) keeps driving baseUrl.
+        writeProfileConfig(profile, {
+            ...(opts.baseUrl ? { base_url: baseUrl } : {}),
+            tenant_slug: tenant,
+            email,
+        });
         writeProfileCreds(profile, {
             session_token: session.sessionToken,
             expires_at: session.expiresAt ?? '',
@@ -202,6 +238,7 @@ program
     const resolved = resolveProfile(profile);
     out({
         profile: resolved.profile,
+        environment: resolved.environment,
         baseUrl: resolved.baseUrl,
         tenantSlug: resolved.tenantSlug,
         email: resolved.email,
@@ -220,6 +257,38 @@ program
         return data;
     });
 });
+// -- env --------------------------------------------------------------------
+// Environments are baked from spec/openapi.yaml servers[] at build time.
+// Default (prod / or last-in-list) is chosen in scripts/gen-environments.mjs.
+const envCmd = program
+    .command('env')
+    .description('List and switch Alvera API environments');
+envCmd
+    .command('list')
+    .description('List available environments (from spec/openapi.yaml)')
+    .action(() => {
+    const profile = getProfileName(program.opts().profile);
+    const resolved = resolveProfile(profile);
+    out(ENVIRONMENT_NAMES.map((name) => ({
+        name,
+        baseUrl: ENVIRONMENTS[name].base_url,
+        description: ENVIRONMENTS[name].description,
+        default: name === DEFAULT_ENVIRONMENT,
+        active: name === resolved.environment,
+    })));
+});
+envCmd
+    .command('use <name>')
+    .description('Persist the selected environment to the profile (clears any custom base_url)')
+    .action((name) => {
+    if (!ENVIRONMENT_NAMES.includes(name)) {
+        die(`unknown environment "${name}". Valid: ${ENVIRONMENT_NAMES.join(', ')}`);
+    }
+    const profile = getProfileName(program.opts().profile);
+    writeProfileConfig(profile, { environment: name }, ['base_url']);
+    process.stderr.write(`Profile "${profile}" now uses environment "${name}" ` +
+        `(${ENVIRONMENTS[name].base_url}).\n`);
+});
 // -- tenants ----------------------------------------------------------------
 const tenants = program.command('tenants').description('Manage tenants');
 tenants
@@ -540,22 +609,109 @@ bodyOption(connectedApps
     });
 });
 // -- data-activation-clients -----------------------------------------------
-const dac = program.command('data-activation-clients').description('Data activation client actions');
-bodyOption(dac.command('ingest <slug> [tenant]').description('Ingest a JSON payload'))
-    .action(async (slug, tenant, opts) => {
+const dac = program.command('data-activation-clients').description('Manage data activation clients');
+dac
+    .command('list <datalake> [tenant]')
+    .description('List data activation clients in a datalake')
+    .action(async (datalake, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.dataActivationClients.list(resolveTenant(tenant, resolved.tenantSlug), datalake);
+        return data;
+    });
+});
+dac
+    .command('get <datalake> <slug> [tenant]')
+    .description('Get a data activation client by slug')
+    .action(async (datalake, slug, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.dataActivationClients.get(resolveTenant(tenant, resolved.tenantSlug), datalake, slug);
+        return data;
+    });
+});
+bodyOption(dac.command('create <datalake> [tenant]').description('Create a data activation client'))
+    .action(async (datalake, tenant, opts) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.dataActivationClients.create(resolveTenant(tenant, resolved.tenantSlug), datalake, readBody(opts.body, opts.bodyFile));
+        return data;
+    });
+});
+bodyOption(dac.command('update <datalake> <slug> [tenant]').description('Update a data activation client'))
+    .action(async (datalake, slug, tenant, opts) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.dataActivationClients.update(resolveTenant(tenant, resolved.tenantSlug), datalake, slug, readBody(opts.body, opts.bodyFile));
+        return data;
+    });
+});
+dac
+    .command('delete <datalake> <slug> [tenant]')
+    .description('Delete a data activation client')
+    .action(async (datalake, slug, tenant) => {
     await run(async () => {
         const { api, resolved } = authedApi(program.opts());
-        const { data } = await api.dataActivationClients.ingest(resolveTenant(tenant, resolved.tenantSlug), slug, readBody(opts.body, opts.bodyFile));
+        const { data } = await api.dataActivationClients.delete(resolveTenant(tenant, resolved.tenantSlug), datalake, slug);
         return data;
     });
 });
 dac
-    .command('ingest-file <slug> <key> [tenant]')
+    .command('metadata <datalake> <slug> [tenant]')
+    .description('Get markdown metadata for a data activation client')
+    .action(async (datalake, slug, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.dataActivationClients.metadata(resolveTenant(tenant, resolved.tenantSlug), datalake, slug);
+        return data;
+    });
+});
+bodyOption(dac
+    .command('run-manually <datalake> <slug> [tenant]')
+    .description('Trigger a manual run (optional --body for tool_call override)'))
+    .action(async (datalake, slug, tenant, opts) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const body = opts.body || opts.bodyFile ? readBody(opts.body, opts.bodyFile) : undefined;
+        const { data } = await api.dataActivationClients.runManually(resolveTenant(tenant, resolved.tenantSlug), datalake, slug, body);
+        return data;
+    });
+});
+bodyOption(dac.command('ingest <datalake> <slug> [tenant]').description('Ingest a JSON payload'))
+    .action(async (datalake, slug, tenant, opts) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.dataActivationClients.ingest(resolveTenant(tenant, resolved.tenantSlug), datalake, slug, readBody(opts.body, opts.bodyFile));
+        return data;
+    });
+});
+dac
+    .command('ingest-file <datalake> <slug> <key> [tenant]')
     .description('Ingest a previously uploaded file (key from upload-link)')
-    .action(async (slug, key, tenant) => {
+    .action(async (datalake, slug, key, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.dataActivationClients.ingestFile(resolveTenant(tenant, resolved.tenantSlug), datalake, slug, { key });
+        return data;
+    });
+});
+dac
+    .command('logs <datalake> <slug> [tenant]')
+    .description('List execution logs for a data activation client')
+    .action(async (datalake, slug, tenant) => {
     await run(async () => {
         const { api, resolved } = authedApi(program.opts());
-        const { data } = await api.dataActivationClients.ingestFile(resolveTenant(tenant, resolved.tenantSlug), slug, { key });
+        const { data } = await api.dataActivationClients.logs.list(resolveTenant(tenant, resolved.tenantSlug), datalake, slug);
+        return data;
+    });
+});
+dac
+    .command('log-get <datalake> <slug> <id> [tenant]')
+    .description('Get a single execution log by id')
+    .action(async (datalake, slug, id, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.dataActivationClients.logs.get(resolveTenant(tenant, resolved.tenantSlug), datalake, slug, id);
         return data;
     });
 });
@@ -575,6 +731,16 @@ datalakes
         return data;
     });
 });
+datalakes
+    .command('download-link <datalake> <bucket> <key> [tenant]')
+    .description('Create a presigned download URL for a datalake object')
+    .action(async (datalake, bucket, key, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.datalakes.createDownloadLink(resolveTenant(tenant, resolved.tenantSlug), datalake, { bucket, key });
+        return data;
+    });
+});
 // -- mdm --------------------------------------------------------------------
 const mdm = program.command('mdm').description('Master data management');
 bodyOption(mdm.command('verify <datalake> [tenant]').description('Fuzzy-verify an identity against MDM'))
@@ -585,8 +751,161 @@ bodyOption(mdm.command('verify <datalake> [tenant]').description('Fuzzy-verify a
         return data;
     });
 });
+// -- datalakes metadata + datasets metadata --------------------------------
+datalakes
+    .command('metadata <datalake> [tenant]')
+    .description('Get markdown metadata for a datalake')
+    .action(async (datalake, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.datalakes.metadata(resolveTenant(tenant, resolved.tenantSlug), datalake);
+        return data;
+    });
+});
+datasets
+    .command('metadata <dataset-type>')
+    .description('Get markdown schema metadata for a dataset type')
+    .option('--datalake-id <id>', 'restrict to a specific datalake')
+    .option('--generic-table-id <id>', 'required when dataset-type is generic_table')
+    .action(async (datasetType, opts) => {
+    await run(async () => {
+        const { api } = authedApi(program.opts());
+        const { data } = await api.datasets.metadata(datasetType, {
+            datalakeId: opts.datalakeId,
+            genericTableId: opts.genericTableId,
+        });
+        return data;
+    });
+});
+// -- interoperability-contracts --------------------------------------------
+const interop = program
+    .command('interoperability-contracts')
+    .alias('interop')
+    .description('Manage interoperability contracts');
+interop
+    .command('list <datalake> [tenant]')
+    .description('List interoperability contracts in a datalake')
+    .action(async (datalake, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.interoperabilityContracts.list(resolveTenant(tenant, resolved.tenantSlug), datalake);
+        return data;
+    });
+});
+interop
+    .command('get <datalake> <slug> [tenant]')
+    .description('Get a contract by slug')
+    .action(async (datalake, slug, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.interoperabilityContracts.get(resolveTenant(tenant, resolved.tenantSlug), datalake, slug);
+        return data;
+    });
+});
+bodyOption(interop.command('create <datalake> [tenant]').description('Create a contract'))
+    .action(async (datalake, tenant, opts) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.interoperabilityContracts.create(resolveTenant(tenant, resolved.tenantSlug), datalake, readBody(opts.body, opts.bodyFile));
+        return data;
+    });
+});
+bodyOption(interop.command('update <datalake> <slug> [tenant]').description('Update a contract'))
+    .action(async (datalake, slug, tenant, opts) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.interoperabilityContracts.update(resolveTenant(tenant, resolved.tenantSlug), datalake, slug, readBody(opts.body, opts.bodyFile));
+        return data;
+    });
+});
+interop
+    .command('delete <datalake> <slug> [tenant]')
+    .description('Delete a contract')
+    .action(async (datalake, slug, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.interoperabilityContracts.delete(resolveTenant(tenant, resolved.tenantSlug), datalake, slug);
+        return data;
+    });
+});
+interop
+    .command('metadata <datalake> <slug> [tenant]')
+    .description('Get markdown metadata for a contract')
+    .action(async (datalake, slug, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.interoperabilityContracts.metadata(resolveTenant(tenant, resolved.tenantSlug), datalake, slug);
+        return data;
+    });
+});
+bodyOption(interop
+    .command('run <datalake> <slug> [tenant]')
+    .description('Execute a contract against a raw source row'))
+    .action(async (datalake, slug, tenant, opts) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.interoperabilityContracts.run(resolveTenant(tenant, resolved.tenantSlug), datalake, slug, readBody(opts.body, opts.bodyFile));
+        return data;
+    });
+});
 // -- workflows --------------------------------------------------------------
 const workflows = program.command('workflows').description('Agentic workflows');
+workflows
+    .command('list <datalake> [tenant]')
+    .description('List workflow definitions in a datalake')
+    .action(async (datalake, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.workflows.list(resolveTenant(tenant, resolved.tenantSlug), datalake);
+        return data;
+    });
+});
+workflows
+    .command('get <datalake> <id> [tenant]')
+    .description('Get a workflow by id')
+    .action(async (datalake, id, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.workflows.get(resolveTenant(tenant, resolved.tenantSlug), datalake, id);
+        return data;
+    });
+});
+bodyOption(workflows.command('create <datalake> [tenant]').description('Create a workflow'))
+    .action(async (datalake, tenant, opts) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.workflows.create(resolveTenant(tenant, resolved.tenantSlug), datalake, readBody(opts.body, opts.bodyFile));
+        return data;
+    });
+});
+bodyOption(workflows.command('update <datalake> <id> [tenant]').description('Update a workflow'))
+    .action(async (datalake, id, tenant, opts) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.workflows.update(resolveTenant(tenant, resolved.tenantSlug), datalake, id, readBody(opts.body, opts.bodyFile));
+        return data;
+    });
+});
+workflows
+    .command('delete <datalake> <id> [tenant]')
+    .description('Delete a workflow')
+    .action(async (datalake, id, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.workflows.delete(resolveTenant(tenant, resolved.tenantSlug), datalake, id);
+        return data;
+    });
+});
+workflows
+    .command('metadata <datalake> <id> [tenant]')
+    .description('Get markdown metadata for a workflow')
+    .action(async (datalake, id, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.workflows.metadata(resolveTenant(tenant, resolved.tenantSlug), datalake, id);
+        return data;
+    });
+});
 bodyOption(workflows.command('execute <workflow-slug> [tenant]').description('Execute an agentic workflow'))
     .action(async (workflowSlug, tenant, opts) => {
     await run(async () => {
@@ -595,5 +914,95 @@ bodyOption(workflows.command('execute <workflow-slug> [tenant]').description('Ex
         return data;
     });
 });
+bodyOption(workflows
+    .command('run <workflow-slug> [tenant]')
+    .description('Run a workflow across records matched by a SQL WHERE clause'))
+    .action(async (workflowSlug, tenant, opts) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.workflows.run(resolveTenant(tenant, resolved.tenantSlug), workflowSlug, readBody(opts.body, opts.bodyFile));
+        return data;
+    });
+});
+workflows
+    .command('batch-logs <workflow-slug> [tenant]')
+    .description('List batch logs for a workflow')
+    .action(async (workflowSlug, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.workflows.batchLogs.list(resolveTenant(tenant, resolved.tenantSlug), workflowSlug);
+        return data;
+    });
+});
+workflows
+    .command('batch-log <workflow-slug> <id> [tenant]')
+    .description('Get a single batch log by id')
+    .action(async (workflowSlug, id, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.workflows.batchLogs.get(resolveTenant(tenant, resolved.tenantSlug), workflowSlug, id);
+        return data;
+    });
+});
+workflows
+    .command('batch-log-start <workflow-slug> <id> [tenant]')
+    .description('Start polling a batch log')
+    .action(async (workflowSlug, id, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.workflows.batchLogs.start(resolveTenant(tenant, resolved.tenantSlug), workflowSlug, id);
+        return data;
+    });
+});
+workflows
+    .command('batch-log-stop <workflow-slug> <id> [tenant]')
+    .description('Stop polling a batch log')
+    .action(async (workflowSlug, id, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.workflows.batchLogs.stop(resolveTenant(tenant, resolved.tenantSlug), workflowSlug, id);
+        return data;
+    });
+});
+workflows
+    .command('batch-log-refresh <workflow-slug> <id> [tenant]')
+    .description('Force-refresh a batch log')
+    .action(async (workflowSlug, id, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.workflows.batchLogs.refresh(resolveTenant(tenant, resolved.tenantSlug), workflowSlug, id);
+        return data;
+    });
+});
+workflows
+    .command('workflow-logs <workflow-slug> [tenant]')
+    .description('List execution logs for a workflow')
+    .action(async (workflowSlug, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.workflows.workflowLogs.list(resolveTenant(tenant, resolved.tenantSlug), workflowSlug);
+        return data;
+    });
+});
+workflows
+    .command('workflow-log <workflow-slug> <id> [tenant]')
+    .description('Get a single execution log by id')
+    .action(async (workflowSlug, id, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.workflows.workflowLogs.get(resolveTenant(tenant, resolved.tenantSlug), workflowSlug, id);
+        return data;
+    });
+});
+workflows
+    .command('workflow-log-download <workflow-slug> <id> [tenant]')
+    .description('Get a presigned download URL for an execution log')
+    .action(async (workflowSlug, id, tenant) => {
+    await run(async () => {
+        const { api, resolved } = authedApi(program.opts());
+        const { data } = await api.workflows.workflowLogs.download(resolveTenant(tenant, resolved.tenantSlug), workflowSlug, id);
+        return data;
+    });
+});
 program.parseAsync();
 //# sourceMappingURL=cli.js.map