Skip to content

LeoYeAI/agent-master-skills / skills/aquaclaw-openclaw-bridge

aquaclaw-openclaw-bridge

Unverified

Use when OpenClaw needs to join a hosted Aqua from URL + invite code, read mirror-backed or live Aqua state, inspect runtime status, or run local/hosted Aqua join, context, pulse, mirror, heartbeat, and diary-digest flows.

FileKindSize
README.mdmarkdown9.9 KB
SKILL.mdskill md24.4 KB
_meta.jsonconfig304 B
agents/openai.yamlconfig2.7 KB
references/MEMORY.example.mdmarkdown617 B
references/TOOLS.example.mdmarkdown7.2 KB
references/beginner-install-connect-switch.mdmarkdown7.8 KB
references/bridge-workflow.mdmarkdown17.5 KB
references/clawhub-release.mdmarkdown3.4 KB
references/command-reference.mdmarkdown14.5 KB
references/doc-map.mdmarkdown4.2 KB
references/hosted-profile-plan.mdmarkdown10.2 KB
references/mirror-memory-boundary.mdmarkdown2.2 KB
references/mirror-pressure-envelope.mdmarkdown3.8 KB
references/mirror-service.mdmarkdown3.5 KB
references/openclaw-cron-template.mdmarkdown1.9 KB
references/public-install.mdmarkdown11.7 KB
references/runtime-heartbeat-service.mdmarkdown2.7 KB
scripts/README.mdmarkdown2.7 KB
scripts/aqua-context.shscript199 B
scripts/aqua-daily-intent.mjsscript57.1 KB
scripts/aqua-daily-intent.shscript151 B
scripts/aqua-hosted-context.mjsscript11.1 KB
scripts/aqua-hosted-context.shscript153 B
scripts/aqua-hosted-direct-message.mjsscript8.8 KB
scripts/aqua-hosted-direct-message.shscript161 B
scripts/aqua-hosted-intro.mjsscript13.8 KB
scripts/aqua-hosted-intro.shscript151 B
scripts/aqua-hosted-join.mjsscript13.5 KB
scripts/aqua-hosted-join.shscript150 B
scripts/aqua-hosted-profile.mjsscript19.8 KB
scripts/aqua-hosted-profile.shscript153 B
scripts/aqua-hosted-public-expression.mjsscript7.6 KB
scripts/aqua-hosted-public-expression.shscript163 B
scripts/aqua-hosted-pulse-loop.mjsscript17.6 KB
scripts/aqua-hosted-pulse-service-common.shscript10.1 KB
scripts/aqua-hosted-pulse.mjsscript115.2 KB
scripts/aqua-hosted-pulse.shscript151 B
scripts/aqua-hosted-relationship.mjsscript15.4 KB
scripts/aqua-hosted-relationship.shscript159 B
scripts/aqua-launch.shscript199 B
scripts/aqua-life-loop-read.mjsscript27.8 KB
scripts/aqua-life-loop-read.shscript154 B
scripts/aqua-life-loop-writeback.mjsscript18.0 KB
scripts/aqua-local-profile.mjsscript11.6 KB
scripts/aqua-local-profile.shscript147 B
scripts/aqua-mirror-common.mjsscript17.2 KB
scripts/aqua-mirror-daily-digest.mjsscript24.0 KB
scripts/aqua-mirror-daily-digest.shscript153 B
scripts/aqua-mirror-envelope.mjsscript24.4 KB
scripts/aqua-mirror-envelope.shscript154 B
scripts/aqua-mirror-memory-synthesis.mjsscript26.5 KB
scripts/aqua-mirror-memory-synthesis.shscript157 B
scripts/aqua-mirror-read.mjsscript24.4 KB
scripts/aqua-mirror-read.shscript150 B
scripts/aqua-mirror-service-common.shscript6.7 KB
scripts/aqua-mirror-status.mjsscript14.6 KB
scripts/aqua-mirror-status.shscript152 B
scripts/aqua-mirror-sync.mjsscript35.2 KB
scripts/aqua-mirror-sync.shscript150 B
scripts/aqua-profile.mjsscript19.8 KB
scripts/aqua-profile.shscript146 B
scripts/aqua-pulse.shscript197 B
scripts/aqua-runtime-heartbeat-service-common.shscript4.9 KB
scripts/aqua-runtime-heartbeat.mjsscript19.4 KB
scripts/aqua-runtime-heartbeat.shscript156 B
scripts/aqua-sea-diary-context.mjsscript33.0 KB
scripts/aqua-sea-diary-context.shscript151 B
scripts/aquaclaw-tools-md.mjsscript19.2 KB
scripts/build-openclaw-aqua-brief.shscript9.6 KB
scripts/community-memory-common.mjsscript14.8 KB
scripts/community-memory-read.mjsscript10.3 KB
scripts/community-memory-read.shscript156 B
scripts/community-memory-retrieval.mjsscript13.4 KB
scripts/community-memory-sync.mjsscript8.1 KB
scripts/community-memory-sync.shscript156 B
scripts/disable-aquaclaw-hosted-pulse-service.shscript1.5 KB
scripts/disable-aquaclaw-mirror-service.shscript1.5 KB
scripts/disable-aquaclaw-runtime-heartbeat-service.shscript1.5 KB
scripts/disable-openclaw-diary-cron.shscript1.0 KB
scripts/disable-openclaw-heartbeat-cron.shscript1.0 KB
scripts/disable-openclaw-pulse-cron.shscript1.0 KB
scripts/ensure-aquaclaw-community-agent.mjsscript8.9 KB
scripts/ensure-aquaclaw-community-agent.shscript165 B
scripts/env-readers.mjsscript1.3 KB
scripts/find-aquaclaw-repo.shscript835 B
scripts/hosted-aqua-common.mjsscript24.2 KB
scripts/hosted-aqua-http.mjsscript1.6 KB
scripts/install-aquaclaw-hosted-pulse-service.shscript10.4 KB
scripts/install-aquaclaw-mirror-service.shscript5.7 KB
scripts/install-aquaclaw-runtime-heartbeat-service.shscript4.6 KB
scripts/install-openclaw-diary-cron.shscript5.9 KB
scripts/install-openclaw-heartbeat-cron.shscript5.8 KB
scripts/install-openclaw-pulse-cron.shscript3.7 KB
scripts/openclaw-cron-common.shscript6.1 KB
scripts/openclaw-cron-job-find.mjsscript1.9 KB
scripts/openclaw-diary-cron-common.shscript3.0 KB
scripts/openclaw-heartbeat-cron-common.shscript1.2 KB
scripts/path-access.mjsscript199 B
scripts/remove-aquaclaw-hosted-pulse-service.shscript1.8 KB
scripts/remove-aquaclaw-mirror-service.shscript1.8 KB
scripts/remove-aquaclaw-runtime-heartbeat-service.shscript1.8 KB
scripts/remove-openclaw-diary-cron.shscript1.0 KB
scripts/remove-openclaw-heartbeat-cron.shscript1.0 KB
scripts/remove-openclaw-pulse-cron.shscript1.0 KB
scripts/resolve-aquaclaw-paths.mjsscript4.9 KB
scripts/resolve-openclaw-delivery-target.mjsscript7.6 KB
scripts/resolve-openclaw-user-timezone.mjsscript4.0 KB
scripts/show-aquaclaw-hosted-pulse-service.shscript6.0 KB
scripts/show-aquaclaw-mirror-service.shscript4.7 KB
scripts/show-aquaclaw-runtime-heartbeat-service.shscript2.7 KB
scripts/show-openclaw-diary-cron.shscript2.2 KB
scripts/show-openclaw-heartbeat-cron.shscript1.7 KB
scripts/show-openclaw-pulse-cron.shscript1.1 KB
scripts/soul-personality.mjsscript16.4 KB
scripts/sync-aquaclaw-tools-md.mjsscript3.8 KB
scripts/sync-aquaclaw-tools-md.shscript156 B

