@swarmclawai/swarmclaw 0.7.6 → 0.7.8

package/src/app/api/openclaw/deploy/route.ts

@@ -1,11 +1,19 @@
 import { NextResponse } from 'next/server'
 import {
   buildOpenClawDeployBundle,
+  deployOpenClawOverSsh,
   getOpenClawLocalDeployStatus,
+  getOpenClawRemoteDeployStatus,
+  restartOpenClawLocalDeploy,
+  runOpenClawRemoteLifecycle,
   startOpenClawLocalDeploy,
   stopOpenClawLocalDeploy,
+  verifyOpenClawDeployment,
+  type OpenClawExposurePreset,
   type OpenClawRemoteDeployProvider,
   type OpenClawRemoteDeployTemplate,
+  type OpenClawSshConfig,
+  type OpenClawUseCaseTemplate,
 } from '@/lib/server/openclaw-deploy'
 
 export const dynamic = 'force-dynamic'
@@ -19,6 +27,12 @@ function parsePort(value: unknown): number | undefined {
   return Number.isFinite(parsed) ? parsed : undefined
 }
 
+function parseIntBounded(value: unknown, fallback: number, min: number, max: number): number {
+  const parsed = parsePort(value)
+  if (typeof parsed !== 'number') return fallback
+  return Math.max(min, Math.min(max, parsed))
+}
+
 function parseTemplate(value: unknown): OpenClawRemoteDeployTemplate | undefined {
   if (value === 'docker' || value === 'render' || value === 'fly' || value === 'railway') {
     return value
@@ -43,9 +57,48 @@ function parseProvider(value: unknown): OpenClawRemoteDeployProvider | undefined
   return undefined
 }
 
+function parseUseCase(value: unknown): OpenClawUseCaseTemplate | undefined {
+  if (
+    value === 'local-dev'
+    || value === 'single-vps'
+    || value === 'private-tailnet'
+    || value === 'browser-heavy'
+    || value === 'team-control'
+  ) {
+    return value
+  }
+  return undefined
+}
+
+function parseExposure(value: unknown): OpenClawExposurePreset | undefined {
+  if (
+    value === 'private-lan'
+    || value === 'tailscale'
+    || value === 'caddy'
+    || value === 'nginx'
+    || value === 'ssh-tunnel'
+  ) {
+    return value
+  }
+  return undefined
+}
+
+function parseSsh(value: unknown): Partial<OpenClawSshConfig> | null {
+  if (!value || typeof value !== 'object') return null
+  const ssh = value as Record<string, unknown>
+  return {
+    host: typeof ssh.host === 'string' ? ssh.host : '',
+    user: typeof ssh.user === 'string' ? ssh.user : null,
+    port: parsePort(ssh.port),
+    keyPath: typeof ssh.keyPath === 'string' ? ssh.keyPath : null,
+    targetDir: typeof ssh.targetDir === 'string' ? ssh.targetDir : null,
+  }
+}
+
 export async function GET() {
   return NextResponse.json({
     local: getOpenClawLocalDeployStatus(),
+    remote: getOpenClawRemoteDeployStatus(),
   })
 }
 
@@ -73,6 +126,18 @@ export async function POST(req: Request) {
       })
     }
 
