@swarmclawai/swarmclaw 0.2.0

package/src/lib/server/skills-normalize.ts

@@ -0,0 +1,130 @@
+import path from 'path'
+
+export type SkillSourceFormat = 'openclaw' | 'plain'
+
+type NormalizeSkillInput = {
+  name?: unknown
+  description?: unknown
+  filename?: unknown
+  content?: unknown
+  sourceUrl?: unknown
+}
+
+export type NormalizedSkill = {
+  name: string
+  description: string
+  filename: string
+  content: string
+  sourceUrl?: string
+  sourceFormat: SkillSourceFormat
+}
+
+function asTrimmedString(value: unknown): string | null {
+  if (typeof value !== 'string') return null
+  const trimmed = value.trim()
+  return trimmed.length > 0 ? trimmed : null
+}
+
+function stripQuotes(value: string): string {
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+    return value.slice(1, -1)
+  }
+  return value
+}
+
+function slugify(input: string): string {
+  return input
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 80) || 'skill'
+}
+
+function sanitizeFilename(input: string): string {
+  const base = path.basename(input.trim())
+  const safe = base.replace(/[^a-zA-Z0-9._-]/g, '-')
+  if (!safe) return 'skill.md'
+  return safe.toLowerCase().endsWith('.md') ? safe : `${safe}.md`
+}
+
+function parseFrontmatterBlock(content: string): { frontmatter: Record<string, string>; body: string } | null {
+  const match = content.match(/^\s*---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/)
+  if (!match) return null
+  const rawFrontmatter = match[1]
+  const body = match[2] || ''
+
+  const frontmatter: Record<string, string> = {}
+  for (const rawLine of rawFrontmatter.split(/\r?\n/)) {
+    const line = rawLine.trim()
+    if (!line || line.startsWith('#')) continue
+    const idx = line.indexOf(':')
+    if (idx === -1) continue
+    const key = line.slice(0, idx).trim().toLowerCase()
+    const value = stripQuotes(line.slice(idx + 1).trim())
+    if (key) frontmatter[key] = value
+  }
+
+  return { frontmatter, body }
+}
+
+function deriveNameFromFilename(filename: string): string {
+  return filename
+    .replace(/\.md$/i, '')
+    .replace(/[-_]+/g, ' ')
+    .trim() || 'Unnamed Skill'
+}
+
+function deriveFilenameFromUrl(url: string): string | null {
+  try {
+    const u = new URL(url)
+    const basename = path.basename(u.pathname)
+    if (!basename) return null
+    if (basename.toUpperCase() === 'SKILL.MD') {
+      const parent = path.basename(path.dirname(u.pathname))
+      if (parent) return `${slugify(parent)}.md`
+    }
+    return sanitizeFilename(basename)
+  } catch {
+    return null
+  }
+}
+
+export function normalizeSkillPayload(input: NormalizeSkillInput): NormalizedSkill {
+  const rawContent = typeof input.content === 'string' ? input.content : ''
+  const parsed = parseFrontmatterBlock(rawContent)
+
+  const frontmatterName = asTrimmedString(parsed?.frontmatter?.name)
+  const frontmatterDescription = asTrimmedString(parsed?.frontmatter?.description)
+
+  const sourceUrl = asTrimmedString(input.sourceUrl) || undefined
+
+  const initialFilename = asTrimmedString(input.filename)
+    || (sourceUrl ? deriveFilenameFromUrl(sourceUrl) : null)
+    || (frontmatterName ? `${slugify(frontmatterName)}.md` : null)
+    || 'skill.md'
+  const filename = sanitizeFilename(initialFilename)
+
+  const name = asTrimmedString(input.name)
+    || frontmatterName
+    || deriveNameFromFilename(filename)
+
+  const description = asTrimmedString(input.description)
+    || frontmatterDescription
+    || ''
+
+  // For OpenClaw SKILL.md, keep only body instructions when frontmatter exists.
+  const normalizedContent = parsed ? parsed.body.trimStart() : rawContent
+
+  const sourceFormat: SkillSourceFormat = parsed && (frontmatterName !== null || frontmatterDescription !== null || parsed.frontmatter.metadata)
+    ? 'openclaw'
+    : 'plain'
+
+  return {
+    name,
+    description,
+    filename,
+    content: normalizedContent,
+    sourceUrl,
+    sourceFormat,
+  }
+}

package/src/lib/server/storage-mcp.test.ts