scripts/ensure-aquaclaw-community-agent.mjs

View on GitHub
#!/usr/bin/env node

import { execFile } from 'node:child_process';
import path from 'node:path';
import process from 'node:process';
import { promisify } from 'node:util';
import { fileURLToPath } from 'node:url';

import {
  HostedPulseAuthoringError,
  ensureCommunityVoiceGuide,
  resolveOpenClawBinary,
  syncCommunityAgentWorkspace,
} from './aqua-hosted-pulse.mjs';
import { parseArgValue, resolveWorkspaceRoot } from './hosted-aqua-common.mjs';

const execFileAsync = promisify(execFile);
const DEFAULT_AGENT_ID = 'community';

function printHelp() {
  console.log(`Usage: ensure-aquaclaw-community-agent.mjs [options]

Ensure the hosted Aqua community authoring agent exists and points at this workspace's derived community lane.

Options:
  --workspace-root <path>    OpenClaw workspace root
  --openclaw-bin <path>      Explicit openclaw binary
  --agent-id <id>            Agent id to provision (default: ${DEFAULT_AGENT_ID})
  --model <id>               Optional model to set when creating the agent
  --replace                  Replace an existing mismatched agent with the same id
  --json                     Output JSON summary
  --help                     Show this message
`);
}

function trimToNull(value) {
  if (typeof value !== 'string') {
    return null;
  }
  const trimmed = value.trim();
  return trimmed ? trimmed : null;
}

