skydive-cli 0.5.0-beta.9 → 0.6.0-beta.3

package/dist/js/chunk-BbwQpWto.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __require as n, __toESM as r, __commonJSMin as t };

package/dist/js/{client-c4c5MmgN.mjs → client-Btq6bMzX.mjs}

@@ -1,6 +1,108 @@
 #!/usr/bin/env node
 import { WebSocket } from "ws";
 
+//#region ../sandbox-stream-protocol/src/fs.ts
+/** fs frame type bytes. Disjoint from FRAME.* in ./index.ts. */
+const FS_FRAME = {
+	REQ: 32,
+	RES: 33
+};
+/** Filesystem operations the channel supports. One byte on the wire. */
+const FS_OP = {
+	LIST: 1,
+	STAT: 2,
+	READ: 3,
+	WRITE: 4,
+	MKDIR: 5,
+	RENAME: 6,
+	REMOVE: 7,
+	EXISTS: 8
+};
+/** Reply status. OK carries a result; ERR carries a message in `json.message`. */
+const FS_STATUS = {
+	OK: 0,
+	ERR: 1
+};
+const FS_MAX_BLOB_BYTES = 8 * 1024 * 1024;
+const OP_TO_CODE = {
+	list: FS_OP.LIST,
+	stat: FS_OP.STAT,
+	read: FS_OP.READ,
+	write: FS_OP.WRITE,
+	mkdir: FS_OP.MKDIR,
+	rename: FS_OP.RENAME,
+	remove: FS_OP.REMOVE,
+	exists: FS_OP.EXISTS
+};
+const CODE_TO_OP = new Map(Object.entries(OP_TO_CODE).map(([op, code]) => [code, op]));
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+function frame(type, reqId, byte2, json, blob) {
+	const jsonBytes = textEncoder.encode(JSON.stringify(json ?? {}));
+	const out = new Uint8Array(10 + jsonBytes.length + blob.length);
+	const dv = new DataView(out.buffer);
+	out[0] = type;
+	dv.setUint32(1, reqId >>> 0);
+	out[5] = byte2;
+	dv.setUint32(6, jsonBytes.length);
+	out.set(jsonBytes, 10);
+	out.set(blob, 10 + jsonBytes.length);
+	return out;
+}
+const EMPTY = new Uint8Array(0);
+/** client → server: encode an fs request. `blob` is the write payload, or null. */
+function encodeFsRequest(reqId, req, blob) {
+	return frame(FS_FRAME.REQ, reqId, OP_TO_CODE[req.op], req, blob ?? EMPTY);
+}
+/**
+* Decode a server fs reply frame. Returns null for a malformed frame so a peer
+* on a newer protocol can't crash the client.
+*/
+function decodeFsResponse(frameBytes) {
+	const parsed = parseFrame(FS_FRAME.RES, frameBytes);
+	if (!parsed) return null;
+	if (parsed.byte2 === FS_STATUS.ERR) {
+		const message = typeof parsed.json.message === "string" ? parsed.json.message : "fs operation failed";
+		return {
+			reqId: parsed.reqId,
+			status: "error",
+			message
+		};
+	}
+	return {
+		reqId: parsed.reqId,
+		status: "ok",
+		result: parsed.json,
+		blob: parsed.blob
+	};
+}
+function parseFrame(expectedType, frameBytes) {
+	if (frameBytes.length < 10) return null;
+	if (frameBytes[0] !== expectedType) return null;
+	const dv = new DataView(frameBytes.buffer, frameBytes.byteOffset, frameBytes.byteLength);
+	const reqId = dv.getUint32(1);
+	const byte2 = frameBytes[5] ?? 0;
+	const jsonLen = dv.getUint32(6);
+	const jsonStart = 10;
+	const jsonEnd = jsonStart + jsonLen;
+	if (jsonEnd > frameBytes.length) return null;
+	let json;
+	try {
+		const parsed = jsonLen ? JSON.parse(textDecoder.decode(frameBytes.subarray(jsonStart, jsonEnd))) : {};
+		if (typeof parsed !== "object" || parsed === null) return null;
+		json = parsed;
+	} catch {
+		return null;
+	}
+	return {
+		reqId,
+		byte2,
+		json,
+		blob: frameBytes.subarray(jsonEnd)
+	};
+}
+
+//#endregion
 //#region ../sandbox-stream-protocol/src/index.ts
 const SANDBOX_STREAM_PATH = "/api/v1/sandbox/stream";
 const FRAME = {
@@ -19,11 +121,15 @@ function streamSpecToQuery(spec) {
 		cols: String(spec.cols),
 		rows: String(spec.rows)
 	};
-	return {
+	if (spec.mode === "exec") return {
 		agentId: spec.agentId,
 		mode: "exec",
 		command: spec.command
 	};
+	return {
+		agentId: spec.agentId,
+		mode: "fs"
+	};
 }
 function withType(type, payload) {
 	const frame = new Uint8Array(1 + payload.length);
@@ -166,4 +272,4 @@ function toBuffer(data) {
 }
 
 //#endregion
-export { SandboxStream as t };
+export { encodeFsRequest as a, decodeFsResponse as i, SANDBOX_STREAM_PATH as n, streamSpecToQuery as r, SandboxStream as t };