@kweaver-ai/kweaver-sdk 0.6.3 → 0.6.5

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;

package/dist/commands/toolbox.js

@@ -0,0 +1,256 @@
+import { createInterface } from "node:readline";
+import { ensureValidToken, formatHttpError, with401RefreshRetry } from "../auth/oauth.js";
+import { createToolbox, deleteToolbox, listToolboxes, setToolboxStatus } from "../api/toolboxes.js";
+import { formatCallOutput } from "./call.js";
+import { resolveBusinessDomain } from "../config/store.js";
+const HELP = `kweaver toolbox
+
+Subcommands:
+  create --name <n> --service-url <url> [--description <d>]   Create a new toolbox
+  list [--keyword <s>] [--limit <n>] [--offset <n>]           List toolboxes
+  publish <box-id>                                            Publish a toolbox (status=published)
+  unpublish <box-id>                                          Unpublish (status=draft)
+  delete <box-id> [-y|--yes]                                  Delete a toolbox
+
+Options:
+  -bd, --biz-domain <s>   Business domain (default: bd_public)
+  --pretty                Pretty-print JSON (default)
+  --compact               Single-line JSON (pipeline-friendly)`;
+export async function runToolboxCommand(args) {
+    const [subcommand, ...rest] = args;
+    if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+        console.log(HELP);
+        return 0;
+    }
+    const dispatch = () => {
+        if (subcommand === "create")
+            return runToolboxCreate(rest);
+        if (subcommand === "list")
+            return runToolboxList(rest);
+        if (subcommand === "publish")
+            return runToolboxSetStatus(rest, "published");
+        if (subcommand === "unpublish")
+            return runToolboxSetStatus(rest, "draft");
+        if (subcommand === "delete")
+            return runToolboxDelete(rest);
+        return Promise.resolve(-1);
+    };
+    try {
+        return await with401RefreshRetry(async () => {
+            const code = await dispatch();
+            if (code === -1) {
+                console.error(`Unknown toolbox subcommand: ${subcommand}`);
+                return 1;
+            }
+            return code;
+        });
+    }
+    catch (error) {
+        console.error(formatHttpError(error));
+        return 1;
+    }
+}
+export function parseToolboxCreateArgs(args) {
+    let name = "";
+    let serviceUrl = "";
+    let description = "";
+    let businessDomain = "";
+    let pretty = true;
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if (a === "--name" && args[i + 1]) {
+            name = args[++i];
+            continue;
+        }
+        if (a === "--service-url" && args[i + 1]) {
+            serviceUrl = args[++i];
+            continue;
+        }
+        if (a === "--description" && args[i + 1]) {
+            description = 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 (!name)
+        throw new Error("Missing required flag: --name");
+    if (!serviceUrl)
+        throw new Error("Missing required flag: --service-url");
+    if (!businessDomain)
+        businessDomain = resolveBusinessDomain();
+    return { name, serviceUrl, description, businessDomain, pretty };
+}
+async function runToolboxCreate(args) {
+    let opts;
+    try {
+        opts = parseToolboxCreateArgs(args);
+    }
+    catch (e) {
+        console.error(e instanceof Error ? e.message : String(e));
+        return 1;
+    }
+    const token = await ensureValidToken();
+    const body = await createToolbox({
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        name: opts.name,
+        description: opts.description,
+        serviceUrl: opts.serviceUrl,
+        businessDomain: opts.businessDomain,
+    });
+    console.log(formatCallOutput(body, opts.pretty));
+    return 0;
+}
+// ── list ──────────────────────────────────────────────────────────────────────
+async function runToolboxList(args) {
+    let keyword;
+    let limit;
+    let offset;
+    let businessDomain = "";
+    let pretty = true;
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if (a === "--keyword" && args[i + 1]) {
+            keyword = args[++i];
+            continue;
+        }
+        if (a === "--limit" && args[i + 1]) {
+            const n = parseInt(args[++i], 10);
+            if (Number.isNaN(n)) {
+                console.error("--limit must be a number");
+                return 1;
+            }
+            limit = n;
+            continue;
+        }
+        if (a === "--offset" && args[i + 1]) {
+            const n = parseInt(args[++i], 10);
+            if (Number.isNaN(n)) {
+                console.error("--offset must be a number");
+                return 1;
+            }
+            offset = n;
+            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 (!businessDomain)
+        businessDomain = resolveBusinessDomain();
+    const token = await ensureValidToken();
+    const body = await listToolboxes({
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        businessDomain,
+        keyword, limit, offset,
+    });
+    console.log(formatCallOutput(body, pretty));
+    return 0;
+}
+export function parseToolboxSetStatusArgs(args) {
+    let boxId = "";
+    let businessDomain = "";
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if ((a === "-bd" || a === "--biz-domain") && args[i + 1]) {
+            businessDomain = args[++i];
+            continue;
+        }
+        if (!a.startsWith("-"))
+            boxId = a;
+    }
+    if (!boxId)
+        throw new Error("Missing required argument: <box-id>");
+    if (!businessDomain)
+        businessDomain = resolveBusinessDomain();
+    return { boxId, businessDomain };
+}
+async function runToolboxSetStatus(args, status) {
+    let opts;
+    try {
+        opts = parseToolboxSetStatusArgs(args);
+    }
+    catch (e) {
+        console.error(`Usage: kweaver toolbox ${status === "published" ? "publish" : "unpublish"} <box-id>`);
+        return 1;
+    }
+    const token = await ensureValidToken();
+    await setToolboxStatus({
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        businessDomain: opts.businessDomain,
+        boxId: opts.boxId,
+        status,
+    });
+    console.error(`${status === "published" ? "Published" : "Unpublished"} toolbox ${opts.boxId}`);
+    return 0;
+}
+// ── delete ────────────────────────────────────────────────────────────────────
+function confirmYes(prompt) {
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(`${prompt} [y/N] `, (answer) => {
+            rl.close();
+            const t = answer.trim().toLowerCase();
+            resolve(t === "y" || t === "yes");
+        });
+    });
+}
+async function runToolboxDelete(args) {
+    let boxId = "";
+    let yes = false;
+    let businessDomain = "";
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if (a === "--yes" || a === "-y")
+            yes = true;
+        else if ((a === "-bd" || a === "--biz-domain") && args[i + 1]) {
+            businessDomain = args[++i];
+        }
+        else if (!a.startsWith("-"))
+            boxId = a;
+    }
+    if (!boxId) {
+        console.error("Usage: kweaver toolbox delete <box-id> [-y|--yes]");
+        return 1;
+    }
+    if (!yes) {
+        const ok = await confirmYes(`Delete toolbox ${boxId}?`);
+        if (!ok) {
+            console.error("Aborted.");
+            return 1;
+        }
+    }
+    if (!businessDomain)
+        businessDomain = resolveBusinessDomain();
+    const token = await ensureValidToken();
+    await deleteToolbox({
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        businessDomain,
+        boxId,
+    });
+    console.error(`Deleted toolbox ${boxId}`);
+    return 0;
+}