function normalizePathForComparison(filePath) {
  return path.resolve(filePath);
}

function parseOptions(argv) {
  const options = {
    agentId: trimToNull(process.env.AQUACLAW_HOSTED_PULSE_COMMUNITY_AGENT_ID) ?? DEFAULT_AGENT_ID,
    format: 'text',
    model: trimToNull(process.env.AQUACLAW_HOSTED_PULSE_COMMUNITY_MODEL),
    openclawBin: trimToNull(process.env.OPENCLAW_BIN),
    replace: false,
    workspaceRoot: resolveWorkspaceRoot(process.env.OPENCLAW_WORKSPACE_ROOT),
  };

  for (let index = 0; index < argv.length; index += 1) {
    const arg = argv[index];

    if (arg === '--help') {
      printHelp();
      process.exit(0);
    }
    if (arg === '--replace') {
      options.replace = true;
      continue;
    }
    if (arg === '--json') {
      options.format = 'json';
      continue;
    }
    if (arg.startsWith('--workspace-root')) {
      options.workspaceRoot = resolveWorkspaceRoot(parseArgValue(argv, index, arg, '--workspace-root'));
      if (!arg.includes('=')) {
        index += 1;
      }
      continue;
    }
    if (arg.startsWith('--openclaw-bin')) {
      options.openclawBin = parseArgValue(argv, index, arg, '--openclaw-bin').trim();
      if (!arg.includes('=')) {
        index += 1;
      }
      continue;
    }
    if (arg.startsWith('--agent-id')) {
      options.agentId = parseArgValue(argv, index, arg, '--agent-id').trim();
      if (!arg.includes('=')) {
        index += 1;
      }
      continue;
    }
    if (arg.startsWith('--model')) {
      options.model = parseArgValue(argv, index, arg, '--model').trim();
      if (!arg.includes('=')) {
        index += 1;
      }
      continue;
    }

    throw new Error(`unknown option: ${arg}`);
  }

  if (!options.agentId) {
    throw new Error('--agent-id must not be empty');
  }

  return options;
}

async function listOpenClawAgents({ openclawBin, workspaceRoot, env }) {
  const { stdout } = await execFileAsync(openclawBin, ['agents', 'list', '--json'], {
    cwd: workspaceRoot,
    env,
    maxBuffer: 1024 * 1024,
  });
  const agents = JSON.parse(stdout);
  if (!Array.isArray(agents)) {
    throw new Error('openclaw agents list returned non-array JSON');
  }
  return agents;
}

async function addOpenClawAgent({ openclawBin, workspaceRoot, agentId, communityWorkspace, model, env }) {
  const args = ['agents', 'add', agentId, '--workspace', communityWorkspace, '--non-interactive', '--json'];
  if (model) {
    args.push('--model', model);
  }
  await execFileAsync(openclawBin, args, {
    cwd: workspaceRoot,
    env,
    maxBuffer: 1024 * 1024,
  });
}

async function deleteOpenClawAgent({ openclawBin, workspaceRoot, agentId, env }) {
  await execFileAsync(openclawBin, ['agents', 'delete', agentId, '--force', '--json'], {
    cwd: workspaceRoot,
    env,
    maxBuffer: 1024 * 1024,
  });
}

async function syncOpenClawAgentIdentity({ openclawBin, workspaceRoot, agentId, communityWorkspace, env }) {
  await execFileAsync(
    openclawBin,
    ['agents', 'set-identity', '--agent', agentId, '--workspace', communityWorkspace, '--from-identity', '--json'],
    {
      cwd: workspaceRoot,
      env,
      maxBuffer: 1024 * 1024,
    },
  );
}

function renderText(result) {
  const lines = [
    `ready: ${result.ready ? 'yes' : 'no'}`,
    `agent: ${result.agentId}`,
    `action: ${result.action ?? 'failed'}`,
    result.openclawBin ? `openclaw bin: ${result.openclawBin}${result.openclawBinSource ? ` [${result.openclawBinSource}]` : ''}` : null,
    result.communityWorkspace ? `community workspace: ${result.communityWorkspace}` : null,
    result.workspaceRoot ? `workspace root: ${result.workspaceRoot}` : null,
    result.errorCode ? `error code: ${result.errorCode}` : null,
    result.errorMessage ? `error: ${result.errorMessage}` : null,
  ].filter(Boolean);

  if (Array.isArray(result.warnings) && result.warnings.length > 0) {
    lines.push(`warnings: ${result.warnings.join(' | ')}`);
  }
  return lines.join('\n');
}

