@swarmclawai/swarmclaw 0.9.9 → 1.0.2

package/src/app/api/tasks/import/github/helpers.ts

@@ -0,0 +1,100 @@
+import { dedup } from '@/lib/shared-utils'
+
+type GitHubIssueLabel = string | { name?: string | null }
+
+export interface GitHubIssueRecord {
+  id: number | string
+  number: number
+  title: string
+  body?: string | null
+  state?: string | null
+  html_url?: string | null
+  labels?: GitHubIssueLabel[]
+  assignee?: { login?: string | null } | null
+  user?: { login?: string | null } | null
+  pull_request?: unknown
+}
+
+export interface ParsedRepo {
+  owner: string
+  repo: string
+  fullName: string
+}
+
+const BODY_CHAR_LIMIT = 12_000
+
+function normalizeLabelName(label: GitHubIssueLabel): string {
+  if (typeof label === 'string') return label.trim()
+  return String(label?.name || '').trim()
+}
+
+function normalizeTag(value: string): string {
+  return value.trim().replace(/\s+/g, ' ').slice(0, 60)
+}
+
+export function parseGitHubRepoInput(input: string): ParsedRepo | null {
+  const trimmed = input.trim().replace(/\.git$/i, '')
+  if (!trimmed) return null
+
+  if (/^https?:\/\//i.test(trimmed)) {
+    try {
+      const url = new URL(trimmed)
+      if (!/github\.com$/i.test(url.hostname)) return null
+      const parts = url.pathname.split('/').filter(Boolean)
+      if (parts.length < 2) return null
+      const owner = parts[0]
+      const repo = parts[1].replace(/\.git$/i, '')
+      if (!owner || !repo) return null
+      return { owner, repo, fullName: `${owner}/${repo}` }
+    } catch {
+      return null
+    }
+  }
+
+  const compact = trimmed.replace(/^github\.com\//i, '')
+  const parts = compact.split('/').filter(Boolean)
+  if (parts.length < 2) return null
+  const owner = parts[0]
+  const repo = parts[1].replace(/\.git$/i, '')
+  if (!owner || !repo) return null
+  return { owner, repo, fullName: `${owner}/${repo}` }
+}
+
+export function buildGitHubIssueTaskTitle(issue: GitHubIssueRecord, repoFullName: string): string {
+  const title = issue.title?.trim() || `Issue ${issue.number}`
+  return `[${repoFullName}#${issue.number}] ${title}`
+}
+
+export function buildGitHubIssueTaskDescription(issue: GitHubIssueRecord, repoFullName: string): string {
+  const labels = (issue.labels || [])
+    .map(normalizeLabelName)
+    .filter(Boolean)
+  const header = [
+    `Imported from GitHub issue ${repoFullName}#${issue.number}`,
+    issue.html_url ? `URL: ${issue.html_url}` : '',
+    issue.state ? `State: ${issue.state}` : '',
+    labels.length > 0 ? `Labels: ${labels.join(', ')}` : '',
+    issue.assignee?.login ? `Assignee: ${issue.assignee.login}` : '',
+    issue.user?.login ? `Opened by: ${issue.user.login}` : '',
+  ]
+    .filter(Boolean)
+    .join('\n')
+
+  const rawBody = String(issue.body || '').trim()
+  if (!rawBody) return header
+
+  const body = rawBody.length > BODY_CHAR_LIMIT
+    ? `${rawBody.slice(0, BODY_CHAR_LIMIT).trimEnd()}\n\n[Truncated during import]`
+    : rawBody
+
+  return `${header}\n\n${body}`
+}
+
+export function buildGitHubIssueTaskTags(issue: GitHubIssueRecord, repoFullName: string): string[] {
+  const raw = [
+    'github',
+    repoFullName,
+    ...(issue.labels || []).map(normalizeLabelName),
+  ]
+  return dedup(raw.map(normalizeTag).filter(Boolean)).slice(0, 8)
+}

package/src/app/api/tasks/import/github/route.test.ts

@@ -5,7 +5,7 @@ import {
   buildGitHubIssueTaskTags,
   buildGitHubIssueTaskTitle,
   parseGitHubRepoInput,
-} from './route'
+} from './helpers'
 
 test('parseGitHubRepoInput accepts repo slugs and GitHub URLs', () => {
   assert.deepEqual(parseGitHubRepoInput('swarmclawai/swarmclaw'), {

package/src/app/api/tasks/import/github/route.ts

@@ -6,10 +6,10 @@ import { formatZodError } from '@/lib/validation/schemas'
 import { loadSettings, loadTasks, logActivity, upsertStoredItems } from '@/lib/server/storage'
 import { notify } from '@/lib/server/ws-hub'
 import type { BoardTask } from '@/types'
-import { dedup } from '@/lib/shared-utils'
+import { parseGitHubRepoInput, buildGitHubIssueTaskTitle, buildGitHubIssueTaskDescription, buildGitHubIssueTaskTags } from './helpers'
+import type { GitHubIssueRecord } from './helpers'
 
 const MAX_IMPORT_LIMIT = 200
-const BODY_CHAR_LIMIT = 12_000
 
 const GitHubIssueImportSchema = z.object({
   repo: z.string().trim().min(1, 'Repository is required'),
@@ -23,25 +23,6 @@ const GitHubIssueImportSchema = z.object({
 
 type GitHubIssueLabel = string | { name?: string | null }
 
-interface GitHubIssueRecord {
-  id: number | string
-  number: number
-  title: string
-  body?: string | null
-  state?: string | null
-  html_url?: string | null
-  labels?: GitHubIssueLabel[]
-  assignee?: { login?: string | null } | null
-  user?: { login?: string | null } | null
-  pull_request?: unknown
-}
-
-interface ParsedRepo {
-  owner: string
-  repo: string
-  fullName: string
-}
-
 function getGitHubToken(explicitToken: string): string {
   return explicitToken.trim()
     || process.env.GITHUB_TOKEN
@@ -55,10 +36,6 @@ function normalizeLabelName(label: GitHubIssueLabel): string {
   return String(label?.name || '').trim()
 }
 
-function normalizeTag(value: string): string {
-  return value.trim().replace(/\s+/g, ' ').slice(0, 60)
-}
-
 function toIssueSummary(issue: GitHubIssueRecord, taskId?: string) {
   return {
     taskId,
@@ -68,73 +45,6 @@ function toIssueSummary(issue: GitHubIssueRecord, taskId?: string) {
   }
 }
 
-export function parseGitHubRepoInput(input: string): ParsedRepo | null {
-  const trimmed = input.trim().replace(/\.git$/i, '')
-  if (!trimmed) return null
-
-  if (/^https?:\/\//i.test(trimmed)) {
-    try {
-      const url = new URL(trimmed)
-      if (!/github\.com$/i.test(url.hostname)) return null
-      const parts = url.pathname.split('/').filter(Boolean)
-      if (parts.length < 2) return null
-      const owner = parts[0]
-      const repo = parts[1].replace(/\.git$/i, '')
-      if (!owner || !repo) return null
-      return { owner, repo, fullName: `${owner}/${repo}` }
-    } catch {
-      return null
-    }
-  }
-
-  const compact = trimmed.replace(/^github\.com\//i, '')
-  const parts = compact.split('/').filter(Boolean)
-  if (parts.length < 2) return null
-  const owner = parts[0]
-  const repo = parts[1].replace(/\.git$/i, '')
-  if (!owner || !repo) return null
-  return { owner, repo, fullName: `${owner}/${repo}` }
-}
-
-export function buildGitHubIssueTaskTitle(issue: GitHubIssueRecord, repoFullName: string): string {
-  const title = issue.title?.trim() || `Issue ${issue.number}`
-  return `[${repoFullName}#${issue.number}] ${title}`
-}
-
-export function buildGitHubIssueTaskDescription(issue: GitHubIssueRecord, repoFullName: string): string {
-  const labels = (issue.labels || [])
-    .map(normalizeLabelName)
-    .filter(Boolean)
-  const header = [
-    `Imported from GitHub issue ${repoFullName}#${issue.number}`,
-    issue.html_url ? `URL: ${issue.html_url}` : '',
-    issue.state ? `State: ${issue.state}` : '',
-    labels.length > 0 ? `Labels: ${labels.join(', ')}` : '',
-    issue.assignee?.login ? `Assignee: ${issue.assignee.login}` : '',
-    issue.user?.login ? `Opened by: ${issue.user.login}` : '',
-  ]
-    .filter(Boolean)
-    .join('\n')
-
-  const rawBody = String(issue.body || '').trim()
-  if (!rawBody) return header
-
-  const body = rawBody.length > BODY_CHAR_LIMIT
-    ? `${rawBody.slice(0, BODY_CHAR_LIMIT).trimEnd()}\n\n[Truncated during import]`
-    : rawBody
-
-  return `${header}\n\n${body}`
-}
-
-export function buildGitHubIssueTaskTags(issue: GitHubIssueRecord, repoFullName: string): string[] {
-  const raw = [
-    'github',
-    repoFullName,
-    ...(issue.labels || []).map(normalizeLabelName),
-  ]
-  return dedup(raw.map(normalizeTag).filter(Boolean)).slice(0, 8)
-}
-
 function findExistingImportedTask(
   tasks: Record<string, BoardTask>,
   repoFullName: string,

package/src/app/api/webhooks/[id]/helpers.ts

@@ -0,0 +1,253 @@
+import { genId } from '@/lib/id'
+import { NextResponse } from 'next/server'
+import { loadAgents, loadSessions, saveSessions, loadWebhooks, appendWebhookLog, upsertWebhookRetry } from '@/lib/server/storage'
+import { WORKSPACE_DIR } from '@/lib/server/data-dir'
+import { enqueueSessionRun } from '@/lib/server/runtime/session-run-manager'
+import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
+import { requestHeartbeatNow } from '@/lib/server/runtime/heartbeat-wake'
+import { notFound } from '@/lib/server/collection-helpers'
+import type { WebhookRetryEntry } from '@/types'
+import { triggerWebhookWatchJobs } from '@/lib/server/runtime/watch-jobs'
+import { errorMessage } from '@/lib/shared-utils'
+
+export type WebhookPostDeps = {
+  enqueueRun: typeof enqueueSessionRun
+  enqueueEvent: typeof enqueueSystemEvent
+  requestHeartbeat: typeof requestHeartbeatNow
+}
+
+export const defaultWebhookPostDeps: WebhookPostDeps = {
+  enqueueRun: enqueueSessionRun,
+  enqueueEvent: enqueueSystemEvent,
+  requestHeartbeat: requestHeartbeatNow,
+}
+
+function normalizeEvents(value: unknown): string[] {
+  if (!Array.isArray(value)) return []
+  return value
+    .filter((v): v is string => typeof v === 'string')
+    .map((v) => v.trim())
+    .filter(Boolean)
+}
+
+function eventMatches(registered: string[], incoming: string): boolean {
+  if (registered.length === 0) return true
+  if (registered.includes('*')) return true
+  return registered.includes(incoming)
+}
+
+export async function handleWebhookPost(
+  req: Request,
+  id: string,
+  deps: WebhookPostDeps = defaultWebhookPostDeps,
+) {
+  const webhooks = loadWebhooks()
+  const webhook = webhooks[id]
+  if (!webhook) return notFound('Webhook not found')
+  if (webhook.isEnabled === false) {
+    appendWebhookLog(genId(8), {
+      id: genId(8), webhookId: id, event: 'unknown',
+      payload: '', status: 'error', error: 'Webhook is disabled', timestamp: Date.now(),
+    })
+    return NextResponse.json({ error: 'Webhook is disabled' }, { status: 409 })
+  }
+
+  const { timingSafeEqual } = await import('node:crypto')
+  const secret = typeof webhook.secret === 'string' ? webhook.secret.trim() : ''
+  if (secret) {
+    const url = new URL(req.url)
+    const provided = req.headers.get('x-webhook-secret') || url.searchParams.get('secret') || ''
+    const secretBuf = Buffer.from(secret)
+    const providedBuf = Buffer.from(provided)
+    // timingSafeEqual requires equal lengths; compare against secretBuf if lengths differ
+    const compareBuf = providedBuf.length === secretBuf.length ? providedBuf : secretBuf
+    const isInvalid = providedBuf.length !== secretBuf.length || !timingSafeEqual(secretBuf, compareBuf)
+    if (isInvalid) {
+      appendWebhookLog(genId(8), {
+        id: genId(8), webhookId: id, event: 'unknown',
+        payload: '', status: 'error', error: 'Invalid webhook secret', timestamp: Date.now(),
+      })
+      return NextResponse.json({ error: 'Invalid webhook secret' }, { status: 401 })
+    }
+  }
+
+  let payload: unknown = null
+  let rawBody = ''
+  const contentType = req.headers.get('content-type') || ''
+  if (contentType.includes('application/json')) {
+    try {
+      payload = await req.json()
+      rawBody = JSON.stringify(payload)
+    } catch {
+      payload = {}
+      rawBody = '{}'
+    }
+  } else {
+    rawBody = await req.text()
+    try {
+      payload = JSON.parse(rawBody)
+    } catch {
+      payload = { raw: rawBody }
+    }
+  }
+
+  const url = new URL(req.url)
+  const incomingEvent = String(
+    (payload as Record<string, unknown> | null)?.type
+      || (payload as Record<string, unknown> | null)?.event
+      || req.headers.get('x-event-type')
+      || url.searchParams.get('event')
+      || 'unknown',
+  )
+  const registeredEvents = normalizeEvents(webhook.events)
+  if (!eventMatches(registeredEvents, incomingEvent)) {
+    return NextResponse.json({
+      ok: true,
+      ignored: true,
+      reason: 'Event does not match webhook filters',
+      event: incomingEvent,
+    })
+  }
+
+  triggerWebhookWatchJobs({
+    webhookId: id,
+    event: incomingEvent,
+    payloadPreview: rawBody,
+  })
+
+  const agents = loadAgents()
+  const agent = webhook.agentId ? agents[webhook.agentId] : null
+  if (!agent) {
+    appendWebhookLog(genId(8), {
+      id: genId(8), webhookId: id, event: incomingEvent,
+      payload: (rawBody || '').slice(0, 2000), status: 'error', error: 'Webhook agent is not configured or missing', timestamp: Date.now(),
+    })
+    return NextResponse.json({ error: 'Webhook agent is not configured or missing' }, { status: 400 })
+  }
+
+  const sessions = loadSessions()
+  const sessionName = `webhook:${id}`
+  let session = Object.values(sessions).find((s: unknown) => {
+    const rec = s as Record<string, unknown>
+    return rec.name === sessionName && rec.agentId === agent.id
+  }) as Record<string, unknown> | undefined
+  if (!session) {
+    const sessionId = genId()
+    const now = Date.now()
+    session = {
+      id: sessionId,
+      name: sessionName,
+      cwd: WORKSPACE_DIR,
+      user: 'system',
+      provider: agent.provider || 'claude-cli',
+      model: agent.model || '',
+      credentialId: agent.credentialId || null,
+      apiEndpoint: agent.apiEndpoint || null,
+      claudeSessionId: null,
+      codexThreadId: null,
+      opencodeSessionId: null,
+      delegateResumeIds: {
+        claudeCode: null,
+        codex: null,
+        opencode: null,
+      },
+      messages: [],
+      createdAt: now,
+      lastActiveAt: now,
+      sessionType: 'human',
+      agentId: agent.id,
+      parentSessionId: null,
+      tools: agent.tools || [],
+      heartbeatEnabled: agent.heartbeatEnabled ?? false,
+      heartbeatIntervalSec: agent.heartbeatIntervalSec ?? null,
+    }
+    sessions[session.id as string] = session
+    saveSessions(sessions)
+  }
+
+  const sid = session.id as string
+  const payloadPreview = (rawBody || '').slice(0, 12_000)
+  const prompt = [
+    'Webhook event received.',
+    `Webhook ID: ${id}`,
+    `Webhook Name: ${webhook.name || id}`,
+    `Source: ${webhook.source || 'custom'}`,
+    `Event: ${incomingEvent}`,
+    `Received At: ${new Date().toISOString()}`,
+    '',
+    'Payload:',
+    payloadPreview || '(empty payload)',
+    '',
+    'Handle this event now. If this requires notifying the user, use configured connector tools.',
+  ].join('\n')
+
+  try {
+    const run = deps.enqueueRun({
+      sessionId: sid,
+      message: prompt,
+      source: 'webhook',
+      internal: false,
+      mode: 'followup',
+    })
+
+    // Enqueue system event + heartbeat wake
+    deps.enqueueEvent(sid, `Webhook received: ${webhook.name || id} (${incomingEvent})`)
+    if (webhook.agentId) {
+      deps.requestHeartbeat({
+        agentId: webhook.agentId,
+        eventId: `webhook:${id}:${incomingEvent}:${Date.now()}`,
+        reason: 'webhook',
+        source: `webhook:${id}`,
+        resumeMessage: `Webhook received: ${webhook.name || id} (${incomingEvent})`,
+        detail: payloadPreview || '(empty payload)',
+      })
+    }
+
+    appendWebhookLog(genId(8), {
+      id: genId(8), webhookId: id, event: incomingEvent,
+      payload: (rawBody || '').slice(0, 2000), status: 'success',
+      sessionId: sid, runId: run.runId, timestamp: Date.now(),
+    })
+
+    return NextResponse.json({
+      ok: true,
+      webhookId: id,
+      event: incomingEvent,
+      sessionId: sid,
+      runId: run.runId,
+    })
+  } catch (err: unknown) {
+    const errorMsg = errorMessage(err)
+
+    // Enqueue for retry with exponential backoff
+    const retryId = genId()
+    const now = Date.now()
+    const retryEntry: WebhookRetryEntry = {
+      id: retryId,
+      webhookId: id,
+      event: incomingEvent,
+      payload: (rawBody || '').slice(0, 12_000),
+      attempts: 1,
+      maxAttempts: 3,
+      nextRetryAt: now + 30_000,
+      deadLettered: false,
+      createdAt: now,
+    }
+    upsertWebhookRetry(retryId, retryEntry)
+
+    appendWebhookLog(genId(8), {
+      id: genId(8), webhookId: id, event: incomingEvent,
+      payload: (rawBody || '').slice(0, 2000), status: 'error',
+      error: `Dispatch failed, queued for retry: ${errorMsg}`, timestamp: Date.now(),
+    })
+
+    return NextResponse.json({
+      ok: true,
+      webhookId: id,
+      event: incomingEvent,
+      retryQueued: true,
+      retryId,
+      error: errorMsg,
+    })
+  }
+}