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/resolve-openclaw-delivery-target.mjs

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

import os from 'node:os';
import path from 'node:path';
import process from 'node:process';
import { readFile } from 'node:fs/promises';

const DEFAULT_SESSIONS_PATH = path.join(
  os.homedir(),
  '.openclaw',
  'agents',
  'main',
  'sessions',
  'sessions.json',
);
const DEFAULT_TELEGRAM_ALLOW_FROM_PATH = path.join(
  os.homedir(),
  '.openclaw',
  'credentials',
  'telegram-default-allowFrom.json',
);

function printHelp() {
  console.log(`Usage: resolve-openclaw-delivery-target.mjs [options]

Options:
  --sessions-path <path>     Override OpenClaw sessions.json path
  --allow-from-path <path>   Override telegram allowFrom path
  --field <name>             Print one field: channel|to|account-id|session-key|source
  --json                     Print the full resolved target as JSON
  --help                     Show this message
`);
}

function parseArgValue(argv, index, current, label) {
  if (current.includes('=')) {
    return current.slice(current.indexOf('=') + 1);
  }
  const next = argv[index + 1];
  if (!next || next.startsWith('--')) {
    throw new Error(`${label} requires a value`);
  }
  return next;
}

async function readJsonIfPresent(filePath) {
  try {
    return JSON.parse(await readFile(filePath, 'utf8'));
  } catch (error) {
    if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
      return null;
    }
    if (error instanceof SyntaxError) {
      throw new Error(`invalid JSON at ${filePath}`);
    }
    throw error;
  }
}

export function normalizeDeliveryTo(value) {
  const text = String(value ?? '').trim();
  if (!text) {
    return null;
  }
  if (text.startsWith('telegram:')) {
    const normalized = text.slice('telegram:'.length).trim();
    return normalized || null;
  }
  return text;
}

export function normalizeChannel(value) {
  const text = String(value ?? '').trim().toLowerCase();
  return text || null;
}

export function normalizeDeliveryToForChannel(value, channel) {
  const text = String(value ?? '').trim();
  if (!text) {
    return null;
  }
  const normalizedChannel = normalizeChannel(channel);
  if (normalizedChannel && text.toLowerCase().startsWith(`${normalizedChannel}:`)) {
    const normalized = text.slice(normalizedChannel.length + 1).trim();
    return normalized || null;
  }
  return normalizeDeliveryTo(text);
}

function numericTimestamp(value) {
  if (typeof value === 'number' && Number.isFinite(value)) {
    return value;
  }
  if (typeof value === 'string' && value.trim()) {
    const asNumber = Number(value);
    if (Number.isFinite(asNumber)) {
      return asNumber;
    }
    const asDate = Date.parse(value);
    if (Number.isFinite(asDate)) {
      return asDate;
    }
  }
  return 0;
}

export function collectDirectSessionCandidates(input) {
  if (!input || typeof input !== 'object') {
    return [];
  }

  const candidates = [];
  for (const [sessionKey, session] of Object.entries(input)) {
    if (!session || typeof session !== 'object') {
      continue;
    }

    const origin = session.origin ?? {};
    const deliveryContext = session.deliveryContext ?? {};
    const channel = normalizeChannel(
      deliveryContext.channel ?? origin.provider ?? origin.surface ?? session.lastChannel ?? null,
    );
    const direct = session.chatType === 'direct' || origin.chatType === 'direct' || sessionKey.includes(':direct:');
    if (!channel || !direct) {
      continue;
    }

    const to = normalizeDeliveryToForChannel(
      deliveryContext.to ?? session.lastTo ?? origin.to ?? origin.from ?? sessionKey.split(':').at(-1) ?? null,
      channel,
    );
    if (!to) {
      continue;
    }

    candidates.push({
      accountId:
        typeof deliveryContext.accountId === 'string' && deliveryContext.accountId.trim()
          ? deliveryContext.accountId.trim()
          : typeof session.lastAccountId === 'string' && session.lastAccountId.trim()
            ? session.lastAccountId.trim()
            : typeof origin.accountId === 'string' && origin.accountId.trim()
            ? origin.accountId.trim()
            : null,
      channel,
      sessionKey,
      source: 'sessions',
      to,
      updatedAt: numericTimestamp(session.updatedAt),
    });
  }

  candidates.sort((left, right) => right.updatedAt - left.updatedAt);
  return candidates;
}

