a2acalling 0.6.75 → 0.6.76

package/.claude/worktrees/agent-a5b87d75/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "a2acalling",
+  "version": "0.6.75",
+  "description": "Agent-to-agent calling for OpenClaw - A2A agent communication",
+  "main": "src/index.js",
+  "bin": {
+    "a2a": "bin/cli.js",
+    "a2acalling": "scripts/install-openclaw.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "start": "node src/server.js",
+    "test": "node test/run.js",
+    "test:coverage": "c8 node test/run.js",
+    "lint": "biome lint src/",
+    "lint:check": "biome check src/",
+    "knip": "knip",
+    "test:e2e:standalone": "node test/run.js --e2e --filter standalone",
+    "build:standalone": "bash scripts/build-standalone.sh",
+    "build:sync-version": "bash scripts/sync-version.sh"
+  },
+  "keywords": [
+    "openclaw",
+    "claudebot",
+    "agent",
+    "a2a",
+    "calling",
+    "ai"
+  ],
+  "author": "OpenClaw Contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/onthegonow/a2a_calling.git"
+  },
+  "bugs": {
+    "url": "https://github.com/onthegonow/a2a_calling/issues"
+  },
+  "homepage": "https://github.com/onthegonow/a2a_calling#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "better-sqlite3": "^11.10.0",
+    "express": "^4.21.0"
+  },
+  "devDependencies": {
+    "@yao-pkg/pkg": "^6.0.0",
+    "@biomejs/biome": "^2.4.4",
+    "c8": "^11.0.0",
+    "eslint": "^10.0.2",
+    "eslint-plugin-sonarjs": "^4.0.0",
+    "knip": "^5.85.0"
+  }
+}

package/.claude/worktrees/agent-a5b87d75/pkg.config.json

@@ -0,0 +1,14 @@
+{
+  "pkg": {
+    "scripts": [
+      "src/**/*.js",
+      "bin/cli.js"
+    ],
+    "assets": [
+      "src/dashboard/public/**/*",
+      "node_modules/better-sqlite3/build/Release/better_sqlite3.node",
+      "node_modules/better-sqlite3/prebuilds/**/*"
+    ],
+    "outputPath": "native/macos/src-tauri/binaries"
+  }
+}

package/.claude/worktrees/agent-a5b87d75/scripts/build-standalone.sh

@@ -0,0 +1,106 @@
+#!/usr/bin/env bash
+# Build standalone Node.js binary for the A2A server using @yao-pkg/pkg.
+# Usage:
+#   scripts/build-standalone.sh                  # Build for current arch
+#   scripts/build-standalone.sh --universal      # Build macOS universal binary (aarch64 + x86_64)
+#   scripts/build-standalone.sh --arch arm64     # Build for specific arch
+#   scripts/build-standalone.sh --arch x64       # Build for specific arch
+#
+# Output: native/macos/src-tauri/binaries/a2a-server-<target-triple>
+# Requires: Node.js 20+, npm, macOS (for native binary builds)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+OUTPUT_DIR="$PROJECT_DIR/native/macos/src-tauri/binaries"
+PKG_TARGET_NODE="node20"
+BINARY_NAME="a2a-server"
+
+cd "$PROJECT_DIR"
+
+# ── Parse args ──
+UNIVERSAL=false
+TARGET_ARCH=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --universal) UNIVERSAL=true; shift ;;
+    --arch) TARGET_ARCH="$2"; shift 2 ;;
+    *) echo "Unknown option: $1" >&2; exit 2 ;;
+  esac
+done
+
+# ── Detect platform ──
+OS="$(uname -s)"
+if [[ "$OS" != "Darwin" ]]; then
+  echo "Warning: This build script is designed for macOS. Binary will target macOS regardless." >&2
+fi
+
+NATIVE_ARCH="$(uname -m)"
+case "$NATIVE_ARCH" in
+  arm64|aarch64) NATIVE_ARCH="arm64" ;;
+  x86_64)        NATIVE_ARCH="x64" ;;
+  *) echo "Unsupported architecture: $NATIVE_ARCH" >&2; exit 1 ;;
+esac
+
+# ── Ensure @yao-pkg/pkg is available ──
+if ! npx --no-install pkg --version >/dev/null 2>&1; then
+  echo "Installing @yao-pkg/pkg..."
+  npm install --save-dev @yao-pkg/pkg
+fi
+
+# ── Ensure production dependencies are built ──
+echo "Rebuilding native modules..."
+npm rebuild better-sqlite3
+
+# ── Build function ──
+build_arch() {
+  local arch="$1"
+  local target="${PKG_TARGET_NODE}-macos-${arch}"
+  local triple
+
+  case "$arch" in
+    arm64)  triple="aarch64-apple-darwin" ;;
+    x64)    triple="x86_64-apple-darwin" ;;
+    *) echo "Unsupported arch: $arch" >&2; return 1 ;;
+  esac
+
+  local output_path="$OUTPUT_DIR/${BINARY_NAME}-${triple}"
+
+  echo "Building standalone binary: $target → $output_path"
+
+  npx pkg src/server.js \
+    --config pkg.config.json \
+    --target "$target" \
+    --output "$output_path" \
+    --compress GZip
+
+  chmod +x "$output_path"
+  echo "Built: $output_path ($(du -h "$output_path" | cut -f1))"
+}
+
+# ── Execute builds ──
+mkdir -p "$OUTPUT_DIR"
+
+if $UNIVERSAL; then
+  echo "=== Building macOS universal binary ==="
+  build_arch "arm64"
+  build_arch "x64"
+
+  ARM_BIN="$OUTPUT_DIR/${BINARY_NAME}-aarch64-apple-darwin"
+  X64_BIN="$OUTPUT_DIR/${BINARY_NAME}-x86_64-apple-darwin"
+  UNIVERSAL_BIN="$OUTPUT_DIR/${BINARY_NAME}-universal-apple-darwin"
+
+  echo "Creating universal binary with lipo..."
+  lipo -create "$ARM_BIN" "$X64_BIN" -output "$UNIVERSAL_BIN"
+  chmod +x "$UNIVERSAL_BIN"
+  echo "Universal: $UNIVERSAL_BIN ($(du -h "$UNIVERSAL_BIN" | cut -f1))"
+elif [[ -n "$TARGET_ARCH" ]]; then
+  build_arch "$TARGET_ARCH"
+else
+  build_arch "$NATIVE_ARCH"
+fi
+
+echo ""
+echo "=== Build complete ==="
+ls -lh "$OUTPUT_DIR"/${BINARY_NAME}-* 2>/dev/null || echo "(no binaries found)"

