ticlawk 0.1.12-dev.0

package/src/runtimes/openclaw/gateway.mjs

@@ -0,0 +1,269 @@
+/**
+ * OpenClaw Gateway WebSocket runtime state.
+ *
+ * Owns the single persistent gateway connection and the in-flight
+ * promise map used by `askGateway`. Module-level closures hold the
+ * state — the gateway is a singleton per ticlawk process, so there's
+ * no need for a class.
+ *
+ * Exported surface:
+ *   askGateway(text, agentId, opts)             — ask an agent, returns
+ *                                                  { text, mediaUrls }
+ *   registerOpenClawChannel({ channelId, ... }) — called after an
+ *                                                  OpenClaw binding is
+ *                                                  available; ensures
+ *                                                  the gateway connects
+ *                                                  on first call
+ * This module is runtime-only. It knows nothing about adapters or
+ * backend channel lookups; callers inject any event forwarding they need
+ * via `askGateway(..., { onEvent })`.
+ */
+
+import { WebSocket } from 'ws';
+import { createPrivateKey, randomUUID, sign } from 'node:crypto';
+import { GATEWAY_HOST, GATEWAY_PORT, loadOpenClawConfig } from './identity.mjs';
+import {
+  buildOpenClawSessionKey,
+  normalizeOpenClawAgentId,
+  describeGatewayRequestContext,
+} from './target.mjs';
+
+// ── Module-level closure state ──────────────────────────────────────────
+
+const openclawConfig = loadOpenClawConfig();
+let gw = null;
+let gwReady = false;
+const pendingRequests = new Map();
+let gatewayStarted = false;
+
+// ── Connection ──────────────────────────────────────────────────────────
+
+function connectGateway() {
+  const url = `ws://${GATEWAY_HOST}:${GATEWAY_PORT}`;
+  console.log(`[relay] connecting to Gateway at ${url}`);
+  gw = new WebSocket(url);
+
+  gw.on('open', () => {
+    console.log('[relay] WebSocket open, waiting for challenge...');
+  });
+
+  gw.on('message', (raw) => {
+    let msg;
+    try { msg = JSON.parse(raw.toString()); } catch { return; }
+
+    if (msg.type === 'event' && msg.event === 'connect.challenge' && !gwReady) {
+      const nonce = msg.payload?.nonce;
+      const { gatewayToken, deviceId, publicKey, privateKeyPem } = openclawConfig;
+      const scopes = ['operator.admin', 'operator.read', 'operator.write', 'operator.approvals', 'operator.pairing'];
+      const params = {
+        minProtocol: 3, maxProtocol: 3,
+        client: { id: 'cli', version: '2026.3.13', platform: 'linux', mode: 'cli' },
+        role: 'operator', scopes,
+        auth: { token: gatewayToken },
+        locale: 'en', userAgent: 'ticlawk/0.6',
+      };
+
+      if (deviceId && privateKeyPem) {
+        const privKey = createPrivateKey(privateKeyPem);
+        const signedAt = Date.now();
+        const payload = ['v2', deviceId, 'cli', 'cli', 'operator', scopes.join(','), String(signedAt), gatewayToken, nonce].join('|');
+        const signature = sign(null, Buffer.from(payload), privKey).toString('base64url');
+        params.device = { id: deviceId, publicKey, signature, signedAt, nonce };
+        console.log('[relay] sending signed connect...');
+      }
+
+      gw.send(JSON.stringify({ type: 'req', id: 'connect', method: 'connect', params }));
+      return;
+    }
+
+    handleGatewayMessage(msg);
+  });
+
+  gw.on('close', () => {
+    console.log('[relay] Gateway connection closed, reconnecting in 5s...');
+    gwReady = false;
+    setTimeout(connectGateway, 5000);
+  });
+
+  gw.on('error', (err) => {
+    console.error('[relay] Gateway WebSocket error:', err.message);
+  });
+}
+
+function emitGatewayEvent(pending, event) {
+  if (!pending || typeof pending.onEvent !== 'function') return;
+  try {
+    pending.onEvent({
+      runId: pending.runId || null,
+      agentId: pending.agentId,
+      sessionKey: pending.sessionKey,
+      channelId: pending.channelId,
+      ...event,
+    });
+  } catch {}
+}
+
+function handleGatewayMessage(msg) {
+  if (msg.type === 'res' && msg.id === 'connect') {
+    if (msg.error) { console.error('[relay] connect failed:', msg.error); return; }
+    console.log('[relay] connected to Gateway ✓');
+    gwReady = true;
+    return;
+  }
+
+  if (msg.type === 'event' && msg.event === 'agent') {
+    const p = msg.payload || {};
+    const d = p.data || {};
+    const runId = p.runId;
+
+    let pending = null;
+    for (const [, req] of pendingRequests) {
+      if (req.runId === runId) { pending = req; break; }
+    }
+    if (!pending) return;
+
+    if (p.stream === 'assistant') {
+      if (typeof d.text === 'string') pending.buffer = d.text;
+      else if (typeof d.delta === 'string') pending.buffer += d.delta;
+    }
+
+    if (d.mediaUrl) pending.mediaUrls.add(d.mediaUrl);
+    if (Array.isArray(d.mediaUrls)) d.mediaUrls.forEach((u) => pending.mediaUrls.add(u));
+
+    if (p.stream === 'compaction') {
+      if (d.phase === 'start') {
+        emitGatewayEvent(pending, {
+          hook_event_name: 'agent.compaction.start',
+          phase: d.phase,
+        });
+      } else if (d.phase === 'end') {
+        emitGatewayEvent(pending, {
+          hook_event_name: 'agent.compaction.end',
+          willRetry: !!d.willRetry,
+          completed: !!d.completed,
+          phase: d.phase,
+        });
+      }
+    }
+
+    if (p.stream === 'lifecycle') {
+      // OpenClaw emits the human-readable error string in `data.error`
+      // (NOT `data.message`). Old protocol used `message` so we keep
+      // it as a fallback.
+      const phaseError = typeof d.error === 'string' ? d.error : (typeof d.message === 'string' ? d.message : '');
+      console.log(`[gateway] event lifecycle ${describeGatewayRequestContext(pending)} phase=${d.phase || 'unknown'} error=${JSON.stringify(phaseError)}`);
+      if (d.phase === 'start') {
+        emitGatewayEvent(pending, {
+          hook_event_name: 'agent.run.start',
+          startedAt: typeof d.startedAt === 'number' ? d.startedAt : null,
+          phase: d.phase,
+        });
+      } else if (d.phase === 'end') {
+        emitGatewayEvent(pending, {
+          hook_event_name: 'agent.run.end',
+          endedAt: typeof d.endedAt === 'number' ? d.endedAt : null,
+          durationMs: Date.now() - pending.startedAt,
+          messageLength: pending.buffer.length,
+          phase: d.phase,
+        });
+        pending.resolve({ text: pending.buffer, mediaUrls: [...pending.mediaUrls] });
+        pendingRequests.delete(pending.id);
+      } else if (d.phase === 'error') {
+        emitGatewayEvent(pending, {
+          hook_event_name: 'agent.run.error',
+          error: phaseError || 'agent error',
+          durationMs: Date.now() - pending.startedAt,
+          phase: d.phase,
+        });
+        const err = new Error(phaseError || 'agent error');
+        err.gatewayKind = 'agent-error';
+        pending.reject(err);
+        pendingRequests.delete(pending.id);
+      }
+    }
+  }
+}
+
+// ── Status ──────────────────────────────────────────────────────────────
+
+/** True iff the gateway WebSocket is connected and authenticated. */
+export function isGatewayReady() {
+  return gwReady;
+}
+
+// ── Ask / channel target resolution ─────────────────────────────────────
+
+export function askGateway(text, agentId = 'main', opts = {}) {
+  return new Promise((resolve, reject) => {
+    if (!gwReady || !gw) return reject(new Error('Gateway not connected'));
+
+    const normalizedAgentId = normalizeOpenClawAgentId(agentId);
+    const sessionKey = String(opts.sessionKey || buildOpenClawSessionKey(normalizedAgentId)).trim();
+    const id = randomUUID();
+    const pending = {
+      id,
+      channelId: normalizedAgentId,
+      agentId: normalizedAgentId,
+      sessionKey,
+      runId: null,
+      resolve,
+      reject,
+      buffer: '',
+      mediaUrls: new Set(),
+      startedAt: Date.now(),
+      onEvent: typeof opts.onEvent === 'function' ? opts.onEvent : null,
+    };
+    console.log(`[gateway] send agent request id=${id.slice(0, 8)} ${describeGatewayRequestContext(pending)}`);
+    gw.send(JSON.stringify({
+      type: 'req', id, method: 'agent',
+      params: {
+        message: text,
+        agentId: normalizedAgentId,
+        sessionKey,
+        deliver: false,
+        idempotencyKey: randomUUID(),
+      },
+    }));
+
+    pendingRequests.set(id, pending);
+
+    const onMsg = (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        if (msg.type === 'res' && msg.id === id) {
+          const req = pendingRequests.get(id);
+          if (req) req.runId = msg.result?.runId || msg.payload?.runId;
+          console.log(`[gateway] agent response id=${id.slice(0, 8)} ${describeGatewayRequestContext(req || pending)} ok=${msg.error ? 'false' : 'true'} error=${JSON.stringify(msg.error || '')}`);
+          gw.off('message', onMsg);
+        }
+      } catch { /* ignore */ }
+    };
+    gw.on('message', onMsg);
+
+    setTimeout(() => {
+      if (pendingRequests.has(id)) {
+        const req = pendingRequests.get(id);
+        pendingRequests.delete(id);
+        console.error(`[gateway] agent request timed out id=${id.slice(0, 8)} ${describeGatewayRequestContext(req || pending)} ageMs=${Date.now() - pending.startedAt}`);
+        const err = new Error('agent request timed out');
+        err.gatewayKind = 'timeout';
+        reject(err);
+      }
+    }, 5 * 60 * 1000);
+  });
+}
+
+// ── Registration (adapter setup + startup) ──────────────────────────────
+
+/**
+ * Register an OpenClaw channel and connect the gateway if this is the
+ * first OpenClaw binding in the current process.
+ */
+export function registerOpenClawChannel({ channelId, agentId }) {
+  if (!gatewayStarted) {
+    const normalizedAgentId = normalizeOpenClawAgentId(agentId || 'main');
+    console.log(`[gateway] registered OpenClaw binding ${channelId} agentId=${normalizedAgentId}, connecting gateway...`);
+    connectGateway();
+    gatewayStarted = true;
+  }
+}