@@ -0,0 +1,161 @@
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import Database from 'better-sqlite3'
+import os from 'node:os'
+import path from 'node:path'
+import fs from 'node:fs'
+
+/**
+ * Tests for the MCP server storage operations (loadMcpServers, saveMcpServers, deleteMcpServer).
+ *
+ * Since storage.ts uses a hardcoded DB path with module-level initialization,
+ * we replicate the same SQL pattern against a temporary SQLite database.
+ */
+
+const TABLE = 'mcp_servers'
+
+let dbPath: string
+let db: InstanceType<typeof Database>
+
+// --- Replicated storage helpers (mirror storage.ts logic) ---
+
+function loadMcpServers(): Record<string, any> {
+  const rows = db.prepare(`SELECT id, data FROM ${TABLE}`).all() as { id: string; data: string }[]
+  const result: Record<string, any> = {}
+  for (const row of rows) {
+    try {
+      result[row.id] = JSON.parse(row.data)
+    } catch {
+      // skip malformed
+    }
+  }
+  return result
+}
+
+function saveMcpServers(m: Record<string, any>) {
+  const upsert = db.prepare(`INSERT OR REPLACE INTO ${TABLE} (id, data) VALUES (?, ?)`)
+  const transaction = db.transaction(() => {
+    for (const [id, val] of Object.entries(m)) {
+      upsert.run(id, JSON.stringify(val))
+    }
+  })
+  transaction()
+}
+
+function deleteMcpServer(id: string) {
+  db.prepare(`DELETE FROM ${TABLE} WHERE id = ?`).run(id)
+}
+
+// --- Test setup / teardown ---
+
+before(() => {
+  dbPath = path.join(os.tmpdir(), `test-storage-mcp-${Date.now()}.db`)
+  db = new Database(dbPath)
+  db.pragma('journal_mode = WAL')
+  db.exec(`CREATE TABLE IF NOT EXISTS ${TABLE} (id TEXT PRIMARY KEY, data TEXT NOT NULL)`)
+})
+
+after(() => {
+  db.close()
+  try { fs.unlinkSync(dbPath) } catch { /* ignore */ }
+  try { fs.unlinkSync(dbPath + '-wal') } catch { /* ignore */ }
+  try { fs.unlinkSync(dbPath + '-shm') } catch { /* ignore */ }
+})
+
+// --- Tests ---
+
+describe('MCP server storage', () => {
+  it('saveMcpServers saves a config and it is retrievable', () => {
+    const config = { id: 'srv-1', name: 'Test MCP', url: 'http://localhost:9000' }
+    saveMcpServers({ 'srv-1': config })
+
+    const row = db.prepare(`SELECT data FROM ${TABLE} WHERE id = ?`).get('srv-1') as { data: string } | undefined
+    assert.ok(row, 'row should exist after save')
+    assert.deepStrictEqual(JSON.parse(row.data), config)
+  })
+
+  it('loadMcpServers returns all saved configs', () => {
+    // srv-1 already exists from previous test
+    saveMcpServers({ 'srv-2': { id: 'srv-2', name: 'Second' } })
+
+    const all = loadMcpServers()
+    assert.ok('srv-1' in all)
+    assert.ok('srv-2' in all)
+    assert.equal(all['srv-2'].name, 'Second')
+  })
+
+  it('loadMcpServers returns empty object when table is empty', () => {
+    db.exec(`DELETE FROM ${TABLE}`)
+    const all = loadMcpServers()
+    assert.deepStrictEqual(all, {})
+  })
+
+  it('saveMcpServers with same id updates the record', () => {
+    saveMcpServers({ 'srv-u': { id: 'srv-u', name: 'Original' } })
+    saveMcpServers({ 'srv-u': { id: 'srv-u', name: 'Updated' } })
+
+    const all = loadMcpServers()
+    assert.equal(all['srv-u'].name, 'Updated')
+
+    // only one row for that id
+    const count = (db.prepare(`SELECT COUNT(*) as c FROM ${TABLE} WHERE id = ?`).get('srv-u') as { c: number }).c
+    assert.equal(count, 1)
+  })
+
+  it('deleteMcpServer removes the record', () => {
+    saveMcpServers({ 'srv-d': { id: 'srv-d', name: 'ToDelete' } })
+    deleteMcpServer('srv-d')
+
+    const row = db.prepare(`SELECT data FROM ${TABLE} WHERE id = ?`).get('srv-d')
+    assert.equal(row, undefined)
+  })
+
+  it('deleteMcpServer does not throw for nonexistent id', () => {
+    assert.doesNotThrow(() => {
+      deleteMcpServer('nonexistent-id-xyz')
+    })
+  })
+
+  it('round-trip: save multiple, load all, verify count and data', () => {
+    db.exec(`DELETE FROM ${TABLE}`)
+
+    const configs: Record<string, any> = {}
+    for (let i = 0; i < 5; i++) {
+      configs[`rt-${i}`] = { id: `rt-${i}`, name: `Server ${i}`, port: 3000 + i }
+    }
+    saveMcpServers(configs)
+
+    const all = loadMcpServers()
+    assert.equal(Object.keys(all).length, 5)
+    for (let i = 0; i < 5; i++) {
+      assert.equal(all[`rt-${i}`].port, 3000 + i)
+    }
+  })
+
+  it('data integrity: saved JSON is correctly parsed back with all fields', () => {
+    db.exec(`DELETE FROM ${TABLE}`)
+
+    const config = {
+      id: 'integrity-1',
+      name: 'Full Config',
+      url: 'https://mcp.example.com',
+      transport: 'stdio',
+      command: 'npx',
+      args: ['-y', '@modelcontextprotocol/server-filesystem'],
+      env: { HOME: '/tmp' },
+      enabled: true,
+      createdAt: 1700000000000,
+      tags: ['production', 'filesystem'],
+      nested: { deep: { value: 42 } },
+    }
+
+    saveMcpServers({ 'integrity-1': config })
+    const loaded = loadMcpServers()
+
+    assert.deepStrictEqual(loaded['integrity-1'], config)
+    assert.ok(Array.isArray(loaded['integrity-1'].args))
+    assert.equal(loaded['integrity-1'].args.length, 2)
+    assert.equal(loaded['integrity-1'].nested.deep.value, 42)
+    assert.equal(typeof loaded['integrity-1'].enabled, 'boolean')
+  })
+})