@kweaver-ai/kweaver-sdk 0.5.1 → 0.6.0

package/dist/commands/explore.js

@@ -0,0 +1,258 @@
+import { createServer } from "node:http";
+import { readFileSync, existsSync } from "node:fs";
+import { join, extname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+import { ensureValidToken } from "../auth/oauth.js";
+import { resolveBusinessDomain } from "../config/store.js";
+import { registerBknRoutes, loadExploreMetaWithRetry, readBody } from "./explore-bkn.js";
+import { registerChatRoutes } from "./explore-chat.js";
+import { registerVegaRoutes } from "./explore-vega.js";
+import { listKnowledgeNetworks } from "../api/knowledge-networks.js";
+import { listAgents } from "../api/agent-list.js";
+import { listVegaCatalogs } from "../api/vega.js";
+export function parseExploreArgs(args) {
+    const opts = {
+        knId: "",
+        agentId: "",
+        port: 3721,
+        open: true,
+        businessDomain: "",
+    };
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--help" || a === "-h")
+            throw new Error("help");
+        if (a === "--port" && args[i + 1]) {
+            opts.port = Number(args[++i]);
+            continue;
+        }
+        if (a === "--no-open") {
+            opts.open = false;
+            continue;
+        }
+        if (a === "--kn" && args[i + 1]) {
+            opts.knId = args[++i];
+            continue;
+        }
+        if (a === "--agent" && args[i + 1]) {
+            opts.agentId = args[++i];
+            continue;
+        }
+        if ((a === "-bd" || a === "--biz-domain") && args[i + 1]) {
+            opts.businessDomain = args[++i];
+            continue;
+        }
+    }
+    return opts;
+}
+function printExploreHelp() {
+    console.log(`kweaver explore
+
+Launch an interactive web UI for exploring KWeaver resources.
+
+Usage:
+  kweaver explore [options]
+
+Options:
+  --kn <id>          Open directly to BKN tab with specified KN
+  --agent <id>       Open directly to Chat tab with specified Agent
+  --port <n>         HTTP server port (default: 3721)
+  --no-open          Don't auto-open browser
+  -bd <value>        Business domain override
+  -h, --help         Show this help
+`);
+}
+// MIME map for static files
+const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".js": "application/javascript; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".png": "image/png",
+    ".svg": "image/svg+xml",
+};
+/**
+ * Returns a fresh token, re-reading from disk each time.
+ * This ensures long-running server processes always use the latest
+ * access token after a refresh, rather than a stale snapshot.
+ */
+async function freshToken() {
+    return ensureValidToken();
+}
+async function startServer(opts, token, businessDomain) {
+    // 1. Load BKN meta if --kn provided
+    let bknMeta = null;
+    if (opts.knId) {
+        console.error(`Loading schema for KN ${opts.knId}...`);
+        bknMeta = await loadExploreMetaWithRetry(token, opts.knId, businessDomain);
+        console.error(`Loaded: ${bknMeta.objectTypes.length} OTs, ${bknMeta.relationTypes.length} RTs`);
+    }
+    // 2. Collect route handlers
+    const routes = new Map();
+    // Dashboard route: aggregate KN, Agents, Vega Catalogs in parallel
+    routes.set("GET /api/dashboard", async (_req, res) => {
+        try {
+            const t = await freshToken();
+            const bd = businessDomain;
+            const [knRaw, agentsRaw, catalogsRaw] = await Promise.allSettled([
+                listKnowledgeNetworks({ baseUrl: t.baseUrl, accessToken: t.accessToken, businessDomain: bd }),
+                listAgents({ baseUrl: t.baseUrl, accessToken: t.accessToken, businessDomain: bd }),
+                listVegaCatalogs({ baseUrl: t.baseUrl, accessToken: t.accessToken, businessDomain: bd }),
+            ]);
+            const parseSettled = (r) => r.status === "fulfilled" ? JSON.parse(r.value) : { error: String(r.reason) };
+            const payload = {
+                kn: parseSettled(knRaw),
+                agents: parseSettled(agentsRaw),
+                catalogs: parseSettled(catalogsRaw),
+            };
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(payload));
+        }
+        catch (err) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: String(err) }));
+        }
+    });
+    // BKN routes
+    if (bknMeta) {
+        const bknRoutes = registerBknRoutes(bknMeta, freshToken, businessDomain);
+        for (const [key, handler] of bknRoutes)
+            routes.set(key, handler);
+    }
+    // Dynamic KN loading: POST /api/bkn/load { knId }
+    routes.set("POST /api/bkn/load", async (req, res) => {
+        try {
+            const bodyStr = await readBody(req);
+            const { knId } = JSON.parse(bodyStr);
+            if (!knId) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "knId required" }));
+                return;
+            }
+            console.error(`Loading schema for KN ${knId}...`);
+            const t = await freshToken();
+            const meta = await loadExploreMetaWithRetry(t, knId, businessDomain);
+            console.error(`Loaded: ${meta.objectTypes.length} OTs, ${meta.relationTypes.length} RTs`);
+            // Replace BKN routes with new KN's routes
+            for (const key of [...routes.keys()]) {
+                if (key.startsWith("GET /api/bkn/") || key.startsWith("POST /api/bkn/")) {
+                    if (key !== "POST /api/bkn/load")
+                        routes.delete(key);
+                }
+            }
+            const newRoutes = registerBknRoutes(meta, freshToken, businessDomain);
+            for (const [key, handler] of newRoutes)
+                routes.set(key, handler);
+            bknMeta = meta;
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true }));
+        }
+        catch (err) {
+            console.error("Failed to load KN:", err.message || err);
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: String(err.message || err) }));
+        }
+    });
+    // Chat routes
+    const chatRoutes = registerChatRoutes(freshToken, businessDomain);
+    for (const [key, handler] of chatRoutes)
+        routes.set(key, handler);
+    // Vega routes
+    const vegaRoutes = registerVegaRoutes(freshToken, businessDomain);
+    for (const [key, handler] of vegaRoutes)
+        routes.set(key, handler);
+    // 3. Resolve template directory
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = join(__filename, "..");
+    const templateDir = join(__dirname, "..", "templates", "explorer");
+    // 4. Create HTTP server
+    const server = createServer((req, res) => {
+        const url = new URL(req.url || "/", `http://localhost:${opts.port}`);
+        const method = req.method || "GET";
+        const pathname = url.pathname;
+        // API route matching
+        const routeKey = `${method} ${pathname}`;
+        const handler = routes.get(routeKey);
+        if (handler) {
+            handler(req, res);
+            return;
+        }
+        // Static file serving
+        let filePath = pathname === "/" ? "/index.html" : pathname;
+        const fullPath = join(templateDir, filePath);
+        // Security: prevent directory traversal
+        if (!fullPath.startsWith(templateDir)) {
+            res.writeHead(403);
+            res.end("Forbidden");
+            return;
+        }
+        if (existsSync(fullPath)) {
+            const ext = extname(fullPath);
+            const contentType = MIME[ext] || "application/octet-stream";
+            const content = readFileSync(fullPath);
+            res.writeHead(200, { "Content-Type": contentType });
+            res.end(content);
+        }
+        else {
+            // SPA fallback: serve index.html for unknown routes
+            const indexPath = join(templateDir, "index.html");
+            if (existsSync(indexPath)) {
+                const content = readFileSync(indexPath);
+                res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                res.end(content);
+            }
+            else {
+                res.writeHead(404);
+                res.end("Not Found");
+            }
+        }
+    });
+    // 5. Start listening
+    server.listen(opts.port, () => {
+        const initialHash = opts.knId ? `#/bkn/${opts.knId}` :
+            opts.agentId ? `#/chat/${opts.agentId}` : "";
+        const url = `http://localhost:${opts.port}/${initialHash}`;
+        console.error(`\nKWeaver Explorer running at ${url}\n`);
+        console.error("Press Ctrl+C to stop.\n");
+        // 6. Open browser
+        if (opts.open) {
+            try {
+                const platform = process.platform;
+                if (platform === "darwin")
+                    execSync(`open "${url}"`);
+                else if (platform === "win32")
+                    execSync(`start "" "${url}"`);
+                else
+                    execSync(`xdg-open "${url}"`);
+            }
+            catch { /* ignore browser open failures */ }
+        }
+    });
+    // 7. Ctrl+C handling
+    await new Promise((resolve) => {
+        process.on("SIGINT", () => {
+            console.error("\nShutting down...");
+            server.close(() => resolve());
+        });
+    });
+}
+export async function runExploreCommand(args) {
+    let opts;
+    try {
+        opts = parseExploreArgs(args);
+    }
+    catch (err) {
+        if (err?.message === "help") {
+            printExploreHelp();
+            return 0;
+        }
+        throw err;
+    }
+    // Acquire token
+    const token = await ensureValidToken();
+    const businessDomain = opts.businessDomain || resolveBusinessDomain();
+    // Start the server
+    await startServer(opts, token, businessDomain);
+    return 0;
+}

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

