agentnetes 0.1.3 → 0.1.4

package/dist/index.js

@@ -965,10 +965,7 @@ async function snapshotList() {
 var import_child_process4 = require("child_process");
 var import_fs4 = require("fs");
 var import_path4 = require("path");
-var import_url = require("url");
 var import_picocolors4 = __toESM(require("picocolors"));
-var import_meta = {};
-var __dirname = (0, import_path4.dirname)((0, import_url.fileURLToPath)(import_meta.url));
 async function serve(port) {
   const webDir = (0, import_path4.join)(__dirname, "..", "web");
   const serverJs = (0, import_path4.join)(webDir, "server.js");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentnetes",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Zero to a self-organizing AI agency. On demand.",
   "keywords": [
     "ai",

package/web/.next/BUILD_ID

@@ -0,0 +1 @@
+Vd1Q6l74_n2F-lMfVCVr_

package/web/.next/app-path-routes-manifest.json

@@ -0,0 +1,9 @@
+{
+  "/_global-error/page": "/_global-error",
+  "/_not-found/page": "/_not-found",
+  "/api/chat/route": "/api/chat",
+  "/api/config/route": "/api/config",
+  "/demo/page": "/demo",
+  "/docs/page": "/docs",
+  "/page": "/"
+}

package/web/.next/build-manifest.json

@@ -0,0 +1,21 @@
+{
+  "pages": {
+    "/_app": []
+  },
+  "devFiles": [],
+  "polyfillFiles": [
+    "static/chunks/03~yq9q893hmn.js"
+  ],
+  "lowPriorityFiles": [
+    "static/Vd1Q6l74_n2F-lMfVCVr_/_buildManifest.js",
+    "static/Vd1Q6l74_n2F-lMfVCVr_/_ssgManifest.js",
+    "static/Vd1Q6l74_n2F-lMfVCVr_/_clientMiddlewareManifest.js"
+  ],
+  "rootMainFiles": [
+    "static/chunks/16i90eio_ss7o.js",
+    "static/chunks/0dgq26a5_oy.a.js",
+    "static/chunks/0h4bq73pogmtb.js",
+    "static/chunks/0257pdz1-imal.js",
+    "static/chunks/turbopack-0hiru4uy9kb-x.js"
+  ]
+}

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

@@ -0,0 +1,412 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIClient = void 0;
+const base_client_1 = require("./base-client");
+const validators_1 = require("./validators");
+const api_error_1 = require("./api-error");
+const file_writer_1 = require("./file-writer");
+const version_1 = require("../version");
+const consume_readable_1 = require("../utils/consume-readable");
+const zod_1 = require("zod");
+const jsonlines_1 = __importDefault(require("jsonlines"));
+const os_1 = __importDefault(require("os"));
+const stream_1 = require("stream");
+const normalizePath_1 = require("../utils/normalizePath");
+const oidc_1 = require("@vercel/oidc");
+const network_policy_1 = require("../utils/network-policy");
+const types_1 = require("../utils/types");
+const promises_1 = require("node:timers/promises");
+function decodeUnverifiedToken(token) {
+    if (token.split(".").length !== 3) {
+        return null;
+    }
+    try {
+        const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64url").toString("utf8"));
+        if (payload.owner_id) {
+            return { owner_id: payload.owner_id, project_id: payload.project_id };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+class APIClient extends base_client_1.BaseClient {
+    constructor(params) {
+        super({
+            baseUrl: params.baseUrl ?? "https://vercel.com/api",
+            token: params.token,
+            debug: false,
+            fetch: params.fetch,
+        });
+        this.teamId = params.teamId;
+        this.isJwtToken = false;
+        const claims = decodeUnverifiedToken(params.token);
+        if (claims) {
+            this.isJwtToken = true;
+            this.projectId = claims.project_id;
+            this.teamId = claims.owner_id;
+        }
+    }
+    async ensureValidToken() {
+        if (!this.isJwtToken) {
+            return;
+        }
+        try {
+            // Use getVercelOidcToken to refresh the token with team/project scope
+            const freshToken = await (0, oidc_1.getVercelOidcToken)({
+                expirationBufferMs: 5 * 60 * 1000, // 5 minutes
+                team: this.teamId,
+                project: this.projectId,
+            });
+            // Update token if it changed
+            if (freshToken !== this.token) {
+                this.token = freshToken;
+                const claims = decodeUnverifiedToken(freshToken);
+                if (claims) {
+                    this.teamId = claims.owner_id;
+                }
+            }
+        }
+        catch {
+            // Ignore refresh errors and continue with current token
+        }
+    }
+    async request(path, params) {
+        await this.ensureValidToken();
+        return super.request(path, {
+            ...params,
+            query: { teamId: this.teamId, ...params?.query },
+            headers: {
+                "content-type": "application/json",
+                "user-agent": `vercel/sandbox/${version_1.VERSION} (Node.js/${process.version}; ${os_1.default.platform()}/${os_1.default.arch()})`,
+                ...params?.headers,
+            },
+        });
+    }
+    async getSandbox(params) {
+        const privateParams = (0, types_1.getPrivateParams)(params);
+        let querystring = new URLSearchParams(privateParams).toString();
+        querystring = querystring ? `?${querystring}` : "";
+        return (0, base_client_1.parseOrThrow)(validators_1.SandboxAndRoutesResponse, await this.request(`/v1/sandboxes/${params.sandboxId}${querystring}`, {
+            signal: params.signal,
+        }));
+    }
+    async createSandbox(params) {
+        const privateParams = (0, types_1.getPrivateParams)(params);
+        return (0, base_client_1.parseOrThrow)(validators_1.SandboxAndRoutesResponse, await this.request("/v1/sandboxes", {
+            method: "POST",
+            body: JSON.stringify({
+                projectId: params.projectId,
+                ports: params.ports,
+                source: params.source,
+                timeout: params.timeout,
+                resources: params.resources,
+                runtime: params.runtime,
+                networkPolicy: params.networkPolicy
+                    ? (0, network_policy_1.toAPINetworkPolicy)(params.networkPolicy)
+                    : undefined,
+                env: params.env,
+                ...privateParams,
+            }),
+            signal: params.signal,
+        }));
+    }
+    async runCommand(params) {
+        if (params.wait) {
+            const response = await this.request(`/v1/sandboxes/${params.sandboxId}/cmd`, {
+                method: "POST",
+                body: JSON.stringify({
+                    command: params.command,
+                    args: params.args,
+                    cwd: params.cwd,
+                    env: params.env,
+                    sudo: params.sudo,
+                    wait: true,
+                }),
+                signal: params.signal,
+            });
+            if (!response.ok) {
+                await (0, base_client_1.parseOrThrow)(zod_1.z.any(), response);
+            }
+            if (response.headers.get("content-type") !== "application/x-ndjson") {
+                throw new api_error_1.APIError(response, {
+                    message: "Expected a stream of command data",
+                    sandboxId: params.sandboxId,
+                });
+            }
+            if (response.body === null) {
+                throw new api_error_1.APIError(response, {
+                    message: "No response body",
+                    sandboxId: params.sandboxId,
+                });
+            }
+            const jsonlinesStream = jsonlines_1.default.parse();
+            pipe(response.body, jsonlinesStream).catch((err) => {
+                console.error("Error piping command stream:", err);
+            });
+            const iterator = jsonlinesStream[Symbol.asyncIterator]();
+            const commandChunk = await iterator.next();
+            const { command } = validators_1.CommandResponse.parse(commandChunk.value);
+            const finished = (async () => {
+                const finishedChunk = await iterator.next();
+                const { command } = validators_1.CommandFinishedResponse.parse(finishedChunk.value);
+                return command;
+            })();
+            return { command, finished };
+        }
+        return (0, base_client_1.parseOrThrow)(validators_1.CommandResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/cmd`, {
+            method: "POST",
+            body: JSON.stringify({
+                command: params.command,
+                args: params.args,
+                cwd: params.cwd,
+                env: params.env,
+                sudo: params.sudo,
+            }),
+            signal: params.signal,
+        }));
+    }
+    async getCommand(params) {
+        return params.wait
+            ? (0, base_client_1.parseOrThrow)(validators_1.CommandFinishedResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/cmd/${params.cmdId}`, { signal: params.signal, query: { wait: "true" } }))
+            : (0, base_client_1.parseOrThrow)(validators_1.CommandResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/cmd/${params.cmdId}`, { signal: params.signal }));
+    }
+    async mkDir(params) {
+        return (0, base_client_1.parseOrThrow)(validators_1.EmptyResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/fs/mkdir`, {
+            method: "POST",
+            body: JSON.stringify({ path: params.path, cwd: params.cwd }),
+            signal: params.signal,
+        }));
+    }
+    getFileWriter(params) {
+        const writer = new file_writer_1.FileWriter();
+        return {
+            response: (async () => {
+                return this.request(`/v1/sandboxes/${params.sandboxId}/fs/write`, {
+                    method: "POST",
+                    headers: {
+                        "content-type": "application/gzip",
+                        "x-cwd": params.extractDir,
+                    },
+                    body: await (0, consume_readable_1.consumeReadable)(writer.readable),
+                    signal: params.signal,
+                });
+            })(),
+            writer,
+        };
+    }
+    async listSandboxes(params) {
+        return (0, base_client_1.parseOrThrow)(validators_1.SandboxesResponse, await this.request(`/v1/sandboxes`, {
+            query: {
+                project: params.projectId,
+                limit: params.limit,
+                since: typeof params.since === "number"
+                    ? params.since
+                    : params.since?.getTime(),
+                until: typeof params.until === "number"
+                    ? params.until
+                    : params.until?.getTime(),
+            },
+            method: "GET",
+            signal: params.signal,
+        }));
+    }
+    async listSnapshots(params) {
+        return (0, base_client_1.parseOrThrow)(validators_1.SnapshotsResponse, await this.request(`/v1/sandboxes/snapshots`, {
+            query: {
+                project: params.projectId,
+                limit: params.limit,
+                since: typeof params.since === "number"
+                    ? params.since
+                    : params.since?.getTime(),
+                until: typeof params.until === "number"
+                    ? params.until
+                    : params.until?.getTime(),
+            },
+            method: "GET",
+            signal: params.signal,
+        }));
+    }
+    async writeFiles(params) {
+        const { writer, response } = this.getFileWriter({
+            sandboxId: params.sandboxId,
+            extractDir: params.extractDir,
+            signal: params.signal,
+        });
+        for (const file of params.files) {
+            await writer.addFile({
+                name: (0, normalizePath_1.normalizePath)({
+                    filePath: file.path,
+                    extractDir: params.extractDir,
+                    cwd: params.cwd,
+                }),
+                content: file.content,
+                mode: file.mode,
+            });
+        }
+        writer.end();
+        await (0, base_client_1.parseOrThrow)(validators_1.EmptyResponse, await response);
+    }
+    async readFile(params) {
+        const response = await this.request(`/v1/sandboxes/${params.sandboxId}/fs/read`, {
+            method: "POST",
+            body: JSON.stringify({ path: params.path, cwd: params.cwd }),
+            signal: params.signal,
+        });
+        if (response.status === 404) {
+            return null;
+        }
+        if (response.body === null) {
+            return null;
+        }
+        return stream_1.Readable.fromWeb(response.body);
+    }
+    async killCommand(params) {
+        return (0, base_client_1.parseOrThrow)(validators_1.CommandResponse, await this.request(`/v1/sandboxes/${params.sandboxId}/${params.commandId}/kill`, {
+            method: "POST",
+            body: JSON.stringify({ signal: params.signal }),
+            signal: params.abortSignal,
+        }));
+    }
+    getLogs(params) {
+        const self = this;
+        const disposer = new AbortController();
+        const signal = !params.signal
+            ? disposer.signal
+            : mergeSignals(params.signal, disposer.signal);
+        const generator = (async function* () {
+            const url = `/v1/sandboxes/${params.sandboxId}/cmd/${params.cmdId}/logs`;
+            const response = await self.request(url, {
+                method: "GET",
+                signal,
+            });
+            if (!response.ok) {
+                await (0, base_client_1.parseOrThrow)(zod_1.z.any(), response);
+            }
+            if (response.headers.get("content-type") !== "application/x-ndjson") {
+                throw new api_error_1.APIError(response, {
+                    message: "Expected a stream of logs",
+                    sandboxId: params.sandboxId,
+                });
+            }
+            if (response.body === null) {
+                throw new api_error_1.APIError(response, {
+                    message: "No response body",
+                    sandboxId: params.sandboxId,
+                });
+            }
+            const jsonlinesStream = jsonlines_1.default.parse();
+            pipe(response.body, jsonlinesStream).catch((err) => {
+                console.error("Error piping logs:", err);
+            });
+            for await (const chunk of jsonlinesStream) {
+                const parsed = validators_1.LogLine.parse(chunk);
+                if (parsed.stream === "error") {
+                    throw new api_error_1.StreamError(parsed.data.code, parsed.data.message, params.sandboxId);
+                }
+                yield parsed;
+            }
+        })();
+        return Object.assign(generator, {
+            [Symbol.dispose]() {
+                disposer.abort("Disposed");
+            },
+            close: () => disposer.abort("Disposed"),
+        });
+    }
+    async stopSandbox(params) {
+        const url = `/v1/sandboxes/${params.sandboxId}/stop`;
+        const response = await (0, base_client_1.parseOrThrow)(validators_1.SandboxResponse, await this.request(url, { method: "POST", signal: params.signal }));
+        if (params.blocking) {
+            let sandbox = response.json.sandbox;
+            while (sandbox.status !== "stopped" && sandbox.status !== "failed" && sandbox.status !== "aborted") {
+                await (0, promises_1.setTimeout)(500, undefined, { signal: params.signal });
+                const poll = await this.getSandbox({
+                    sandboxId: params.sandboxId,
+                    signal: params.signal,
+                });
+                sandbox = poll.json.sandbox;
+                response.json.sandbox = sandbox;
+            }
+        }
+        return response;
+    }
+    async updateNetworkPolicy(params) {
+        const url = `/v1/sandboxes/${params.sandboxId}/network-policy`;
+        return (0, base_client_1.parseOrThrow)(validators_1.UpdateNetworkPolicyResponse, await this.request(url, {
+            method: "POST",
+            body: JSON.stringify((0, network_policy_1.toAPINetworkPolicy)(params.networkPolicy)),
+            signal: params.signal,
+        }));
+    }
+    async extendTimeout(params) {
+        const url = `/v1/sandboxes/${params.sandboxId}/extend-timeout`;
+        return (0, base_client_1.parseOrThrow)(validators_1.ExtendTimeoutResponse, await this.request(url, {
+            method: "POST",
+            body: JSON.stringify({ duration: params.duration }),
+            signal: params.signal,
+        }));
+    }
+    async createSnapshot(params) {
+        const url = `/v1/sandboxes/${params.sandboxId}/snapshot`;
+        const body = params.expiration === undefined
+            ? undefined
+            : JSON.stringify({ expiration: params.expiration });
+        return (0, base_client_1.parseOrThrow)(validators_1.CreateSnapshotResponse, await this.request(url, {
+            method: "POST",
+            body,
+            signal: params.signal,
+        }));
+    }
+    async deleteSnapshot(params) {
+        const url = `/v1/sandboxes/snapshots/${params.snapshotId}`;
+        return (0, base_client_1.parseOrThrow)(validators_1.SnapshotResponse, await this.request(url, { method: "DELETE", signal: params.signal }));
+    }
+    async getSnapshot(params) {
+        const url = `/v1/sandboxes/snapshots/${params.snapshotId}`;
+        return (0, base_client_1.parseOrThrow)(validators_1.SnapshotResponse, await this.request(url, { signal: params.signal }));
+    }
+}
+exports.APIClient = APIClient;
+async function pipe(readable, output) {
+    const reader = readable.getReader();
+    try {
+        while (true) {
+            const read = await reader.read();
+            if (read.value) {
+                output.write(Buffer.from(read.value));
+            }
+            if (read.done) {
+                break;
+            }
+        }
+    }
+    catch (err) {
+        output.emit("error", err);
+    }
+    finally {
+        output.end();
+    }
+}
+function mergeSignals(...signals) {
+    const controller = new AbortController();
+    const onAbort = () => {
+        controller.abort();
+        for (const signal of signals) {
+            signal.removeEventListener("abort", onAbort);
+        }
+    };
+    for (const signal of signals) {
+        if (signal.aborted) {
+            controller.abort();
+            break;
+        }
+        signal.addEventListener("abort", onAbort);
+    }
+    return controller.signal;
+}
+//# sourceMappingURL=api-client.js.map

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamError = exports.APIError = void 0;
+class APIError extends Error {
+    constructor(response, options) {
+        super(response.statusText);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, APIError);
+        }
+        this.response = response;
+        this.message = options?.message ?? "";
+        this.json = options?.json;
+        this.text = options?.text;
+        this.sandboxId = options?.sandboxId;
+    }
+}
+exports.APIError = APIError;
+/**
+ * Error thrown when a stream error is received streaming.
+ * This typically occurs when the sandbox is stopped while streaming.
+ */
+class StreamError extends Error {
+    constructor(code, message, sandboxId) {
+        super(message);
+        this.name = "StreamError";
+        this.code = code;
+        this.sandboxId = sandboxId;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, StreamError);
+        }
+    }
+}
+exports.StreamError = StreamError;
+//# sourceMappingURL=api-error.js.map

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

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseClient = void 0;
+exports.parse = parse;
+exports.parseOrThrow = parseOrThrow;
+const api_error_1 = require("./api-error");
+const array_1 = require("../utils/array");
+const with_retry_1 = require("./with-retry");
+const undici_1 = require("undici");
+/**
+ * A base API client that provides a convenience wrapper for fetching where
+ * we can pass query parameters as an object, support retries, debugging
+ * and automatic authorization.
+ */
+class BaseClient {
+    constructor(params) {
+        this.fetch = (0, with_retry_1.withRetry)(params.fetch ?? globalThis.fetch);
+        this.baseUrl = params.baseUrl;
+        this.debug = params.debug ?? process.env.DEBUG_FETCH === "true";
+        this.token = params.token;
+        this.agent = new undici_1.Agent({
+            bodyTimeout: 0, // disable body timeout to allow long logs streaming
+        });
+    }
+    async request(path, opts) {
+        const url = new URL(`${this.baseUrl}${path}`);
+        if (opts?.query) {
+            for (const [key, value] of Object.entries(opts.query)) {
+                (0, array_1.array)(value).forEach((value) => {
+                    url.searchParams.append(key, value.toString());
+                });
+            }
+        }
+        const start = Date.now();
+        const response = await this.fetch(url.toString(), {
+            ...opts,
+            body: opts?.body,
+            method: opts?.method || "GET",
+            headers: this.token
+                ? { Authorization: `Bearer ${this.token}`, ...opts?.headers }
+                : opts?.headers,
+            // @ts-expect-error Node.js' and undici's Agent have different types
+            dispatcher: this.agent,
+            signal: opts?.signal,
+        });
+        if (this.debug) {
+            const duration = Date.now() - start;
+            console.log(`[API] ${url} (${response.status}) ${duration}ms`);
+            if (response.status === 429) {
+                const retry = parseInt(response.headers.get("Retry-After") ?? "", 10);
+                const hours = Math.floor(retry / 60 / 60);
+                const minutes = Math.floor(retry / 60) % 60;
+                const seconds = retry % 60;
+                console.warn(`[API] ${url} Rate Limited, Retry After ${hours}h ${minutes}m ${seconds}s`);
+            }
+        }
+        return response;
+    }
+}
+exports.BaseClient = BaseClient;
+/**
+ * Extract sandboxId from a sandbox API URL.
+ * URLs follow the pattern: /v1/sandboxes/{sandboxId}/...
+ */
+function extractSandboxId(url) {
+    const match = url.match(/\/v1\/sandboxes\/([^/?]+)/);
+    return match?.[1];
+}
+/**
+ * Allows to read the response text and parse it as JSON casting to the given
+ * type. If the response is not ok or cannot be parsed it will return error.
+ *
+ * @param response Response to parse.
+ * @returns Parsed response or error.
+ */
+async function parse(validator, response) {
+    const sandboxId = extractSandboxId(response.url);
+    const text = await response.text().catch((err) => {
+        return new api_error_1.APIError(response, {
+            message: `Can't read response text: ${String(err)}`,
+            sandboxId,
+        });
+    });
+    if (typeof text !== "string") {
+        return text;
+    }
+    let json;
+    try {
+        json = JSON.parse(text || "{}");
+    }
+    catch (error) {
+        return new api_error_1.APIError(response, {
+            message: `Can't parse JSON: ${String(error)}`,
+            text,
+            sandboxId,
+        });
+    }
+    if (!response.ok) {
+        return new api_error_1.APIError(response, {
+            message: `Status code ${response.status} is not ok`,
+            json: json,
+            text,
+            sandboxId,
+        });
+    }
+    const validated = validator.safeParse(json);
+    if (!validated.success) {
+        return new api_error_1.APIError(response, {
+            message: `Response JSON is not valid: ${validated.error}`,
+            json: json,
+            text,
+            sandboxId,
+        });
+    }
+    return {
+        json: validated.data,
+        response,
+        text,
+    };
+}
+async function parseOrThrow(validator, response) {
+    const result = await parse(validator, response);
+    if (result instanceof api_error_1.APIError) {
+        throw result;
+    }
+    return result;
+}
+//# sourceMappingURL=base-client.js.map