@kweaver-ai/kweaver-sdk 0.5.1 → 0.6.0

package/dist/api/skills.d.ts

@@ -0,0 +1,141 @@
+export type SkillStatus = "unpublish" | "published" | "offline";
+export type SkillFileType = "zip" | "content";
+export interface SkillSummary {
+    skill_id: string;
+    name: string;
+    description?: string;
+    version?: string;
+    status?: SkillStatus;
+    source?: string;
+    create_user?: string;
+    create_time?: number;
+    update_user?: string;
+    update_time?: number;
+    business_domain_id?: string;
+    category?: string;
+    category_name?: string;
+}
+export interface SkillInfo extends SkillSummary {
+    dependencies?: Record<string, unknown>;
+    extend_info?: Record<string, unknown>;
+}
+export interface SkillFileSummary {
+    rel_path: string;
+    file_type?: string;
+    size?: number;
+    mime_type?: string;
+}
+export interface SkillContentIndex {
+    skill_id: string;
+    url: string;
+    files: SkillFileSummary[];
+    status?: SkillStatus;
+}
+export interface SkillFileReadResult {
+    skill_id: string;
+    rel_path: string;
+    url: string;
+    mime_type?: string;
+    file_type?: string;
+}
+export interface RegisterSkillResult {
+    skill_id: string;
+    name: string;
+    description?: string;
+    version?: string;
+    status?: SkillStatus;
+    files?: string[];
+}
+export interface DeleteSkillResult {
+    skill_id: string;
+    deleted: boolean;
+}
+export interface UpdateSkillStatusResult {
+    skill_id: string;
+    status: SkillStatus;
+}
+export interface SkillListResult {
+    total_count?: number;
+    total?: number;
+    page?: number;
+    page_size?: number;
+    total_page?: number;
+    total_pages?: number;
+    has_next?: boolean;
+    has_prev?: boolean;
+    data: SkillSummary[];
+}
+export interface SkillApiBaseOptions {
+    baseUrl: string;
+    accessToken: string;
+    businessDomain?: string;
+}
+export interface ListSkillsOptions extends SkillApiBaseOptions {
+    page?: number;
+    pageSize?: number;
+    sortBy?: "create_time" | "update_time" | "name";
+    sortOrder?: "asc" | "desc";
+    all?: boolean;
+    name?: string;
+    status?: SkillStatus;
+    source?: string;
+    createUser?: string;
+}
+export interface ListSkillMarketOptions extends SkillApiBaseOptions {
+    page?: number;
+    pageSize?: number;
+    sortBy?: "create_time" | "update_time" | "name";
+    sortOrder?: "asc" | "desc";
+    all?: boolean;
+    name?: string;
+    source?: string;
+}
+export interface GetSkillOptions extends SkillApiBaseOptions {
+    skillId: string;
+}
+export interface RegisterSkillContentOptions extends SkillApiBaseOptions {
+    content: string;
+    source?: string;
+    extendInfo?: Record<string, unknown>;
+}
+export interface RegisterSkillZipOptions extends SkillApiBaseOptions {
+    filename: string;
+    bytes: Uint8Array;
+    source?: string;
+    extendInfo?: Record<string, unknown>;
+}
+export interface UpdateSkillStatusOptions extends SkillApiBaseOptions {
+    skillId: string;
+    status: SkillStatus;
+}
+export interface ReadSkillFileOptions extends SkillApiBaseOptions {
+    skillId: string;
+    relPath: string;
+}
+export interface DownloadSkillOptions extends SkillApiBaseOptions {
+    skillId: string;
+}
+export interface DownloadedSkillArchive {
+    fileName: string;
+    bytes: Uint8Array;
+}
+export interface InstallSkillArchiveOptions {
+    bytes: Uint8Array;
+    directory: string;
+    force?: boolean;
+}
+export declare function listSkills(options: ListSkillsOptions): Promise<SkillListResult>;
+export declare function listSkillMarket(options: ListSkillMarketOptions): Promise<SkillListResult>;
+export declare function getSkill(options: GetSkillOptions): Promise<SkillInfo>;
+export declare function deleteSkill(options: GetSkillOptions): Promise<DeleteSkillResult>;
+export declare function updateSkillStatus(options: UpdateSkillStatusOptions): Promise<UpdateSkillStatusResult>;
+export declare function registerSkillContent(options: RegisterSkillContentOptions): Promise<RegisterSkillResult>;
+export declare function registerSkillZip(options: RegisterSkillZipOptions): Promise<RegisterSkillResult>;
+export declare function getSkillContentIndex(options: GetSkillOptions): Promise<SkillContentIndex>;
+export declare function fetchSkillContent(options: GetSkillOptions): Promise<string>;
+export declare function readSkillFile(options: ReadSkillFileOptions): Promise<SkillFileReadResult>;
+export declare function fetchSkillFile(options: ReadSkillFileOptions): Promise<Uint8Array>;
+export declare function downloadSkill(options: DownloadSkillOptions): Promise<DownloadedSkillArchive>;
+export declare function installSkillArchive(options: InstallSkillArchiveOptions): {
+    directory: string;
+};

