@swarmclawai/swarmclaw 0.7.4 → 0.7.6

package/src/components/providers/provider-list.tsx

@@ -1,9 +1,19 @@
 'use client'
 
 import { useCallback, useEffect, useState } from 'react'
+import { toast } from 'sonner'
+import { OpenClawDeployPanel } from '@/components/openclaw/openclaw-deploy-panel'
 import { useAppStore } from '@/stores/use-app-store'
 import { useWs } from '@/hooks/use-ws'
 import { api } from '@/lib/api-client'
+import type { Credential } from '@/types'
+
+interface OpenClawDeployDraft {
+  endpoint: string
+  token?: string
+  name?: string
+  notes?: string
+}
 
 export function ProviderList({ inSidebar }: { inSidebar?: boolean }) {
   const providers = useAppStore((s) => s.providers)
@@ -21,6 +31,8 @@ export function ProviderList({ inSidebar }: { inSidebar?: boolean }) {
   const setGatewaySheetOpen = useAppStore((s) => s.setGatewaySheetOpen)
   const setEditingGatewayId = useAppStore((s) => s.setEditingGatewayId)
   const [loaded, setLoaded] = useState(false)
+  const [deployDraft, setDeployDraft] = useState<OpenClawDeployDraft | null>(null)
+  const [savingDeploy, setSavingDeploy] = useState(false)
 
   const refresh = useCallback(async () => {
     await Promise.all([loadProviders(), loadProviderConfigs(), loadGatewayProfiles(), loadExternalAgents(), loadCredentials()])
@@ -66,6 +78,57 @@ export function ProviderList({ inSidebar }: { inSidebar?: boolean }) {
     await loadGatewayProfiles()
   }
 
+  const handleDeployApply = (patch: { endpoint?: string; token?: string; name?: string; notes?: string }) => {
+    if (!patch.endpoint) return
+    setDeployDraft({
+      endpoint: patch.endpoint,
+      token: patch.token,
+      name: patch.name,
+      notes: patch.notes,
+    })
+  }
+
+  const handleSavePreparedGateway = async () => {
+    if (!deployDraft?.endpoint) return
+    setSavingDeploy(true)
+    try {
+      let nextCredentialId: string | null = null
+      if (deployDraft.token?.trim()) {
+        const credential = await api<Credential>('POST', '/credentials', {
+          provider: 'openclaw',
+          name: `${deployDraft.name || 'OpenClaw Gateway'} token`,
+          apiKey: deployDraft.token.trim(),
+        })
+        nextCredentialId = credential.id
+      }
+
+      const existing = gatewayProfiles.find((gateway) => gateway.endpoint === deployDraft.endpoint) || null
+      const nextTags = Array.from(new Set([...(existing?.tags || []), 'managed-deploy']))
+      const payload = {
+        name: deployDraft.name || existing?.name || 'OpenClaw Gateway',
+        endpoint: deployDraft.endpoint,
+        credentialId: nextCredentialId || existing?.credentialId || null,
+        notes: deployDraft.notes || existing?.notes || 'Managed OpenClaw deploy prepared from SwarmClaw.',
+        tags: nextTags,
+        isDefault: existing?.isDefault === true || gatewayProfiles.length === 0,
+      }
+
+      if (existing) {
+        await api('PUT', `/gateways/${existing.id}`, payload)
+      } else {
+        await api('POST', '/gateways', payload)
+      }
+
+      await Promise.all([loadGatewayProfiles(), loadCredentials()])
+      setDeployDraft(null)
+      toast.success(existing ? 'Gateway profile updated' : 'Gateway profile saved')
+    } catch (err: unknown) {
+      toast.error(err instanceof Error ? err.message : 'Failed to save prepared gateway')
+    } finally {
+      setSavingDeploy(false)
+    }
+  }
+
   // Merge built-in providers with custom configs
   const builtinItems = providers.map((p) => ({
     id: p.id,
@@ -180,15 +243,47 @@ export function ProviderList({ inSidebar }: { inSidebar?: boolean }) {
       <div className="mt-8 mb-4 flex items-center justify-between">
         <div className="text-[12px] font-700 uppercase tracking-[0.08em] text-text-3/60">OpenClaw Gateways</div>
         {!inSidebar && (
-          <button
-            type="button"
-            onClick={() => handleEditGateway(null)}
-            className="px-3 py-1.5 rounded-[8px] border border-white/[0.08] bg-transparent text-[11px] font-700 text-text-2 hover:bg-white/[0.04] transition-all cursor-pointer"
-          >
-            + New Gateway
-          </button>
+          <div className="flex items-center gap-2">
+            <button
+              type="button"
+              onClick={() => handleEditGateway(null)}
+              className="px-3 py-1.5 rounded-[8px] border border-white/[0.08] bg-transparent text-[11px] font-700 text-text-2 hover:bg-white/[0.04] transition-all cursor-pointer"
+            >
+              + New Gateway
+            </button>
+          </div>
         )}
       </div>
+      {!inSidebar && (
+        <div className="mb-4 rounded-[16px] border border-white/[0.06] bg-white/[0.02] p-4">
+          <OpenClawDeployPanel
+            compact
+            title="Deploy OpenClaw Control Planes"
+            description="Use official OpenClaw sources only. Start a local control plane on this machine, or generate a pre-configured remote bundle for Docker VPS hosts like Hetzner, DigitalOcean, Vultr, Linode, Lightsail, plus Render, Fly.io, and Railway."
+            onApply={handleDeployApply}
+          />
+          {deployDraft?.endpoint && (
+            <div className="mt-3 flex flex-wrap items-center justify-between gap-3 rounded-[12px] border border-emerald-500/20 bg-emerald-500/[0.05] px-4 py-3">
+              <div>
+                <div className="text-[13px] font-700 text-emerald-300">Prepared gateway profile</div>
+                <div className="mt-1 text-[12px] text-text-3">
+                  {deployDraft.name || 'OpenClaw Gateway'} · <code className="text-text-2">{deployDraft.endpoint}</code>
+                </div>
+              </div>
+              <div className="flex flex-wrap gap-2">
+                <button
+                  type="button"
+                  onClick={() => void handleSavePreparedGateway()}
+                  disabled={savingDeploy}
+                  className="rounded-[10px] bg-accent-bright px-3.5 py-2 text-[12px] font-700 text-white border-none cursor-pointer hover:brightness-110 transition-all disabled:opacity-40"
+                >
+                  {savingDeploy ? 'Saving…' : 'Save Prepared Gateway'}
+                </button>
+              </div>
+            </div>
+          )}
+        </div>
+      )}
       <div className={inSidebar ? 'space-y-2' : 'grid grid-cols-1 md:grid-cols-2 xl:grid-cols-3 gap-3'}>
         {gatewayProfiles.map((gateway, idx) => (
           <div
@@ -246,7 +341,7 @@ export function ProviderList({ inSidebar }: { inSidebar?: boolean }) {
         ))}
         {gatewayProfiles.length === 0 && (
           <div className="p-4 rounded-[14px] border border-dashed border-white/[0.08] text-[13px] text-text-3/70">
-            No gateway profiles yet. Add one to route OpenClaw agents by named control plane instead of a singleton default.
+            No gateway profiles yet. Use Smart Deploy above for a local runtime, a Docker VPS bundle, or a hosted OpenClaw deployment profile.
           </div>
         )}
       </div>

package/src/lib/server/agent-thread-session.test.ts

@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { describe, it } from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-agent-thread-'))
+  try {
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        DATA_DIR: path.join(tempDir, 'data'),
+        WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+        BROWSER_PROFILES_DIR: path.join(tempDir, 'browser-profiles'),
+      },
+      encoding: 'utf-8',
+    })
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+describe('ensureAgentThreadSession', () => {
+  it('creates and reuses an agent shortcut chat for heartbeat-enabled agents', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const storage = storageMod.default || storageMod['module.exports'] || storageMod
+      const helperMod = await import('./src/lib/server/agent-thread-session.ts')
+      const ensureAgentThreadSession = helperMod.ensureAgentThreadSession
+        || helperMod.default?.ensureAgentThreadSession
+        || helperMod['module.exports']?.ensureAgentThreadSession
+
+      const now = Date.now()
+      storage.saveAgents({
+        molly: {
+          id: 'molly',
+          name: 'Molly',
+          description: 'Autonomous helper',
+          provider: 'openai',
+          model: 'gpt-test',
+          credentialId: null,
+          apiEndpoint: null,
+          fallbackCredentialIds: [],
+          heartbeatEnabled: true,
+          heartbeatIntervalSec: 600,
+          createdAt: now,
+          updatedAt: now,
+          plugins: ['memory', 'web_search'],
+        },
+      })
+
+      const first = ensureAgentThreadSession('molly')
+      const second = ensureAgentThreadSession('molly')
+      const agents = storage.loadAgents()
+      const sessions = storage.loadSessions()
+
+      console.log(JSON.stringify({
+        firstId: first?.id,
+        secondId: second?.id,
+        threadSessionId: agents.molly?.threadSessionId || null,
+        session: first ? sessions[first.id] : null,
+      }))
+    `)
+
+    assert.equal(output.firstId, output.secondId)
+    assert.equal(output.threadSessionId, output.firstId)
+    assert.equal(output.session.shortcutForAgentId, 'molly')
+    assert.equal(output.session.agentId, 'molly')
+    assert.equal(output.session.heartbeatEnabled, true)
+    assert.deepEqual(output.session.plugins, ['memory', 'web_search'])
+  })
+})

package/src/lib/server/agent-thread-session.ts

@@ -0,0 +1,123 @@
+import { genId } from '@/lib/id'
+import type { Agent, Session } from '@/types'
+import { applyResolvedRoute, resolvePrimaryAgentRoute } from './agent-runtime-config'
+import { WORKSPACE_DIR } from './data-dir'
+import { loadAgents, loadSessions, saveAgents, saveSessions } from './storage'
+
+function buildEmptyDelegateResumeIds(): NonNullable<Session['delegateResumeIds']> {
+  return {
+    claudeCode: null,
+    codex: null,
+    opencode: null,
+    gemini: null,
+  }
+}
+
+function buildThreadSession(agent: Agent, sessionId: string, user: string, createdAt: number, existing?: Session): Session {
+  const baseSession: Session = {
+    id: sessionId,
+    name: agent.name,
+    shortcutForAgentId: agent.id,
+    cwd: existing?.cwd || WORKSPACE_DIR,
+    user: existing?.user || user,
+    provider: agent.provider,
+    model: agent.model,
+    credentialId: agent.credentialId || null,
+    fallbackCredentialIds: agent.fallbackCredentialIds || [],
+    apiEndpoint: agent.apiEndpoint || null,
+    gatewayProfileId: agent.gatewayProfileId || null,
+    claudeSessionId: existing?.claudeSessionId || null,
+    codexThreadId: existing?.codexThreadId || null,
+    opencodeSessionId: existing?.opencodeSessionId || null,
+    delegateResumeIds: existing?.delegateResumeIds || buildEmptyDelegateResumeIds(),
+    messages: Array.isArray(existing?.messages) ? existing.messages : [],
+    createdAt: existing?.createdAt || createdAt,
+    lastActiveAt: createdAt,
+    active: existing?.active || false,
+    sessionType: existing?.sessionType || 'human',
+    agentId: agent.id,
+    parentSessionId: existing?.parentSessionId || null,
+    plugins: agent.plugins || agent.tools || [],
+    tools: agent.plugins || agent.tools || [],
+    heartbeatEnabled: agent.heartbeatEnabled || false,
+    heartbeatIntervalSec: agent.heartbeatIntervalSec || null,
+    heartbeatTarget: existing?.heartbeatTarget || null,
+    sessionResetMode: existing?.sessionResetMode || null,
+    sessionIdleTimeoutSec: existing?.sessionIdleTimeoutSec || null,
+    sessionMaxAgeSec: existing?.sessionMaxAgeSec || null,
+    sessionDailyResetAt: existing?.sessionDailyResetAt || null,
+    sessionResetTimezone: existing?.sessionResetTimezone || null,
+    thinkingLevel: existing?.thinkingLevel || null,
+    browserProfileId: existing?.browserProfileId || null,
+    connectorThinkLevel: existing?.connectorThinkLevel || null,
+    connectorSessionScope: existing?.connectorSessionScope || null,
+    connectorReplyMode: existing?.connectorReplyMode || null,
+    connectorThreadBinding: existing?.connectorThreadBinding || null,
+    connectorGroupPolicy: existing?.connectorGroupPolicy || null,
+    connectorIdleTimeoutSec: existing?.connectorIdleTimeoutSec || null,
+    connectorMaxAgeSec: existing?.connectorMaxAgeSec || null,
+    mailbox: existing?.mailbox || null,
+    connectorContext: existing?.connectorContext || undefined,
+    lastAutoMemoryAt: existing?.lastAutoMemoryAt || null,
+    lastHeartbeatText: existing?.lastHeartbeatText || null,
+    lastHeartbeatSentAt: existing?.lastHeartbeatSentAt || null,
+    lastSessionResetAt: existing?.lastSessionResetAt || null,
+    lastSessionResetReason: existing?.lastSessionResetReason || null,
+    identityState: existing?.identityState || null,
+    sessionArchiveState: existing?.sessionArchiveState || null,
+    pinned: existing?.pinned || false,
+    file: existing?.file || null,
+    queuedCount: existing?.queuedCount,
+    currentRunId: existing?.currentRunId || null,
+    conversationTone: existing?.conversationTone,
+    emoji: existing?.emoji,
+    creature: existing?.creature,
+    vibe: existing?.vibe,
+    theme: existing?.theme,
+    avatar: existing?.avatar,
+    canvasContent: existing?.canvasContent || null,
+  }
+  return applyResolvedRoute(baseSession, resolvePrimaryAgentRoute(agent))
+}
+
+export function ensureAgentThreadSession(agentId: string, user = 'default'): Session | null {
+  const agents = loadAgents()
+  const agent = agents[agentId] as Agent | undefined
+  if (!agent) return null
+
+  const sessions = loadSessions()
+  const now = Date.now()
+
+  const existingId = typeof agent.threadSessionId === 'string' ? agent.threadSessionId : ''
+  if (existingId && sessions[existingId]) {
+    const session = buildThreadSession(agent, existingId, user, now, sessions[existingId] as Session)
+    sessions[existingId] = session
+    saveSessions(sessions)
+    return session
+  }
+
+  const legacySession = Object.values(sessions).find((session) => (
+    (session.shortcutForAgentId === agentId || session.name === `agent-thread:${agentId}`)
+    && session.user === user
+  )) as Session | undefined
+
+  if (legacySession) {
+    agent.threadSessionId = legacySession.id
+    agent.updatedAt = now
+    saveAgents(agents)
+    const session = buildThreadSession(agent, legacySession.id, user, now, legacySession)
+    sessions[legacySession.id] = session
+    saveSessions(sessions)
+    return session
+  }
+
+  const sessionId = `agent-chat-${agentId}-${genId()}`
+  const session = buildThreadSession(agent, sessionId, user, now)
+  sessions[sessionId] = session
+  saveSessions(sessions)
+
+  agent.threadSessionId = sessionId
+  agent.updatedAt = now
+  saveAgents(agents)
+  return session
+}

package/src/lib/server/data-dir.test.ts

@@ -0,0 +1,56 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { describe, it } from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../..')
+
+function extractLastJson(stdout: string): Record<string, unknown> {
+  const lines = stdout
+    .trim()
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+  const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+  return JSON.parse(jsonLine || '{}')
+}
+
+describe('data-dir resolution', () => {
+  it('falls back to in-project workspace when the external workspace root exists but child writes fail', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-data-dir-'))
+    const fakeHome = path.join(tempDir, 'home')
+    const dataDir = path.join(tempDir, 'data')
+    const externalWorkspace = path.join(fakeHome, '.swarmclaw', 'workspace')
+    fs.mkdirSync(externalWorkspace, { recursive: true })
+    fs.chmodSync(externalWorkspace, 0o555)
+
+    try {
+      const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', `
+        const modNs = await import('./src/lib/server/data-dir.ts')
+        const mod = modNs.default || modNs['module.exports'] || modNs
+        console.log(JSON.stringify({
+          dataDir: mod.DATA_DIR,
+          workspaceDir: mod.WORKSPACE_DIR,
+        }))
+      `], {
+        cwd: repoRoot,
+        env: {
+          ...process.env,
+          HOME: fakeHome,
+          DATA_DIR: dataDir,
+        },
+        encoding: 'utf-8',
+      })
+
+      assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+      const payload = extractLastJson(result.stdout || '')
+      assert.equal(payload.dataDir, dataDir)
+      assert.equal(payload.workspaceDir, path.join(dataDir, 'workspace'))
+    } finally {
+      fs.chmodSync(externalWorkspace, 0o755)
+      fs.rmSync(tempDir, { recursive: true, force: true })
+    }
+  })
+})

package/src/lib/server/data-dir.ts

@@ -4,18 +4,26 @@ import fs from 'fs'
 
 export const DATA_DIR = process.env.DATA_DIR || path.join(process.cwd(), 'data')
 
+function supportsChildWrites(dir: string): boolean {
+  try {
+    fs.mkdirSync(dir, { recursive: true })
+    const probeDir = fs.mkdtempSync(path.join(dir, '.swarmclaw-probe-'))
+    fs.rmSync(probeDir, { recursive: true, force: true })
+    return true
+  } catch {
+    return false
+  }
+}
+
 // Workspace lives outside the project directory to avoid triggering Next.js HMR
 // when agents create/modify files. Falls back to data/workspace for Docker/CI.
 function resolveWorkspaceDir(): string {
   if (process.env.WORKSPACE_DIR) return process.env.WORKSPACE_DIR
   const external = path.join(os.homedir(), '.swarmclaw', 'workspace')
-  try {
-    fs.mkdirSync(external, { recursive: true })
+  if (supportsChildWrites(external)) {
     return external
-  } catch {
-    // If we can't create the external dir (permissions, etc.), fall back to in-project
-    return path.join(DATA_DIR, 'workspace')
   }
+  return path.join(DATA_DIR, 'workspace')
 }
 
 export const WORKSPACE_DIR = resolveWorkspaceDir()
@@ -23,12 +31,10 @@ export const WORKSPACE_DIR = resolveWorkspaceDir()
 function resolveBrowserProfilesDir(): string {
   if (process.env.BROWSER_PROFILES_DIR) return process.env.BROWSER_PROFILES_DIR
   const external = path.join(os.homedir(), '.swarmclaw', 'browser-profiles')
-  try {
-    fs.mkdirSync(external, { recursive: true })
+  if (supportsChildWrites(external)) {
     return external
-  } catch {
-    return path.join(DATA_DIR, 'browser-profiles')
   }
+  return path.join(DATA_DIR, 'browser-profiles')
 }
 
 export const BROWSER_PROFILES_DIR = resolveBrowserProfilesDir()

package/src/lib/server/heartbeat-service.ts

@@ -12,6 +12,7 @@ import { log } from './logger'
 import { WORKSPACE_DIR } from './data-dir'
 import { drainSystemEvents } from './system-events'
 import { buildIdentityContinuityContext } from './identity-continuity'
+import { ensureAgentThreadSession } from './agent-thread-session'
 
 const HEARTBEAT_TICK_MS = 5_000
 
@@ -126,9 +127,13 @@ export interface HeartbeatConfig {
   target: string | null
 }
 
+interface HeartbeatFileSession {
+  cwd?: string | null
+}
+
 const DEFAULT_HEARTBEAT_PROMPT = 'Read HEARTBEAT.md if it exists (workspace context). Follow it strictly. Do not infer or repeat old tasks from prior chats. If nothing needs attention, reply HEARTBEAT_OK.'
 
-function readHeartbeatFile(session: any): string {
+function readHeartbeatFile(session: HeartbeatFileSession): string {
   try {
     const filePath = path.join(session.cwd || WORKSPACE_DIR, 'HEARTBEAT.md')
     if (fs.existsSync(filePath)) {
@@ -358,8 +363,12 @@ async function tickHeartbeats() {
     return
   }
 
-  const sessions = loadSessions()
   const agents = loadAgents()
+  for (const agent of Object.values(agents) as any[]) {
+    if (!agent?.id || agent.heartbeatEnabled !== true) continue
+    ensureAgentThreadSession(String(agent.id))
+  }
+  const sessions = loadSessions()
   const hasScopedAgents = Object.values(agents).some((a: any) => a?.heartbeatEnabled === true)
 
   // Prune tracked sessions that no longer exist or have heartbeat disabled
@@ -377,7 +386,6 @@ async function tickHeartbeats() {
 
   for (const session of Object.values(sessions) as any[]) {
     if (!session?.id) continue
-    if (!Array.isArray(session.plugins) || session.plugins.length === 0) continue
     if (session.sessionType && session.sessionType !== 'human') continue
 
     // Check if this session or its agent has explicit heartbeat opt-in
@@ -402,8 +410,13 @@ async function tickHeartbeats() {
       : Math.max(cfg.intervalSec * 2, 180)
     const userIdleThresholdSec = resolveHeartbeatUserIdleSec(settings, defaultIdleSec)
     const lastUserAt = lastUserMessageAt(session)
-    if (lastUserAt <= 0) continue
-    const idleMs = now - lastUserAt
+    const baselineAt = lastUserAt > 0
+      ? lastUserAt
+      : explicitOptIn
+        ? (typeof session.lastActiveAt === 'number' ? session.lastActiveAt : (typeof session.createdAt === 'number' ? session.createdAt : 0))
+        : 0
+    if (baselineAt <= 0) continue
+    const idleMs = now - baselineAt
     if (idleMs < userIdleThresholdSec * 1000) continue
 
     const last = state.lastBySession.get(session.id) || 0

package/src/lib/server/heartbeat-wake.ts

@@ -3,6 +3,7 @@
  * Requests are debounced with a 250ms coalesce window to batch rapid-fire events.
  */
 
+import { ensureAgentThreadSession } from './agent-thread-session'
 import { loadSessions, loadAgents, loadSettings } from './storage'
 import { enqueueSessionRun } from './session-run-manager'
 import { log } from './logger'
@@ -29,7 +30,6 @@ function flushWakes(): void {
   const wakes = new Map(state.pending)
   state.pending.clear()
 
-  const sessions = loadSessions()
   const agents = loadAgents()
   const settings = loadSettings()
 
@@ -39,6 +39,7 @@ function flushWakes(): void {
 
       // If only agentId provided, find the agent's most recently active session
       if (!sessionId && wake.agentId) {
+        const sessions = loadSessions()
         let bestSession: { id: string; lastActiveAt: number } | null = null
         for (const s of Object.values(sessions) as Array<Record<string, unknown>>) {
           if (s.agentId !== wake.agentId) continue
@@ -48,11 +49,14 @@ function flushWakes(): void {
           }
         }
         sessionId = bestSession?.id
+        if (!sessionId) {
+          sessionId = ensureAgentThreadSession(wake.agentId)?.id
+        }
       }
 
       if (!sessionId) continue
 
-      const session = sessions[sessionId] as Record<string, unknown> | undefined
+      const session = loadSessions()[sessionId] as Record<string, unknown> | undefined
       if (!session) continue
 
       const agentId = (session.agentId || wake.agentId) as string | undefined

package/src/lib/server/openclaw-deploy.test.ts

@@ -0,0 +1,67 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import {
+  buildOpenClawDeployBundle,
+  getOpenClawLocalDeployStatus,
+} from './openclaw-deploy.ts'
+
+test('docker smart deploy bundle uses official image and provider-specific metadata', () => {
+  const bundle = buildOpenClawDeployBundle({
+    template: 'docker',
+    provider: 'digitalocean',
+    target: 'gateway.example.com',
+    token: 'test-token',
+  })
+
+  assert.equal(bundle.template, 'docker')
+  assert.equal(bundle.provider, 'digitalocean')
+  assert.equal(bundle.providerLabel, 'DigitalOcean')
+  assert.equal(bundle.endpoint, 'https://gateway.example.com/v1')
+  assert.equal(bundle.wsUrl, 'wss://gateway.example.com')
+  assert.match(bundle.summary, /official OpenClaw Docker image/i)
+  assert.deepEqual(bundle.files.map((file) => file.name), [
+    'cloud-init.yaml',
+    '.env',
+    'docker-compose.yml',
+    'bootstrap.sh',
+  ])
+
+  const envFile = bundle.files.find((file) => file.name === '.env')
+  assert.ok(envFile)
+  assert.match(envFile.content, /OPENCLAW_IMAGE=openclaw:latest/)
+  assert.match(envFile.content, /OPENCLAW_GATEWAY_TOKEN=test-token/)
+
+  const cloudInit = bundle.files.find((file) => file.name === 'cloud-init.yaml')
+  assert.ok(cloudInit)
+  assert.match(cloudInit.content, /docker\.io/)
+  assert.match(cloudInit.content, /docker pull "\$\{OPENCLAW_IMAGE:-openclaw:latest\}"/)
+  assert.match(cloudInit.content, /\/opt\/openclaw\/docker-compose\.yml/)
+})
+
+test('render bundle stays aligned with the official repo flow', () => {
+  const bundle = buildOpenClawDeployBundle({
+    template: 'render',
+    target: 'https://openclaw.onrender.com',
+    token: 'render-token',
+  })
+
+  assert.equal(bundle.template, 'render')
+  assert.equal(bundle.providerLabel, 'Render')
+  assert.equal(bundle.endpoint, 'https://openclaw.onrender.com/v1')
+  assert.equal(bundle.token, 'render-token')
+  assert.deepEqual(bundle.files.map((file) => file.name), [
+    'render.yaml',
+    'OPENCLAW_GATEWAY_TOKEN.txt',
+  ])
+  assert.match(bundle.runbook[0] || '', /official OpenClaw GitHub repo/i)
+})
+
+test('local deploy status exposes a sensible default endpoint before startup', () => {
+  const status = getOpenClawLocalDeployStatus()
+
+  assert.equal(status.running, false)
+  assert.equal(status.port, 18789)
+  assert.equal(status.endpoint, 'http://127.0.0.1:18789/v1')
+  assert.equal(status.wsUrl, 'ws://127.0.0.1:18789')
+  assert.match(status.launchCommand, /npx openclaw gateway run/)
+})