+    if (action === 'restart-local') {
+      const result = await restartOpenClawLocalDeploy({
+        port: parsePort(body.port),
+        token: typeof body.token === 'string' ? body.token : null,
+      })
+      return NextResponse.json({
+        ok: true,
+        local: result.local,
+        token: result.token,
+      })
+    }
+
     if (action === 'bundle') {
       const bundle = buildOpenClawDeployBundle({
         template: parseTemplate(body.template),
@@ -81,6 +146,8 @@ export async function POST(req: Request) {
         scheme: body.scheme === 'http' ? 'http' : 'https',
         port: parsePort(body.port),
         provider: parseProvider(body.provider),
+        useCase: parseUseCase(body.useCase),
+        exposure: parseExposure(body.exposure),
       })
       return NextResponse.json({
         ok: true,
@@ -88,6 +155,78 @@ export async function POST(req: Request) {
       })
     }
 
+    if (action === 'ssh-deploy') {
+      const result = await deployOpenClawOverSsh({
+        template: parseTemplate(body.template),
+        target: typeof body.target === 'string' ? body.target : null,
+        token: typeof body.token === 'string' ? body.token : null,
+        scheme: body.scheme === 'http' ? 'http' : 'https',
+        port: parsePort(body.port),
+        provider: parseProvider(body.provider),
+        useCase: parseUseCase(body.useCase),
+        exposure: parseExposure(body.exposure),
+        ssh: parseSsh(body.ssh),
+      })
+      return NextResponse.json({
+        ok: result.ok,
+        remote: getOpenClawRemoteDeployStatus(),
+        processId: result.processId || null,
+        token: result.token,
+        bundle: result.bundle,
+        summary: result.summary,
+        commandPreview: result.commandPreview,
+      })
+    }
+
+    if (
+      action === 'remote-start'
+      || action === 'remote-stop'
+      || action === 'remote-restart'
+      || action === 'remote-upgrade'
+      || action === 'remote-backup'
+      || action === 'remote-restore'
+      || action === 'remote-rotate-token'
+    ) {
+      const actionMap = {
+        'remote-start': 'start',
+        'remote-stop': 'stop',
+        'remote-restart': 'restart',
+        'remote-upgrade': 'upgrade',
+        'remote-backup': 'backup',
+        'remote-restore': 'restore',
+        'remote-rotate-token': 'rotate-token',
+      } as const
+      const lifecycleAction = action as keyof typeof actionMap
+      const result = await runOpenClawRemoteLifecycle({
+        action: actionMap[lifecycleAction],
+        ssh: parseSsh(body.ssh),
+        token: typeof body.token === 'string' ? body.token : null,
+        backupPath: typeof body.backupPath === 'string' ? body.backupPath : null,
+      })
+      return NextResponse.json({
+        ok: result.ok,
+        remote: getOpenClawRemoteDeployStatus(),
+        processId: result.processId || null,
+        token: result.token,
+        summary: result.summary,
+        commandPreview: result.commandPreview,
+      })
+    }
+
+    if (action === 'verify') {
+      const result = await verifyOpenClawDeployment({
+        endpoint: typeof body.endpoint === 'string' ? body.endpoint : null,
+        credentialId: typeof body.credentialId === 'string' ? body.credentialId : null,
+        token: typeof body.token === 'string' ? body.token : null,
+        model: typeof body.model === 'string' ? body.model : null,
+        timeoutMs: parseIntBounded(body.timeoutMs, 8000, 1000, 30000),
+      })
+      return NextResponse.json({
+        ok: result.ok,
+        verify: result,
+      })
+    }
+
     return NextResponse.json({ ok: false, error: 'Unknown deploy action.' }, { status: 400 })
   } catch (err: unknown) {
     return NextResponse.json(

package/src/app/api/projects/[id]/route.ts

@@ -1,6 +1,7 @@
 import { NextResponse } from 'next/server'
-import { loadProjects, saveProjects, deleteProject, loadAgents, saveAgents, loadTasks, saveTasks, loadSchedules, saveSchedules, loadSkills, saveSkills } from '@/lib/server/storage'
+import { loadProjects, saveProjects, deleteProject, loadAgents, saveAgents, loadTasks, saveTasks, loadSchedules, saveSchedules, loadSkills, saveSkills, loadSecrets, saveSecrets } from '@/lib/server/storage'
 import { mutateItem, deleteItem, notFound, type CollectionOps } from '@/lib/server/collection-helpers'
+import { ensureProjectWorkspace, normalizeProjectPatchInput } from '@/lib/server/project-utils'
 import { notify } from '@/lib/server/ws-hub'
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -17,12 +18,14 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
   const { id } = await params
   const body = await req.json()
   const result = mutateItem(ops, id, (project) => {
-    Object.assign(project, body, { updatedAt: Date.now() })
+    const patch = normalizeProjectPatchInput(body && typeof body === 'object' ? body as Record<string, unknown> : {})
+    Object.assign(project, patch, { updatedAt: Date.now() })
     delete (project as Record<string, unknown>).id
     project.id = id
     return project
   })
   if (!result) return notFound()
+  ensureProjectWorkspace(id, result.name)
   return NextResponse.json(result)
 }
 
@@ -50,6 +53,7 @@ export async function DELETE(_req: Request, { params }: { params: Promise<{ id:
   clearProjectId(loadTasks, saveTasks, 'tasks')
   clearProjectId(loadSchedules, saveSchedules, 'schedules')
   clearProjectId(loadSkills, saveSkills, 'skills')
+  clearProjectId(loadSecrets, saveSecrets, 'secrets')
 
   return NextResponse.json({ ok: true })
 }

package/src/app/api/projects/route.ts

@@ -1,6 +1,7 @@
 import { NextResponse } from 'next/server'
 import { genId } from '@/lib/id'
 import { loadProjects, saveProjects } from '@/lib/server/storage'
+import { ensureProjectWorkspace, normalizeProjectCreateInput } from '@/lib/server/project-utils'
 import { notify } from '@/lib/server/ws-hub'
 export const dynamic = 'force-dynamic'
 
@@ -13,15 +14,15 @@ export async function POST(req: Request) {
   const id = genId()
   const now = Date.now()
   const projects = loadProjects()
+  const normalized = normalizeProjectCreateInput(body && typeof body === 'object' ? body as Record<string, unknown> : {})
   projects[id] = {
     id,
-    name: body.name || 'Unnamed Project',
-    description: body.description || '',
-    color: body.color || undefined,
+    ...normalized,
     createdAt: now,
     updatedAt: now,
   }
   saveProjects(projects)
+  ensureProjectWorkspace(id, projects[id].name)
   notify('projects')
   return NextResponse.json(projects[id])
 }

package/src/app/api/secrets/[id]/route.ts

@@ -19,6 +19,7 @@ export async function PUT(req: Request, { params }: { params: Promise<{ id: stri
     if (body.service !== undefined) secret.service = body.service
     if (body.scope !== undefined) secret.scope = body.scope
     if (body.agentIds !== undefined) secret.agentIds = body.agentIds
+    if (body.projectId !== undefined) secret.projectId = body.projectId || undefined
     secret.updatedAt = Date.now()
     return secret
   })

package/src/app/api/secrets/route.ts

@@ -10,7 +10,7 @@ export async function GET(_req: Request) {
   const safe = Object.fromEntries(
     Object.entries(secrets).map(([id, s]: [string, any]) => [
       id,
-      { id: s.id, name: s.name, service: s.service, scope: s.scope, agentIds: s.agentIds, createdAt: s.createdAt, updatedAt: s.updatedAt },
+      { id: s.id, name: s.name, service: s.service, scope: s.scope, agentIds: s.agentIds, projectId: s.projectId, createdAt: s.createdAt, updatedAt: s.updatedAt },
     ])
   )
   return NextResponse.json(safe)
@@ -33,6 +33,7 @@ export async function POST(req: Request) {
     encryptedValue: encryptKey(body.value),
     scope: body.scope || 'global',
     agentIds: body.agentIds || [],
+    projectId: typeof body.projectId === 'string' && body.projectId.trim() ? body.projectId.trim() : undefined,
     createdAt: now,
     updatedAt: now,
   }

package/src/app/api/settings/route.ts

@@ -126,6 +126,8 @@ export async function PUT(req: Request) {
   settings.taskQualityGateRequireVerification = parseBoolSetting(settings.taskQualityGateRequireVerification, false)
   settings.taskQualityGateRequireArtifact = parseBoolSetting(settings.taskQualityGateRequireArtifact, false)
   settings.taskQualityGateRequireReport = parseBoolSetting(settings.taskQualityGateRequireReport, false)
+  settings.taskManagementEnabled = parseBoolSetting(settings.taskManagementEnabled, true)
+  settings.projectManagementEnabled = parseBoolSetting(settings.projectManagementEnabled, true)
   settings.integrityMonitorEnabled = parseBoolSetting(settings.integrityMonitorEnabled, true)
   settings.sessionResetMode = settings.sessionResetMode === 'daily' ? 'daily' : settings.sessionResetMode === 'idle' ? 'idle' : null
   settings.sessionIdleTimeoutSec = parseIntSetting(

package/src/cli/index.js

@@ -319,10 +319,50 @@ const COMMAND_GROUPS = [
         expectsJsonBody: true,
         defaultBody: { action: 'stop-local' },
       }),
+      cmd('deploy-local-restart', 'POST', '/openclaw/deploy', 'Restart the managed local OpenClaw deployment (use --data JSON for port/token overrides)', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'restart-local' },
+      }),
       cmd('deploy-bundle', 'POST', '/openclaw/deploy', 'Generate an OpenClaw remote deployment bundle (use --data JSON for template/target/token)', {
         expectsJsonBody: true,
         defaultBody: { action: 'bundle' },
       }),
+      cmd('deploy-ssh', 'POST', '/openclaw/deploy', 'Push the official-image OpenClaw bundle to a remote host over SSH (use --data JSON for target/ssh/provider)', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'ssh-deploy' },
+      }),
+      cmd('deploy-verify', 'POST', '/openclaw/deploy', 'Verify an OpenClaw endpoint/token pair (use --data JSON for endpoint/token)', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'verify' },
+      }),
+      cmd('remote-start', 'POST', '/openclaw/deploy', 'Start a remote SSH-managed OpenClaw stack', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'remote-start' },
+      }),
+      cmd('remote-stop', 'POST', '/openclaw/deploy', 'Stop a remote SSH-managed OpenClaw stack', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'remote-stop' },
+      }),
+      cmd('remote-restart', 'POST', '/openclaw/deploy', 'Restart a remote SSH-managed OpenClaw stack', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'remote-restart' },
+      }),
+      cmd('remote-upgrade', 'POST', '/openclaw/deploy', 'Upgrade a remote SSH-managed OpenClaw stack', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'remote-upgrade' },
+      }),
+      cmd('remote-backup', 'POST', '/openclaw/deploy', 'Create a remote backup on an SSH-managed OpenClaw host', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'remote-backup' },
+      }),
+      cmd('remote-restore', 'POST', '/openclaw/deploy', 'Restore a remote backup on an SSH-managed OpenClaw host', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'remote-restore' },
+      }),
+      cmd('remote-rotate-token', 'POST', '/openclaw/deploy', 'Rotate the gateway token on an SSH-managed OpenClaw host', {
+        expectsJsonBody: true,
+        defaultBody: { action: 'remote-rotate-token' },
+      }),
       cmd('directory', 'GET', '/openclaw/directory', 'List directory entries from running OpenClaw connectors'),
       cmd('gateway-status', 'GET', '/openclaw/gateway', 'Check OpenClaw gateway connection status'),
       cmd('gateway', 'POST', '/openclaw/gateway', 'Call OpenClaw gateway RPC/control action', { expectsJsonBody: true }),

