@kweaver-ai/kweaver-sdk 0.5.1 → 0.6.0

package/dist/commands/call.js

@@ -1,4 +1,5 @@
 import { ensureValidToken, formatHttpError, with401RefreshRetry } from "../auth/oauth.js";
+import { isNoAuth } from "../config/no-auth.js";
 import { HttpError } from "../utils/http.js";
 import { resolveBusinessDomain } from "../config/store.js";
 export function parseCallArgs(args) {
@@ -74,11 +75,13 @@ export function parseCallArgs(args) {
     return { url, method, headers, body, pretty, verbose, businessDomain };
 }
 function injectAuthHeaders(headers, accessToken, businessDomain) {
-    if (!headers.has("authorization")) {
-        headers.set("authorization", `Bearer ${accessToken}`);
-    }
-    if (!headers.has("token")) {
-        headers.set("token", accessToken);
+    if (!isNoAuth(accessToken)) {
+        if (!headers.has("authorization")) {
+            headers.set("authorization", `Bearer ${accessToken}`);
+        }
+        if (!headers.has("token")) {
+            headers.set("token", accessToken);
+        }
     }
     if (!headers.has("x-business-domain")) {
         headers.set("x-business-domain", businessDomain);

package/dist/commands/dataflow.d.ts

@@ -0,0 +1 @@
+export declare function runDataflowCommand(args: string[]): Promise<number>;

package/dist/commands/dataflow.js

@@ -0,0 +1,251 @@
+import { access, readFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import columnify from "columnify";
+import stringWidth from "string-width";
+import yargs from "yargs";
+import { ensureValidToken, formatHttpError, with401RefreshRetry } from "../auth/oauth.js";
+import { resolveBusinessDomain } from "../config/store.js";
+import { getDataflowLogsPage, listDataflowRuns, listDataflows, runDataflowWithFile, runDataflowWithRemoteUrl, } from "../api/dataflow2.js";
+function renderTable(rows) {
+    if (rows.length === 0)
+        return "";
+    return columnify(rows, {
+        showHeaders: true,
+        preserveNewLines: true,
+        stringLength: stringWidth,
+        headingTransform: (heading) => heading,
+    });
+}
+function buildListTableRows(items) {
+    return items.map((item) => ({
+        "ID": item.id,
+        "Title": item.title ?? "",
+        "Status": item.status ?? "",
+        "Trigger": item.trigger ?? "",
+        "Creator": item.creator ?? "",
+        "Updated At": item.updated_at != null ? String(item.updated_at) : "",
+        "Version ID": item.version_id ?? "",
+    }));
+}
+function buildRunTableRows(items) {
+    return items.map((item) => ({
+        "ID": item.id,
+        "Status": item.status ?? "",
+        "Started At": item.started_at != null ? String(item.started_at) : "",
+        "Ended At": item.ended_at != null ? String(item.ended_at) : "",
+        "Source Name": item.source?.name != null ? String(item.source.name) : "",
+        "Content Type": item.source?.content_type != null ? String(item.source.content_type) : "",
+        "Size": item.source?.size != null ? String(item.source.size) : "",
+        "Reason": item.reason ?? "",
+    }));
+}
+function parseSinceToLocalDayRange(value) {
+    // 只支持 YYYY-MM-DD 格式，解析为本地时区的一整天范围
+    const match = value.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+    if (!match)
+        return null;
+    const year = parseInt(match[1], 10);
+    const month = parseInt(match[2], 10) - 1; // Date month is 0-indexed
+    const day = parseInt(match[3], 10);
+    const start = new Date(year, month, day, 0, 0, 0);
+    const end = new Date(year, month, day, 23, 59, 59);
+    return {
+        startTime: Math.floor(start.getTime() / 1000),
+        endTime: Math.floor(end.getTime() / 1000),
+    };
+}
+function formatDataflowLogSummary(item) {
+    const duration = item.metadata?.duration ?? "-";
+    return [
+        `[${item.id}] ${item.taskId ?? ""} ${item.operator ?? ""}`,
+        `Status: ${item.status ?? ""}`,
+        `Started At: ${item.started_at ?? ""}`,
+        `Updated At: ${item.updated_at ?? ""}`,
+        `Duration: ${duration}`
+    ].join("\n");
+}
+function formatIndentedJsonBlock(label, value) {
+    const pretty = JSON.stringify(value ?? {}, null, 4) ?? "{}";
+    const indented = pretty
+        .split("\n")
+        .map((line) => `        ${line}`)
+        .join("\n");
+    return `    ${label}:\n${indented}`;
+}
+function formatDataflowLogOutput(item, detail) {
+    const parts = [formatDataflowLogSummary(item)];
+    if (detail) {
+        parts.push("");
+        parts.push(formatIndentedJsonBlock("input", item.inputs ?? {}));
+        parts.push("");
+        parts.push(formatIndentedJsonBlock("output", item.outputs ?? {}));
+    }
+    return parts.join("\n");
+}
+async function requireTokenAndBusinessDomain(businessDomain) {
+    const token = await ensureValidToken();
+    return {
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        businessDomain: businessDomain || resolveBusinessDomain(),
+    };
+}
+export async function runDataflowCommand(args) {
+    let exitCode = 0;
+    const parser = yargs(args)
+        .scriptName("kweaver dataflow")
+        .exitProcess(false)
+        .help()
+        .version(false)
+        .strict()
+        .fail((message, error) => {
+        throw error ?? new Error(message);
+    })
+        .command("list", "List all dataflows", (command) => command.option("biz-domain", {
+        alias: "bd",
+        type: "string",
+    }), async (argv) => {
+        exitCode = await with401RefreshRetry(async () => {
+            const base = await requireTokenAndBusinessDomain(argv.bizDomain);
+            const body = await listDataflows(base);
+            const table = renderTable(buildListTableRows(body.dags));
+            if (table) {
+                console.log(table);
+            }
+            return 0;
+        });
+    })
+        .command("run <dagId>", "Trigger one dataflow run", (command) => command
+        .positional("dagId", { type: "string" })
+        .option("file", { type: "string" })
+        .option("url", { type: "string" })
+        .option("name", { type: "string" })
+        .option("biz-domain", { alias: "bd", type: "string" })
+        .check((argv) => {
+        const hasFile = typeof argv.file === "string";
+        const hasUrl = typeof argv.url === "string";
+        if (hasFile === hasUrl) {
+            throw new Error("Exactly one of --file or --url is required.");
+        }
+        if (hasUrl && typeof argv.name !== "string") {
+            throw new Error("--url requires --name.");
+        }
+        return true;
+    }), async (argv) => {
+        exitCode = await with401RefreshRetry(async () => {
+            const base = await requireTokenAndBusinessDomain(argv.bizDomain);
+            if (typeof argv.file === "string") {
+                await access(argv.file, constants.R_OK);
+                const fileBytes = await readFile(argv.file);
+                const fileName = argv.file.split(/[\\/]/).pop() || "upload.bin";
+                const body = await runDataflowWithFile({
+                    ...base,
+                    dagId: argv.dagId,
+                    fileName,
+                    fileBytes,
+                });
+                console.log(body.dag_instance_id);
+                return 0;
+            }
+            const body = await runDataflowWithRemoteUrl({
+                ...base,
+                dagId: argv.dagId,
+                url: String(argv.url),
+                name: String(argv.name),
+            });
+            console.log(body.dag_instance_id);
+            return 0;
+        });
+    })
+        .command("runs <dagId>", "List run records for one dataflow", (command) => command
+        .positional("dagId", { type: "string" })
+        .option("since", { type: "string" })
+        .option("biz-domain", { alias: "bd", type: "string" }), async (argv) => {
+        exitCode = await with401RefreshRetry(async () => {
+            const base = await requireTokenAndBusinessDomain(argv.bizDomain);
+            const dayRange = typeof argv.since === "string" ? parseSinceToLocalDayRange(argv.since) : null;
+            let results = [];
+            if (!dayRange) {
+                const body = await listDataflowRuns({
+                    ...base,
+                    dagId: argv.dagId,
+                    page: 0,
+                    limit: 20,
+                    sortBy: "started_at",
+                    order: "desc",
+                });
+                results = body.results;
+            }
+            else {
+                const first = await listDataflowRuns({
+                    ...base,
+                    dagId: argv.dagId,
+                    page: 0,
+                    limit: 20,
+                    sortBy: "started_at",
+                    order: "desc",
+                    startTime: dayRange.startTime,
+                    endTime: dayRange.endTime,
+                });
+                results = [...first.results];
+                const total = first.total ?? first.results.length;
+                for (let page = 1; page * 20 < total; page += 1) {
+                    const next = await listDataflowRuns({
+                        ...base,
+                        dagId: argv.dagId,
+                        page,
+                        limit: 20,
+                        sortBy: "started_at",
+                        order: "desc",
+                        startTime: dayRange.startTime,
+                        endTime: dayRange.endTime,
+                    });
+                    results = results.concat(next.results);
+                }
+            }
+            const table = renderTable(buildRunTableRows(results));
+            if (table) {
+                console.log(table);
+            }
+            return 0;
+        });
+    })
+        .command("logs <dagId> <instanceId>", "Show logs for one run in summary or detail mode", (command) => command
+        .positional("dagId", { type: "string" })
+        .positional("instanceId", { type: "string" })
+        .option("detail", { type: "boolean", default: false })
+        .option("biz-domain", { alias: "bd", type: "string" }), async (argv) => {
+        exitCode = await with401RefreshRetry(async () => {
+            const base = await requireTokenAndBusinessDomain(argv.bizDomain);
+            let seen = 0;
+            for (let page = 0;; page += 1) {
+                const body = await getDataflowLogsPage({
+                    ...base,
+                    dagId: argv.dagId,
+                    instanceId: argv.instanceId,
+                    page,
+                    limit: 100,
+                });
+                if (body.results.length === 0)
+                    break;
+                for (const item of body.results) {
+                    console.log(formatDataflowLogOutput(item, argv.detail === true));
+                    console.log("");
+                }
+                seen += body.results.length;
+                if ((body.total ?? 0) > 0 && seen >= (body.total ?? 0))
+                    break;
+            }
+            return 0;
+        });
+    })
+        .demandCommand(1);
+    try {
+        await parser.parseAsync();
+        return exitCode;
+    }
+    catch (error) {
+        console.error(formatHttpError(error));
+        return 1;
+    }
+}

package/dist/commands/dataview.d.ts

@@ -1 +1,8 @@
+/**
+ * Strip SQL line/block comments and leading whitespace, then return the first identifier token (lowercase).
+ * Used to reject DDL/DML passed to dataview query (server applies LIMIT semantics).
+ */
+export declare function getFirstSqlTokenAfterComments(sql: string): string;
+/** True if ad-hoc SQL is safe for dataview query (SELECT / WITH only). */
+export declare function isDataviewSelectLikeSql(sql: string): boolean;
 export declare function runDataviewCommand(args: string[]): Promise<number>;

package/dist/commands/dataview.js

@@ -3,6 +3,33 @@ import { ensureValidToken, formatHttpError, with401RefreshRetry } from "../auth/
 import { deleteDataView, findDataView, getDataView, listDataViews, queryDataView, } from "../api/dataviews.js";
 import { formatCallOutput } from "./call.js";
 import { resolveBusinessDomain } from "../config/store.js";
+/**
+ * Strip SQL line/block comments and leading whitespace, then return the first identifier token (lowercase).
+ * Used to reject DDL/DML passed to dataview query (server applies LIMIT semantics).
+ */
+export function getFirstSqlTokenAfterComments(sql) {
+    let s = sql.replace(/\/\*[\s\S]*?\*\//g, " ");
+    const lines = s.split("\n").map((line) => {
+        const idx = line.indexOf("--");
+        return idx >= 0 ? line.slice(0, idx) : line;
+    });
+    s = lines.join("\n");
+    s = s.replace(/\s+/g, " ").trim();
+    if (!s)
+        return "";
+    const match = /^([a-zA-Z_][a-zA-Z0-9_]*|"(?:[^"]|"")*")/.exec(s);
+    if (!match)
+        return "";
+    const tok = match[1];
+    if (tok.startsWith('"'))
+        return tok.slice(1, -1).replace(/""/g, '"').toLowerCase();
+    return tok.toLowerCase();
+}
+/** True if ad-hoc SQL is safe for dataview query (SELECT / WITH only). */
+export function isDataviewSelectLikeSql(sql) {
+    const kw = getFirstSqlTokenAfterComments(sql);
+    return kw === "select" || kw === "with";
+}
 function confirmYes(prompt) {
     return new Promise((resolve) => {
         const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -27,7 +54,7 @@ Subcommands:
 
   list  — list all data views (no keyword search)
   find  — search by name; default fuzzy, --exact for strict match, --wait to poll
-  query — run SQL query against a data view (mdl-uniquery); omit --sql to use view default SQL`);
+  query — run SQL query against a data view (mdl-uniquery); omit --sql to use view default SQL; only SELECT/WITH unless --raw-sql`);
         return 0;
     }
     const dispatch = () => {
@@ -214,8 +241,9 @@ async function runDataviewQueryCommand(args) {
     let limit = 50;
     let offset = 0;
     let needTotal = false;
+    let rawSql = false;
     if (args.length === 0 || args[0].startsWith("-")) {
-        console.error("Usage: kweaver dataview query <id> [--sql <sql>] [--limit <n>] [--offset <n>] [--need-total] [-bd value] [--pretty]");
+        console.error("Usage: kweaver dataview query <id> [--sql <sql>] [--limit <n>] [--offset <n>] [--need-total] [--raw-sql] [-bd value] [--pretty]");
         return 1;
     }
     const id = args[0];
@@ -228,6 +256,10 @@ async function runDataviewQueryCommand(args) {
         }
         if (arg === "--pretty")
             continue;
+        if (arg === "--raw-sql") {
+            rawSql = true;
+            continue;
+        }
         if ((arg === "--sql" || arg === "-s") && tail[i + 1]) {
             sql = tail[++i];
             continue;
@@ -249,6 +281,10 @@ async function runDataviewQueryCommand(args) {
             continue;
         }
     }
+    if (sql !== undefined && sql !== "" && !rawSql && !isDataviewSelectLikeSql(sql)) {
+        console.error("dataview query only supports SELECT statements (or WITH for CTEs). Use --raw-sql to send other SQL at your own risk.");
+        return 1;
+    }
     const token = await ensureValidToken();
     const result = await queryDataView({
         baseUrl: token.baseUrl,

package/dist/commands/ds.d.ts

@@ -11,6 +11,7 @@ export declare function parseImportCsvArgs(args: string[]): {
     tablePrefix: string;
     batchSize: number;
     businessDomain: string;
+    recreate: boolean;
 };
 export declare function resolveFiles(pattern: string): Promise<string[]>;
 export interface ImportCsvResult {

package/dist/commands/ds.js

@@ -306,6 +306,7 @@ Options:
   --files <s>          CSV file paths (comma-separated or glob pattern, required)
   --table-prefix <s>   Table name prefix (default: none)
   --batch-size <n>     Rows per batch (default: 500, range: 1-10000)
+  --recreate           First batch uses overwrite (drop/recreate table) then append; use when schema changed
   -bd, --biz-domain    Business domain (default: bd_public)`;
 export function parseImportCsvArgs(args) {
     let datasourceId = "";
@@ -313,6 +314,7 @@ export function parseImportCsvArgs(args) {
     let tablePrefix = "";
     let batchSize = 500;
     let businessDomain = "";
+    let recreate = false;
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
         if (arg === "--help" || arg === "-h")
@@ -321,6 +323,10 @@ export function parseImportCsvArgs(args) {
             files = args[++i];
             continue;
         }
+        if (arg === "--recreate") {
+            recreate = true;
+            continue;
+        }
         if (arg === "--table-prefix" && args[i + 1]) {
             tablePrefix = args[++i];
             continue;
@@ -343,7 +349,7 @@ export function parseImportCsvArgs(args) {
     }
     if (!businessDomain)
         businessDomain = resolveBusinessDomain();
-    return { datasourceId, files, tablePrefix, batchSize, businessDomain };
+    return { datasourceId, files, tablePrefix, batchSize, businessDomain, recreate };
 }
 export async function resolveFiles(pattern) {
     const parts = pattern.split(",").map((p) => p.trim()).filter(Boolean);
@@ -446,6 +452,7 @@ export async function runDsImportCsv(args) {
                 tableExist,
                 data: batch,
                 fieldMappings,
+                recreate: options.recreate,
             });
             const t0 = Date.now();
             process.stderr.write(`[${tableName}] batch ${batchLabel} (${rowCount} rows)... `);

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

@@ -0,0 +1,79 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+export interface ExploreMeta {
+    bkn: {
+        id: string;
+        name: string;
+    };
+    statistics: {
+        object_count: number;
+        relation_count: number;
+    };
+    objectTypes: Array<{
+        id: string;
+        name: string;
+        displayKey: string;
+        propertyCount: number;
+        properties: Array<{
+            name: string;
+            type?: string;
+        }>;
+    }>;
+    relationTypes: Array<{
+        id: string;
+        name: string;
+        sourceOtId: string;
+        targetOtId: string;
+        sourceOtName: string;
+        targetOtName: string;
+    }>;
+    actionTypes: Array<{
+        id: string;
+        name: string;
+    }>;
+}
+export interface ExploreOt {
+    id: string;
+    name: string;
+    displayKey: string;
+    propertyCount: number;
+    properties: Array<{
+        name: string;
+        type?: string;
+    }>;
+}
+export interface ExploreRt {
+    id: string;
+    name: string;
+    sourceOtId: string;
+    targetOtId: string;
+    sourceOtName: string;
+    targetOtName: string;
+}
+export interface ExploreAt {
+    id: string;
+    name: string;
+}
+export interface ExploreBkn {
+    id: string;
+    name: string;
+}
+export interface ExploreStats {
+    object_count: number;
+    relation_count: number;
+}
+export declare const EXPLORE_BOOTSTRAP_RETRY_DELAY_MS = 300;
+export declare const EXPLORE_BOOTSTRAP_MAX_ATTEMPTS = 2;
+export declare function buildMeta(knRaw: string, otRaw: string, rtRaw: string, atRaw: string): ExploreMeta;
+export declare function isRetryableExploreBootstrapError(error: unknown): boolean;
+export declare function loadExploreMetaWithRetry(token: {
+    baseUrl: string;
+    accessToken: string;
+}, knId: string, businessDomain: string): Promise<ExploreMeta>;
+export declare function readBody(req: IncomingMessage): Promise<string>;
+export declare function jsonResponse(res: ServerResponse, status: number, data: unknown): void;
+export declare function handleApiError(res: ServerResponse, error: unknown): void;
+export type TokenProvider = () => Promise<{
+    baseUrl: string;
+    accessToken: string;
+}>;
+export declare function registerBknRoutes(meta: ExploreMeta, getToken: TokenProvider, businessDomain: string): Map<string, (req: IncomingMessage, res: ServerResponse) => void>;