agentnetes 0.1.3 → 0.1.4

package/web/.next/node_modules/@vercel/sandbox-458c632d4d217a3e/dist/api-client/file-writer.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileWriter = void 0;
+const zlib_1 = __importDefault(require("zlib"));
+const tar_stream_1 = __importDefault(require("tar-stream"));
+const stream_1 = require("stream");
+/**
+ * Allows to create a Readable stream with methods to write files
+ * to it and to finish it. Files written are compressed together
+ * and gzipped in the stream.
+ */
+class FileWriter {
+    constructor() {
+        const gzip = zlib_1.default.createGzip();
+        this.pack = tar_stream_1.default.pack();
+        this.readable = this.pack.pipe(gzip);
+    }
+    /**
+     * Allows to add a file to the stream. Size is required to write
+     * the tarball header so when content is a stream it must be
+     * provided.
+     *
+     * Returns a Promise resolved once the file is written in the
+     * stream.
+     */
+    async addFile(file) {
+        return new Promise((resolve, reject) => {
+            const entry = this.pack.entry("size" in file
+                ? { name: file.name, size: file.size, mode: file.mode }
+                : { name: file.name, size: file.content.length, mode: file.mode }, (error) => {
+                if (error) {
+                    return reject(error);
+                }
+                else {
+                    resolve();
+                }
+            });
+            if (file.content instanceof stream_1.Readable) {
+                file.content.pipe(entry);
+            }
+            else {
+                entry.end(file.content);
+            }
+        });
+    }
+    /**
+     * Allows to finish the stream returning a Promise that will
+     * resolve once the readable is effectively closed or
+     * errored.
+     */
+    async end() {
+        return new Promise((resolve, reject) => {
+            this.readable.on("error", reject);
+            this.readable.on("end", resolve);
+            this.pack.finalize();
+        });
+    }
+}
+exports.FileWriter = FileWriter;
+//# sourceMappingURL=file-writer.js.map

package/web/.next/node_modules/@vercel/sandbox-458c632d4d217a3e/dist/api-client/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIClient = void 0;
+var api_client_1 = require("./api-client");
+Object.defineProperty(exports, "APIClient", { enumerable: true, get: function () { return api_client_1.APIClient; } });
+__exportStar(require("./validators"), exports);
+//# sourceMappingURL=index.js.map

