openclaw-multi-auto 1.0.9 → 1.1.1

package/scripts/pr-merge

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+script_dir="$(cd "$(dirname "$0")" && pwd)"
+base="$script_dir/pr"
+if common_git_dir=$(git -C "$script_dir" rev-parse --path-format=absolute --git-common-dir 2>/dev/null); then
+  canonical_base="$(dirname "$common_git_dir")/scripts/pr"
+  if [ -x "$canonical_base" ]; then
+    base="$canonical_base"
+  fi
+fi
+
+usage() {
+  cat <<USAGE
+Usage:
+  scripts/pr-merge <PR>          # verify only (backward compatible)
+  scripts/pr-merge verify <PR>   # verify only
+  scripts/pr-merge run <PR>      # verify + merge + post-merge checks + cleanup
+USAGE
+}
+
+if [ "$#" -eq 1 ]; then
+  exec "$base" merge-verify "$1"
+fi
+
+if [ "$#" -eq 2 ]; then
+  mode="$1"
+  pr="$2"
+  case "$mode" in
+    verify)
+      exec "$base" merge-verify "$pr"
+      ;;
+    run)
+      exec "$base" merge-run "$pr"
+      ;;
+    *)
+      usage
+      exit 2
+      ;;
+  esac
+fi
+
+usage
+exit 2

package/scripts/pr-prepare

@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [ "$#" -ne 2 ]; then
+  echo "Usage: scripts/pr-prepare <init|validate-commit|gates|push|run> <PR>"
+  exit 2
+fi
+
+mode="$1"
+pr="$2"
+script_dir="$(cd "$(dirname "$0")" && pwd)"
+base="$script_dir/pr"
+if common_git_dir=$(git -C "$script_dir" rev-parse --path-format=absolute --git-common-dir 2>/dev/null); then
+  canonical_base="$(dirname "$common_git_dir")/scripts/pr"
+  if [ -x "$canonical_base" ]; then
+    base="$canonical_base"
+  fi
+fi
+
+case "$mode" in
+  init)
+    exec "$base" prepare-init "$pr"
+    ;;
+  validate-commit)
+    exec "$base" prepare-validate-commit "$pr"
+    ;;
+  gates)
+    exec "$base" prepare-gates "$pr"
+    ;;
+  push)
+    exec "$base" prepare-push "$pr"
+    ;;
+  run)
+    exec "$base" prepare-run "$pr"
+    ;;
+  *)
+    echo "Usage: scripts/pr-prepare <init|validate-commit|gates|push|run> <PR>"
+    exit 2
+    ;;
+esac

package/scripts/pr-review

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+script_dir="$(cd "$(dirname "$0")" && pwd)"
+base="$script_dir/pr"
+if common_git_dir=$(git -C "$script_dir" rev-parse --path-format=absolute --git-common-dir 2>/dev/null); then
+  canonical_base="$(dirname "$common_git_dir")/scripts/pr"
+  if [ -x "$canonical_base" ]; then
+    base="$canonical_base"
+  fi
+fi
+
+exec "$base" review-init "$@"

package/scripts/pre-commit/filter-staged-files.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import path from "node:path";
+
+/**
+ * Prints selected files as NUL-delimited tokens to stdout.
+ *
+ * Usage:
+ *   node scripts/pre-commit/filter-staged-files.mjs lint -- <files...>
+ *   node scripts/pre-commit/filter-staged-files.mjs format -- <files...>
+ *
+ * Keep this dependency-free: the pre-commit hook runs in many environments.
+ */
+
+const mode = process.argv[2];
+const rawArgs = process.argv.slice(3);
+const files = rawArgs[0] === "--" ? rawArgs.slice(1) : rawArgs;
+
+if (mode !== "lint" && mode !== "format") {
+  process.stderr.write("usage: filter-staged-files.mjs <lint|format> -- <files...>\n");
+  process.exit(2);
+}
+
+const lintExts = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+const formatExts = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json", ".md", ".mdx"]);
+
+const shouldSelect = (filePath) => {
+  const ext = path.extname(filePath).toLowerCase();
+  if (mode === "lint") {
+    return lintExts.has(ext);
+  }
+  return formatExts.has(ext);
+};
+
+for (const file of files) {
+  if (shouldSelect(file)) {
+    process.stdout.write(file);
+    process.stdout.write("\0");
+  }
+}