@@ -19,6 +19,8 @@ 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. */
+    recreate?: boolean;
 }
 /**
  * Read a CSV file and return its headers and rows.

package/dist/commands/import-csv.js

@@ -80,8 +80,9 @@ export function buildFieldMappings(headers) {
  * The DAG has two steps: a manual trigger and the database write.
  */
 export function buildDagBody(options) {
-    const { datasourceId, datasourceType, tableName, tableExist, data, fieldMappings } = options;
+    const { datasourceId, datasourceType, tableName, tableExist, data, fieldMappings, recreate } = options;
     const ts = Date.now();
+    const operateType = tableExist ? "append" : recreate ? "overwrite" : "append";
     const triggerStep = {
         id: "step-trigger",
         title: "Trigger",
@@ -97,7 +98,7 @@ export function buildDagBody(options) {
             datasource_id: datasourceId,
             table_name: tableName,
             table_exist: tableExist,
-            operate_type: "append",
+            operate_type: operateType,
             data,
             sync_model_fields: fieldMappings,
         },

package/dist/commands/skill.d.ts

@@ -0,0 +1,26 @@
+import { type SkillStatus } from "../api/skills.js";
+interface BaseOptions {
+    businessDomain: string;
+    pretty: boolean;
+}
+interface ListOptions extends BaseOptions {
+    page: number;
+    pageSize: number;
+    all: boolean;
+    name?: string;
+    source?: string;
+    status?: SkillStatus;
+    createUser?: string;
+    sortBy?: "create_time" | "update_time" | "name";
+    sortOrder?: "asc" | "desc";
+}
+interface RegisterOptions extends BaseOptions {
+    contentFile?: string;
+    zipFile?: string;
+    source?: string;
+    extendInfo?: Record<string, unknown>;
+}
+export declare function parseSkillListArgs(args: string[]): ListOptions;
+export declare function parseSkillRegisterArgs(args: string[]): RegisterOptions;
+export declare function runSkillCommand(args: string[]): Promise<number>;
+export {};