package/web/.next/node_modules/@vercel/sandbox-458c632d4d217a3e/dist/api-client/validators.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SnapshotResponse = exports.CreateSnapshotResponse = exports.UpdateNetworkPolicyResponse = exports.ExtendTimeoutResponse = exports.SnapshotsResponse = exports.SandboxesResponse = exports.LogLine = exports.LogError = exports.LogLineStderr = exports.LogLineStdout = exports.EmptyResponse = exports.CommandFinishedResponse = exports.CommandResponse = exports.SandboxAndRoutesResponse = exports.SandboxResponse = exports.Command = exports.Pagination = exports.Snapshot = exports.SandboxRoute = exports.Sandbox = exports.NetworkPolicyValidator = exports.InjectionRuleValidator = void 0;
+const zod_1 = require("zod");
+exports.InjectionRuleValidator = zod_1.z.object({
+    domain: zod_1.z.string(),
+    // headers are only sent in requests
+    headers: zod_1.z.record(zod_1.z.string()).optional(),
+    // headerNames are returned in responses
+    headerNames: zod_1.z.array(zod_1.z.string()).optional(),
+});
+exports.NetworkPolicyValidator = zod_1.z.union([
+    zod_1.z.object({ mode: zod_1.z.literal("allow-all") }).passthrough(),
+    zod_1.z.object({ mode: zod_1.z.literal("deny-all") }).passthrough(),
+    zod_1.z
+        .object({
+        mode: zod_1.z.literal("custom"),
+        allowedDomains: zod_1.z.array(zod_1.z.string()).optional(),
+        allowedCIDRs: zod_1.z.array(zod_1.z.string()).optional(),
+        deniedCIDRs: zod_1.z.array(zod_1.z.string()).optional(),
+        injectionRules: zod_1.z.array(exports.InjectionRuleValidator).optional(),
+    })
+        .passthrough(),
+]);
+exports.Sandbox = zod_1.z.object({
+    id: zod_1.z.string(),
+    memory: zod_1.z.number(),
+    vcpus: zod_1.z.number(),
+    region: zod_1.z.string(),
+    runtime: zod_1.z.string(),
+    timeout: zod_1.z.number(),
+    status: zod_1.z.enum([
+        "pending",
+        "running",
+        "stopping",
+        "stopped",
+        "failed",
+        "aborted",
+        "snapshotting",
+    ]),
+    requestedAt: zod_1.z.number(),
+    startedAt: zod_1.z.number().optional(),
+    requestedStopAt: zod_1.z.number().optional(),
+    stoppedAt: zod_1.z.number().optional(),
+    abortedAt: zod_1.z.number().optional(),
+    duration: zod_1.z.number().optional(),
+    sourceSnapshotId: zod_1.z.string().optional(),
+    snapshottedAt: zod_1.z.number().optional(),
+    createdAt: zod_1.z.number(),
+    cwd: zod_1.z.string(),
+    updatedAt: zod_1.z.number(),
+    interactivePort: zod_1.z.number().optional(),
+    networkPolicy: exports.NetworkPolicyValidator.optional(),
+    activeCpuDurationMs: zod_1.z.number().optional(),
+    networkTransfer: zod_1.z.object({
+        ingress: zod_1.z.number(),
+        egress: zod_1.z.number(),
+    }).optional(),
+});
+exports.SandboxRoute = zod_1.z.object({
+    url: zod_1.z.string(),
+    subdomain: zod_1.z.string(),
+    port: zod_1.z.number(),
+});
+exports.Snapshot = zod_1.z.object({
+    id: zod_1.z.string(),
+    sourceSandboxId: zod_1.z.string(),
+    region: zod_1.z.string(),
+    status: zod_1.z.enum(["created", "deleted", "failed"]),
+    sizeBytes: zod_1.z.number(),
+    expiresAt: zod_1.z.number().optional(),
+    createdAt: zod_1.z.number(),
+    updatedAt: zod_1.z.number(),
+});
+exports.Pagination = zod_1.z.object({
+    /**
+     * Amount of items in the current page.
+     * @example 20
+     */
+    count: zod_1.z.number(),
+    /**
+     * Timestamp that must be used to request the next page.
+     * @example 1540095775951
+     */
+    next: zod_1.z.number().nullable(),
+    /**
+     * Timestamp that must be used to request the previous page.
+     * @example 1540095775951
+     */
+    prev: zod_1.z.number().nullable(),
+});
+exports.Command = zod_1.z.object({
+    id: zod_1.z.string(),
+    name: zod_1.z.string(),
+    args: zod_1.z.array(zod_1.z.string()),
+    cwd: zod_1.z.string(),
+    sandboxId: zod_1.z.string(),
+    exitCode: zod_1.z.number().nullable(),
+    startedAt: zod_1.z.number(),
+});
+const CommandFinished = exports.Command.extend({
+    exitCode: zod_1.z.number(),
+});
+exports.SandboxResponse = zod_1.z.object({
+    sandbox: exports.Sandbox,
+});
+exports.SandboxAndRoutesResponse = exports.SandboxResponse.extend({
+    routes: zod_1.z.array(exports.SandboxRoute),
+});
+exports.CommandResponse = zod_1.z.object({
+    command: exports.Command,
+});
+exports.CommandFinishedResponse = zod_1.z.object({
+    command: CommandFinished,
+});
+exports.EmptyResponse = zod_1.z.object({});
+const LogLineBase = zod_1.z.object({ data: zod_1.z.string() });
+exports.LogLineStdout = LogLineBase.extend({
+    stream: zod_1.z.literal("stdout"),
+});
+exports.LogLineStderr = LogLineBase.extend({
+    stream: zod_1.z.literal("stderr"),
+});
+exports.LogError = zod_1.z.object({
+    stream: zod_1.z.literal("error"),
+    data: zod_1.z.object({
+        code: zod_1.z.string(),
+        message: zod_1.z.string(),
+    }),
+});
+exports.LogLine = zod_1.z.discriminatedUnion("stream", [
+    exports.LogLineStdout,
+    exports.LogLineStderr,
+    exports.LogError,
+]);
+exports.SandboxesResponse = zod_1.z.object({
+    sandboxes: zod_1.z.array(exports.Sandbox),
+    pagination: exports.Pagination,
+});
+exports.SnapshotsResponse = zod_1.z.object({
+    snapshots: zod_1.z.array(exports.Snapshot),
+    pagination: exports.Pagination,
+});
+exports.ExtendTimeoutResponse = zod_1.z.object({
+    sandbox: exports.Sandbox,
+});
+exports.UpdateNetworkPolicyResponse = zod_1.z.object({
+    sandbox: exports.Sandbox,
+});
+exports.CreateSnapshotResponse = zod_1.z.object({
+    snapshot: exports.Snapshot,
+    sandbox: exports.Sandbox,
+});
+exports.SnapshotResponse = zod_1.z.object({
+    snapshot: exports.Snapshot,
+});
+//# sourceMappingURL=validators.js.map

