@sipher.dev/agents 0.1.0 → 0.1.2

package/dist/src-ghbvDJyd.js

@@ -0,0 +1,731 @@
+const MAX_MACHINE_TERMINAL_HISTORY_BYTES = 512 * 1024;
+const utf8$2 = new TextEncoder();
+function isTerminalRpcRequest(value) {
+	if (!isRecord$5(value) || value.type !== "rpc/request" || !isNonEmptyString$3(value.id)) return false;
+	if (value.method === "terminal/open") {
+		const params = value.params;
+		return isRecord$5(params) && isMachineTerminalId(params.terminalId) && optionalNonEmptyString$2(params.cwd) && optionalPositiveBoundedSafeInteger$1(params.cols, 1e3) && optionalPositiveBoundedSafeInteger$1(params.rows, 500);
+	}
+	if (value.method === "terminal/write") {
+		const params = value.params;
+		return isRecord$5(params) && isMachineTerminalId(params.terminalId) && isNonEmptyRawString(params.data) && utf8$2.encode(params.data).byteLength <= 65536;
+	}
+	if (value.method === "terminal/resize") {
+		const params = value.params;
+		return isRecord$5(params) && isMachineTerminalId(params.terminalId) && isPositiveBoundedSafeInteger(params.cols, 1e3) && isPositiveBoundedSafeInteger(params.rows, 500);
+	}
+	if (value.method === "terminal/close") {
+		const params = value.params;
+		return isRecord$5(params) && isMachineTerminalId(params.terminalId);
+	}
+	if (value.method === "terminal/clear") {
+		const params = value.params;
+		return isRecord$5(params) && isMachineTerminalId(params.terminalId);
+	}
+	return false;
+}
+function optionalNonEmptyString$2(value) {
+	return value === void 0 || isNonEmptyString$3(value);
+}
+function optionalPositiveBoundedSafeInteger$1(value, max) {
+	return value === void 0 || typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= max;
+}
+function isPositiveBoundedSafeInteger(value, max) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= max;
+}
+function isMachineTerminalId(value) {
+	return isNonEmptyString$3(value) && value.length <= 128;
+}
+function isNonEmptyString$3(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+function isNonEmptyRawString(value) {
+	return typeof value === "string" && value.length > 0;
+}
+function isRecord$5(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region ../machine-protocol/src/local-control.ts
+function negotiateLocalControlVersion(client, supervisor) {
+	if (!isVersionRange(client) || !isVersionRange(supervisor)) return void 0;
+	const version = Math.min(client.maxVersion, supervisor.maxVersion);
+	return version >= Math.max(client.minVersion, supervisor.minVersion) ? version : void 0;
+}
+function isLocalControlHello(value) {
+	return isRecord$4(value) && value.type === "local-control/hello" && typeof value.secret === "string" && value.secret.length > 0 && isVersionRange(value);
+}
+function isLocalControlCommand(value) {
+	if (!isRecord$4(value) || value.type !== "local-control/request" || typeof value.id !== "string" || !value.id) return false;
+	if (value.command === "status" || value.command === "ensure-installed" || value.command === "start" || value.command === "restart") return !("capability" in value);
+	return (value.command === "retry" || value.command === "force") && isLocalControlCapability(value.capability);
+}
+function isLocalControlCapability(value) {
+	return isRecord$4(value) && [
+		"token",
+		"ownerUserId",
+		"deploymentId",
+		"machineId",
+		"candidateVersion",
+		"policyDigest",
+		"expiresAt"
+	].every((key) => typeof value[key] === "string" && value[key].length > 0) && Number.isSafeInteger(value.lifecycleGeneration) && Number.isSafeInteger(value.connectionGeneration) && Number.isSafeInteger(value.activityGeneration);
+}
+function isVersionRange(value) {
+	return isRecord$4(value) && Number.isSafeInteger(value.minVersion) && Number.isSafeInteger(value.maxVersion) && value.minVersion > 0 && value.maxVersion >= value.minVersion;
+}
+function isRecord$4(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+//#endregion
+//#region ../machine-protocol/src/mcp.ts
+const utf8$1 = new TextEncoder();
+const MACHINE_MCP_TAG = "mcp:";
+const MACHINE_MCP_MAX_FRAME_BYTES = 6 * 1024 * 1024;
+const MACHINE_MCP_MAX_STDERR_BYTES = 64 * 1024;
+const MACHINE_MCP_MAX_ERROR_MESSAGE_BYTES = 4 * 1024;
+const CONNECTOR_MAX_WEBSOCKET_PAYLOAD_BYTES = 32 * 1024 * 1024;
+var MachineMcpValidationError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "MachineMcpValidationError";
+	}
+};
+function utf8Bytes(value) {
+	return utf8$1.encode(value).byteLength;
+}
+function serializedBytes(value) {
+	return utf8Bytes(JSON.stringify(value));
+}
+function validateMachineMcpLaunchSpec(value) {
+	if (!isRecord$3(value)) invalid("Invalid MCP launch specification.");
+	const launch = value;
+	if (!hasOnlyKeys(launch, [
+		"definitionId",
+		"configVersion",
+		"catalogRevision",
+		"catalogFingerprint",
+		"command",
+		"args",
+		"cwdMode",
+		"projectRoot"
+	]) || !isBoundedString(launch.definitionId, 256, true) || !isPositiveInteger(launch.configVersion) || !isNonNegativeInteger(launch.catalogRevision) || launch.catalogFingerprint !== void 0 && (typeof launch.catalogFingerprint !== "string" || !/^[a-f0-9]{64}$/.test(launch.catalogFingerprint)) || !isBoundedString(launch.command, 4096, true) || !Array.isArray(launch.args) || launch.args.length > 64 || !launch.args.every((arg) => typeof arg === "string" && utf8Bytes(arg) <= 4096) || launch.args.reduce((total, arg) => total + (typeof arg === "string" ? utf8Bytes(arg) : 0), 0) > 65536 || launch.cwdMode !== "project_root" && launch.cwdMode !== "home" || !isAbsoluteHostPath$1(launch.projectRoot)) invalid("Invalid MCP launch specification.");
+	if (utf8Bytes(launch.projectRoot) > 32768) throw new MachineMcpValidationError("project_root_too_large", "Project root is too large.");
+	if (serializedBytes(value) > 131072) throw new MachineMcpValidationError("launch_request_too_large", "MCP launch request is too large.");
+	if (serializedBytes({
+		...launch,
+		args: launch.args.map((arg) => arg === "{projectRoot}" ? launch.projectRoot : arg),
+		cwd: launch.projectRoot
+	}) > 131072) throw new MachineMcpValidationError("launch_request_too_large", "Expanded MCP launch request is too large.");
+	return value;
+}
+function validateMachineMcpRequest(value) {
+	if (!isRecord$3(value) || value.type !== "mcp/request" || !isBoundedString(value.id, 256, true)) invalid("Invalid MCP request.");
+	if (!isRecord$3(value.params)) invalid("Invalid MCP request parameters.");
+	if (!hasOnlyKeys(value, [
+		"type",
+		"id",
+		"method",
+		"params"
+	])) invalid("Invalid MCP request.");
+	if (value.method === "mcp/probe") {
+		if (!hasOnlyKeys(value.params, ["launch", "timeoutMs"])) invalid("Invalid MCP probe parameters.");
+		validateMachineMcpLaunchSpec(value.params.launch);
+		if (!isBoundedTimeout(value.params.timeoutMs)) invalid("Invalid MCP timeout.");
+	} else if (value.method === "mcp/call") {
+		if (!hasOnlyKeys(value.params, [
+			"launch",
+			"toolName",
+			"arguments",
+			"timeoutMs"
+		])) invalid("Invalid MCP call parameters.");
+		validateMachineMcpCallRequestSize(value);
+		if (!validateMachineMcpLaunchSpec(value.params.launch).catalogFingerprint) invalid("MCP calls require an accepted catalog fingerprint.");
+		if (!isBoundedString(value.params.toolName, 256, true)) invalid("Invalid MCP tool name.");
+		if (!isRecord$3(value.params.arguments)) invalid("Invalid MCP tool arguments.");
+		if (serializedBytes(value.params.arguments) > 262144) throw new MachineMcpValidationError("arguments_too_large", "MCP tool arguments are too large.");
+		if (!isBoundedTimeout(value.params.timeoutMs)) invalid("Invalid MCP timeout.");
+	} else if (value.method === "mcp/stop") {
+		if (!hasOnlyKeys(value.params, [
+			"definitionId",
+			"configVersion",
+			"projectRoot"
+		]) || !isBoundedString(value.params.definitionId, 256, true) || value.params.configVersion !== void 0 && !isPositiveInteger(value.params.configVersion) || value.params.projectRoot !== void 0 && (!isAbsoluteHostPath$1(value.params.projectRoot) || utf8Bytes(value.params.projectRoot) > 32768)) invalid("Invalid MCP stop request.");
+	} else if (value.method === "mcp/cancel") {
+		if (!hasOnlyKeys(value.params, ["requestId"]) || !isBoundedString(value.params.requestId, 256, true)) invalid("Invalid MCP cancel request.");
+	} else invalid("Unknown MCP request method.");
+	return value;
+}
+function validateMachineMcpCallRequestSize(value) {
+	if (serializedBytes(value) > 524288) throw new MachineMcpValidationError("launch_request_too_large", "MCP call request is too large.");
+}
+function encodeMachineMcpFrame(message) {
+	const frame = `${MACHINE_MCP_TAG}${JSON.stringify(message)}`;
+	if (utf8Bytes(frame) > 6291456) throw new MachineMcpValidationError("frame_too_large", "MCP connector frame is too large.");
+	return frame;
+}
+function validateMachineMcpResult(result) {
+	if (serializedBytes(result) > 5242880) throw new MachineMcpValidationError("result_too_large", "MCP result is too large.");
+	return result;
+}
+function sanitizeMachineMcpCatalog(input) {
+	const serverInfo = sanitizeServerInfo(input.serverInfo);
+	if (!Array.isArray(input.tools) || input.tools.length > 500) throw new MachineMcpValidationError("catalog_overflow", "MCP catalog has too many tools.");
+	let catalogValues = 0;
+	const tools = input.tools.map((tool) => {
+		if (!isRecord$3(tool) || typeof tool.name !== "string") throw new MachineMcpValidationError("catalog_structure_overflow", "Invalid MCP tool name.");
+		const name = tool.name.trim();
+		if (!isBoundedString(name, 256, true)) throw new MachineMcpValidationError("catalog_structure_overflow", "Invalid MCP tool name.");
+		let toolValues = 0;
+		const countValues = (count) => {
+			toolValues += count;
+			catalogValues += count;
+			if (toolValues > 1e4) structureError();
+			if (catalogValues > 1e5) structureError();
+		};
+		const sanitized = {
+			name,
+			inputSchema: isRecord$3(tool.inputSchema) ? sanitizeObject(tool.inputSchema, countValues) : { type: "object" }
+		};
+		if (typeof tool.title === "string") {
+			if (utf8Bytes(tool.title) > 16384) structureError();
+			sanitized.title = tool.title;
+		}
+		if (typeof tool.description === "string") {
+			if (utf8Bytes(tool.description) > 16384) structureError();
+			sanitized.description = tool.description.trim();
+		}
+		if (isRecord$3(tool.outputSchema)) sanitized.outputSchema = sanitizeObject(tool.outputSchema, countValues);
+		if (isRecord$3(tool.annotations)) sanitized.annotations = sanitizeObject(tool.annotations, countValues);
+		if (catalogValues > 1e5) structureError();
+		if (serializedBytes(sanitized) > 262144) throw new MachineMcpValidationError("catalog_overflow", "MCP tool is too large.");
+		return sanitized;
+	}).sort((a, b) => compareCodeUnits(a.name, b.name));
+	if (new Set(tools.map((tool) => tool.name)).size !== tools.length) throw new MachineMcpValidationError("catalog_structure_overflow", "MCP tool names must be unique.");
+	const catalog = {
+		serverInfo,
+		tools
+	};
+	if (serializedBytes(catalog) > 1048576) throw new MachineMcpValidationError("catalog_overflow", "MCP catalog is too large.");
+	return catalog;
+}
+function sanitizeAndCanonicalizeMachineMcpCatalog(input) {
+	const catalog = sanitizeMachineMcpCatalog(input);
+	return {
+		catalog,
+		canonicalJson: canonicalizeSanitizedMachineMcpCatalog(catalog)
+	};
+}
+function canonicalizeSanitizedMachineMcpCatalog(catalog) {
+	return canonicalJson(catalog.tools);
+}
+function substituteMachineMcpLaunch(launch, platform = processPlatform(), homeRoot = launch.projectRoot) {
+	const root = platform === "windows" ? launch.projectRoot.replaceAll("/", "\\") : launch.projectRoot.replaceAll("\\", "/");
+	const command = launch.command;
+	const args = launch.args.map((argument) => argument === "{projectRoot}" ? root : argument);
+	const cwd = launch.cwdMode === "project_root" ? root : homeRoot;
+	const resolved = {
+		command,
+		args,
+		cwd
+	};
+	if (serializedBytes({
+		...launch,
+		command,
+		args,
+		...cwd ? { cwd } : {}
+	}) > 131072) throw new MachineMcpValidationError("launch_request_too_large", "Resolved MCP launch request is too large.");
+	return resolved;
+}
+function sanitizeServerInfo(value) {
+	if (!isRecord$3(value) || !isBoundedString(value.name, 256, true)) structureError("Invalid MCP server info.");
+	if (value.version !== void 0 && !isBoundedString(value.version, 256, true)) structureError("Invalid MCP server version.");
+	return {
+		name: value.name,
+		...value.version ? { version: value.version } : {}
+	};
+}
+function sanitizeObject(value, addToCatalog) {
+	if (!isRecord$3(value)) structureError();
+	const output = {};
+	const stack = [{
+		source: value,
+		target: output,
+		depth: 1
+	}];
+	let values = 0;
+	while (stack.length > 0) {
+		const item = stack.pop();
+		if (item.depth > 32) structureError();
+		const entries = Array.isArray(item.source) ? item.source.map((entry, index) => [String(index), entry]) : Object.entries(item.source).sort(([a], [b]) => compareCodeUnits(a, b));
+		if (Array.isArray(item.source) && entries.length > 4096) structureError();
+		if (!Array.isArray(item.source) && entries.length > 1024) structureError();
+		for (const [key, child] of entries) {
+			values += 1;
+			if (values > 1e4) structureError();
+			if (utf8Bytes(key) > 65536) structureError();
+			let next;
+			if (typeof child === "string") {
+				if (utf8Bytes(child) > 65536) structureError();
+				next = child;
+			} else if (child === null || typeof child === "boolean" || typeof child === "number") {
+				if (typeof child === "number" && !Number.isFinite(child)) structureError();
+				next = child;
+			} else if (Array.isArray(child)) {
+				next = [];
+				stack.push({
+					source: child,
+					target: next,
+					depth: item.depth + 1
+				});
+			} else if (isRecord$3(child)) {
+				next = {};
+				stack.push({
+					source: child,
+					target: next,
+					depth: item.depth + 1
+				});
+			} else structureError();
+			if (Array.isArray(item.target)) item.target.push(next);
+			else Object.defineProperty(item.target, key, {
+				configurable: true,
+				enumerable: true,
+				value: next,
+				writable: true
+			});
+		}
+	}
+	addToCatalog(values);
+	return output;
+}
+function canonicalJson(value) {
+	const output = [];
+	const stack = [{
+		kind: "value",
+		value
+	}];
+	while (stack.length > 0) {
+		const task = stack.pop();
+		if (task.kind === "text") {
+			output.push(task.value);
+			continue;
+		}
+		const item = task.value;
+		if (Array.isArray(item)) {
+			stack.push({
+				kind: "text",
+				value: "]"
+			});
+			for (let index = item.length - 1; index >= 0; index -= 1) {
+				stack.push({
+					kind: "value",
+					value: item[index]
+				});
+				if (index > 0) stack.push({
+					kind: "text",
+					value: ","
+				});
+			}
+			stack.push({
+				kind: "text",
+				value: "["
+			});
+			continue;
+		}
+		if (isRecord$3(item)) {
+			const keys = Object.keys(item).sort(compareCodeUnits);
+			stack.push({
+				kind: "text",
+				value: "}"
+			});
+			for (let index = keys.length - 1; index >= 0; index -= 1) {
+				const key = keys[index];
+				stack.push({
+					kind: "value",
+					value: item[key]
+				});
+				stack.push({
+					kind: "text",
+					value: `${JSON.stringify(key)}:`
+				});
+				if (index > 0) stack.push({
+					kind: "text",
+					value: ","
+				});
+			}
+			stack.push({
+				kind: "text",
+				value: "{"
+			});
+			continue;
+		}
+		const encoded = JSON.stringify(item);
+		if (encoded === void 0) structureError();
+		output.push(encoded);
+	}
+	return output.join("");
+}
+function compareCodeUnits(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function isBoundedString(value, maxBytes, nonBlank) {
+	return typeof value === "string" && (!nonBlank || value.trim().length > 0) && utf8Bytes(value) <= maxBytes;
+}
+function isAbsoluteHostPath$1(value) {
+	return isNonEmptyString$2(value) && !value.includes("\0") && (value.startsWith("/") || value.startsWith("\\\\") || /^[A-Za-z]:[\\/]/.test(value));
+}
+function isNonEmptyString$2(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPositiveInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function isNonNegativeInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isBoundedTimeout(value) {
+	return isPositiveInteger(value) && value <= 12e4;
+}
+function hasOnlyKeys(value, allowed) {
+	return Object.keys(value).every((key) => allowed.includes(key));
+}
+function invalid(message) {
+	throw new MachineMcpValidationError("invalid_request", message);
+}
+function structureError(message = "MCP catalog structure is too large or invalid.") {
+	throw new MachineMcpValidationError("catalog_structure_overflow", message);
+}
+function processPlatform() {
+	return typeof process !== "undefined" && process.platform === "win32" ? "windows" : "posix";
+}
+//#endregion
+//#region ../machine-protocol/src/deployment.ts
+function normalizeDeploymentPolicy(input, options = {}) {
+	if (!isDeploymentUuid(input.deploymentId)) throw new Error("DEPLOYMENT_ID must be a UUID.");
+	const canonicalOrigin = normalizeDeploymentOrigin(input.canonicalOrigin, options);
+	const aliases = [...new Set(input.aliases.map((origin) => normalizeDeploymentOrigin(origin, options)))].filter((origin) => origin !== canonicalOrigin).sort();
+	if (input.connectorChannel !== "latest" && input.connectorChannel !== "next") throw new Error("CONNECTOR_CHANNEL must be latest or next.");
+	if (!isAllowedConnectorCaretRange(input.connectorVersionRange)) throw new Error("CONNECTOR_VERSION_RANGE must be a non-prerelease caret range and cannot use ^0.0.Z.");
+	return {
+		deploymentId: input.deploymentId.toLowerCase(),
+		canonicalOrigin,
+		aliases,
+		connectorChannel: input.connectorChannel,
+		connectorVersionRange: input.connectorVersionRange
+	};
+}
+function normalizeDeploymentOrigin(value, options = {}) {
+	const url = new URL(value);
+	const httpAllowed = url.protocol === "http:" && (options.allowHttp === true || options.allowHttp === "loopback" && isLoopbackHost(url.hostname));
+	if (url.protocol !== "https:" && !httpAllowed) throw new Error("Connector origins must use HTTPS outside development and test.");
+	if (url.username || url.password || url.search || url.hash || url.pathname && url.pathname !== "/") throw new Error("Connector origins must not include credentials, paths, queries, or fragments.");
+	return url.origin.toLowerCase();
+}
+function canonicalDeploymentPolicyJson(policy) {
+	return JSON.stringify({
+		aliases: [...policy.aliases].sort(),
+		canonicalOrigin: policy.canonicalOrigin,
+		connectorChannel: policy.connectorChannel,
+		connectorVersionRange: policy.connectorVersionRange,
+		deploymentId: policy.deploymentId
+	});
+}
+function isAllowedConnectorCaretRange(value) {
+	const component = "(?:0|[1-9]\\d*)";
+	const match = new RegExp(`^\\^(${component})\\.(${component})\\.(${component})$`).exec(value);
+	return Boolean(match && !(match[1] === "0" && match[2] === "0"));
+}
+function isDeploymentUuid(value) {
+	return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+}
+function isConnectorReady(value) {
+	return isRecord$2(value) && value.type === "connector/ready" && value.version === 1 && isNonEmptyString$1(value.deploymentId) && isNonEmptyString$1(value.machineId) && Number.isSafeInteger(value.connectionGeneration) && value.connectionGeneration > 0 && optionalNonEmptyString$1(value.candidateAttemptId) && optionalNonEmptyString$1(value.activationReceipt) && (value.candidateAttemptId === void 0 && value.activationReceipt === void 0 || isNonEmptyString$1(value.candidateAttemptId) && isNonEmptyString$1(value.activationReceipt));
+}
+function isConnectorActivated(value) {
+	return isRecord$2(value) && value.type === "connector/activated" && isNonEmptyString$1(value.candidateAttemptId) && isNonEmptyString$1(value.activationReceipt) && Number.isSafeInteger(value.statusRevision) && value.statusRevision > 0;
+}
+function optionalNonEmptyString$1(value) {
+	return value === void 0 || isNonEmptyString$1(value);
+}
+function isNonEmptyString$1(value) {
+	return typeof value === "string" && value.length > 0;
+}
+function isLoopbackHost(hostname) {
+	return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+function isRecord$2(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+//#endregion
+//#region ../machine-protocol/src/connector-release.ts
+function canonicalSignedConnectorReleaseTuple(tuple) {
+	return JSON.stringify({
+		arch: tuple.arch,
+		integrity: tuple.integrity,
+		manifestDigest: tuple.manifestDigest,
+		packageName: tuple.packageName,
+		platform: tuple.platform,
+		releaseId: tuple.releaseId,
+		runtimeVersion: tuple.runtimeVersion,
+		tarballUrl: tuple.tarballUrl
+	});
+}
+//#endregion
+//#region ../machine-protocol/src/rpc-activity.ts
+function classifyServerRpcActivity(request) {
+	switch (request.method) {
+		case "shell/exec":
+		case "shell/job_start":
+		case "file/read":
+		case "file/read_text":
+		case "file/read_patch_source":
+		case "file/write":
+		case "file/delete":
+		case "file/move":
+		case "file/search_entries":
+		case "terminal/open":
+		case "terminal/write":
+		case "terminal/resize": return "work";
+		case "shell/close":
+		case "shell/job_get":
+		case "shell/job_kill":
+		case "terminal/clear":
+		case "terminal/close": return "control";
+		case "connector/update_preflight":
+		case "connector/update_retry":
+		case "connector/update_force": return "update_control";
+		default: return assertNever$1(request);
+	}
+}
+function classifyMachineMcpActivity(request) {
+	switch (request.method) {
+		case "mcp/probe":
+		case "mcp/call": return "work";
+		case "mcp/stop":
+		case "mcp/cancel": return "control";
+		default: return assertNever$1(request);
+	}
+}
+function assertNever$1(value) {
+	throw new Error(`Unhandled connector RPC: ${JSON.stringify(value)}`);
+}
+//#endregion
+//#region ../machine-protocol/src/update.ts
+const connectorUpdateStates = [
+	"unreported",
+	"unchecked",
+	"up_to_date",
+	"available",
+	"waiting_for_idle",
+	"updating",
+	"blocked",
+	"error"
+];
+const connectorUpdateErrorCodes = [
+	"download_failed",
+	"integrity_failed",
+	"manifest_invalid",
+	"incompatible",
+	"candidate_start_failed",
+	"candidate_exited",
+	"readiness_timeout",
+	"attempt_timed_out",
+	"rollback_failed",
+	"active_work_termination_failed"
+];
+const retryableConnectorUpdateErrors = [
+	"download_failed",
+	"integrity_failed",
+	"manifest_invalid",
+	"candidate_start_failed",
+	"candidate_exited",
+	"readiness_timeout"
+];
+function canRetryConnectorUpdate(status) {
+	return status.state === "blocked" && status.errorCode !== null && retryableConnectorUpdateErrors.includes(status.errorCode);
+}
+function canForceConnectorUpdate(status) {
+	return status.state === "available" || status.state === "waiting_for_idle" || status.state === "error" && status.errorCode === "active_work_termination_failed";
+}
+function isConnectorUpdateAccepted(value) {
+	return isRecord$1(value) && value.type === "connector/update-accepted" && typeof value.reportSequence === "number" && Number.isSafeInteger(value.reportSequence) && value.reportSequence > 0 && typeof value.statusRevision === "number" && Number.isSafeInteger(value.statusRevision) && value.statusRevision > 0;
+}
+function isConnectorUpdateResponse(value) {
+	if (isConnectorUpdateAccepted(value)) return true;
+	if (!isRecord$1(value) || value.type !== "connector/update-reconcile" || !Number.isSafeInteger(value.reportSequence) || value.reportSequence < 1 || !Number.isSafeInteger(value.serverReportSequence) || value.serverReportSequence < 0 || !Number.isSafeInteger(value.statusRevision) || value.statusRevision < 1 || value.attemptId !== null && !nonEmptyString(value.attemptId)) return false;
+	const installedVersion = nullableString(value.installedVersion);
+	const availableVersion = nullableString(value.availableVersion);
+	const channel = nullableChannel(value.channel);
+	return installedVersion !== void 0 && availableVersion !== void 0 && channel !== void 0 && connectorUpdateStates.includes(value.state) && (value.errorCode === null || connectorUpdateErrorCodes.includes(value.errorCode)) && validateConnectorUpdateStatus({
+		installedVersion,
+		availableVersion,
+		channel,
+		state: value.state,
+		errorCode: value.errorCode
+	});
+}
+function isConnectorForceConsumeResult(value) {
+	return isRecord$1(value) && value.type === "connector/force-consume-result" && nonEmptyString(value.requestId) && typeof value.accepted === "boolean";
+}
+function validateConnectorUpdateStatus(input) {
+	const { installedVersion, availableVersion, channel, state, errorCode } = input;
+	const installed = isRuntimeVersion(installedVersion);
+	const available = isRuntimeVersion(availableVersion);
+	const noError = errorCode === null;
+	const candidateError = errorCode === "download_failed" || errorCode === "integrity_failed" || errorCode === "manifest_invalid" || errorCode === "candidate_start_failed" || errorCode === "candidate_exited" || errorCode === "readiness_timeout";
+	if (channel !== null && channel !== "latest" && channel !== "next") return false;
+	switch (state) {
+		case "unreported": return installedVersion === null && availableVersion === null && channel === null && noError;
+		case "unchecked":
+		case "up_to_date": return installed && availableVersion === null && channel !== null && noError;
+		case "available":
+		case "waiting_for_idle":
+		case "updating": return installed && available && installedVersion !== availableVersion && channel !== null && noError;
+		case "blocked": return installed && available && installedVersion !== availableVersion && channel !== null && candidateError;
+		case "error":
+			if (errorCode === "incompatible") return availableVersion === null && channel !== null;
+			if (errorCode === "active_work_termination_failed") return installed && available && installedVersion !== availableVersion && channel !== null;
+			if (errorCode === "attempt_timed_out") return channel !== null;
+			if (errorCode === "rollback_failed") return available && channel !== null;
+			return false;
+		default: return assertNever(state);
+	}
+}
+function nullableString(value) {
+	return value === null || typeof value === "string" ? value : void 0;
+}
+function nullableChannel(value) {
+	return value === null || value === "latest" || value === "next" ? value : void 0;
+}
+function isRuntimeVersion(value) {
+	return typeof value === "string" && /^\d+\.\d+\.\d+$/.test(value);
+}
+function nonEmptyString(value) {
+	return typeof value === "string" && value.length > 0;
+}
+function isRecord$1(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function assertNever(value) {
+	throw new Error(`Unhandled connector update state: ${String(value)}`);
+}
+//#endregion
+//#region ../machine-protocol/src/index.ts
+const DEFAULT_MACHINE_EXEC_TIMEOUT_MS = 6e4;
+const MAX_MACHINE_EXEC_TIMEOUT_MS = 12e4;
+const DEFAULT_MACHINE_EXEC_OUTPUT_BYTES = 512e3;
+const MAX_MACHINE_EXEC_OUTPUT_BYTES = 1048576;
+const DEFAULT_MACHINE_FILE_READ_BYTES = 20 * 1024 * 1024;
+const MAX_MACHINE_FILE_READ_BYTES = 20 * 1024 * 1024;
+const DEFAULT_TEXT_FILE_READ_BYTES = 50 * 1024;
+const MAX_TEXT_FILE_READ_BYTES = 50 * 1024;
+const DEFAULT_TEXT_FILE_READ_LINES = 2e3;
+const MAX_TEXT_FILE_READ_LINES = 2e3;
+const MAX_MACHINE_JOB_OUTPUT_BYTES = 512 * 1024;
+const MAX_PATCH_SOURCE_FILE_BYTES = 5 * 1024 * 1024;
+const MAX_TEXT_FILE_WRITE_BYTES = 5 * 1024 * 1024;
+const MAX_MACHINE_FILE_SEARCH_PATH_LENGTH = 4096;
+const utf8 = new TextEncoder();
+function isServerRpcRequest(value) {
+	if (!isRecord(value)) return false;
+	if (value.type !== "rpc/request" || !isNonEmptyString(value.id)) return false;
+	if (isTerminalRpcRequest(value)) return true;
+	if (value.method === "shell/exec") {
+		const params = value.params;
+		return isRecord(params) && isNonEmptyString(params.shellId) && isNonEmptyString(params.command) && optionalString(params.cwd) && optionalNumber(params.timeoutMs) && optionalNumber(params.maxOutputBytes);
+	}
+	if (value.method === "shell/close") {
+		const params = value.params;
+		return isRecord(params) && isNonEmptyString(params.shellId);
+	}
+	if (value.method === "shell/job_start") {
+		const params = value.params;
+		return isRecord(params) && isNonEmptyString(params.command) && optionalNonEmptyString(params.cwd);
+	}
+	if (value.method === "shell/job_get") {
+		const params = value.params;
+		return isRecord(params) && isBoundedNonEmptyString(params.jobId, 128) && optionalNonNegativeSafeInteger(params.cursor);
+	}
+	if (value.method === "shell/job_kill") {
+		const params = value.params;
+		return isRecord(params) && isBoundedNonEmptyString(params.jobId, 128);
+	}
+	if (value.method === "file/read") {
+		const params = value.params;
+		return isRecord(params) && isNonEmptyString(params.path) && optionalPositiveBoundedSafeInteger(params.maxBytes, 20971520);
+	}
+	if (value.method === "file/read_text") {
+		const params = value.params;
+		return isRecord(params) && isNonEmptyString(params.path) && (params.mode === void 0 || params.mode === "offset" || params.mode === "tail") && !(params.mode === "tail" && params.offset !== void 0) && optionalPositiveSafeInteger(params.offset) && optionalPositiveBoundedSafeInteger(params.limit, 2e3) && optionalPositiveBoundedSafeInteger(params.maxBytes, 51200);
+	}
+	if (value.method === "file/read_patch_source") {
+		const params = value.params;
+		return isRecord(params) && isNonEmptyString(params.path) && optionalPositiveBoundedSafeInteger(params.maxBytes, 5242880);
+	}
+	if (value.method === "file/write") {
+		const params = value.params;
+		return isRecord(params) && isNonEmptyString(params.path) && typeof params.content === "string" && utf8.encode(params.content).byteLength <= 5242880;
+	}
+	if (value.method === "file/delete") {
+		const params = value.params;
+		return isRecord(params) && isNonEmptyString(params.path);
+	}
+	if (value.method === "file/move") {
+		const params = value.params;
+		return isRecord(params) && isNonEmptyString(params.sourcePath) && isNonEmptyString(params.targetPath);
+	}
+	if (value.method === "file/search_entries") {
+		const params = value.params;
+		return isRecord(params) && isAbsoluteHostPath(params.rootPath) && typeof params.query === "string" && optionalPositiveBoundedSafeInteger(params.limit, 100);
+	}
+	if (value.method === "connector/update_preflight" || value.method === "connector/update_retry") {
+		const params = value.params;
+		return isRecord(params) && /^\d+\.\d+\.\d+$/.test(String(params.candidateVersion)) && Number.isSafeInteger(params.statusRevision) && params.statusRevision >= 0;
+	}
+	if (value.method === "connector/update_force") return isRecord(value.params) && isLocalControlCapability(value.params.capability);
+	return false;
+}
+function optionalString(value) {
+	return value === void 0 || typeof value === "string";
+}
+function optionalNonEmptyString(value) {
+	return value === void 0 || isNonEmptyString(value);
+}
+function isBoundedNonEmptyString(value, maxLength) {
+	return isNonEmptyString(value) && value.length <= maxLength;
+}
+function optionalNumber(value) {
+	return value === void 0 || typeof value === "number" && Number.isFinite(value);
+}
+function optionalPositiveBoundedSafeInteger(value, max) {
+	return value === void 0 || typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= max;
+}
+function optionalPositiveSafeInteger(value) {
+	return value === void 0 || isPositiveSafeInteger(value);
+}
+function optionalNonNegativeSafeInteger(value) {
+	return value === void 0 || isNonNegativeSafeInteger(value);
+}
+function isPositiveSafeInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function isNonNegativeSafeInteger(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isAbsoluteHostPath(value) {
+	if (!isNonEmptyString(value) || value.includes("\0")) return false;
+	return value.startsWith("/") || value.startsWith("\\\\") || /^[A-Za-z]:[\\/]/.test(value);
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { CONNECTOR_MAX_WEBSOCKET_PAYLOAD_BYTES as A, validateMachineMcpLaunchSpec as B, canonicalSignedConnectorReleaseTuple as C, isDeploymentUuid as D, isConnectorReady as E, MachineMcpValidationError as F, negotiateLocalControlVersion as G, validateMachineMcpResult as H, encodeMachineMcpFrame as I, MAX_MACHINE_TERMINAL_HISTORY_BYTES as K, sanitizeAndCanonicalizeMachineMcpCatalog as L, MACHINE_MCP_MAX_FRAME_BYTES as M, MACHINE_MCP_MAX_STDERR_BYTES as N, normalizeDeploymentOrigin as O, MACHINE_MCP_TAG as P, substituteMachineMcpLaunch as R, classifyServerRpcActivity as S, isConnectorActivated as T, isLocalControlCommand as U, validateMachineMcpRequest as V, isLocalControlHello as W, canRetryConnectorUpdate as _, DEFAULT_TEXT_FILE_READ_LINES as a, validateConnectorUpdateStatus as b, MAX_MACHINE_FILE_READ_BYTES as c, MAX_PATCH_SOURCE_FILE_BYTES as d, MAX_TEXT_FILE_READ_BYTES as f, canForceConnectorUpdate as g, isServerRpcRequest as h, DEFAULT_TEXT_FILE_READ_BYTES as i, MACHINE_MCP_MAX_ERROR_MESSAGE_BYTES as j, normalizeDeploymentPolicy as k, MAX_MACHINE_FILE_SEARCH_PATH_LENGTH as l, MAX_TEXT_FILE_WRITE_BYTES as m, DEFAULT_MACHINE_EXEC_TIMEOUT_MS as n, MAX_MACHINE_EXEC_OUTPUT_BYTES as o, MAX_TEXT_FILE_READ_LINES as p, DEFAULT_MACHINE_FILE_READ_BYTES as r, MAX_MACHINE_EXEC_TIMEOUT_MS as s, DEFAULT_MACHINE_EXEC_OUTPUT_BYTES as t, MAX_MACHINE_JOB_OUTPUT_BYTES as u, isConnectorForceConsumeResult as v, canonicalDeploymentPolicyJson as w, classifyMachineMcpActivity as x, isConnectorUpdateResponse as y, utf8Bytes as z };