package/scripts/pre-commit/run-node-tool.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+
+if [[ $# -lt 1 ]]; then
+  echo "usage: run-node-tool.sh <tool> [args...]" >&2
+  exit 2
+fi
+
+tool="$1"
+shift
+
+if [[ -f "$ROOT_DIR/pnpm-lock.yaml" ]] && command -v pnpm >/dev/null 2>&1; then
+  exec pnpm exec "$tool" "$@"
+fi
+
+if { [[ -f "$ROOT_DIR/bun.lockb" ]] || [[ -f "$ROOT_DIR/bun.lock" ]]; } && command -v bun >/dev/null 2>&1; then
+  exec bunx --bun "$tool" "$@"
+fi
+
+if command -v npm >/dev/null 2>&1; then
+  exec npm exec -- "$tool" "$@"
+fi
+
+if command -v npx >/dev/null 2>&1; then
+  exec npx "$tool" "$@"
+fi
+
+echo "Missing package manager: pnpm, bun, or npm required." >&2
+exit 1

package/scripts/protocol-gen-swift.ts

@@ -0,0 +1,247 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { ErrorCodes, PROTOCOL_VERSION, ProtocolSchemas } from "../src/gateway/protocol/schema.js";
+
+type JsonSchema = {
+  type?: string | string[];
+  properties?: Record<string, JsonSchema>;
+  required?: string[];
+  items?: JsonSchema;
+  enum?: string[];
+  patternProperties?: Record<string, JsonSchema>;
+};
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, "..");
+const outPaths = [
+  path.join(repoRoot, "apps", "macos", "Sources", "OpenClawProtocol", "GatewayModels.swift"),
+  path.join(
+    repoRoot,
+    "apps",
+    "shared",
+    "OpenClawKit",
+    "Sources",
+    "OpenClawProtocol",
+    "GatewayModels.swift",
+  ),
+];
+
+const header = `// Generated by scripts/protocol-gen-swift.ts — do not edit by hand\n// swiftlint:disable file_length\nimport Foundation\n\npublic let GATEWAY_PROTOCOL_VERSION = ${PROTOCOL_VERSION}\n\npublic enum ErrorCode: String, Codable, Sendable {\n${Object.values(
+  ErrorCodes,
+)
+  .map((c) => `    case ${camelCase(c)} = "${c}"`)
+  .join("\n")}\n}\n`;
+
+const reserved = new Set([
+  "associatedtype",
+  "class",
+  "deinit",
+  "enum",
+  "extension",
+  "fileprivate",
+  "func",
+  "import",
+  "init",
+  "inout",
+  "internal",
+  "let",
+  "open",
+  "operator",
+  "private",
+  "precedencegroup",
+  "protocol",
+  "public",
+  "rethrows",
+  "static",
+  "struct",
+  "subscript",
+  "typealias",
+  "var",
+]);
+
+function camelCase(input: string) {
+  return input
+    .replace(/[^a-zA-Z0-9]+/g, " ")
+    .trim()
+    .toLowerCase()
+    .split(/\s+/)
+    .map((p, i) => (i === 0 ? p : p[0].toUpperCase() + p.slice(1)))
+    .join("");
+}
+
+function safeName(name: string) {
+  const cc = camelCase(name.replace(/-/g, "_"));
+  if (reserved.has(cc)) {
+    return `_${cc}`;
+  }
+  return cc;
+}
+
+// filled later once schemas are loaded
+const schemaNameByObject = new Map<object, string>();
+
+function swiftType(schema: JsonSchema, required: boolean): string {
+  const t = schema.type;
+  const isOptional = !required;
+  let base: string;
+  const named = schemaNameByObject.get(schema as object);
+  if (named) {
+    base = named;
+  } else if (t === "string") {
+    base = "String";
+  } else if (t === "integer") {
+    base = "Int";
+  } else if (t === "number") {
+    base = "Double";
+  } else if (t === "boolean") {
+    base = "Bool";
+  } else if (t === "array") {
+    base = `[${swiftType(schema.items ?? { type: "Any" }, true)}]`;
+  } else if (schema.enum) {
+    base = "String";
+  } else if (schema.patternProperties) {
+    base = "[String: AnyCodable]";
+  } else if (t === "object") {
+    base = "[String: AnyCodable]";
+  } else {
+    base = "AnyCodable";
+  }
+  return isOptional ? `${base}?` : base;
+}
+
+function emitStruct(name: string, schema: JsonSchema): string {
+  const props = schema.properties ?? {};
+  const required = new Set(schema.required ?? []);
+  const lines: string[] = [];
+  if (Object.keys(props).length === 0) {
+    return `public struct ${name}: Codable, Sendable {}\n`;
+  }
+  lines.push(`public struct ${name}: Codable, Sendable {`);
+  const codingKeys: string[] = [];
+  for (const [key, propSchema] of Object.entries(props)) {
+    const propName = safeName(key);
+    const propType = swiftType(propSchema, required.has(key));
+    lines.push(`    public let ${propName}: ${propType}`);
+    if (propName !== key) {
+      codingKeys.push(`        case ${propName} = "${key}"`);
+    } else {
+      codingKeys.push(`        case ${propName}`);
+    }
+  }
+  lines.push(
+    "\n    public init(\n" +
+      Object.entries(props)
+        .map(([key, prop]) => {
+          const propName = safeName(key);
+          const req = required.has(key);
+          return `        ${propName}: ${swiftType(prop, true)}${req ? "" : "?"}`;
+        })
+        .join(",\n") +
+      ")\n" +
+      "    {\n" +
+      Object.entries(props)
+        .map(([key]) => {
+          const propName = safeName(key);
+          return `        self.${propName} = ${propName}`;
+        })
+        .join("\n") +
+      "\n    }\n\n" +
+      "    private enum CodingKeys: String, CodingKey {\n" +
+      codingKeys.join("\n") +
+      "\n    }\n}",
+  );
+  lines.push("");
+  return lines.join("\n");
+}
+
+function emitGatewayFrame(): string {
+  const cases = ["req", "res", "event"];
+  const associated: Record<string, string> = {
+    req: "RequestFrame",
+    res: "ResponseFrame",
+    event: "EventFrame",
+  };
+  const caseLines = cases.map((c) => `    case ${safeName(c)}(${associated[c]})`);
+  const initLines = `
+    private enum CodingKeys: String, CodingKey {
+        case type
+    }
+
+    public init(from decoder: Decoder) throws {
+        let typeContainer = try decoder.container(keyedBy: CodingKeys.self)
+        let type = try typeContainer.decode(String.self, forKey: .type)
+        switch type {
+        case "req":
+            self = try .req(RequestFrame(from: decoder))
+        case "res":
+            self = try .res(ResponseFrame(from: decoder))
+        case "event":
+            self = try .event(EventFrame(from: decoder))
+        default:
+            let container = try decoder.singleValueContainer()
+            let raw = try container.decode([String: AnyCodable].self)
+            self = .unknown(type: type, raw: raw)
+        }
+    }
+
+    public func encode(to encoder: Encoder) throws {
+        switch self {
+        case let .req(v):
+            try v.encode(to: encoder)
+        case let .res(v):
+            try v.encode(to: encoder)
+        case let .event(v):
+            try v.encode(to: encoder)
+        case let .unknown(_, raw):
+            var container = encoder.singleValueContainer()
+            try container.encode(raw)
+        }
+    }
+`;
+
+  return [
+    "public enum GatewayFrame: Codable, Sendable {",
+    ...caseLines,
+    "    case unknown(type: String, raw: [String: AnyCodable])",
+    initLines.trimEnd(),
+    "}",
+    "",
+  ].join("\n");
+}
+
+async function generate() {
+  const definitions = Object.entries(ProtocolSchemas) as Array<[string, JsonSchema]>;
+
+  for (const [name, schema] of definitions) {
+    schemaNameByObject.set(schema as object, name);
+  }
+
+  const parts: string[] = [];
+  parts.push(header);
+
+  // Value structs
+  for (const [name, schema] of definitions) {
+    if (name === "GatewayFrame") {
+      continue;
+    }
+    if (schema.type === "object") {
+      parts.push(emitStruct(name, schema));
+    }
+  }
+
+  // Frame enum must come after payload structs
+  parts.push(emitGatewayFrame());
+
+  const content = parts.join("\n");
+  for (const outPath of outPaths) {
+    await fs.mkdir(path.dirname(outPath), { recursive: true });
+    await fs.writeFile(outPath, content);
+    console.log(`wrote ${outPath}`);
+  }
+}
+
+generate().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/scripts/protocol-gen.ts

@@ -0,0 +1,51 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { ProtocolSchemas } from "../src/gateway/protocol/schema.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, "..");
+
+async function writeJsonSchema() {
+  const definitions: Record<string, unknown> = {};
+  for (const [name, schema] of Object.entries(ProtocolSchemas)) {
+    definitions[name] = schema;
+  }
+
+  const rootSchema = {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    $id: "https://openclaw.ai/protocol.schema.json",
+    title: "OpenClaw Gateway Protocol",
+    description: "Handshake, request/response, and event frames for the Gateway WebSocket.",
+    oneOf: [
+      { $ref: "#/definitions/RequestFrame" },
+      { $ref: "#/definitions/ResponseFrame" },
+      { $ref: "#/definitions/EventFrame" },
+    ],
+    discriminator: {
+      propertyName: "type",
+      mapping: {
+        req: "#/definitions/RequestFrame",
+        res: "#/definitions/ResponseFrame",
+        event: "#/definitions/EventFrame",
+      },
+    },
+    definitions,
+  };
+
+  const distDir = path.join(repoRoot, "dist");
+  await fs.mkdir(distDir, { recursive: true });
+  const jsonSchemaPath = path.join(distDir, "protocol.schema.json");
+  await fs.writeFile(jsonSchemaPath, JSON.stringify(rootSchema, null, 2));
+  console.log(`wrote ${jsonSchemaPath}`);
+  return { jsonSchemaPath, schemaString: JSON.stringify(rootSchema) };
+}
+
+async function main() {
+  await writeJsonSchema();
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/scripts/readability-basic-compare.ts

@@ -0,0 +1,66 @@
+import { createWebFetchTool } from "../src/agents/tools/web-tools.js";
+
+const DEFAULT_URLS = [
+  "https://example.com/",
+  "https://news.ycombinator.com/",
+  "https://www.reddit.com/r/javascript/",
+  "https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent",
+  "https://httpbin.org/html",
+];
+
+const urls = process.argv.slice(2);
+const targets = urls.length > 0 ? urls : DEFAULT_URLS;
+
+async function runFetch(url: string, readability: boolean) {
+  if (!readability) {
+    throw new Error("Basic extraction removed. Set readability=true or enable Firecrawl.");
+  }
+  const tool = createWebFetchTool({
+    config: {
+      tools: {
+        web: { fetch: { readability, cacheTtlMinutes: 0, firecrawl: { enabled: false } } },
+      },
+    },
+    sandboxed: false,
+  });
+  if (!tool) {
+    throw new Error("web_fetch tool is disabled");
+  }
+  const result = await tool.execute("test", { url, extractMode: "markdown" });
+  return result.details as {
+    text?: string;
+    title?: string;
+    extractor?: string;
+    length?: number;
+    truncated?: boolean;
+  };
+}
+
+function truncate(value: string, max = 160): string {
+  if (!value) {
+    return "";
+  }
+  return value.length > max ? `${value.slice(0, max)}…` : value;
+}
+
+async function run() {
+  for (const url of targets) {
+    console.log(`\n=== ${url}`);
+    const readable = await runFetch(url, true);
+
+    console.log(
+      `readability: ${readable.extractor ?? "unknown"} len=${readable.length ?? 0} title=${truncate(
+        readable.title ?? "",
+        80,
+      )}`,
+    );
+    if (readable.text) {
+      console.log(`readability sample: ${truncate(readable.text)}`);
+    }
+  }
+}
+
+run().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});