@openclaw/lobster 2026.7.1 → 2026.7.2-beta.2

package/dist/index.js

@@ -1,136 +1,18 @@
-import { createRequire } from "node:module";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import { optionalNonNegativeIntegerSchema, optionalPositiveIntegerSchema } from "openclaw/plugin-sdk/channel-actions";
 import { readNonNegativeIntegerParam, readPositiveIntegerParam } from "openclaw/plugin-sdk/param-readers";
 import { jsonResult } from "openclaw/plugin-sdk/tool-results";
 import { Type } from "typebox";
-import { readFileSync } from "node:fs";
 import { stat } from "node:fs/promises";
 import path from "node:path";
 import { Readable, Writable } from "node:stream";
-import { pathToFileURL } from "node:url";
-import { createHash } from "node:crypto";
-//#region extensions/lobster/src/lobster-ajv-cache.ts
-const installedSymbol = Symbol.for("openclaw.lobster.ajv-compile-cache.installed");
-const cacheSymbol = Symbol.for("openclaw.lobster.ajv-compile-cache.entries");
-const maxEntries = 512;
-function stableJsonStringify(value, seen = /* @__PURE__ */ new WeakSet()) {
-	if (value === null || typeof value !== "object") return JSON.stringify(value);
-	if (seen.has(value)) throw new TypeError("Cannot cache cyclic JSON schema");
-	seen.add(value);
-	if (Array.isArray(value)) {
-		const items = value.map((entry) => stableJsonStringify(entry, seen));
-		seen.delete(value);
-		return `[${items.join(",")}]`;
-	}
-	const record = value;
-	const properties = Object.keys(record).toSorted().filter((key) => record[key] !== void 0).map((key) => `${JSON.stringify(key)}:${stableJsonStringify(record[key], seen)}`);
-	seen.delete(value);
-	return `{${properties.join(",")}}`;
-}
-function compileCacheKey(schema) {
-	try {
-		return createHash("sha256").update(stableJsonStringify(schema)).digest("hex");
-	} catch {
-		return null;
-	}
-}
-function readCompileCache(instance) {
-	let cache = instance[cacheSymbol];
-	if (!cache) {
-		cache = /* @__PURE__ */ new Map();
-		Object.defineProperty(instance, cacheSymbol, {
-			value: cache,
-			configurable: true
-		});
-	}
-	return cache;
-}
-function rememberCompiledValidator(params) {
-	const { cache, instance, key, removeSchema, schema, validate } = params;
-	if (!cache.has(key) && cache.size >= maxEntries) {
-		const oldest = cache.keys().next().value;
-		if (oldest !== void 0) {
-			const evicted = cache.get(oldest);
-			cache.delete(oldest);
-			if (evicted) removeSchema.call(instance, evicted.schema);
-		}
-	}
-	cache.set(key, {
-		schema,
-		validate
-	});
-}
-async function resolveLobsterAjvConstructor(packageEntryPath) {
-	const ajvModule = await import(pathToFileURL(createRequire(packageEntryPath).resolve("ajv")).href);
-	return ajvModule.default ?? ajvModule;
-}
-async function installLobsterAjvCompileCache(packageEntryPath) {
-	let AjvCtor;
-	try {
-		AjvCtor = await resolveLobsterAjvConstructor(packageEntryPath);
-	} catch {
-		return;
-	}
-	const proto = AjvCtor.prototype;
-	if (proto[installedSymbol]) return;
-	const originalCompile = proto.compile;
-	const originalRemoveSchema = proto.removeSchema;
-	Object.defineProperty(proto, installedSymbol, {
-		value: true,
-		configurable: true
-	});
-	proto.compile = function compileWithContentCache(schema) {
-		const key = compileCacheKey(schema);
-		if (!key) return originalCompile.call(this, schema);
-		const cache = readCompileCache(this);
-		const cached = cache.get(key);
-		if (cached) return cached.validate;
-		const validate = originalCompile.call(this, schema);
-		rememberCompiledValidator({
-			cache,
-			instance: this,
-			key,
-			removeSchema: originalRemoveSchema,
-			schema,
-			validate
-		});
-		return validate;
-	};
-	proto.removeSchema = function removeSchemaAndClearContentCache(schemaKeyRef) {
-		this[cacheSymbol]?.clear();
-		return originalRemoveSchema.call(this, schemaKeyRef);
-	};
-}
-//#endregion
 //#region extensions/lobster/src/lobster-runner.ts
-const lobsterRequire = createRequire(import.meta.url);
 const workflowExts = /* @__PURE__ */ new Set([
 	".lobster",
 	".yaml",
 	".yml",
 	".json"
 ]);
