ticlawk 0.1.17-dev.23 → 0.1.17-dev.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticlawk",
-  "version": "0.1.17-dev.23",
+  "version": "0.1.17-dev.24",
   "description": "Local connector that links agent harnesses (Claude Code, Codex, OpenClaw, opencode, Pi) to the Ticlawk mobile app.",
   "type": "module",
   "main": "ticlawk.mjs",

package/src/adapters/ticlawk/api.mjs

@@ -115,7 +115,10 @@ async function apiFetch(path, opts = {}) {
 // ── Agents ──
 
 export async function getAgents({ hostId } = {}) {
-  const query = hostId ? `?${new URLSearchParams({ runtime_host_id: hostId })}` : '';
+  const params = new URLSearchParams();
+  if (hostId) params.set('runtime_host_id', hostId);
+  params.set('ticlawk_version', getTiclawkVersion());
+  const query = `?${params}`;
   const { data } = await apiFetch(`/api/agents${query}`);
   if (!Array.isArray(data)) {
     const err = new Error('API /api/agents response missing data array');
@@ -584,14 +587,23 @@ export async function getMe() {
   return data || null;
 }
 
+export async function checkConnectorReadiness({ hostId }) {
+  return apiFetch('/api/connector/readiness', {
+    method: 'POST',
+    body: JSON.stringify(withTiclawkVersion({
+      runtime_host_id: hostId,
+    })),
+  });
+}
+
 export async function reportHostCapabilities({ hostId, hostLabel, runtimesHealth, daemonVersion }) {
   return apiFetch('/api/hosts/capabilities', {
     method: 'POST',
-    body: JSON.stringify({
+    body: JSON.stringify(withTiclawkVersion({
       host_id: hostId,
       host_label: hostLabel || null,
       runtimes_health: runtimesHealth || {},
-      daemon_version: daemonVersion || null,
-    }),
+      daemon_version: daemonVersion || getTiclawkVersion(),
+    })),
   });
 }

package/src/adapters/ticlawk/index.mjs

@@ -16,6 +16,7 @@ const require = createRequire(import.meta.url);
 const qrcode = require('qrcode-terminal');
 const JOBS_WAKE_DEBOUNCE_MS = 100;
 const BINDINGS_WAKE_DEBOUNCE_MS = 500;
+const READINESS_AUDIT_INTERVAL_MS = 60 * 1000;
 const RECOVERY_AUDIT_INTERVAL_MS = 5 * 60 * 1000;
 const BINDING_AUDIT_INTERVAL_MS = 5 * 60 * 1000;
 const UPDATE_RETRY_COOLDOWN_MS = 15 * 60 * 1000;
@@ -286,6 +287,7 @@ export function createTiclawkAdapter(ctx) {
   let bindingsWakeTimer = null;
   let lastJobsWakeAt = 0;
   let lastBindingsWakeAt = 0;
+  let lastReadinessCheckAt = 0;
   let updateRequired = null;
   let lastUpdateRequiredLogAt = 0;
   let startupSyncing = false;
@@ -369,6 +371,7 @@ export function createTiclawkAdapter(ctx) {
       autoUpdateError,
       lastAutoUpdateAttemptAt,
     });
+    stopWakeSocket('update_required');
 
     if (now - lastUpdateRequiredLogAt > UPDATE_REQUIRED_LOG_INTERVAL_MS) {
       lastUpdateRequiredLogAt = now;
@@ -732,6 +735,35 @@ export function createTiclawkAdapter(ctx) {
     bindingsWakeTimer.unref?.();
   }
 
+  async function checkConnectorReadiness(reason, { force = false } = {}) {
+    const now = Date.now();
+    if (!force && now - lastReadinessCheckAt < READINESS_AUDIT_INTERVAL_MS) {
+      return true;
+    }
+    lastReadinessCheckAt = now;
+    try {
+      await api.checkConnectorReadiness({ hostId });
+      clearUpdateRequired(`readiness.${reason}`);
+      debugLog('ticlawk', 'readiness.ok', {
+        reason,
+        hostId,
+        ticlawkVersion: api.getTiclawkVersion(),
+      });
+      return true;
+    } catch (err) {
+      if (api.isUpdateRequiredError(err)) {
+        recordUpdateRequired(err, `readiness.${reason}`);
+        return false;
+      }
+      debugError('ticlawk', 'readiness.failed', {
+        reason,
+        hostId,
+        error: err?.message || 'readiness check failed',
+      });
+      return true;
+    }
+  }
+
   async function reportHostCapabilitiesNow() {
     const entries = await Promise.all(Object.entries(ctx.runtimes || {})
       .filter(([, runtime]) => typeof runtime?.health === 'function')
@@ -757,22 +789,39 @@ export function createTiclawkAdapter(ctx) {
           .map(([k]) => k)
           .join(','),
       });
+      clearUpdateRequired('host.capabilities');
+      return true;
     } catch (err) {
+      if (api.isUpdateRequiredError(err)) {
+        recordUpdateRequired(err, 'host.capabilities');
+        return false;
+      }
       debugError('ticlawk', 'host.capabilities.failed', {
         hostId,
         error: err?.message || 'report failed',
       });
+      return true;
     }
   }
 
+  async function handleWakeHello() {
+    const ready = await checkConnectorReadiness('wake.hello', { force: true });
+    if (!ready) return;
+    const capabilitiesReported = await reportHostCapabilitiesNow();
+    if (!capabilitiesReported) return;
+    if (startupSyncing) return;
+    await refreshBindings('wake.hello');
+    await requestDrain('wake.hello');
+  }
+
   function handleWakeEvent(event) {
     wakeState.lastEventAt = new Date().toISOString();
     if (event?.type === 'hello') {
-      void reportHostCapabilitiesNow();
-      if (startupSyncing) return;
-      void refreshBindings('wake.hello')
-        .then(() => requestDrain('wake.hello'))
-        .catch(() => {});
+      void handleWakeHello().catch(() => {});
+      return;
+    }
+    if (event?.type === 'heartbeat') {
+      void checkConnectorReadiness('wake.heartbeat').catch(() => {});
       return;
     }
     if (event?.type === 'jobs.available') {
@@ -848,6 +897,13 @@ export function createTiclawkAdapter(ctx) {
     connectorSocket.start();
   }
 
+  function stopWakeSocket(reason) {
+    if (!connectorSocket) return;
+    connectorSocket.stop();
+    connectorSocket = null;
+    debugLog('ticlawk-wake', 'stopped', { reason });
+  }
+
   function restartWakeSocket(reason) {
     if (connectorSocket) {
       connectorSocket.stop();
@@ -882,11 +938,14 @@ export function createTiclawkAdapter(ctx) {
         meta: pairedIdentity,
       });
     }
-    if (connectorSocket) {
+    const ready = await checkConnectorReadiness('connect.paired', { force: true });
+    if (connectorSocket && ready) {
       restartWakeSocket('connect.paired');
     }
 
-    await reportHostCapabilitiesNow();
+    if (ready) {
+      await reportHostCapabilitiesNow();
+    }
     return {
       statusCode: 200,
       body: {
@@ -948,10 +1007,13 @@ export function createTiclawkAdapter(ctx) {
       // was dropped in X1; no cron has replaced it. Rare in practice;
       // when it happens the fix is a one-row UPDATE in supabase.
       startupSyncing = true;
-      connectWakeSocket();
       try {
-        await refreshBindings('startup');
-        await requestDrain('startup');
+        const ready = await checkConnectorReadiness('startup', { force: true });
+        if (ready) {
+          connectWakeSocket();
+          await refreshBindings('startup');
+          await requestDrain('startup');
+        }
       } finally {
         startupSyncing = false;
       }