package/web/.next/node_modules/@vercel/sandbox-458c632d4d217a3e/dist/api-client/with-retry.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRetry = withRetry;
+const api_error_1 = require("./api-error");
+const promises_1 = require("node:timers/promises");
+const async_retry_1 = __importDefault(require("async-retry"));
+/**
+ * Wraps a fetch function with retry logic. The retry logic will retry
+ * on network errors, 429 responses and 5xx responses. The retry logic
+ * will not retry on 4xx responses.
+ *
+ * @param rawFetch The fetch function to wrap.
+ * @returns The wrapped fetch function.
+ */
+function withRetry(rawFetch) {
+    return async (url, opts = {}) => {
+        /**
+         * Timeouts by default will be [10, 60, 360, 2160, 12960]
+         * before randomization is added.
+         */
+        const retryOpts = Object.assign({
+            minTimeout: 10,
+            retries: 5,
+            factor: 6,
+            maxRetryAfter: 20,
+        }, opts.retry);
+        if (opts.onRetry) {
+            retryOpts.onRetry = (error, attempts) => {
+                opts.onRetry(error, opts);
+                if (opts.retry && opts.retry.onRetry) {
+                    opts.retry.onRetry(error, attempts);
+                }
+            };
+        }
+        try {
+            return (await (0, async_retry_1.default)(async (bail) => {
+                try {
+                    if (opts.signal?.aborted) {
+                        return bail(opts.signal.reason || new Error("Request aborted"));
+                    }
+                    const response = await rawFetch(url, opts);
+                    /**
+                     * When the response is 429 we will try to parse the Retry-After
+                     * header. If the header exists we will try to parse it and, if
+                     * the wait time is higher than the maximum defined, we respond.
+                     * Otherwise we wait for the time given in the header and throw
+                     * to retry.
+                     */
+                    if (response.status === 429) {
+                        const retryAfter = parseInt(response.headers.get("retry-after") || "", 10);
+                        if (retryAfter && !isNaN(retryAfter)) {
+                            if (retryAfter > retryOpts.maxRetryAfter) {
+                                return response;
+                            }
+                            await (0, promises_1.setTimeout)(retryAfter * 1e3);
+                        }
+                        throw new api_error_1.APIError(response);
+                    }
+                    /**
+                     * If the response is a a retryable error, we throw in
+                     * order to retry.
+                     */
+                    if (response.status >= 500 && response.status < 600) {
+                        throw new api_error_1.APIError(response);
+                    }
+                    return response;
+                }
+                catch (error) {
+                    /**
+                     * If the request was aborted using the AbortController
+                     * we bail from retrying throwing the original error.
+                     */
+                    if (isAbortError(error)) {
+                        return bail(error);
+                    }
+                    /**
+                     * If the signal was aborted meanwhile we were
+                     * waiting, we bail from retrying.
+                     */
+                    if (opts.signal?.aborted) {
+                        return bail(opts.signal.reason || new Error("Request aborted"));
+                    }
+                    throw error;
+                }
+            }, retryOpts));
+        }
+        catch (error) {
+            /**
+             * The ResponseError is only intended for retries so in case we
+             * ran out of attempts we will respond with the last response
+             * we obtained.
+             */
+            if (error instanceof api_error_1.APIError) {
+                return error.response;
+            }
+            throw error;
+        }
+    };
+}
+function isAbortError(error) {
+    return (error !== undefined &&
+        error !== null &&
+        error.name === "AbortError");
+}
+//# sourceMappingURL=with-retry.js.map

package/web/.next/node_modules/@vercel/sandbox-458c632d4d217a3e/dist/auth/api.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchApi = fetchApi;
+const error_1 = require("./error");
+async function fetchApi(opts) {
+    const x = await fetch(`https://api.vercel.com${opts.endpoint}`, {
+        method: opts.method,
+        body: opts.body,
+        headers: {
+            Authorization: `Bearer ${opts.token}`,
+            "Content-Type": "application/json",
+        },
+    });
+    if (!x.ok) {
+        let message = await x.text();
+        try {
+            const { error } = JSON.parse(message);
+            message = `${error.code.toUpperCase()}: ${error.message}`;
+        }
+        catch { }
+        throw new error_1.NotOk({
+            responseText: message,
+            statusCode: x.status,
+        });
+    }
+    return (await x.json());
+}
+//# sourceMappingURL=api.js.map

package/web/.next/node_modules/@vercel/sandbox-458c632d4d217a3e/dist/auth/error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotOk = void 0;
+class NotOk extends Error {
+    constructor(response) {
+        super(`HTTP ${response.statusCode}: ${response.responseText}`);
+        this.name = "NotOk";
+        this.response = response;
+    }
+}
+exports.NotOk = NotOk;
+//# sourceMappingURL=error.js.map