export function collectTelegramSessionCandidates(input) {
  return collectDirectSessionCandidates(input).filter((candidate) => candidate.channel === 'telegram');
}

export function resolveTelegramAllowFromTarget(input) {
  const allowFrom = Array.isArray(input?.allowFrom) ? input.allowFrom : [];
  const first = normalizeDeliveryTo(allowFrom[0] ?? null);
  if (!first) {
    return null;
  }
  return {
    accountId: null,
    channel: 'telegram',
    sessionKey: null,
    source: 'allow_from',
    to: first,
    updatedAt: 0,
  };
}

export function resolveDeliveryTarget({ sessions, telegramAllowFrom }) {
  const sessionTarget = collectDirectSessionCandidates(sessions)[0] ?? null;
  if (sessionTarget) {
    return sessionTarget;
  }
  return resolveTelegramAllowFromTarget(telegramAllowFrom);
}

function parseOptions(argv) {
  const options = {
    allowFromPath: DEFAULT_TELEGRAM_ALLOW_FROM_PATH,
    field: null,
    json: false,
    sessionsPath: DEFAULT_SESSIONS_PATH,
  };

  for (let index = 0; index < argv.length; index += 1) {
    const arg = argv[index];
    if (arg === '--help') {
      printHelp();
      process.exit(0);
    }
    if (arg.startsWith('--sessions-path')) {
      options.sessionsPath = parseArgValue(argv, index, arg, '--sessions-path').trim();
      if (!arg.includes('=')) {
        index += 1;
      }
      continue;
    }
    if (arg.startsWith('--allow-from-path')) {
      options.allowFromPath = parseArgValue(argv, index, arg, '--allow-from-path').trim();
      if (!arg.includes('=')) {
        index += 1;
      }
      continue;
    }
    if (arg.startsWith('--field')) {
      options.field = parseArgValue(argv, index, arg, '--field').trim();
      if (!arg.includes('=')) {
        index += 1;
      }
      continue;
    }
    if (arg === '--json') {
      options.json = true;
      continue;
    }
    throw new Error(`unknown option: ${arg}`);
  }

  if (options.field && !new Set(['channel', 'to', 'account-id', 'session-key', 'source']).has(options.field)) {
    throw new Error('--field must be one of: channel, to, account-id, session-key, source');
  }

  return options;
}

async function main() {
  const options = parseOptions(process.argv.slice(2));
  const sessions = await readJsonIfPresent(options.sessionsPath);
  const telegramAllowFrom = await readJsonIfPresent(options.allowFromPath);
  const resolved = resolveDeliveryTarget({ sessions, telegramAllowFrom });

  if (!resolved) {
    process.exit(2);
  }

  if (options.json) {
    process.stdout.write(`${JSON.stringify(resolved, null, 2)}\n`);
    return;
  }

  if (options.field === 'to') {
    process.stdout.write(`${resolved.to}\n`);
    return;
  }
  if (options.field === 'channel') {
    if (resolved.channel) {
      process.stdout.write(`${resolved.channel}\n`);
    }
    return;
  }
  if (options.field === 'account-id') {
    if (resolved.accountId) {
      process.stdout.write(`${resolved.accountId}\n`);
    }
    return;
  }
  if (options.field === 'session-key') {
    if (resolved.sessionKey) {
      process.stdout.write(`${resolved.sessionKey}\n`);
    }
    return;
  }
  if (options.field === 'source') {
    process.stdout.write(`${resolved.source}\n`);
    return;
  }

  process.stdout.write(`${resolved.to}\n`);
}

if (import.meta.url === `file://${process.argv[1]}`) {
  main().catch((error) => {
    console.error(error instanceof Error ? error.message : String(error));
    process.exit(1);
  });
}
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: 322kUpdated Claude CodeCodexVerifiedInstall
requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirementsStars: 322kUpdated 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: 322kUpdated 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: 322kUpdated Claude CodeCodexVerifiedInstall