package/dist/index.d.ts

@@ -62,3 +62,4 @@ export type { TokenConfig, ContextLoaderEntry, ContextLoaderConfig, } from "./co
 export type { UserProfile } from "./config/store.js";
 export { NO_AUTH_TOKEN, isNoAuth, saveNoAuthPlatform, autoSelectBusinessDomain, getConfigDir, getCurrentPlatform, getActiveUser, setActiveUser, listUsers, listUserProfiles, resolveUserId, extractUserId, } from "./config/store.js";
 export { decodeJwtPayload, extractUserIdFromJwt } from "./config/jwt.js";
+export { DEFAULT_SIGNIN_RSA_MODULUS_HEX, oauth2PasswordSigninLogin, parseSigninPageHtmlProps, rsaModulusHexToSpkiPem, STUDIOWEB_LOGIN_PUBLIC_KEY_PEM, } from "./auth/oauth.js";

package/dist/index.js

@@ -49,3 +49,5 @@ export { HttpError, NetworkRequestError, fetchTextOrThrow } from "./utils/http.j
 export { NO_AUTH_TOKEN, isNoAuth, saveNoAuthPlatform, autoSelectBusinessDomain, getConfigDir, getCurrentPlatform, getActiveUser, setActiveUser, listUsers, listUserProfiles, resolveUserId, extractUserId, } from "./config/store.js";
 // ── JWT utilities ─────────────────────────────────────────────────────────────
 export { decodeJwtPayload, extractUserIdFromJwt } from "./config/jwt.js";
+// ── OAuth (advanced — CLI uses these internally; optional for custom login tools) ─
+export { DEFAULT_SIGNIN_RSA_MODULUS_HEX, oauth2PasswordSigninLogin, parseSigninPageHtmlProps, rsaModulusHexToSpkiPem, STUDIOWEB_LOGIN_PUBLIC_KEY_PEM, } from "./auth/oauth.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kweaver-ai/kweaver-sdk",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "KWeaver TypeScript SDK — CLI tool and programmatic API for knowledge networks and Decision Agents.",
   "type": "module",
   "main": "./dist/index.js",