crawd 0.9.7 → 0.9.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crawd",
-  "version": "0.9.7",
+  "version": "0.9.9",
   "description": "CLI for crawd.bot - AI agent livestreaming platform",
   "type": "module",
   "types": "./dist/types.d.ts",

package/skills/crawd/SKILL.md

@@ -72,6 +72,8 @@ Chat arrives as `[CRAWD:CHAT]` batches:
 
 Each message has a short ID in brackets. You decide which messages deserve a response — you have agency, you don't have to reply to everything. Prioritize messages that are interesting, funny, or ask you to do something. **You MUST reply to chat ONLY via `livestream_reply` tool calls.** Never respond to chat with plaintext — it will not be seen or heard by anyone.
 
+**Reply FIRST, act SECOND.** When you decide to respond to a chat message, call `livestream_reply` IMMEDIATELY — before browsing, before searching, before opening any page. Viewers are waiting for your reaction. If someone says "yo what's new on X", reply first ("let me check what's going on"), THEN open X. The reply is instant acknowledgment; the browsing is the follow-up. Dead air while you silently research kills the vibe. Talk first, do second.
+
 ## Autonomous Vibes
 
 The coordinator manages your activity cycle through three states:

package/src/backend/coordinator.test.ts

@@ -281,7 +281,7 @@ describe('Coordinator — Plan Mode', () => {
       coord.stop()
     })
 