package/src/runtimes/openclaw/identity.mjs

@@ -0,0 +1,34 @@
+/**
+ * OpenClaw Gateway connection config and device identity.
+ *
+ * Reads the user's local OpenClaw install (`~/.openclaw/openclaw.json`,
+ * `~/.openclaw/identity/device.json`) to recover the gateway token,
+ * deviceId, and the keypair used to sign the connect challenge.
+ */
+
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+
+export const GATEWAY_HOST = process.env.GATEWAY_HOST || '127.0.0.1';
+export const GATEWAY_PORT = process.env.GATEWAY_PORT || 18789;
+
+export function loadOpenClawConfig() {
+  try {
+    const configPath = `${homedir()}/.openclaw/openclaw.json`;
+    const config = JSON.parse(readFileSync(configPath, 'utf8'));
+    const identityPath = `${homedir()}/.openclaw/identity/device.json`;
+    const identity = JSON.parse(readFileSync(identityPath, 'utf8'));
+    return {
+      gatewayToken: config.gateway?.auth?.token || '',
+      deviceId: identity.deviceId,
+      publicKey: (() => {
+        const spki = identity.publicKeyPem?.match(/-----BEGIN PUBLIC KEY-----\n(.*?)\n-----END/s)?.[1]?.replace(/\n/g, '') || '';
+        const der = Buffer.from(spki, 'base64');
+        return der.length === 44 ? der.subarray(12).toString('base64url') : spki;
+      })(),
+      privateKeyPem: identity.privateKeyPem,
+    };
+  } catch {
+    return { gatewayToken: process.env.GATEWAY_TOKEN || '', deviceId: '', publicKey: '', privateKeyPem: '' };
+  }
+}