package/src/cli/index.test.js

@@ -197,6 +197,74 @@ test('openclaw deploy bundle command merges action with provided JSON body', asy
   assert.equal(stderr.toString(), '')
 })
 
+test('openclaw deploy ssh command merges action with provided JSON body', async () => {
+  const stdout = makeWritable()
+  const stderr = makeWritable()
+  const calls = []
+
+  const fetchImpl = async (url, init) => {
+    calls.push({ url: String(url), init })
+    return jsonResponse({ ok: true, processId: 'remote-1' })
+  }
+
+  const exitCode = await runCli(
+    ['openclaw', 'deploy-ssh', '--data', '{"target":"openclaw.example.com","ssh":{"host":"1.2.3.4"}}', '--json'],
+    {
+      fetchImpl,
+      stdout,
+      stderr,
+      env: {},
+      cwd: process.cwd(),
+    }
+  )
+
+  assert.equal(exitCode, 0)
+  assert.equal(calls.length, 1)
+  assert.match(calls[0].url, /\/api\/openclaw\/deploy$/)
+  assert.equal(calls[0].init.method, 'POST')
+  assert.deepEqual(JSON.parse(String(calls[0].init.body)), {
+    action: 'ssh-deploy',
+    target: 'openclaw.example.com',
+    ssh: { host: '1.2.3.4' },
+  })
+  assert.equal(stdout.toString().trim(), '{"ok":true,"processId":"remote-1"}')
+  assert.equal(stderr.toString(), '')
+})
+
+test('openclaw remote restore command merges action with provided JSON body', async () => {
+  const stdout = makeWritable()
+  const stderr = makeWritable()
+  const calls = []
+
+  const fetchImpl = async (url, init) => {
+    calls.push({ url: String(url), init })
+    return jsonResponse({ ok: true, remote: { status: 'running' } })
+  }
+
+  const exitCode = await runCli(
+    ['openclaw', 'remote-restore', '--data', '{"backupPath":"/opt/openclaw/backups/latest.tgz","ssh":{"host":"1.2.3.4"}}', '--json'],
+    {
+      fetchImpl,
+      stdout,
+      stderr,
+      env: {},
+      cwd: process.cwd(),
+    }
+  )
+
+  assert.equal(exitCode, 0)
+  assert.equal(calls.length, 1)
+  assert.match(calls[0].url, /\/api\/openclaw\/deploy$/)
+  assert.equal(calls[0].init.method, 'POST')
+  assert.deepEqual(JSON.parse(String(calls[0].init.body)), {
+    action: 'remote-restore',
+    backupPath: '/opt/openclaw/backups/latest.tgz',
+    ssh: { host: '1.2.3.4' },
+  })
+  assert.equal(stdout.toString().trim(), '{"ok":true,"remote":{"status":"running"}}')
+  assert.equal(stderr.toString(), '')
+})
+
 test('runCli falls back to platform-api-key.txt when env key is missing', async () => {
   const stdout = makeWritable()
   const stderr = makeWritable()

package/src/cli/spec.js

@@ -224,12 +224,72 @@ const COMMAND_GROUPS = {
         path: '/openclaw/deploy',
         staticBody: { action: 'stop-local' },
       },
+      'deploy-local-restart': {
+        description: 'Restart the managed local OpenClaw deployment (use --data JSON for port/token overrides)',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'restart-local' },
+      },
       'deploy-bundle': {
         description: 'Generate an OpenClaw remote deployment bundle (use --data JSON for template/target/token)',
         method: 'POST',
         path: '/openclaw/deploy',
         staticBody: { action: 'bundle' },
       },
+      'deploy-ssh': {
+        description: 'Push the official-image OpenClaw bundle to a remote host over SSH (use --data JSON for target/ssh/provider)',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'ssh-deploy' },
+      },
+      'deploy-verify': {
+        description: 'Verify an OpenClaw endpoint/token pair (use --data JSON for endpoint/token)',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'verify' },
+      },
+      'remote-start': {
+        description: 'Start a remote SSH-managed OpenClaw stack',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'remote-start' },
+      },
+      'remote-stop': {
+        description: 'Stop a remote SSH-managed OpenClaw stack',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'remote-stop' },
+      },
+      'remote-restart': {
+        description: 'Restart a remote SSH-managed OpenClaw stack',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'remote-restart' },
+      },
+      'remote-upgrade': {
+        description: 'Upgrade a remote SSH-managed OpenClaw stack',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'remote-upgrade' },
+      },
+      'remote-backup': {
+        description: 'Create a remote backup on an SSH-managed OpenClaw host',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'remote-backup' },
+      },
+      'remote-restore': {
+        description: 'Restore a remote backup on an SSH-managed OpenClaw host',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'remote-restore' },
+      },
+      'remote-rotate-token': {
+        description: 'Rotate the gateway token on an SSH-managed OpenClaw host',
+        method: 'POST',
+        path: '/openclaw/deploy',
+        staticBody: { action: 'remote-rotate-token' },
+      },
       directory: { description: 'List directory entries from running OpenClaw connectors', method: 'GET', path: '/openclaw/directory' },
       'gateway-status': { description: 'Check OpenClaw gateway connection status', method: 'GET', path: '/openclaw/gateway' },
       gateway: { description: 'Call OpenClaw gateway RPC/control action', method: 'POST', path: '/openclaw/gateway' },