-    it('does not nudge when plan is completed', async () => {
+    it('nudges to create new plan when plan is completed', async () => {
       const coord = createCoordinator()
       coord.setPlan('Quick', ['Only step'])
       coord.markStepDone(0)
@@ -291,9 +291,49 @@ describe('Coordinator — Plan Mode', () => {
       clock.advance(200)
       await new Promise(r => setTimeout(r, 50))
 
-      // No plan nudge should have been sent
+      // Should nudge agent to create a new plan
       const planNudges = triggerFn.mock.calls.filter((c: any[]) => c[0]?.includes('[CRAWD:PLAN]'))
-      expect(planNudges).toHaveLength(0)
+      expect(planNudges).toHaveLength(1)
+      expect(planNudges[0][0]).toContain('No active plan')
+      expect(planNudges[0][0]).toContain('plan_set')
+
+      coord.stop()
+    })
+
+    it('includes reply context in plan nudge when no active plan', async () => {
+      const coord = createCoordinator()
+
+      // Agent replies to a chat message — no plan exists
+      coord.notifySpeech({ username: 'viewer42', message: 'yo you are popular on x' })
+
+      clock.advance(200)
+      await vi.waitFor(() => {
+        const calls = triggerFn.mock.calls.filter((c: any[]) => c[0]?.includes('[CRAWD:PLAN]'))
+        return expect(calls.length).toBeGreaterThan(0)
+      })
+
+      const planNudge = triggerFn.mock.calls.find((c: any[]) => c[0]?.includes('[CRAWD:PLAN]'))
+      expect(planNudge![0]).toContain('viewer42')
+      expect(planNudge![0]).toContain('yo you are popular on x')
+      // Chat context is a hint, not a directive
+      expect(planNudge![0]).toContain('ignore it')
+
+      coord.stop()
+    })
+
+    it('does not include chat hint when no reply context', async () => {
+      const coord = createCoordinator()
+
+      coord.wake()
+
+      clock.advance(200)
+      await vi.waitFor(() => {
+        const calls = triggerFn.mock.calls.filter((c: any[]) => c[0]?.includes('[CRAWD:PLAN]'))
+        return expect(calls.length).toBeGreaterThan(0)
+      })
+
+      const planNudge = triggerFn.mock.calls.find((c: any[]) => c[0]?.includes('[CRAWD:PLAN]'))
+      expect(planNudge![0]).not.toContain('Recent chat context')
 
       coord.stop()
     })

package/src/backend/coordinator.ts

@@ -1,9 +1,87 @@
-import { randomUUID } from 'crypto'
+import { randomUUID, createPrivateKey, createPublicKey, sign } from 'crypto'
+import { readFileSync, existsSync } from 'fs'
+import { join } from 'path'
+import { homedir } from 'os'
 import WebSocket from 'ws'
 import type { ChatMessage } from '../lib/chat/types'
 
 const SESSION_KEY = process.env.CRAWD_CHANNEL_ID || 'agent:main:crawd:live'
 
+// ---------------------------------------------------------------------------
+// Device identity for gateway authentication
+// ---------------------------------------------------------------------------
+
+type DeviceIdentity = {
+  deviceId: string
+  publicKeyPem: string
+  privateKeyPem: string
+}
+
+/**
+ * Load device identity from ~/.openclaw/identity/device.json.
+ * Returns null if not found (gateway will fall back to token-only auth without scopes).
+ */
+function loadDeviceIdentity(): DeviceIdentity | null {
+  const identityPath = join(homedir(), '.openclaw', 'identity', 'device.json')
+  try {
+    if (!existsSync(identityPath)) return null
+    const raw = JSON.parse(readFileSync(identityPath, 'utf8'))
+    if (raw?.version === 1 && typeof raw.deviceId === 'string' &&
+        typeof raw.publicKeyPem === 'string' && typeof raw.privateKeyPem === 'string') {
+      return { deviceId: raw.deviceId, publicKeyPem: raw.publicKeyPem, privateKeyPem: raw.privateKeyPem }
+    }
+    return null
+  } catch {
+    return null
+  }
+}
+
+function base64UrlEncode(buf: Buffer): string {
+  return buf.toString('base64url')
+}
+
+/** Extract raw 32-byte Ed25519 public key from PEM and return as base64url */
+function publicKeyRawBase64Url(publicKeyPem: string): string {
+  const pubKey = createPublicKey(publicKeyPem)
+  const der = pubKey.export({ type: 'spki', format: 'der' })
+  // Ed25519 SPKI DER: 12-byte header + 32-byte raw key
+  return base64UrlEncode(der.subarray(der.length - 32))
+}
+
+/** Sign a device auth payload with Ed25519 private key */
+function signPayload(privateKeyPem: string, payload: string): string {
+  const key = createPrivateKey(privateKeyPem)
+  return base64UrlEncode(sign(null, Buffer.from(payload, 'utf8'), key))
+}
+
+/**
+ * Build the device auth fields for a gateway connect request.
+ * Returns the `device` object to include in connect params, or undefined if no identity.
+ */
+function buildDeviceAuth(
+  identity: DeviceIdentity,
+  opts: { clientId: string; clientMode: string; role: string; scopes: string[]; token?: string }
+): { id: string; publicKey: string; signature: string; signedAt: number } {
+  const signedAtMs = Date.now()
+  const payload = [
+    'v1',
+    identity.deviceId,
+    opts.clientId,
+    opts.clientMode,
+    opts.role,
+    opts.scopes.join(','),
+    String(signedAtMs),
+    opts.token ?? '',
+  ].join('|')
+
+  return {
+    id: identity.deviceId,
+    publicKey: publicKeyRawBase64Url(identity.publicKeyPem),
+    signature: signPayload(identity.privateKeyPem, payload),
+    signedAt: signedAtMs,
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Plan types
 // ---------------------------------------------------------------------------
@@ -142,6 +220,7 @@ export class GatewayClient implements IGatewayClient {
   private reconnectDelay = 1000
   private readonly maxReconnectDelay = 30_000
   private shouldReconnect = false
+  private deviceIdentity: DeviceIdentity | null
 
   /** Callback invoked when the gateway dispatches a node.invoke.request */
   onInvokeRequest?: (payload: InvokeRequestPayload) => void
@@ -150,6 +229,12 @@ export class GatewayClient implements IGatewayClient {
     this.url = url
     this.token = token
     this.targetSessionKey = sessionKey
+    this.deviceIdentity = loadDeviceIdentity()
+    if (this.deviceIdentity) {
+      console.log(`[Gateway] Device identity loaded: ${this.deviceIdentity.deviceId.slice(0, 12)}...`)
+    } else {
+      console.warn('[Gateway] No device identity found — scopes will be stripped by gateway')
+    }
   }
 
 
@@ -215,19 +300,30 @@ export class GatewayClient implements IGatewayClient {
   }
 
   private async authenticate(): Promise<void> {
+    const scopes = ['operator.write']
+    const clientId = 'gateway-client'
+    const clientMode = 'backend'
+    const role = 'operator'
+
+    const device = this.deviceIdentity
+      ? buildDeviceAuth(this.deviceIdentity, { clientId, clientMode, role, scopes, token: this.token })
+      : undefined
+
     // Skip connected check since we're establishing the connection
     return this.request('connect', {
       minProtocol: 3,
       maxProtocol: 3,
       client: {
-        id: 'gateway-client',
+        id: clientId,
         version: '1.0.0',
         platform: 'node',
-        mode: 'backend',
+        mode: clientMode,
       },
-      scopes: ['operator.write'],
+      role,
+      scopes,
       commands: ['talk'],
       auth: { token: this.token },
+      device,
     }, true) as Promise<void>
   }
 
@@ -397,12 +493,15 @@ export class GatewayClient implements IGatewayClient {
  * No persistent connection or reconnect logic needed.
  */
 export class OneShotGateway {
+  private deviceIdentity: DeviceIdentity | null
+
   constructor(
     private url: string,
     private token: string,
     private sessionKey: string = SESSION_KEY,
   ) {
-    console.log(`[OneShotGateway] url=${url} session=${sessionKey}`)
+    this.deviceIdentity = loadDeviceIdentity()
+    console.log(`[OneShotGateway] url=${url} session=${sessionKey} device=${this.deviceIdentity ? this.deviceIdentity.deviceId.slice(0, 12) + '...' : 'none'}`)
   }
 
   async triggerAgent(message: string): Promise<string[]> {
@@ -434,6 +533,15 @@ export class OneShotGateway {
       }
 
       const sendConnect = () => {
+        const scopes = ['operator.write']
+        const clientId = 'gateway-client'
+        const clientMode = 'backend'
+        const role = 'operator'
+
+        const device = this.deviceIdentity
+          ? buildDeviceAuth(this.deviceIdentity, { clientId, clientMode, role, scopes, token: this.token })
+          : undefined
+
         ws.send(JSON.stringify({
           type: 'req',
           id: authId,
@@ -442,14 +550,16 @@ export class OneShotGateway {
             minProtocol: 3,
             maxProtocol: 3,
             client: {
-              id: 'gateway-client',
+              id: clientId,
               version: '1.0.0',
               platform: 'node',
-              mode: 'backend',
+              mode: clientMode,
             },
-            scopes: ['operator.write'],
+            role,
+            scopes,
             commands: ['talk'],
             auth: this.token ? { token: this.token } : {},
+            device,
           },
         }))
       }
@@ -563,6 +673,7 @@ export class Coordinator {
   // === Plan State ===
   private currentPlan: Plan | null = null
   private planNudgeTimer: NodeJS.Timeout | null = null
+  private lastReplyContext: { username: string; message: string } | null = null
 
   // === Injected dependencies ===
   private readonly clock: IClock
@@ -662,8 +773,8 @@ export class Coordinator {
 
     this.startVibeLoop() // starts sleep/idle check timers + vibe loop (if mode=vibe)
 
-    // In plan mode, also start plan nudges if there are pending steps
-    if (this.config.autonomyMode === 'plan' && this.hasPendingPlanSteps()) {
+    // In plan mode, start plan nudges (pending steps or needs a new plan)
+    if (this.config.autonomyMode === 'plan' && this.needsPlanNudge()) {
       this.schedulePlanNudge()
     }
   }
@@ -696,7 +807,8 @@ export class Coordinator {
   }
 
   /** Signal that the agent is speaking (via tool call) — keeps coordinator awake */
-  notifySpeech(): void {
+  notifySpeech(replyContext?: { username: string; message: string }): void {
+    if (replyContext) this.lastReplyContext = replyContext
     if (this._state !== 'active') this.wake()
     else this.resetActivity()
   }
@@ -772,6 +884,11 @@ export class Coordinator {
     return this.currentPlan.steps.some(s => s.status === 'pending')
   }
 
+  /** Check if a plan nudge is needed — either pending steps or no plan at all */
+  private needsPlanNudge(): boolean {
+    return this.hasPendingPlanSteps() || !this.currentPlan || this.currentPlan.status !== 'active'
+  }
+
   // === Plan Nudge Loop ===
 
   /** Schedule next plan nudge (short delay to avoid spinning) */
@@ -779,7 +896,7 @@ export class Coordinator {
     this.cancelPlanNudge()
     if (this._state === 'sleep') return
     if (this.config.autonomyMode !== 'plan') return
-    if (!this.hasPendingPlanSteps()) return
+    if (!this.needsPlanNudge()) return
 
     const delay = this.config.planNudgeDelayMs
     const nextNudgeAt = this.clock.now() + delay
@@ -799,7 +916,7 @@ export class Coordinator {
   private checkPlanProgress(): void {
     if (this.config.autonomyMode !== 'plan') return
     if (this._state === 'sleep') return
-    if (this.hasPendingPlanSteps()) {
+    if (this.needsPlanNudge()) {
       this.schedulePlanNudge()
     }
   }
@@ -818,7 +935,7 @@ export class Coordinator {
       return
     }
 
-    if (!this.hasPendingPlanSteps()) {
+    if (!this.needsPlanNudge()) {
       this.logger.log('[Coordinator] Plan nudge skipped - no pending steps')
       this.emit({ type: 'planNudgeExecuted', skipped: true, reason: 'no pending steps' })
       return
@@ -882,7 +999,13 @@ export class Coordinator {
   /** Build the [CRAWD:PLAN] prompt with current plan progress */
   private buildPlanNudgePrompt(): string {
     if (!this.currentPlan || this.currentPlan.status !== 'active') {
-      return '[CRAWD:PLAN] No active plan. Come up with something fun to do — check X, browse HN, find something weird on the internet, go down a rabbit hole. Create a plan using plan_set with concrete steps. Be creative, not reactive. Or respond with NO_REPLY to idle.'
+      const ctx = this.lastReplyContext
+      this.lastReplyContext = null
+      const base = '[CRAWD:PLAN] No active plan. Come up with something to do — check X, browse HN, find something weird on the internet, go down a rabbit hole. Create a plan using plan_set with 2-4 concrete steps. Be creative and unpredictable.'
+      const chatHint = ctx
+        ? `\nRecent chat context: ${ctx.username} said "${ctx.message}" — you can riff on this, ignore it, or do something completely unrelated. Your call.`
+        : ''
+      return `${base}${chatHint}\nOr respond with NO_REPLY to idle.`
     }
 
     const lines: string[] = ['[CRAWD:PLAN] Continue your plan.', '']

package/src/backend/server.ts

@@ -157,7 +157,7 @@ export class CrawdBackend {
       return { spoken: false }
     }
 
-    this.coordinator?.notifySpeech()
+    this.coordinator?.notifySpeech({ username: chat.username, message: chat.message })
 
     const id = randomUUID()
     this.io.emit('crawd:reply-turn', {

package/src/plugin.ts

@@ -221,7 +221,7 @@ const plugin: PluginDefinition = {
           const { text, username, message } = params as { text: string; username: string; message: string }
           const result = await b.handleReply(text, { username, message })
           return {
-            content: [{ type: 'text', text: result.spoken ? `Replied to @${username}: "${text}"` : 'Failed to reply' }],
+            content: [{ type: 'text', text: result.spoken ? `Replied to ${username}: "${text}"` : 'Failed to reply' }],
             details: result,
           }
         },