@kweaver-ai/kweaver-sdk 0.6.4 → 0.6.6

package/dist/commands/auth.js

@@ -1,18 +1,7 @@
 import { isNoAuth } from "../config/no-auth.js";
 import { autoSelectBusinessDomain, clearPlatformSession, deletePlatform, deleteUser, getActiveUser, getConfigDir, getCurrentPlatform, getPlatformAlias, hasPlatform, listPlatforms, listUserProfiles, loadClientConfig, loadTokenConfig, resolveBusinessDomain, resolvePlatformIdentifier, resolveUserId, saveNoAuthPlatform, setActiveUser, setCurrentPlatform, setPlatformAlias, } from "../config/store.js";
 import { decodeJwtPayload } from "../config/jwt.js";
-import { buildCopyCommand, formatHttpError, isStudiowebShellUnavailableError, normalizeBaseUrl, oauth2Login, oauth2PasswordSigninLogin, playwrightLogin, refreshTokenLogin, } from "../auth/oauth.js";
-/** True when the `playwright` npm package can be imported (browser binaries may still need `npx playwright install`). */
-async function isPlaywrightPackageResolvable() {
-    try {
-        const modName = "playwright";
-        await import(/* webpackIgnore: true */ modName);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
+import { buildCopyCommand, formatHttpError, normalizeBaseUrl, oauth2Login, oauth2PasswordSigninLogin, promptForUsername, promptForPassword, refreshTokenLogin, } from "../auth/oauth.js";
 export async function runAuthCommand(args) {
     const target = args[0];
     const rest = args.slice(1);
@@ -39,24 +28,24 @@ Login options:
                          Requires --client-id and --client-secret.
                          Get these from the callback page after browser login or \`auth export\`.
   --port <n>             Local callback port (default: 9010). Use when 9010 is occupied.
-  --no-browser           Do not open a browser; print the auth URL and prompt for the callback URL or code (stdin).
-                         Use on headless servers or when automatic browser launch fails.
-  -u, --username         Username (with -p: tries HTTP /oauth2/signin first when the Studio web shell is available)
-  -p, --password         Password (with -u: falls back to Playwright headless only when studioweb is unavailable and Playwright is installed)
-  --http-signin          With -u/-p: HTTP POST /oauth2/signin only (no Playwright fallback). Uses the built-in RSA public key.
-  --playwright           With -u/-p: force Playwright (skip HTTP sign-in). Without -u/-p: open Playwright for manual login.
+  --no-browser           Do not open a browser. Without -u/-p: print the auth URL and prompt for the
+                         callback URL or code (stdin). With -u and/or -p: route through HTTP sign-in
+                         (any missing credential is prompted; password is hidden when stdin is a TTY).
+  -u, --username         Username for HTTP /oauth2/signin (POST). If -p is omitted, password is prompted.
+  -p, --password         Password for HTTP /oauth2/signin (POST). If -u is omitted, username is prompted.
+  --http-signin          Force HTTP /oauth2/signin (no browser). Missing -u/-p are prompted from stdin.
   --insecure, -k         Skip TLS certificate verification (self-signed / dev HTTPS only)
   --no-auth              Save platform without OAuth (servers with no authentication). Same as detecting OAuth 404 during login.`);
         return 0;
     }
     if (target === "login") {
         if (rest[0] === "--help" || rest[0] === "-h") {
-            console.log(`kweaver auth login <platform-url> [--alias <name>] [--no-auth] [--no-browser] [-u user] [-p pass] [--http-signin] [--playwright] [--refresh-token T --client-id ID --client-secret S]`);
+            console.log(`kweaver auth login <platform-url> [--alias <name>] [--no-auth] [--no-browser] [-u user] [-p pass] [--http-signin] [--refresh-token T --client-id ID --client-secret S]`);
             return 0;
         }
         const url = rest[0];
         if (!url || url.startsWith("-")) {
-            console.error("Usage: kweaver auth login <platform-url> [--alias <name>] [-u user] [-p pass] [--playwright]");
+            console.error("Usage: kweaver auth login <platform-url> [--alias <name>] [-u user] [-p pass]");
             return 1;
         }
         return runAuthCommand([url, ...rest.slice(1)]);
@@ -78,9 +67,8 @@ Login options:
         try {
             const normalizedTarget = normalizeBaseUrl(target);
             const alias = readOption(args, "--alias");
-            const username = readOption(args, "--username") ?? readOption(args, "-u");
-            const password = readOption(args, "--password") ?? readOption(args, "-p");
-            const usePlaywright = args.includes("--playwright");
+            let username = readOption(args, "--username") ?? readOption(args, "-u");
+            let password = readOption(args, "--password") ?? readOption(args, "-p");
             const httpSignin = args.includes("--http-signin");
             const oauthProduct = readOption(args, "--oauth-product");
             const signinPublicKeyFile = readOption(args, "--signin-public-key-file");
@@ -101,7 +89,7 @@ Login options:
                 "--http-signin",
                 "--oauth-product",
                 "--signin-public-key-file",
-                "--playwright", "--insecure", "-k", "--no-auth", "--redirect-uri",
+                "--insecure", "-k", "--no-auth", "--redirect-uri",
             ]);
             const KNOWN_VALUE_FLAGS = new Set([
                 "--alias", "--client-id", "--client-secret", "--refresh-token",
@@ -130,30 +118,34 @@ Login options:
             if (noAuth && noBrowser) {
                 console.error("--no-auth does not require a browser; --no-browser is ignored.");
             }
-            if (noAuth && (username || password || usePlaywright || httpSignin)) {
-                console.error("--no-auth cannot be used with Playwright login, HTTP sign-in, or -u/-p.");
+            if (noAuth && (username || password || httpSignin)) {
+                console.error("--no-auth cannot be used with HTTP sign-in or -u/-p.");
                 return 1;
             }
-            if (noBrowser && (username || password || usePlaywright || httpSignin)) {
-                console.error("--no-browser cannot be used with Playwright login, HTTP sign-in, or -u/-p.");
-                return 1;
-            }
-            if (httpSignin && usePlaywright) {
-                console.error("--http-signin cannot be used with --playwright.");
-                return 1;
+            if (noBrowser && httpSignin) {
+                // HTTP sign-in already runs without a browser; --no-browser is a no-op signal here.
+                console.error("--http-signin already runs without a browser; --no-browser is redundant and ignored.");
             }
             if (httpSignin && refreshToken) {
                 console.error("--http-signin cannot be used with --refresh-token.");
                 return 1;
             }
-            if (httpSignin && (!username || !password)) {
-                console.error("--http-signin requires -u/--username and -p/--password.");
-                return 1;
-            }
             if (noBrowser && refreshToken) {
                 console.error("--no-browser cannot be used with --refresh-token.");
                 return 1;
             }
+            // Headless credential login: if the user signalled HTTP sign-in (--http-signin,
+            // or partial -u/-p, or --no-browser combined with -u/-p) but didn't provide both
+            // credentials inline, prompt for the missing one(s) on stderr. Password is read
+            // without echo when stdin is a TTY.
+            const wantsCredentialLogin = !noAuth && !refreshToken &&
+                (httpSignin || (noBrowser && (username || password)) || (!!username !== !!password));
+            if (wantsCredentialLogin) {
+                if (!username)
+                    username = await promptForUsername("Username");
+                if (!password)
+                    password = await promptForPassword("Password");
+            }
             let token;
             if (noAuth) {
                 token = saveNoAuthPlatform(normalizedTarget, { tlsInsecure });
@@ -182,17 +174,9 @@ Login options:
                     signinPublicKeyPemPath: signinPublicKeyFile ?? undefined,
                 });
             }
-            else if (username && password && usePlaywright) {
-                console.log("Logging in (headless, Playwright)...");
-                token = await playwrightLogin(normalizedTarget, {
-                    username,
-                    password,
-                    tlsInsecure,
-                    port: customPort,
-                });
-            }
             else if (username && password) {
-                const signinOpts = {
+                console.log("Logging in (HTTP /oauth2/signin)...");
+                token = await oauth2PasswordSigninLogin(normalizedTarget, {
                     username,
                     password,
                     tlsInsecure,
@@ -201,39 +185,6 @@ Login options:
                     clientSecret: clientSecret ?? undefined,
                     oauthProduct: oauthProduct ?? undefined,
                     signinPublicKeyPemPath: signinPublicKeyFile ?? undefined,
-                };
-                console.log("Logging in (HTTP /oauth2/signin)...");
-                try {
-                    token = await oauth2PasswordSigninLogin(normalizedTarget, signinOpts);
-                }
-                catch (err) {
-                    if (!isStudiowebShellUnavailableError(err)) {
-                        throw err;
-                    }
-                    const playwrightOk = await isPlaywrightPackageResolvable();
-                    if (playwrightOk) {
-                        process.stderr.write("Studio web sign-in shell is not available; falling back to Playwright headless login.\n");
-                        console.log("Logging in (headless, Playwright)...");
-                        token = await playwrightLogin(normalizedTarget, {
-                            username,
-                            password,
-                            tlsInsecure,
-                            port: customPort,
-                        });
-                    }
-                    else {
-                        console.error("Studio web sign-in shell is not available on this platform, and the Playwright package is not installed.");
-                        console.error("Install Playwright for headless browser login: npm install playwright && npx playwright install chromium");
-                        console.error("Alternatively, use OAuth without credentials:");
-                        console.error(`  kweaver auth login ${normalizedTarget} --no-browser`);
-                        throw err;
-                    }
-                }
-            }
-            else if (usePlaywright) {
-                console.log("Opening browser for login (Playwright)...");
-                token = await playwrightLogin(normalizedTarget, {
-                    tlsInsecure, port: customPort,
                 });
             }
             else {
@@ -456,7 +407,7 @@ Login options:
         console.log(`Run \`kweaver auth login ${logoutTarget}\` to sign in again.`);
         return 0;
     }
-    console.error("Usage: kweaver auth login <platform-url> [--alias <name>] [-u user] [-p pass] [--playwright]");
+    console.error("Usage: kweaver auth login <platform-url> [--alias <name>] [-u user] [-p pass]");
     console.error("       kweaver auth whoami [platform-url|alias] [--json]");
     console.error("       kweaver auth export [platform-url|alias] [--json]");
     console.error("       kweaver auth status [platform-url|alias]");

package/dist/commands/bkn-ops.d.ts

@@ -49,6 +49,7 @@ export declare function parseKnCreateFromCsvArgs(args: string[]): {
     batchSize: number;
     tables: string[];
     build: boolean;
+    recreate: boolean;
     timeout: number;
     businessDomain: string;
 };

package/dist/commands/bkn-ops.js

@@ -706,6 +706,7 @@ Options:
   --tables <a,b>       Tables to include in KN (default: all imported)
   --build (default)    Build after creation
   --no-build           Skip build
+  --recreate           Use "insert" mode on first batch (only effective for new tables)
   --timeout <n>        Build timeout in seconds (default: 300)
   -bd, --biz-domain    Business domain (default: bd_public)`;
 export function parseKnCreateFromCsvArgs(args) {
@@ -716,6 +717,7 @@ export function parseKnCreateFromCsvArgs(args) {
     let batchSize = 500;
     let tablesStr = "";
     let build = true;
+    let recreate = false;
     let timeout = 300;
     let businessDomain = "";
     for (let i = 0; i < args.length; i += 1) {
@@ -752,6 +754,10 @@ export function parseKnCreateFromCsvArgs(args) {
             build = false;
             continue;
         }
+        if (arg === "--recreate") {
+            recreate = true;
+            continue;
+        }
         if (arg === "--timeout" && args[i + 1]) {
             timeout = parseInt(args[++i], 10);
             if (Number.isNaN(timeout) || timeout < 1)
@@ -772,7 +778,7 @@ export function parseKnCreateFromCsvArgs(args) {
     }
     if (!businessDomain)
         businessDomain = resolveBusinessDomain();
-    return { dsId, files, name, tablePrefix, batchSize, tables, build, timeout, businessDomain };
+    return { dsId, files, name, tablePrefix, batchSize, tables, build, recreate, timeout, businessDomain };
 }
 export async function runKnCreateFromCsvCommand(args) {
     let options;
@@ -795,6 +801,7 @@ export async function runKnCreateFromCsvCommand(args) {
         "--table-prefix", options.tablePrefix,
         "--batch-size", String(options.batchSize),
         "-bd", options.businessDomain,
+        ...(options.recreate ? ["--recreate"] : []),
     ];
     const importResult = await runDsImportCsv(importArgs);
     if (importResult.code !== 0) {

package/dist/commands/call.d.ts

@@ -1,8 +1,18 @@
+export type FormField = {
+    name: string;
+    kind: "string";
+    value: string;
+} | {
+    name: string;
+    kind: "file";
+    path: string;
+};
 export interface CallInvocation {
     url: string;
     method: string;
     headers: Headers;
     body?: string;
+    formFields?: FormField[];
     pretty: boolean;
     verbose: boolean;
     businessDomain: string;

package/dist/commands/call.js

@@ -1,3 +1,5 @@
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
 import { ensureValidToken, formatHttpError, with401RefreshRetry } from "../auth/oauth.js";
 import { isNoAuth } from "../config/no-auth.js";
 import { HttpError } from "../utils/http.js";
@@ -6,6 +8,7 @@ export function parseCallArgs(args) {
     const headers = new Headers();
     let method = "GET";
     let body;
+    const formFields = [];
     let url;
     let pretty = true;
     let verbose = false;
@@ -40,6 +43,26 @@ export function parseCallArgs(args) {
             index += 1;
             continue;
         }
+        if (arg === "-F" || arg === "--form") {
+            const raw = args[index + 1];
+            if (!raw)
+                throw new Error("Missing value for -F flag");
+            const eq = raw.indexOf("=");
+            if (eq === -1)
+                throw new Error(`Invalid -F format: ${raw} (expected key=value or key=@path)`);
+            const name = raw.slice(0, eq);
+            const rhs = raw.slice(eq + 1);
+            if (rhs.startsWith("@")) {
+                formFields.push({ name, kind: "file", path: rhs.slice(1) });
+            }
+            else {
+                formFields.push({ name, kind: "string", value: rhs });
+            }
+            if (method === "GET")
+                method = "POST";
+            index += 1;
+            continue;
+        }
         if (arg === "--pretty") {
             pretty = true;
             continue;
@@ -70,9 +93,21 @@ export function parseCallArgs(args) {
     if (!url) {
         throw new Error("Missing request URL");
     }
+    if (formFields.length > 0 && body !== undefined) {
+        throw new Error("-F and -d are mutually exclusive");
+    }
     if (!businessDomain)
         businessDomain = resolveBusinessDomain();
-    return { url, method, headers, body, pretty, verbose, businessDomain };
+    return {
+        url,
+        method,
+        headers,
+        body,
+        formFields: formFields.length > 0 ? formFields : undefined,
+        pretty,
+        verbose,
+        businessDomain,
+    };
 }
 function injectAuthHeaders(headers, accessToken, businessDomain) {
     if (!isNoAuth(accessToken)) {
@@ -115,12 +150,17 @@ export function formatVerboseRequest(invocation) {
     for (const [name, value] of entries) {
         lines.push(`  ${name}: ${value}`);
     }
-    lines.push(`Body: ${invocation.body ? "present" : "empty"}`);
+    const bodyDesc = invocation.formFields && invocation.formFields.length > 0
+        ? `multipart (${invocation.formFields.length} field${invocation.formFields.length > 1 ? "s" : ""})`
+        : invocation.body
+            ? "present"
+            : "empty";
+    lines.push(`Body: ${bodyDesc}`);
     return lines;
 }
 export async function runCallCommand(args) {
     if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
-        console.log(`kweaver call <url> [-X METHOD] [-H "Name: value"] [-d BODY] [--pretty] [--verbose] [-bd value]
+        console.log(`kweaver call <url> [-X METHOD] [-H "Name: value"] [-d BODY] [-F key=value] [--pretty] [--verbose] [-bd value]
 
 Call an API with curl-style flags and auto-injected token headers.
 
@@ -129,6 +169,7 @@ Options:
   -X, --request      HTTP method (default: GET)
   -H, --header       Extra header (repeatable)
   -d, --data, --data-raw   JSON request body (sets Content-Type: application/json if not set)
+  -F, --form         Multipart form field. -F key=value or -F key=@/path/to/file. Repeatable. Mutually exclusive with -d.
   -bd, --biz-domain  Override x-business-domain (default: bd_public)
   -v, --verbose      Print request info to stderr
   --pretty           Pretty-print JSON output (default)`);
@@ -150,7 +191,22 @@ Options:
             : invocation.url;
         const headers = new Headers(invocation.headers);
         injectAuthHeaders(headers, token.accessToken, invocation.businessDomain);
-        if (invocation.body !== undefined &&
+        let requestBody = invocation.body;
+        if (invocation.formFields && invocation.formFields.length > 0) {
+            const form = new FormData();
+            for (const field of invocation.formFields) {
+                if (field.kind === "string") {
+                    form.append(field.name, field.value);
+                }
+                else {
+                    const buf = await readFile(field.path);
+                    form.append(field.name, new Blob([buf]), basename(field.path));
+                }
+            }
+            requestBody = form;
+            // do not set content-type — fetch sets multipart boundary
+        }
+        else if (invocation.body !== undefined &&
             invocation.body.length > 0 &&
             !headers.has("content-type") &&
             !headers.has("Content-Type")) {
@@ -164,7 +220,7 @@ Options:
         const response = await fetch(url, {
             method: invocation.method,
             headers,
-            body: invocation.body,
+            body: requestBody,
         });
         const rawText = await response.text();
         const text = stripSseDoneMarker(rawText, response.headers.get("content-type"));

package/dist/commands/ds.js

@@ -466,7 +466,7 @@ export async function runDsImportCsv(args) {
                 process.stderr.write(`${elapsed}s\n`);
             }
             catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
+                const msg = formatHttpError(err);
                 process.stderr.write(`FAILED\n`);
                 console.error(`[${tableName}] batch ${batchLabel} error: ${msg}`);
                 batchFailed = true;

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

@@ -19,7 +19,7 @@ export interface DagBodyOptions {
     tableExist: boolean;
     data: Array<Record<string, string | null>>;
     fieldMappings: FieldMapping[];
-    /** When true on the first batch (`tableExist` false), use overwrite to drop/recreate table before import. */
+    /** When true on the first batch (`tableExist` false), use "insert" to force table recreation. */
     recreate?: boolean;
 }
 /**

package/dist/commands/import-csv.js

@@ -82,7 +82,9 @@ export function buildFieldMappings(headers) {
 export function buildDagBody(options) {
     const { datasourceId, datasourceType, tableName, tableExist, data, fieldMappings, recreate } = options;
     const ts = Date.now();
-    const operateType = tableExist ? "append" : recreate ? "overwrite" : "append";
+    // "insert" creates/replaces the table; "append" adds rows to an existing table.
+    // With --recreate, use "insert" on first batch to force table recreation when schema changed.
+    const operateType = tableExist ? "append" : recreate ? "insert" : "append";
     const triggerStep = {
         id: "step-trigger",
         title: "Trigger",

package/dist/commands/tool.d.ts

@@ -0,0 +1,16 @@
+export declare function runToolCommand(args: string[]): Promise<number>;
+export interface ToolUploadOptions {
+    boxId: string;
+    filePath: string;
+    metadataType: "openapi";
+    businessDomain: string;
+    pretty: boolean;
+}
+export declare function parseToolUploadArgs(args: string[]): ToolUploadOptions;
+export interface ToolStatusOptions {
+    boxId: string;
+    toolIds: string[];
+    status: "enabled" | "disabled";
+    businessDomain: string;
+}
+export declare function parseToolStatusArgs(args: string[], status: "enabled" | "disabled"): ToolStatusOptions;

package/dist/commands/tool.js

@@ -0,0 +1,208 @@
+import { access } from "node:fs/promises";
+import { ensureValidToken, formatHttpError, with401RefreshRetry } from "../auth/oauth.js";
+import { listTools, setToolStatuses, uploadTool } from "../api/toolboxes.js";
+import { formatCallOutput } from "./call.js";
+import { resolveBusinessDomain } from "../config/store.js";
+const HELP = `kweaver tool
+
+Subcommands:
+  upload --toolbox <box-id> <openapi-spec-path> [--metadata-type openapi]
+                                          Upload an OpenAPI spec file as a tool
+  list --toolbox <box-id>                  List tools in a toolbox
+  enable --toolbox <box-id> <tool-id>...   Enable one or more tools
+  disable --toolbox <box-id> <tool-id>...  Disable one or more tools
+
+Options:
+  -bd, --biz-domain <s>   Business domain (default: bd_public)
+  --pretty                Pretty-print JSON (default)
+  --compact               Single-line JSON (pipeline-friendly)`;
+export async function runToolCommand(args) {
+    const [subcommand, ...rest] = args;
+    if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+        console.log(HELP);
+        return 0;
+    }
+    const dispatch = () => {
+        if (subcommand === "upload")
+            return runToolUpload(rest);
+        if (subcommand === "list")
+            return runToolList(rest);
+        if (subcommand === "enable")
+            return runToolStatus(rest, "enabled");
+        if (subcommand === "disable")
+            return runToolStatus(rest, "disabled");
+        return Promise.resolve(-1);
+    };
+    try {
+        return await with401RefreshRetry(async () => {
+            const code = await dispatch();
+            if (code === -1) {
+                console.error(`Unknown tool subcommand: ${subcommand}`);
+                return 1;
+            }
+            return code;
+        });
+    }
+    catch (error) {
+        console.error(formatHttpError(error));
+        return 1;
+    }
+}
+export function parseToolUploadArgs(args) {
+    let boxId = "";
+    let filePath = "";
+    let metadataType = "openapi";
+    let businessDomain = "";
+    let pretty = true;
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if (a === "--toolbox" && args[i + 1]) {
+            boxId = args[++i];
+            continue;
+        }
+        if (a === "--metadata-type" && args[i + 1]) {
+            const val = args[++i];
+            if (val !== "openapi") {
+                throw new Error(`Unsupported --metadata-type: ${val} (only "openapi" is supported)`);
+            }
+            metadataType = val;
+            continue;
+        }
+        if ((a === "-bd" || a === "--biz-domain") && args[i + 1]) {
+            businessDomain = args[++i];
+            continue;
+        }
+        if (a === "--pretty") {
+            pretty = true;
+            continue;
+        }
+        if (a === "--compact") {
+            pretty = false;
+            continue;
+        }
+        if (!a.startsWith("-") && !filePath) {
+            filePath = a;
+            continue;
+        }
+    }
+    if (!boxId)
+        throw new Error("Missing required flag: --toolbox");
+    if (!filePath)
+        throw new Error("Missing required positional argument: <file-path>");
+    if (!businessDomain)
+        businessDomain = resolveBusinessDomain();
+    return { boxId, filePath, metadataType, businessDomain, pretty };
+}
+async function runToolUpload(args) {
+    let opts;
+    try {
+        opts = parseToolUploadArgs(args);
+    }
+    catch (e) {
+        console.error(e instanceof Error ? e.message : String(e));
+        return 1;
+    }
+    try {
+        await access(opts.filePath);
+    }
+    catch {
+        console.error(`File not found: ${opts.filePath}`);
+        return 1;
+    }
+    const token = await ensureValidToken();
+    const body = await uploadTool({
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        businessDomain: opts.businessDomain,
+        boxId: opts.boxId,
+        filePath: opts.filePath,
+        metadataType: opts.metadataType,
+    });
+    console.log(formatCallOutput(body, opts.pretty));
+    return 0;
+}
+// ── list ──────────────────────────────────────────────────────────────────────
+async function runToolList(args) {
+    let boxId = "";
+    let businessDomain = "";
+    let pretty = true;
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if (a === "--toolbox" && args[i + 1]) {
+            boxId = args[++i];
+            continue;
+        }
+        if ((a === "-bd" || a === "--biz-domain") && args[i + 1]) {
+            businessDomain = args[++i];
+            continue;
+        }
+        if (a === "--pretty") {
+            pretty = true;
+            continue;
+        }
+        if (a === "--compact") {
+            pretty = false;
+            continue;
+        }
+    }
+    if (!boxId) {
+        console.error("Missing required flag: --toolbox");
+        return 1;
+    }
+    if (!businessDomain)
+        businessDomain = resolveBusinessDomain();
+    const token = await ensureValidToken();
+    const body = await listTools({
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        businessDomain,
+        boxId,
+    });
+    console.log(formatCallOutput(body, pretty));
+    return 0;
+}
+export function parseToolStatusArgs(args, status) {
+    let boxId = "";
+    let businessDomain = "";
+    const toolIds = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if (a === "--toolbox" && args[i + 1]) {
+            boxId = args[++i];
+            continue;
+        }
+        if ((a === "-bd" || a === "--biz-domain") && args[i + 1]) {
+            businessDomain = args[++i];
+            continue;
+        }
+        if (!a.startsWith("-"))
+            toolIds.push(a);
+    }
+    if (!boxId)
+        throw new Error("Missing required flag: --toolbox");
+    if (toolIds.length === 0)
+        throw new Error("Missing tool id(s)");
+    if (!businessDomain)
+        businessDomain = resolveBusinessDomain();
+    return { boxId, toolIds, status, businessDomain };
+}
+async function runToolStatus(args, status) {
+    let opts;
+    try {
+        opts = parseToolStatusArgs(args, status);
+    }
+    catch (e) {
+        console.error(e instanceof Error ? e.message : String(e));
+        return 1;
+    }
+    const token = await ensureValidToken();
+    await setToolStatuses({
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        businessDomain: opts.businessDomain,
+        boxId: opts.boxId,
+        updates: opts.toolIds.map((toolId) => ({ toolId, status: opts.status })),
+    });
+    console.error(`${status === "enabled" ? "Enabled" : "Disabled"} ${opts.toolIds.length} tool(s) in toolbox ${opts.boxId}`);
+    return 0;
+}

package/dist/commands/toolbox.d.ts

@@ -0,0 +1,14 @@
+export declare function runToolboxCommand(args: string[]): Promise<number>;
+export interface ToolboxCreateOptions {
+    name: string;
+    serviceUrl: string;
+    description: string;
+    businessDomain: string;
+    pretty: boolean;
+}
+export declare function parseToolboxCreateArgs(args: string[]): ToolboxCreateOptions;
+export interface ToolboxSetStatusOptions {
+    boxId: string;
+    businessDomain: string;
+}
+export declare function parseToolboxSetStatusArgs(args: string[]): ToolboxSetStatusOptions;