package/src/runtimes/openclaw/index.mjs

@@ -0,0 +1,228 @@
+import { normalizeOutboundMedia } from '../../core/media/outbound.mjs';
+import { reportSubprocessFailure, sendAdapterMessage, sendResult, terminalRuntimeFailure } from '../../core/runtime-support.mjs';
+import { GATEWAY_HOST, GATEWAY_PORT } from './identity.mjs';
+import { buildOpenClawSessionKey, normalizeOpenClawAgentId, resolveOpenClawWorkspace } from './target.mjs';
+import { askGateway, isGatewayReady, registerOpenClawChannel } from './gateway.mjs';
+import { addInFlight, recoverInFlightEntries, removeInFlight } from './inflight.mjs';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { extname } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+const EXT_TO_MIME = {
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.png': 'image/png',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.bmp': 'image/bmp',
+  '.tiff': 'image/tiff',
+  '.tif': 'image/tiff',
+  '.heic': 'image/heic',
+  '.heif': 'image/heif',
+};
+
+async function buildOpenClawImagePrompt(inbound) {
+  const mediaDir = '/tmp/openclaw/ticlawk-media';
+  mkdirSync(mediaDir, { recursive: true });
+  const successful = [];
+
+  for (const item of inbound.media || []) {
+    if (item.kind === 'local_path' && item.value && existsSync(item.value)) {
+      successful.push({
+        path: item.value,
+        mime: item.mime || EXT_TO_MIME[extname(item.value).toLowerCase()] || 'application/octet-stream',
+        source: item.value,
+      });
+      continue;
+    }
+    if (item.kind !== 'remote_url' || !item.value) continue;
+    const guessedExt = extname(item.value.split('?')[0] || '').toLowerCase() || '.jpg';
+    const localPath = `${mediaDir}/${randomUUID()}${guessedExt}`;
+    try {
+      const res = await fetch(item.value);
+      const buf = Buffer.from(await res.arrayBuffer());
+      writeFileSync(localPath, buf);
+      successful.push({
+        path: localPath,
+        mime: item.mime || EXT_TO_MIME[guessedExt] || 'application/octet-stream',
+        source: item.value,
+      });
+    } catch {}
+  }
+
+  const userText = (inbound.text || '').trim();
+  if (successful.length === 0) {
+    const fallbackList = (inbound.media || [])
+      .map((item) => `[media attached: ${item.value}]`)
+      .join('\n');
+    return [userText, fallbackList].filter(Boolean).join('\n\n').trim() || '(image attached)';
+  }
+
+  const lines = successful.map((entry, index) => {
+    const prefix = successful.length > 1
+      ? `[media attached ${index + 1}/${successful.length}: `
+      : '[media attached: ';
+    const mimePart = entry.mime ? ` (${entry.mime})` : '';
+    const sourcePart = entry.source ? ` | ${entry.source}` : '';
+    return `${prefix}${entry.path}${mimePart}${sourcePart}]`;
+  });
+
+  console.log(`[openclaw] inbound image prepared count=${successful.length} firstPath=${successful[0]?.path || 'none'}`);
+  return [userText, ...lines].filter(Boolean).join('\n\n').trim();
+}
+
+export const openClawRuntime = {
+  name: 'openclaw',
+
+  askGateway,
+
+  isReady() {
+    return isGatewayReady();
+  },
+
+  async resolveBinding(payload) {
+    if (!payload?.agentId) {
+      throw new Error('agentId is required for openclaw binding');
+    }
+    const agentId = normalizeOpenClawAgentId(payload.agentId);
+    const workspace = String(
+      payload.workdir
+      || payload.projectDir
+      || payload.cwd
+      || resolveOpenClawWorkspace(agentId)
+      || '',
+    ).trim();
+    const sessionKey = payload.sessionKey
+      ? String(payload.sessionKey).trim()
+      : buildOpenClawSessionKey(agentId);
+    return {
+      runtime: this.name,
+      displayName: payload.name || agentId,
+      runtimeMeta: {
+        agentId,
+        sessionKey,
+        gatewayHost: GATEWAY_HOST,
+        gatewayPort: GATEWAY_PORT,
+        ...(workspace ? {
+          workdir: workspace,
+          projectDir: workspace,
+          cwd: workspace,
+        } : {}),
+      },
+    };
+  },
+
+  onBindingUpdated(binding) {
+    if (binding.runtime !== this.name) return;
+    registerOpenClawChannel({
+      channelId: binding.id,
+      agentId: binding.runtimeMeta?.agentId || binding.id,
+    });
+  },
+
+  async deliverTurn(inbound, ctx) {
+    const binding = ctx.getBinding(inbound.bindingId);
+    if (!binding) return false;
+    const adapter = ctx.adapter;
+    const meta = binding.runtimeMeta || {};
+    const prompt = inbound.action === 'image'
+      ? await buildOpenClawImagePrompt(inbound)
+      : (inbound.text || '').trim();
+    const agentId = normalizeOpenClawAgentId(meta.agentId || binding.id);
+    const sessionId = String(meta.sessionKey || buildOpenClawSessionKey(agentId)).trim();
+
+    if (inbound.messageId) {
+      addInFlight({
+        messageId: inbound.messageId,
+        bindingId: binding.id,
+        sentAt: Date.now(),
+      });
+    }
+
+    try {
+      const result = await askGateway(prompt, agentId, {
+        sessionKey: sessionId,
+        onEvent: (event) => {
+          if (typeof adapter.emitEvent !== 'function') return;
+          void adapter.emitEvent(binding, {
+            agent: this.name,
+            sessionId,
+            cwd: '',
+            event,
+          });
+        },
+      });
+      await sendResult(adapter, binding, inbound, {
+        ...result,
+        media: normalizeOutboundMedia(result),
+      });
+      return true;
+    } catch (err) {
+      if (typeof adapter.emitEvent === 'function') {
+        await adapter.emitEvent(binding, {
+          agent: this.name,
+          sessionId,
+          cwd: '',
+          event: {
+            hook_event_name: 'agent.run.error',
+            error: err?.message || 'OpenClaw failed',
+            durationMs: 0,
+            phase: 'error',
+            reply_to_message_id: inbound.messageId || null,
+            turn_id: inbound.messageId || null,
+          },
+        }).catch(() => {});
+      }
+      await reportSubprocessFailure({
+        adapter,
+        binding,
+        inbound,
+        runtimeName: `OpenClaw ${binding.displayName || binding.id}`,
+        info: {
+          ok: false,
+          durationMs: 0,
+          kind: err.gatewayKind === 'timeout' ? 'gateway-timeout' : 'gateway-error',
+          errorMessage: err.message,
+        },
+      });
+      return terminalRuntimeFailure(err?.message || 'OpenClaw failed');
+    } finally {
+      if (inbound.messageId) {
+        removeInFlight(inbound.messageId);
+      }
+    }
+  },
+
+  async recoverInFlight(ctx) {
+    const entries = recoverInFlightEntries();
+    for (const entry of entries) {
+      const binding = ctx.getBinding(entry.bindingId);
+      if (!binding) continue;
+      await sendAdapterMessage(ctx.adapter, binding, {
+        type: 'assistant',
+        text: '⚠️ Lost while ticlawk restarted.\n\nThis OpenClaw message was in flight when ticlawk restarted. Please retry your message.',
+        media: [],
+        replyToMessageId: entry.messageId || null,
+      }).catch(() => {});
+    }
+    return entries.length;
+  },
+
+  async reconcileAfterRestart(binding, ctx) {
+    const meta = binding.runtimeMeta || {};
+    if (typeof ctx.adapter.emitEvent === 'function') {
+      await ctx.adapter.emitEvent(binding, {
+        agent: this.name,
+        sessionId: String(meta.sessionKey || buildOpenClawSessionKey(meta.agentId || binding.id)).trim(),
+        cwd: '',
+        event: {
+          hook_event_name: 'agent.run.end',
+          reason: 'connector.restart.reconcile',
+        },
+      });
+    }
+    return 1;
+  },
+};
+
+export default openClawRuntime;