async function ensureCommunityAgent(options) {
  const env = {
    ...process.env,
    ...(options.openclawBin ? { OPENCLAW_BIN: options.openclawBin } : {}),
  };
  const binary = await resolveOpenClawBinary({ env });
  const communityVoiceGuide = await ensureCommunityVoiceGuide({
    workspaceRoot: options.workspaceRoot,
  });
  const communityWorkspace = await syncCommunityAgentWorkspace({
    workspaceRoot: options.workspaceRoot,
    communityVoiceGuide,
  });
  const agents = await listOpenClawAgents({
    openclawBin: binary.binPath,
    workspaceRoot: options.workspaceRoot,
    env,
  });

  const existing = agents.find((item) => item?.id === options.agentId) ?? null;
  let action = 'validated';
  const warnings = [];

  if (existing) {
    const actualWorkspace = trimToNull(existing.workspace);
    const matches =
      actualWorkspace !== null &&
      normalizePathForComparison(actualWorkspace) === normalizePathForComparison(communityWorkspace);
    if (!matches) {
      if (!options.replace) {
        throw new HostedPulseAuthoringError(
          'community_agent_workspace_mismatch',
          `agent ${options.agentId} already exists at ${actualWorkspace ?? 'an unknown workspace'} instead of ${communityWorkspace}`,
          {
            agentId: options.agentId,
            openclawBin: binary.binPath,
            openclawBinSource: binary.source,
          },
        );
      }
      await deleteOpenClawAgent({
        openclawBin: binary.binPath,
        workspaceRoot: options.workspaceRoot,
        agentId: options.agentId,
        env,
      });
      await addOpenClawAgent({
        openclawBin: binary.binPath,
        workspaceRoot: options.workspaceRoot,
        agentId: options.agentId,
        communityWorkspace,
        model: options.model,
        env,
      });
      action = 'replaced';
      warnings.push(`replaced mismatched agent ${options.agentId}`);
    }
  } else {
    await addOpenClawAgent({
      openclawBin: binary.binPath,
      workspaceRoot: options.workspaceRoot,
      agentId: options.agentId,
      communityWorkspace,
      model: options.model,
      env,
    });
    action = 'created';
  }

  await syncOpenClawAgentIdentity({
    openclawBin: binary.binPath,
    workspaceRoot: options.workspaceRoot,
    agentId: options.agentId,
    communityWorkspace,
    env,
  });

  return {
    ready: true,
    action,
    agentId: options.agentId,
    communityWorkspace,
    openclawBin: binary.binPath,
    openclawBinSource: binary.source,
    warnings,
    workspaceRoot: options.workspaceRoot,
  };
}

async function main() {
  const options = parseOptions(process.argv.slice(2));
  try {
    const result = await ensureCommunityAgent(options);
    if (options.format === 'json') {
      console.log(JSON.stringify(result, null, 2));
      return;
    }
    console.log(renderText(result));
  } catch (error) {
    const result = {
      ready: false,
      action: null,
      agentId: options.agentId,
      communityWorkspace: path.resolve(options.workspaceRoot, '.openclaw', 'community-agent-workspace'),
      openclawBin: error?.details?.openclawBin ?? null,
      openclawBinSource: error?.details?.openclawBinSource ?? null,
      warnings: Array.isArray(error?.details?.warnings) ? error.details.warnings : [],
      workspaceRoot: options.workspaceRoot,
      errorCode: error instanceof HostedPulseAuthoringError ? error.code : 'community_agent_setup_failed',
      errorMessage: error instanceof Error ? error.message : String(error),
    };
    if (options.format === 'json') {
      console.log(JSON.stringify(result, null, 2));
    } else {
      console.error(renderText(result));
    }
    process.exit(1);
  }
}

const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);

if (isMain) {
  await main();
}
receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementationStars: 323kUpdated Claude CodeCodexVerifiedInstall
requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirementsStars: 323kUpdated Claude CodeCodexVerifiedInstall
using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallbackStars: 323kUpdated Claude CodeCodexVerifiedInstall
verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions alwaysStars: 323kUpdated Claude CodeCodexVerifiedInstall