-function toEmbeddedToolRuntime(moduleExports, source) {
-	const { runToolRequest, resumeToolRequest } = moduleExports;
-	if (typeof runToolRequest === "function" && typeof resumeToolRequest === "function") return {
-		runToolRequest,
-		resumeToolRequest
-	};
-	throw new Error(`${source} does not export Lobster embedded runtime functions`);
-}
-function findLobsterPackageRoot(resolvedEntryPath) {
-	let dir = path.dirname(resolvedEntryPath);
-	while (true) {
-		const packageJsonPath = path.join(dir, "package.json");
-		try {
-			if (JSON.parse(readFileSync(packageJsonPath, "utf8")).name === "@clawdbot/lobster") return dir;
-		} catch {}
-		const parent = path.dirname(dir);
-		if (parent === dir) throw new Error(`Could not locate @clawdbot/lobster package root from ${resolvedEntryPath}`);
-		dir = parent;
-	}
-}
 function normalizeForCwdSandbox(p) {
 	const normalized = path.normalize(p);
 	return process.platform === "win32" ? normalized.toLowerCase() : normalized;
@@ -249,29 +131,12 @@ async function withTimeout(timeoutMs, fn) {
 		});
 	});
 }
-async function loadEmbeddedToolRuntimeFromPackage(options = {}) {
-	const importModule = options.importModule ?? (async (specifier) => await import(specifier));
-	const packageEntryPath = (options.resolvePackageEntry ?? ((specifier) => lobsterRequire.resolve(specifier)))("@clawdbot/lobster");
-	await installLobsterAjvCompileCache(packageEntryPath);
-	let coreLoadError;
-	try {
-		return toEmbeddedToolRuntime(await importModule([
-			"@clawdbot",
-			"lobster",
-			"core"
-		].join("/")), "@clawdbot/lobster/core");
-	} catch (error) {
-		coreLoadError = error;
-	}
-	let fallbackLoadError;
-	try {
-		const packageRoot = findLobsterPackageRoot(packageEntryPath);
-		const coreRuntimeUrl = pathToFileURL(path.join(packageRoot, "dist/src/core/index.js")).href;
-		return toEmbeddedToolRuntime(await importModule(coreRuntimeUrl), coreRuntimeUrl);
-	} catch (error) {
-		fallbackLoadError = error;
-	}
-	throw new Error("Failed to load the Lobster embedded runtime", { cause: new AggregateError([coreLoadError, fallbackLoadError], "Both Lobster embedded runtime load paths failed") });
+async function loadEmbeddedToolRuntimeFromPackage() {
+	return await import([
+		"@clawdbot",
+		"lobster",
+		"core"
+	].join("/"));
 }
 function createEmbeddedLobsterRunner(options) {
 	const loadRuntime = options?.loadRuntime ?? loadEmbeddedToolRuntimeFromPackage;
@@ -591,10 +456,7 @@ function createLobsterTool(api, options) {
 		label: "Lobster Workflow",
 		description: "Run Lobster pipelines as a local-first workflow runtime (typed JSON envelope + resumable approvals).",
 		parameters: Type.Object({
-			action: Type.Unsafe({
-				type: "string",
-				enum: ["run", "resume"]
-			}),
+			action: Type.Enum(["run", "resume"], { type: "string" }),
 			pipeline: Type.Optional(Type.String()),
 			argsJson: Type.Optional(Type.String()),
 			token: Type.Optional(Type.String()),

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@openclaw/lobster",
-  "version": "2026.7.1",
+  "version": "2026.7.2-beta.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/lobster",
-      "version": "2026.7.1",
+      "version": "2026.7.2-beta.2",
       "dependencies": {
         "@clawdbot/lobster": "2026.6.11",
         "typebox": "1.3.3"

package/openclaw.plugin.json

@@ -5,6 +5,7 @@
   },
   "name": "Lobster",
   "description": "Lobster workflow tool plugin for typed pipelines and resumable approvals.",
+  "catalog": { "featured": true, "order": 50 },
   "contracts": {
     "tools": ["lobster"]
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/lobster",
-  "version": "2026.7.1",
+  "version": "2026.7.2-beta.2",
   "description": "Lobster workflow tool plugin for typed pipelines and resumable approvals.",
   "repository": {
     "type": "git",
@@ -21,10 +21,10 @@
       "minHostVersion": ">=2026.4.25"
     },
     "compat": {
-      "pluginApi": ">=2026.7.1"
+      "pluginApi": ">=2026.7.2-beta.2"
     },
     "build": {
-      "openclawVersion": "2026.7.1"
+      "openclawVersion": "2026.7.2-beta.2"
     },
     "release": {
       "publishToClawHub": true,
@@ -42,7 +42,7 @@
     "SKILL.md"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.7.1"
+    "openclaw": ">=2026.7.2-beta.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {