@openclaw/lobster 2026.7.2-beta.7 → 2026.7.33

package/dist/index.js

@@ -1,18 +1,137 @@
+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 ajvPath = createRequire(packageEntryPath).resolve("ajv");
+	const ajvModule = await import(pathToFileURL(ajvPath).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;
@@ -131,12 +250,29 @@ async function withTimeout(timeoutMs, fn) {
 		});
 	});
 }
-async function loadEmbeddedToolRuntimeFromPackage() {
-	return await import([
-		"@clawdbot",
-		"lobster",
-		"core"
-	].join("/"));
+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") });
 }
 function createEmbeddedLobsterRunner(options) {
 	const loadRuntime = options?.loadRuntime ?? loadEmbeddedToolRuntimeFromPackage;
@@ -435,11 +571,12 @@ function parseResumeFlowParams(params) {
 	};
 }
 function formatManagedFlowResult(result) {
-	return jsonResult({
+	const details = {
 		...result.envelope && typeof result.envelope === "object" && !Array.isArray(result.envelope) ? result.envelope : { envelope: result.envelope },
 		flow: result.flow,
 		mutation: result.mutation
-	});
+	};
+	return jsonResult(details);
 }
 function requireTaskFlowRuntime(taskFlow, action) {
 	if (!taskFlow) throw new Error(`Managed TaskFlow ${action} mode requires a bound taskFlow runtime`);
@@ -456,7 +593,10 @@ 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.Enum(["run", "resume"], { type: "string" }),
+			action: Type.Unsafe({
+				type: "string",
+				enum: ["run", "resume"]
+			}),
 			pipeline: Type.Optional(Type.String()),
 			argsJson: Type.Optional(Type.String()),
 			token: Type.Optional(Type.String()),

package/node_modules/@clawdbot/lobster/node_modules/fast-uri/.github/dependabot.yml

@@ -2,52 +2,12 @@ version: 2
 updates:
   - package-ecosystem: "github-actions"
     directory: "/"
-    commit-message:
-      # Prefix all commit messages with "chore: "
-      prefix: "chore"
     schedule:
-      interval: "weekly"
-    cooldown:
-      default-days: 7
-    allow:
-      - dependency-name: "*"
-        update-types:
-          - "version-update:semver-major"
+      interval: "monthly"
     open-pull-requests-limit: 10
 
   - package-ecosystem: "npm"
     directory: "/"
-    commit-message:
-      # Prefix all commit messages with "chore: "
-      prefix: "chore"
     schedule:
-      interval: "weekly"
-    cooldown:
-      default-days: 7
-    versioning-strategy: "increase-if-necessary"
-    allow:
-      - dependency-name: "*"
-        update-types:
-          - "version-update:semver-major"
-    ignore:
-      # TODO: remove ignore until neostandard support ESLint 10
-      - dependency-name: "eslint"
-      - dependency-name: "neostandard"
-      - dependency-name: "@stylistic/*"
+      interval: "monthly"
     open-pull-requests-limit: 10
-    groups:
-      # Production dependencies with breaking changes
-      dependencies:
-        dependency-type: "production"
-      # ESLint related dependencies
-      dev-dependencies-eslint:
-        patterns:
-          - "eslint"
-          - "neostandard"
-          - "@stylistic/*"
-      # TypeScript related dependencies
-      dev-dependencies-typescript:
-        patterns:
-          - "@types/*"
-          - "tstyche"
-          - "typescript"

package/node_modules/@clawdbot/lobster/node_modules/fast-uri/.github/workflows/ci.yml

@@ -23,61 +23,13 @@ permissions:
   contents: read
 
 jobs:
-  type-tests:
-    name: Type Tests
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: ['20', '22', '24', '26']
-    steps:
-      - uses: actions/checkout@v7
-        with:
-          persist-credentials: false
-
-      - uses: actions/setup-node@v6
-        with:
-          node-version: ${{ matrix.node-version }}
-          cache: 'npm'
-          cache-dependency-path: package.json
-          check-latest: true
-
-      - name: Install dependencies
-        run: npm install --ignore-scripts
-
-      - name: Run type tests
-        run: npm run test:typescript
-
-  unit-tests:
-    name: Unit Tests
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: ['16', '18', '20', '22', '24', '26']
-    steps:
-      - uses: actions/checkout@v7
-        with:
-          persist-credentials: false
-
-      - uses: actions/setup-node@v6
-        with:
-          node-version: ${{ matrix.node-version }}
-          cache: 'npm'
-          cache-dependency-path: package.json
-          check-latest: true
-
-      - name: Install dependencies
-        run: npm install --ignore-scripts
-
-      - name: Run unit tests
-        run: npm test
-
   test-regression-check-node10:
     name: Test compatibility with Node.js 10
     runs-on: ubuntu-latest
     permissions:
       contents: read
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -119,7 +71,7 @@ jobs:
     permissions:
       contents: read
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
         with:
           persist-credentials: false
 
@@ -151,4 +103,4 @@ jobs:
     with:
       license-check: true
       lint: true
-      node-versions: '["16", "18", "20", "22", "24", "26"]'
+      node-versions: '["16", "18", "20", "22", "24"]'

package/node_modules/@clawdbot/lobster/node_modules/fast-uri/.github/workflows/package-manager-ci.yml

@@ -0,0 +1,24 @@
+name: package-manager-ci
+
+on:
+  push:
+    branches:
+     - main
+     - next
+     - 'v*'
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    permissions:
+      contents: read
+    uses: fastify/workflows/.github/workflows/plugins-ci-package-manager.yml@v6

package/node_modules/@clawdbot/lobster/node_modules/fast-uri/README.md

@@ -27,10 +27,10 @@ Malformed authorities and out-of-range ports are reported through the parsed com
 	If set to `true`, the serializer will not resolve a relative `path` component.
 
 *	`unicodeSupport` (boolean, false)
-	If set to `true`, the parser will unescape non-ASCII characters in the parsed output as per [RFC 3987](https://www.ietf.org/rfc/rfc3987.txt).
+	If set to `true`, the parser will unescape non-ASCII characters in the parsed output as per [RFC 3987](http://www.ietf.org/rfc/rfc3987.txt).
 
 *	`domainHost` (boolean, false)
-	If set to `true`, the library will treat the `host` component as a domain name, and convert IDNs (International Domain Names) as per [RFC 5891](https://www.ietf.org/rfc/rfc5891.txt).
+	If set to `true`, the library will treat the `host` component as a domain name, and convert IDNs (International Domain Names) as per [RFC 5891](http://www.ietf.org/rfc/rfc5891.txt).
 
 ### Parse
 
@@ -90,14 +90,14 @@ true
 
 ## Scheme supports
 
-fast-uri supports inserting custom [scheme](https://en.wikipedia.org/wiki/URI_scheme)-dependent processing rules. Currently, fast-uri has built-in support for the following schemes:
+fast-uri supports inserting custom [scheme](http://en.wikipedia.org/wiki/URI_scheme)-dependent processing rules. Currently, fast-uri has built-in support for the following schemes:
 
-*	http \[[RFC 2616](https://www.ietf.org/rfc/rfc2616.txt)\]
-*	https \[[RFC 2818](https://www.ietf.org/rfc/rfc2818.txt)\]
-*	ws \[[RFC 6455](https://www.ietf.org/rfc/rfc6455.txt)\]
-*	wss \[[RFC 6455](https://www.ietf.org/rfc/rfc6455.txt)\]
-*	urn \[[RFC 2141](https://www.ietf.org/rfc/rfc2141.txt)\]
-*	urn:uuid \[[RFC 4122](https://www.ietf.org/rfc/rfc4122.txt)\]
+*	http \[[RFC 2616](http://www.ietf.org/rfc/rfc2616.txt)\]
+*	https \[[RFC 2818](http://www.ietf.org/rfc/rfc2818.txt)\]
+*	ws \[[RFC 6455](http://www.ietf.org/rfc/rfc6455.txt)\]
+*	wss \[[RFC 6455](http://www.ietf.org/rfc/rfc6455.txt)\]
+*	urn \[[RFC 2141](http://www.ietf.org/rfc/rfc2141.txt)\]
+*	urn:uuid \[[RFC 4122](http://www.ietf.org/rfc/rfc4122.txt)\]
 
 
 ## Benchmarks