package/.claude/worktrees/agent-a5b87d75/scripts/cleanup.js

@@ -0,0 +1,251 @@
+// ============================================================================
+// Shared cleanup function used by both:
+//   1. npm preuninstall hook (scripts/preuninstall.js)
+//   2. `a2a uninstall` CLI command (bin/cli.js)
+//
+// Reads .a2a-manifest.json to determine which files to remove.
+// CLAUDE.md section removal uses the same boundary markers as the
+// merge logic in installSkills() — "# A2A Calling" start marker
+// and "<!-- END A2A CALLING SECTION -->" end marker.
+//
+// Returns { removed: string[], preserved: string[], errors: string[] }
+// so callers can print a meaningful summary.
+// ============================================================================
+
+const fs = require('fs');
+const path = require('path');
+
+// These markers must match the ones used in install-skills.js merge logic.
+// If they diverge, cleanup will fail to find the section boundaries.
+const A2A_SECTION_START = '# A2A Calling';
+const A2A_SECTION_END = '<!-- END A2A CALLING SECTION -->';
+
+/**
+ * cleanupProjectFiles — manifest-driven removal of all postinstall artifacts
+ *
+ * Reads .a2a-manifest.json from targetDir, then removes every file listed in
+ * the manifest. CLAUDE.md gets special handling: only the A2A section is
+ * removed, preserving any user content before/after. Empty directories
+ * (.claude/commands/, .claude/) are cleaned up if no non-a2a files remain.
+ *
+ * @param {string} targetDir - The project directory containing .a2a-manifest.json
+ * @returns {{ removed: string[], preserved: string[], errors: string[] }}
+ */
+function cleanupProjectFiles(targetDir) {
+  const result = { removed: [], preserved: [], errors: [] };
+  const manifestPath = path.join(targetDir, '.a2a-manifest.json');
+
+  // If manifest doesn't exist, skip cleanup gracefully.
+  // This happens for manual installs, old versions, or projects where the
+  // manifest was already cleaned up. Better to leave files than crash.
+  if (!fs.existsSync(manifestPath)) {
+    return result;
+  }
+
+  let manifest;
+  try {
+    manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  } catch (err) {
+    // Corrupt or unreadable manifest — can't determine what to clean up.
+    // Return gracefully so npm uninstall doesn't fail.
+    result.errors.push(`.a2a-manifest.json: could not parse (${err.message})`);
+    return result;
+  }
+
+  const files = manifest.files || [];
+
+  for (const entry of files) {
+    // Skip the manifest itself — we remove it last, after all other files
+    if (entry.path === '.a2a-manifest.json') continue;
+
+    const filePath = path.join(targetDir, entry.path);
+
+    // If a file listed in manifest doesn't exist on disk, skip it silently.
+    // This handles cases where the user manually deleted files, or a previous
+    // partial cleanup already removed some files.
+    if (!fs.existsSync(filePath)) continue;
+
+    // ── CLAUDE.md: section removal, not whole-file deletion ──────────────
+    //
+    // The user may have their own project-specific content in CLAUDE.md.
+    // We only remove the A2A section (bounded by start/end markers), leaving
+    // everything else intact.
+    if (entry.path === 'CLAUDE.md') {
+      try {
+        const cleaned = removeA2ASectionFromClaudeMd(filePath);
+        if (cleaned === 'deleted') {
+          result.removed.push('CLAUDE.md (was A2A-only, deleted entirely)');
+        } else if (cleaned === 'trimmed') {
+          result.preserved.push('CLAUDE.md (A2A section removed, user content preserved)');
+        } else {
+          // 'no-section' — CLAUDE.md exists but has no A2A section.
+          // This shouldn't happen if the manifest says it was installed, but
+          // could occur if the user manually edited it. Leave it alone.
+          result.preserved.push('CLAUDE.md (no A2A section found, left unchanged)');
+        }
+      } catch (err) {
+        result.errors.push(`CLAUDE.md: ${err.message}`);
+      }
+      continue;
+    }
+
+    // ── All other files: delete entirely ─────────────────────────────────
+    try {
+      fs.rmSync(filePath, { force: true });
+      result.removed.push(entry.path);
+    } catch (err) {
+      // If file permissions prevent deletion, log warning and continue.
+      // We don't want a single permission error to abort the entire cleanup.
+      result.errors.push(`${entry.path}: ${err.message}`);
+    }
+  }
+
+  // ── Empty directory cleanup ──────────────────────────────────────────────
+  //
+  // After removing .claude/commands/a2a-*.md and .claude/a2a-skill-reference.md,
+  // the directories may be empty. We clean them up to avoid leaving empty dirs,
+  // but ONLY if they contain no non-a2a files (user's own commands, settings, etc.).
+  cleanupEmptyDir(path.join(targetDir, '.claude', 'commands'), result);
+  cleanupEmptyDir(path.join(targetDir, '.claude'), result);
+  cleanupEmptyDir(path.join(targetDir, '.codex'), result);
+
+  // ── Remove the install log ───────────────────────────────────────────────
+  //
+  // .a2a-install.log is written by postinstall.js as a convenience log.
+  // It's listed in the manifest but we also try to remove it explicitly
+  // in case the manifest entry was missing (belt and suspenders).
+  const logPath = path.join(targetDir, '.a2a-install.log');
+  if (fs.existsSync(logPath)) {
+    try {
+      fs.rmSync(logPath, { force: true });
+      // Only add to removed list if not already tracked from manifest iteration
+      if (!result.removed.includes('.a2a-install.log')) {
+        result.removed.push('.a2a-install.log');
+      }
+    } catch (err) {
+      result.errors.push(`.a2a-install.log: ${err.message}`);
+    }
+  }
+
+  // ── Remove the manifest itself last ──────────────────────────────────────
+  //
+  // The manifest is the cleanup driver, so we remove it after everything else.
+  // If this fails, the manifest is left behind — which is acceptable since
+  // a stale manifest is harmless and helps debug failed cleanups.
+  try {
+    fs.rmSync(manifestPath, { force: true });
+    result.removed.push('.a2a-manifest.json');
+  } catch (err) {
+    result.errors.push(`.a2a-manifest.json: ${err.message}`);
+  }
+
+  return result;
+}
+
+/**
+ * removeA2ASectionFromClaudeMd — surgically removes the A2A section from CLAUDE.md
+ *
+ * Three outcomes:
+ *   - 'deleted'    : File was entirely A2A content, deleted the file
+ *   - 'trimmed'    : A2A section removed, remaining user content preserved
+ *   - 'no-section' : No A2A section found (file left unchanged)
+ *
+ * Edge case: CLAUDE.md becomes empty after A2A section removal.
+ * If the only content was the A2A section, the file would be left as
+ * whitespace-only, which is confusing. Delete it entirely instead.
+ *
+ * Edge case: Legacy installs without end marker.
+ * Pre-A2A-34 installs wrote the A2A section without the
+ * <!-- END A2A CALLING SECTION --> marker. For these, we fall back
+ * to removing from "# A2A Calling" to EOF, same as the old merge
+ * replacement behavior. This means any user content added after the
+ * A2A section in a legacy install will be lost — but this is the
+ * same behavior they already had on upgrade, so it's not a regression.
+ */
+function removeA2ASectionFromClaudeMd(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+
+  // If the A2A section start marker isn't present, nothing to remove
+  if (!content.includes(A2A_SECTION_START)) {
+    return 'no-section';
+  }
+
+  const sectionStart = content.indexOf(A2A_SECTION_START);
+  const endMarkerIndex = content.indexOf(A2A_SECTION_END, sectionStart);
+
+  let before, after;
+
+  if (endMarkerIndex !== -1) {
+    // End marker found — extract content before and after the bounded section.
+    // trimEnd/trimStart collapse the whitespace gap left by the removed section.
+    const sectionEnd = endMarkerIndex + A2A_SECTION_END.length;
+    before = content.slice(0, sectionStart).trimEnd();
+    after = content.slice(sectionEnd).trimStart();
+  } else {
+    // Legacy install without end marker — remove from header to EOF.
+    // Everything after "# A2A Calling" is considered part of the A2A section.
+    before = content.slice(0, sectionStart).trimEnd();
+    after = '';
+  }
+
+  // Reassemble the file from the non-A2A portions
+  let cleaned;
+  if (before && after) {
+    // Content exists both before and after — join with double newline
+    cleaned = before + '\n\n' + after;
+  } else if (before) {
+    cleaned = before;
+  } else if (after) {
+    cleaned = after;
+  } else {
+    cleaned = '';
+  }
+
+  // Collapse any triple+ blank lines into double blank lines.
+  // This prevents ugly whitespace gaps where the A2A section used to be.
+  cleaned = cleaned.replace(/\n{3,}/g, '\n\n');
+
+  // Edge case: CLAUDE.md becomes empty after A2A section removal.
+  // If the only content was the A2A section, the file would be left as
+  // whitespace-only, which is confusing. Delete it entirely instead.
+  if (!cleaned.trim()) {
+    fs.rmSync(filePath, { force: true });
+    return 'deleted';
+  }
+
+  // Write the cleaned content back, ensuring the file ends with a newline
+  fs.writeFileSync(filePath, cleaned.trimEnd() + '\n');
+  return 'trimmed';
+}
+
+/**
+ * cleanupEmptyDir — removes a directory if it exists and contains no files.
+ *
+ * After removing A2A skill files, directories like .claude/commands/ may be
+ * empty. We remove them to avoid clutter, but ONLY if no user files remain.
+ * This prevents accidentally deleting directories that contain the user's
+ * own Claude Code commands or settings.
+ */
+function cleanupEmptyDir(dirPath, result) {
+  try {
+    if (!fs.existsSync(dirPath)) return;
+
+    // Check if directory stat confirms it's actually a directory
+    const stat = fs.statSync(dirPath);
+    if (!stat.isDirectory()) return;
+
+    const entries = fs.readdirSync(dirPath);
+
+    // Only remove if the directory is completely empty.
+    // Any remaining files (user's own commands, .gitkeep, etc.) mean we keep it.
+    if (entries.length === 0) {
+      fs.rmdirSync(dirPath);
+      result.removed.push(dirPath.split(path.sep).slice(-2).join('/') + '/ (empty directory)');
+    }
+  } catch (err) {
+    // Directory cleanup is best-effort. Failures here are non-fatal —
+    // an empty directory is harmless, just slightly untidy.
+  }
+}
+
+module.exports = { cleanupProjectFiles };