package/src/runtimes/openclaw/inflight.mjs

@@ -0,0 +1,46 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { AF_HOME } from '../../core/config.mjs';
+
+const IN_FLIGHT_PATH = join(AF_HOME, 'in-flight-openclaw.json');
+
+function readEntries() {
+  if (!existsSync(IN_FLIGHT_PATH)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(IN_FLIGHT_PATH, 'utf8'));
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+function writeEntries(entries) {
+  try {
+    mkdirSync(dirname(IN_FLIGHT_PATH), { recursive: true });
+    writeFileSync(IN_FLIGHT_PATH, JSON.stringify(entries, null, 2));
+  } catch {}
+}
+
+export function addInFlight(entry) {
+  if (!entry?.messageId || !entry?.bindingId) return;
+  const entries = readEntries().filter((current) => current.messageId !== entry.messageId);
+  entries.push(entry);
+  writeEntries(entries);
+}
+
+export function removeInFlight(messageId) {
+  if (!messageId) return;
+  const entries = readEntries();
+  const filtered = entries.filter((entry) => entry.messageId !== messageId);
+  if (filtered.length !== entries.length) {
+    writeEntries(filtered);
+  }
+}
+
+export function recoverInFlightEntries() {
+  const entries = readEntries();
+  if (entries.length > 0) {
+    writeEntries([]);
+  }
+  return entries;
+}

package/src/runtimes/openclaw/target.mjs

@@ -0,0 +1,57 @@
+/**
+ * OpenClaw target helpers.
+ *
+ * Public and persisted state only carries `agentId`. The gateway-specific
+ * `agent:<id>:main` session key is derived internally when dispatching.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+let cachedOpenClawConfig = null;
+
+function loadOpenClawConfig() {
+  if (cachedOpenClawConfig !== null) return cachedOpenClawConfig;
+  const home = process.env.HOME || '';
+  const configPath = home ? join(home, '.openclaw', 'openclaw.json') : '';
+  if (!configPath || !existsSync(configPath)) {
+    cachedOpenClawConfig = {};
+    return cachedOpenClawConfig;
+  }
+  try {
+    cachedOpenClawConfig = JSON.parse(readFileSync(configPath, 'utf8')) || {};
+  } catch {
+    cachedOpenClawConfig = {};
+  }
+  return cachedOpenClawConfig;
+}
+
+export function normalizeOpenClawAgentId(value) {
+  const trimmed = String(value || '').trim().toLowerCase();
+  if (!trimmed) return 'main';
+  return trimmed.replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '') || 'main';
+}
+
+export function resolveOpenClawWorkspace(agentId) {
+  const normalizedId = normalizeOpenClawAgentId(agentId);
+  const config = loadOpenClawConfig();
+  const agents = Array.isArray(config?.agents?.list) ? config.agents.list : [];
+  const matched = agents.find((agent) => normalizeOpenClawAgentId(agent?.id || agent?.name || '') === normalizedId);
+  const workspace = String(matched?.workspace || '').trim();
+  return workspace || '';
+}
+
+export function buildOpenClawSessionKey(agentId = 'main') {
+  return `agent:${normalizeOpenClawAgentId(agentId)}:main`;
+}
+
+export function describeGatewayRequestContext(req = {}) {
+  const agentId = normalizeOpenClawAgentId(req.agentId || 'main');
+  const parts = [
+    `channelId=${req.channelId || 'unknown'}`,
+    `agentId=${agentId}`,
+    `sessionKey=${req.sessionKey || buildOpenClawSessionKey(agentId)}`,
+  ];
+  if (req.runId) parts.push(`runId=${req.runId}`);
+  return parts.join(' ');
+}