package/dist/api/skills.js

@@ -0,0 +1,208 @@
+import { spawnSync } from "node:child_process";
+import { Buffer } from "node:buffer";
+import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { buildHeaders as buildPlatformHeaders } from "./headers.js";
+import { HttpError, fetchTextOrThrow } from "../utils/http.js";
+const SKILL_API_PREFIX = "/api/agent-operator-integration/v1";
+function baseHeaders(opts) {
+    return buildPlatformHeaders(opts.accessToken, opts.businessDomain ?? "bd_public");
+}
+function buildUrl(baseUrl, path) {
+    return `${baseUrl.replace(/\/+$/, "")}${path}`;
+}
+function unwrapEnvelope(raw) {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && "data" in parsed) {
+        return parsed.data;
+    }
+    return parsed;
+}
+function appendCommonListParams(url, opts) {
+    if (opts.page !== undefined)
+        url.searchParams.set("page", String(opts.page));
+    if (opts.pageSize !== undefined)
+        url.searchParams.set("page_size", String(opts.pageSize));
+    if (opts.sortBy)
+        url.searchParams.set("sort_by", opts.sortBy);
+    if (opts.sortOrder)
+        url.searchParams.set("sort_order", opts.sortOrder);
+    if (opts.all !== undefined)
+        url.searchParams.set("all", String(opts.all));
+    if (opts.name)
+        url.searchParams.set("name", opts.name);
+    if (opts.source)
+        url.searchParams.set("source", opts.source);
+}
+function parseContentDisposition(value) {
+    if (!value)
+        return undefined;
+    const utf8Match = /filename\*=UTF-8''([^;]+)/i.exec(value);
+    if (utf8Match?.[1]) {
+        return decodeURIComponent(utf8Match[1]);
+    }
+    const plainMatch = /filename="?([^";]+)"?/i.exec(value);
+    return plainMatch?.[1];
+}
+async function fetchBytesOrThrow(input, init) {
+    const response = await fetch(input, init);
+    const body = new Uint8Array(await response.arrayBuffer());
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, new TextDecoder().decode(body));
+    }
+    return { response, body };
+}
+export async function listSkills(options) {
+    const url = new URL(buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills`));
+    appendCommonListParams(url, options);
+    if (options.status)
+        url.searchParams.set("status", options.status);
+    if (options.createUser)
+        url.searchParams.set("create_user", options.createUser);
+    const { body } = await fetchTextOrThrow(url, { headers: baseHeaders(options) });
+    return unwrapEnvelope(body);
+}
+export async function listSkillMarket(options) {
+    const url = new URL(buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills/market`));
+    appendCommonListParams(url, options);
+    const { body } = await fetchTextOrThrow(url, { headers: baseHeaders(options) });
+    return unwrapEnvelope(body);
+}
+export async function getSkill(options) {
+    const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills/${encodeURIComponent(options.skillId)}`);
+    const { body } = await fetchTextOrThrow(url, { headers: baseHeaders(options) });
+    return unwrapEnvelope(body);
+}
+export async function deleteSkill(options) {
+    const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills/${encodeURIComponent(options.skillId)}`);
+    const { body } = await fetchTextOrThrow(url, { method: "DELETE", headers: baseHeaders(options) });
+    return unwrapEnvelope(body);
+}
+export async function updateSkillStatus(options) {
+    const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills/${encodeURIComponent(options.skillId)}/status`);
+    const { body } = await fetchTextOrThrow(url, {
+        method: "PUT",
+        headers: { ...baseHeaders(options), "content-type": "application/json" },
+        body: JSON.stringify({ status: options.status }),
+    });
+    return unwrapEnvelope(body);
+}
+export async function registerSkillContent(options) {
+    const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills`);
+    const payload = {
+        file_type: "content",
+        file: options.content,
+    };
+    if (options.source)
+        payload.source = options.source;
+    if (options.extendInfo)
+        payload.extend_info = options.extendInfo;
+    const { body } = await fetchTextOrThrow(url, {
+        method: "POST",
+        headers: { ...baseHeaders(options), "content-type": "application/json" },
+        body: JSON.stringify(payload),
+    });
+    return unwrapEnvelope(body);
+}
+export async function registerSkillZip(options) {
+    const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills`);
+    const form = new FormData();
+    form.set("file_type", "zip");
+    form.set("file", new Blob([Buffer.from(options.bytes)]), options.filename);
+    if (options.source)
+        form.set("source", options.source);
+    if (options.extendInfo)
+        form.set("extend_info", JSON.stringify(options.extendInfo));
+    const { body } = await fetchTextOrThrow(url, {
+        method: "POST",
+        headers: baseHeaders(options),
+        body: form,
+    });
+    return unwrapEnvelope(body);
+}
+export async function getSkillContentIndex(options) {
+    const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills/${encodeURIComponent(options.skillId)}/content`);
+    const { body } = await fetchTextOrThrow(url, { headers: baseHeaders(options) });
+    return unwrapEnvelope(body);
+}
+export async function fetchSkillContent(options) {
+    const index = await getSkillContentIndex(options);
+    const { body } = await fetchTextOrThrow(index.url);
+    return body;
+}
+export async function readSkillFile(options) {
+    const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills/${encodeURIComponent(options.skillId)}/files/read`);
+    const { body } = await fetchTextOrThrow(url, {
+        method: "POST",
+        headers: { ...baseHeaders(options), "content-type": "application/json" },
+        body: JSON.stringify({ rel_path: options.relPath }),
+    });
+    return unwrapEnvelope(body);
+}
+export async function fetchSkillFile(options) {
+    const file = await readSkillFile(options);
+    const { body } = await fetchBytesOrThrow(file.url);
+    return body;
+}
+export async function downloadSkill(options) {
+    const url = buildUrl(options.baseUrl, `${SKILL_API_PREFIX}/skills/${encodeURIComponent(options.skillId)}/download`);
+    const { response, body } = await fetchBytesOrThrow(url, { headers: baseHeaders(options) });
+    const serverName = parseContentDisposition(response.headers.get("content-disposition"));
+    return {
+        fileName: basename(serverName || `${options.skillId}.zip`),
+        bytes: body,
+    };
+}
+export function installSkillArchive(options) {
+    const targetDir = resolve(options.directory);
+    const existed = existsSync(targetDir);
+    if (existed) {
+        const entries = readdirSync(targetDir);
+        if (entries.length > 0) {
+            if (!options.force) {
+                throw new Error(`Install target is not empty: ${targetDir}. Use --force to replace it.`);
+            }
+        }
+    }
+    const parentDir = resolve(targetDir, "..");
+    mkdirSync(parentDir, { recursive: true });
+    const archivePath = resolve(parentDir, `${basename(targetDir)}.zip`);
+    const stagingDir = resolve(parentDir, `.${basename(targetDir)}.tmp-${process.pid}-${Date.now()}`);
+    const backupDir = existed ? resolve(parentDir, `.${basename(targetDir)}.bak-${process.pid}-${Date.now()}`) : undefined;
+    mkdirSync(stagingDir, { recursive: true });
+    writeFileSync(archivePath, options.bytes);
+    try {
+        const result = spawnSync("unzip", ["-oq", archivePath, "-d", stagingDir], {
+            encoding: "utf8",
+        });
+        if (result.error) {
+            throw result.error;
+        }
+        if (result.status !== 0) {
+            throw new Error(result.stderr || `unzip exited with status ${result.status}`);
+        }
+        if (existsSync(targetDir)) {
+            renameSync(targetDir, backupDir);
+        }
+        renameSync(stagingDir, targetDir);
+        if (backupDir && existsSync(backupDir)) {
+            rmSync(backupDir, { recursive: true, force: true });
+        }
+        return { directory: targetDir };
+    }
+    catch (error) {
+        rmSync(stagingDir, { recursive: true, force: true });
+        if (backupDir && existsSync(backupDir) && !existsSync(targetDir)) {
+            renameSync(backupDir, targetDir);
+        }
+        throw new Error(error instanceof Error
+            ? `Skill install failed: ${error.message}`
+            : `Skill install failed: ${String(error)}`);
+    }
+    finally {
+        rmSync(archivePath, { force: true });
+        if (backupDir && existsSync(backupDir)) {
+            rmSync(backupDir, { recursive: true, force: true });
+        }
+    }
+}

package/dist/api/vega.d.ts

@@ -165,19 +165,66 @@ export interface SetVegaConnectorTypeEnabledOptions {
     businessDomain?: string;
 }
 export declare function setVegaConnectorTypeEnabled(options: SetVegaConnectorTypeEnabledOptions): Promise<string>;
-export interface ListVegaDiscoverTasksOptions {
+export interface CreateVegaDatasetDocsOptions {
     baseUrl: string;
     accessToken: string;
-    status?: string;
-    limit?: number;
-    offset?: number;
+    id: string;
+    body: string;
+    businessDomain?: string;
+}
+export declare function createVegaDatasetDocs(options: CreateVegaDatasetDocsOptions): Promise<string>;
+export interface UpdateVegaDatasetDocsOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    body: string;
+    businessDomain?: string;
+}
+export declare function updateVegaDatasetDocs(options: UpdateVegaDatasetDocsOptions): Promise<string>;
+export interface DeleteVegaDatasetDocsOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    docIds: string;
+    businessDomain?: string;
+}
+export declare function deleteVegaDatasetDocs(options: DeleteVegaDatasetDocsOptions): Promise<string>;
+export interface DeleteVegaDatasetDocsQueryOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    body: string;
+    businessDomain?: string;
+}
+export declare function deleteVegaDatasetDocsQuery(options: DeleteVegaDatasetDocsQueryOptions): Promise<string>;
+export interface BuildVegaDatasetOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    mode?: string;
     businessDomain?: string;
 }
-export declare function listVegaDiscoverTasks(options: ListVegaDiscoverTasksOptions): Promise<string>;
-export interface GetVegaDiscoverTaskOptions {
+export declare function buildVegaDataset(options: BuildVegaDatasetOptions): Promise<string>;
+export interface GetVegaDatasetBuildStatusOptions {
     baseUrl: string;
     accessToken: string;
     id: string;
+    taskId: string;
+    businessDomain?: string;
+}
+export declare function getVegaDatasetBuildStatus(options: GetVegaDatasetBuildStatusOptions): Promise<string>;
+export interface ExecuteVegaQueryOptions {
+    baseUrl: string;
+    accessToken: string;
+    body: string;
+    businessDomain?: string;
+}
+export declare function executeVegaQuery(options: ExecuteVegaQueryOptions): Promise<string>;
+export interface ListAllVegaResourcesOptions {
+    baseUrl: string;
+    accessToken: string;
+    limit?: number;
+    offset?: number;
     businessDomain?: string;
 }
-export declare function getVegaDiscoverTask(options: GetVegaDiscoverTaskOptions): Promise<string>;
+export declare function listAllVegaResources(options: ListAllVegaResourcesOptions): Promise<string>;

package/dist/api/vega.js

@@ -1,15 +1,6 @@
 import { HttpError } from "../utils/http.js";
+import { buildHeaders } from "./headers.js";
 const VEGA_BASE = "/api/vega-backend/v1";
-function buildHeaders(accessToken, businessDomain) {
-    return {
-        accept: "application/json, text/plain, */*",
-        "accept-language": "zh-cn",
-        authorization: `Bearer ${accessToken}`,
-        token: accessToken,
-        "x-business-domain": businessDomain,
-        "x-language": "zh-cn",
-    };
-}
 export async function vegaHealth(options) {
     const { baseUrl, accessToken, businessDomain = "bd_public", } = options;
     const base = baseUrl.replace(/\/+$/, "");
@@ -355,31 +346,127 @@ export async function setVegaConnectorTypeEnabled(options) {
         throw new HttpError(response.status, response.statusText, body);
     return body;
 }
-export async function listVegaDiscoverTasks(options) {
-    const { baseUrl, accessToken, status, limit, offset, businessDomain = "bd_public", } = options;
+export async function createVegaDatasetDocs(options) {
+    const { baseUrl, accessToken, id, body: requestBody, businessDomain = "bd_public" } = options;
     const base = baseUrl.replace(/\/+$/, "");
-    const url = new URL(`${base}${VEGA_BASE}/discover-tasks`);
-    if (status)
-        url.searchParams.set("status", status);
-    if (limit !== undefined)
-        url.searchParams.set("limit", String(limit));
-    if (offset !== undefined)
-        url.searchParams.set("offset", String(offset));
-    const response = await fetch(url.toString(), {
+    const url = `${base}${VEGA_BASE}/resources/dataset/${encodeURIComponent(id)}/docs`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body: requestBody,
+    });
+    const body = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, body);
+    return body;
+}
+export async function updateVegaDatasetDocs(options) {
+    const { baseUrl, accessToken, id, body: requestBody, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/resources/dataset/${encodeURIComponent(id)}/docs`;
+    const response = await fetch(url, {
+        method: "PUT",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body: requestBody,
+    });
+    const body = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, body);
+    return body;
+}
+export async function deleteVegaDatasetDocs(options) {
+    const { baseUrl, accessToken, id, docIds, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/resources/dataset/${encodeURIComponent(id)}/docs/${encodeURIComponent(docIds)}`;
+    const response = await fetch(url, {
+        method: "DELETE",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, body);
+    return body;
+}
+export async function deleteVegaDatasetDocsQuery(options) {
+    const { baseUrl, accessToken, id, body: requestBody, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/resources/dataset/${encodeURIComponent(id)}/docs/query`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+            "x-http-method-override": "DELETE",
+        },
+        body: requestBody,
+    });
+    const body = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, body);
+    return body;
+}
+export async function buildVegaDataset(options) {
+    const { baseUrl, accessToken, id, mode = "full", businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/resources/${encodeURIComponent(id)}/build`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body: JSON.stringify({ mode }),
+    });
+    const body = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, body);
+    return body;
+}
+export async function getVegaDatasetBuildStatus(options) {
+    const { baseUrl, accessToken, id, taskId, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/resources/dataset/${encodeURIComponent(id)}/build/${encodeURIComponent(taskId)}`;
+    const response = await fetch(url, {
         method: "GET",
         headers: buildHeaders(accessToken, businessDomain),
     });
     const body = await response.text();
-    if (!response.ok) {
+    if (!response.ok)
         throw new HttpError(response.status, response.statusText, body);
-    }
     return body;
 }
-export async function getVegaDiscoverTask(options) {
-    const { baseUrl, accessToken, id, businessDomain = "bd_public" } = options;
+export async function executeVegaQuery(options) {
+    const { baseUrl, accessToken, body: requestBody, businessDomain = "bd_public" } = options;
     const base = baseUrl.replace(/\/+$/, "");
-    const url = `${base}${VEGA_BASE}/discover-tasks/${encodeURIComponent(id)}`;
+    const url = `${base}${VEGA_BASE}/query/execute`;
     const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body: requestBody,
+    });
+    const body = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, body);
+    return body;
+}
+export async function listAllVegaResources(options) {
+    const { baseUrl, accessToken, limit, offset, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}${VEGA_BASE}/resources/list`);
+    if (limit !== undefined)
+        url.searchParams.set("limit", String(limit));
+    if (offset !== undefined)
+        url.searchParams.set("offset", String(offset));
+    const response = await fetch(url.toString(), {
         method: "GET",
         headers: buildHeaders(accessToken, businessDomain),
     });

package/dist/auth/oauth.d.ts

@@ -15,12 +15,14 @@ export declare function normalizeBaseUrl(value: string): string;
  * OAuth2 Authorization Code login flow.
  * 1. Register client (if not already registered), OR use a provided client ID
  * 2. Open browser to /oauth2/auth
- * 3. Receive authorization code via local HTTP callback
+ * 3. Receive authorization code via local HTTP callback (or manual paste for non-localhost)
  * 4. Exchange code for access_token + refresh_token
  * 5. Save token.json + client.json to ~/.kweaver/
  */
 export declare function oauth2Login(baseUrl: string, options?: {
     port?: number;
+    /** Full redirect URI override (e.g. "http://127.0.0.1:9010/callback" or a remote URL). */
+    redirectUri?: string;
     scope?: string;
     clientId?: string;
     clientSecret?: string;
@@ -42,6 +44,8 @@ export declare function playwrightLogin(baseUrl: string, options?: {
     username?: string;
     password?: string;
     port?: number;
+    /** Full redirect URI override. */
+    redirectUri?: string;
     scope?: string;
     tlsInsecure?: boolean;
 }): Promise<TokenConfig>;