package/.claude/worktrees/agent-a5b87d75/scripts/generate-update-manifest.sh

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+# A2A-100: Generate Tauri updater manifest (latest.json) for GitHub Releases.
+# Usage: bash scripts/generate-update-manifest.sh <version> <signature_file> [notes]
+
+set -euo pipefail
+
+VERSION="${1:?Usage: generate-update-manifest.sh <version> <sig_file> [notes]}"
+SIG_FILE="${2:?Signature file path required}"
+NOTES="${3:-Release v${VERSION}}"
+
+REPO="onthegonow/a2a_calling"
+TAR_NAME="A2A-Callbook-${VERSION}.app.tar.gz"
+URL="https://github.com/${REPO}/releases/download/v${VERSION}/${TAR_NAME}"
+
+if [ ! -f "${SIG_FILE}" ]; then
+  echo "Signature file not found: ${SIG_FILE}" >&2
+  exit 1
+fi
+
+SIGNATURE=$(cat "${SIG_FILE}")
+
+cat <<EOF
+{
+  "version": "${VERSION}",
+  "notes": "${NOTES}",
+  "pub_date": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
+  "platforms": {
+    "darwin-universal": {
+      "signature": "${SIGNATURE}",
+      "url": "${URL}"
+    },
+    "darwin-aarch64": {
+      "signature": "${SIGNATURE}",
+      "url": "${URL}"
+    },
+    "darwin-x86_64": {
+      "signature": "${SIGNATURE}",
+      "url": "${URL}"
+    }
+  }
+}
+EOF