@keboola/api-client 1.0.0 → 1.0.1

package/dist/index.js

@@ -961,6 +961,24 @@ var toolInfoSchema2 = z.object({
 var toolsListResponseSchema2 = z.object({
   tools: z.array(toolInfoSchema2)
 });
+var sandboxFileEntrySchema = z.object({
+  name: z.string(),
+  path: z.string(),
+  type: z.enum(["file", "dir"]),
+  size: z.number().int().nonnegative().optional()
+});
+var sandboxFileListingSchema = z.object({
+  entries: z.array(sandboxFileEntrySchema)
+});
+var sandboxFileContentSchema = z.object({
+  content: z.string(),
+  encoding: z.enum(["utf-8", "binary"]),
+  truncated: z.boolean(),
+  size: z.number().int().nonnegative()
+});
+var sandboxGitBranchSchema = z.object({
+  branch: z.string().nullable()
+});
 var createKaiAgentClient = ({ baseUrl, middlewares }) => {
   const clientOptions = { baseUrl, middlewares };
   const client = createOpenapiFetchClient(clientOptions);
@@ -1070,6 +1088,42 @@ var createKaiAgentClient = ({ baseUrl, middlewares }) => {
     }
     return result.data;
   };
+  const listSandboxFiles = async (chatId, path, signal) => {
+    const { data } = await genericClient.get(
+      `/api/chat/${encodeURIComponent(chatId)}/sandbox/files`,
+      { query: path ? { path } : void 0 },
+      { signal }
+    );
+    const result = sandboxFileListingSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid sandbox files response format");
+    }
+    return result.data;
+  };
+  const readSandboxFile = async (chatId, path, signal) => {
+    const { data } = await genericClient.get(
+      `/api/chat/${encodeURIComponent(chatId)}/sandbox/file`,
+      { query: { path } },
+      { signal }
+    );
+    const result = sandboxFileContentSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid sandbox file response format");
+    }
+    return result.data;
+  };
+  const getSandboxGitBranch = async (chatId, signal) => {
+    const { data } = await genericClient.get(
+      `/api/chat/${encodeURIComponent(chatId)}/sandbox/git-branch`,
+      {},
+      { signal }
+    );
+    const result = sandboxGitBranchSchema.safeParse(data);
+    if (!result.success) {
+      throw new Error("Invalid sandbox git-branch response format");
+    }
+    return result.data;
+  };
   const chatStreamUrl = baseUrl + "/api/chat";
   return {
     getHistory,
@@ -1088,6 +1142,9 @@ var createKaiAgentClient = ({ baseUrl, middlewares }) => {
     getUserAgentSettings,
     updateUserAgentSettings,
     getToolsList,
+    listSandboxFiles,
+    readSandboxFile,
+    getSandboxGitBranch,
     chatStreamUrl
   };
 };
@@ -2307,6 +2364,30 @@ var createBranches = (client) => {
   };
 };
 
+// src/clients/storage/buckets/listingConversion.ts
+var toBackendSubscribers = (subscribers) => subscribers.map((s) => `${s.type}:${s.email}`);
+var fromBackendSubscribers = (raw) => {
+  const result = [];
+  for (const entry of raw) {
+    const colon = entry.indexOf(":");
+    if (colon === -1) continue;
+    const prefix = entry.slice(0, colon);
+    const email2 = entry.slice(colon + 1);
+    if (prefix !== "user" && prefix !== "group") continue;
+    if (email2.length === 0) continue;
+    result.push({ type: prefix, email: email2 });
+  }
+  return result;
+};
+var toBucketListing = (raw, bucketId) => ({
+  bucketId,
+  name: raw.name,
+  description: raw.description ?? null,
+  listingId: raw.bigquery.listingId,
+  subscribers: fromBackendSubscribers(raw.bigquery.subscribers),
+  createdAt: raw.createdAt
+});
+
 // src/clients/storage/buckets/buckets.ts
 var createBuckets = (client) => {
   const getBuckets = async (query = {}, signal) => {
@@ -2358,6 +2439,64 @@ var createBuckets = (client) => {
       path: { taskId }
     });
   };
+  const getListing = async (bucketId, signal) => {
+    try {
+      const { data } = await client.get(
+        `/buckets/{bucketId}/listing`,
+        { path: { bucketId } },
+        { signal }
+      );
+      return toBucketListing(data, bucketId);
+    } catch (error) {
+      if (isApiError(error) && error.response.status === 404) return null;
+      throw error;
+    }
+  };
+  const createListing = async (bucketId, input, signal) => {
+    const { data } = await client.post(
+      `/buckets/{bucketId}/listing`,
+      {
+        path: { bucketId },
+        body: {
+          listingName: input.name,
+          listingDescription: input.description?.trim() || null,
+          bigquery: {
+            listingId: input.listingId,
+            subscribers: toBackendSubscribers(input.subscribers)
+          }
+        }
+      },
+      { signal }
+    );
+    return data;
+  };
+  const updateListing = async (bucketId, input, signal) => {
+    const body = {};
+    if (input.name !== void 0) body.exposureName = input.name;
+    if (input.description !== void 0) {
+      body.exposureDescription = input.description?.trim() || null;
+    }
+    if (input.subscribers !== void 0) {
+      body.bigquery = { subscribers: toBackendSubscribers(input.subscribers) };
+    }
+    if (Object.keys(body).length === 0) {
+      throw new Error("updateListing requires at least one field");
+    }
+    const { data } = await client.patch(`/buckets/{bucketId}/listing`, { path: { bucketId }, body }, { signal });
+    return data;
+  };
+  const deleteListing = async (bucketId, signal) => {
+    const { data } = await client.delete(
+      `/buckets/{bucketId}/listing`,
+      { path: { bucketId } },
+      { signal }
+    );
+    return data;
+  };
+  const listListings = async (signal) => {
+    const { data } = await client.get(`/listings`, {}, { signal });
+    return data.map((row) => toBucketListing(row, row.bucketId));
+  };
   return {
     getBuckets,
     getBucket,
@@ -2366,7 +2505,12 @@ var createBuckets = (client) => {
     deleteBucket,
     deleteBucketAsync,
     createScheduledRefresh,
-    deleteScheduledTask
+    deleteScheduledTask,
+    getListing,
+    createListing,
+    updateListing,
+    deleteListing,
+    listListings
   };
 };
 
@@ -3433,10 +3577,29 @@ var createStorageSdk = ({ storageClient }) => {
     const job = await storageClient.tables.exportAsync(tableId, body, options?.abortSignal);
     return waitForJob(job, options);
   };
+  const getBucketListing = async (bucketId, signal) => storageClient.buckets.getListing(bucketId, signal);
+  const listBucketListings = async (signal) => storageClient.buckets.listListings(signal);
+  const createBucketListing = async (bucketId, input, options) => {
+    const job = await storageClient.buckets.createListing(bucketId, input, options?.abortSignal);
+    return waitForJob(job, options);
+  };
+  const updateBucketListing = async (bucketId, input, options) => {
+    const job = await storageClient.buckets.updateListing(bucketId, input, options?.abortSignal);
+    return waitForJob(job, options);
+  };
+  const deleteBucketListing = async (bucketId, options) => {
+    const job = await storageClient.buckets.deleteListing(bucketId, options?.abortSignal);
+    return waitForJob(job, options);
+  };
   return {
     createTable,
     importFromFile,
-    exportToFile
+    exportToFile,
+    getBucketListing,
+    listBucketListings,
+    createBucketListing,
+    updateBucketListing,
+    deleteBucketListing
   };
 };