package/web/.next/node_modules/@vercel/sandbox-458c632d4d217a3e/dist/auth/file.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuth = void 0;
+exports.updateAuthConfig = updateAuthConfig;
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = require("node:os");
+const xdg_app_paths_1 = __importDefault(require("xdg-app-paths"));
+const zod_1 = require("zod");
+const zod_2 = require("./zod");
+const ZodDate = zod_1.z.number().transform((seconds) => new Date(seconds * 1000));
+const AuthFile = zod_1.z.object({
+    token: zod_1.z.string().min(1).optional(),
+    refreshToken: zod_1.z.string().min(1).optional(),
+    expiresAt: ZodDate.optional(),
+});
+const StoredAuthFile = zod_2.json.pipe(AuthFile);
+// Returns whether a directory exists
+const isDirectory = (path) => {
+    try {
+        return node_fs_1.default.lstatSync(path).isDirectory();
+    }
+    catch (_) {
+        // We don't care which kind of error occured, it isn't a directory anyway.
+        return false;
+    }
+};
+/**
+ * Returns in which directory the config should be present.
+ *
+ * @internal The `VERCEL_AUTH_CONFIG_DIR` env var is for testing purposes only
+ * and is not part of the public API.
+ */
+const getGlobalPathConfig = () => {
+    if (process.env.VERCEL_AUTH_CONFIG_DIR) {
+        return process.env.VERCEL_AUTH_CONFIG_DIR;
+    }
+    const vercelDirectories = (0, xdg_app_paths_1.default)("com.vercel.cli").dataDirs();
+    const possibleConfigPaths = [
+        ...vercelDirectories, // latest vercel directory
+        node_path_1.default.join((0, node_os_1.homedir)(), ".now"), // legacy config in user's home directory
+        ...(0, xdg_app_paths_1.default)("now").dataDirs(), // legacy XDG directory
+    ];
+    // The customPath flag is the preferred location,
+    // followed by the vercel directory,
+    // followed by the now directory.
+    // If none of those exist, use the vercel directory.
+    return (possibleConfigPaths.find((configPath) => isDirectory(configPath)) ||
+        vercelDirectories[0]);
+};
+const getAuth = () => {
+    try {
+        const pathname = node_path_1.default.join(getGlobalPathConfig(), "auth.json");
+        return StoredAuthFile.parse(node_fs_1.default.readFileSync(pathname, "utf8"));
+    }
+    catch {
+        return null;
+    }
+};
+exports.getAuth = getAuth;
+function updateAuthConfig(config) {
+    const pathname = node_path_1.default.join(getGlobalPathConfig(), "auth.json");
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(pathname), { recursive: true });
+    const content = {
+        token: config.token,
+        expiresAt: config.expiresAt && Math.round(config.expiresAt.getTime() / 1000),
+        refreshToken: config.refreshToken,
+    };
+    node_fs_1.default.writeFileSync(pathname, JSON.stringify(content) + "\n");
+}
+//# sourceMappingURL=file.js.map

package/web/.next/node_modules/@vercel/sandbox-458c632d4d217a3e/dist/auth/index.js

@@ -0,0 +1,27 @@
+"use strict";
+// This file can also be imported as `@vercel/sandbox/dist/auth`, which is completely fine.
+// The only valid importer of this would be the CLI as we share the same codebase.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectTeam = exports.inferScope = exports.pollForToken = void 0;
+__exportStar(require("./file"), exports);
+__exportStar(require("./oauth"), exports);
+var poll_for_token_1 = require("./poll-for-token");
+Object.defineProperty(exports, "pollForToken", { enumerable: true, get: function () { return poll_for_token_1.pollForToken; } });
+var project_1 = require("./project");
+Object.defineProperty(exports, "inferScope", { enumerable: true, get: function () { return project_1.inferScope; } });
+Object.defineProperty(exports, "selectTeam", { enumerable: true, get: function () { return project_1.selectTeam; } });
+//# sourceMappingURL=index.js.map

package/web/.next/node_modules/@vercel/sandbox-458c632d4d217a3e/dist/auth/linked-project.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readLinkedProject = readLinkedProject;
+const zod_1 = require("zod");
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const zod_2 = require("./zod");
+const LinkedProjectSchema = zod_2.json.pipe(zod_1.z.object({
+    projectId: zod_1.z.string(),
+    orgId: zod_1.z.string(),
+}));
+/**
+ * Reads the linked project configuration from `.vercel/project.json`.
+ *
+ * @param cwd - The directory to search for `.vercel/project.json`.
+ * @returns The linked project's `projectId` and `teamId`, or `null` if not found.
+ */
+async function readLinkedProject(cwd) {
+    const projectJsonPath = path.join(cwd, ".vercel", "project.json");
+    let content;
+    try {
+        content = await fs.readFile(projectJsonPath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    const parsed = LinkedProjectSchema.safeParse(content);
+    if (!parsed.success) {
+        return null;
+    }
+    return {
+        projectId: parsed.data.projectId,
+        teamId: parsed.data.orgId,
+    };
+}
+//# sourceMappingURL=linked-project.js.map