@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/src/lib/server/watch-jobs.ts

@@ -8,6 +8,7 @@ import { enqueueSystemEvent } from './system-events'
 import { loadApprovals, loadTasks, loadWatchJobs, upsertWatchJob, upsertWatchJobs } from './storage'
 import { notify } from './ws-hub'
 import { fetchMailboxMessages, getMailboxHighwaterUid } from './mailbox-utils'
+import { errorMessage } from '@/lib/shared-utils'
 
 export interface CreateWatchJobInput {
   type: WatchJob['type']
@@ -408,7 +409,7 @@ export async function processDueWatchJobs(timestamp = now()): Promise<{ checked:
       updates.push([job.id, scheduleNextCheck({
         ...job,
         lastCheckedAt: timestamp,
-        lastError: err instanceof Error ? err.message : String(err),
+        lastError: errorMessage(err),
       }, timestamp)])
     }
   }

package/src/lib/server/workspace-context.ts

@@ -9,8 +9,8 @@
  */
 
 import fs from 'fs'
-import path from 'path'
 import { WORKSPACE_DIR } from './data-dir'
+import { resolvePathWithinBaseDir } from './path-utils'
 
 /**
  * Workspace files to inject, in priority order.
@@ -87,7 +87,7 @@ export function buildWorkspaceContext(opts: WorkspaceContextOptions = {}): Works
   for (const spec of WORKSPACE_FILES) {
     if (totalChars >= maxTotal) break
 
-    const filePath = path.join(workspaceDir, spec.name)
+    const filePath = resolvePathWithinBaseDir(workspaceDir, spec.name)
     const content = readFileSafe(filePath)
     if (!content || isEffectivelyEmpty(content)) continue
 

package/src/lib/shared-utils.test.ts

@@ -0,0 +1,142 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import {
+  errorMessage,
+  safeJsonParse,
+  truncate,
+  hmrSingleton,
+  dedup,
+  dedupBy,
+  sleep,
+} from './shared-utils'
+
+describe('errorMessage', () => {
+  it('extracts message from Error', () => {
+    assert.equal(errorMessage(new Error('boom')), 'boom')
+  })
+  it('converts string to string', () => {
+    assert.equal(errorMessage('fail'), 'fail')
+  })
+  it('converts number to string', () => {
+    assert.equal(errorMessage(42), '42')
+  })
+  it('converts null to string', () => {
+    assert.equal(errorMessage(null), 'null')
+  })
+  it('converts undefined to string', () => {
+    assert.equal(errorMessage(undefined), 'undefined')
+  })
+  it('handles TypeError subclass', () => {
+    assert.equal(errorMessage(new TypeError('bad type')), 'bad type')
+  })
+})
+
+describe('safeJsonParse', () => {
+  it('parses valid JSON', () => {
+    assert.deepEqual(safeJsonParse('{"a":1}', null), { a: 1 })
+  })
+  it('returns fallback for invalid JSON', () => {
+    assert.equal(safeJsonParse('not json', 'default'), 'default')
+  })
+  it('returns fallback for empty string', () => {
+    assert.deepEqual(safeJsonParse('', []), [])
+  })
+  it('parses arrays', () => {
+    assert.deepEqual(safeJsonParse('[1,2,3]', []), [1, 2, 3])
+  })
+  it('parses null literal', () => {
+    assert.equal(safeJsonParse('null', 'fallback'), null)
+  })
+})
+
+describe('truncate', () => {
+  it('returns short strings unchanged', () => {
+    assert.equal(truncate('hello', 10), 'hello')
+  })
+  it('truncates long strings', () => {
+    assert.equal(truncate('hello world', 5), 'hello')
+  })
+  it('truncates with suffix', () => {
+    assert.equal(truncate('hello world', 8, '…'), 'hello w…')
+  })
+  it('handles exact limit', () => {
+    assert.equal(truncate('hello', 5), 'hello')
+  })
+  it('handles zero limit', () => {
+    assert.equal(truncate('hello', 0), '')
+  })
+  it('handles suffix longer than limit gracefully', () => {
+    assert.equal(truncate('hello world', 2, '...'), '...')
+  })
+  it('empty string unchanged', () => {
+    assert.equal(truncate('', 10), '')
+  })
+})
+
+describe('hmrSingleton', () => {
+  it('creates and returns a value', () => {
+    const val = hmrSingleton('__test_hmr_1__', () => ({ count: 0 }))
+    assert.deepEqual(val, { count: 0 })
+  })
+  it('returns same instance on second call', () => {
+    const a = hmrSingleton('__test_hmr_2__', () => ({ id: Math.random() }))
+    const b = hmrSingleton('__test_hmr_2__', () => ({ id: Math.random() }))
+    assert.equal(a, b)
+    assert.equal(a.id, b.id)
+  })
+  it('creates different instances for different keys', () => {
+    const a = hmrSingleton('__test_hmr_3a__', () => 'a')
+    const b = hmrSingleton('__test_hmr_3b__', () => 'b')
+    assert.notEqual(a, b)
+  })
+})
+
+describe('dedup', () => {
+  it('removes duplicates', () => {
+    assert.deepEqual(dedup([1, 2, 2, 3, 1]), [1, 2, 3])
+  })
+  it('preserves order', () => {
+    assert.deepEqual(dedup(['b', 'a', 'b', 'c']), ['b', 'a', 'c'])
+  })
+  it('handles empty array', () => {
+    assert.deepEqual(dedup([]), [])
+  })
+  it('handles all unique', () => {
+    assert.deepEqual(dedup([1, 2, 3]), [1, 2, 3])
+  })
+})
+
+describe('dedupBy', () => {
+  it('deduplicates by key function', () => {
+    const items = [
+      { id: '1', name: 'a' },
+      { id: '2', name: 'b' },
+      { id: '1', name: 'c' },
+    ]
+    const result = dedupBy(items, (i) => i.id)
+    assert.equal(result.length, 2)
+    assert.equal(result[0].name, 'a')
+    assert.equal(result[1].name, 'b')
+  })
+  it('keeps first occurrence', () => {
+    const result = dedupBy(['hello', 'HELLO', 'world'], (s) => s.toLowerCase())
+    assert.deepEqual(result, ['hello', 'world'])
+  })
+  it('handles empty array', () => {
+    assert.deepEqual(dedupBy([], (x) => String(x)), [])
+  })
+})
+
+describe('sleep', () => {
+  it('resolves after delay', async () => {
+    const start = Date.now()
+    await sleep(50)
+    const elapsed = Date.now() - start
+    assert.ok(elapsed >= 40, `Expected ≥40ms, got ${elapsed}ms`)
+  })
+  it('resolves with undefined', async () => {
+    const result = await sleep(1)
+    assert.equal(result, undefined)
+  })
+})

package/src/lib/shared-utils.ts

@@ -0,0 +1,62 @@
+/**
+ * Shared utility functions used across the codebase.
+ *
+ * These replace ad-hoc patterns that were duplicated in 100+ files:
+ * - errorMessage: 231 occurrences across 112 files
+ * - safeJsonParse: 137 occurrences across 82 files
+ * - truncate: 62+ occurrences across 20+ files
+ * - hmrSingleton: 77 occurrences across 38 files
+ * - dedup/dedupBy: 40 occurrences across 28 files
+ * - sleep: 25 occurrences across 17 files
+ */
+
+/** Extract a human-readable error message from an unknown catch value. */
+export function errorMessage(err: unknown): string {
+  return err instanceof Error ? err.message : String(err)
+}
+
+/** Parse JSON with a fallback value instead of throwing. */
+export function safeJsonParse<T>(json: string, fallback: T): T {
+  try {
+    return JSON.parse(json) as T
+  } catch {
+    return fallback
+  }
+}
+
+/** Truncate a string to `limit` characters, optionally appending a suffix. */
+export function truncate(s: string, limit: number, suffix = ''): string {
+  if (s.length <= limit) return s
+  const cutoff = Math.max(0, limit - suffix.length)
+  return s.slice(0, cutoff) + suffix
+}
+
+/**
+ * HMR-safe singleton on globalThis. Survives Next.js hot module reloads.
+ * Replaces the ad-hoc `__swarmclaw_*` pattern scattered across 38 files.
+ */
+export function hmrSingleton<T>(key: string, init: () => T): T {
+  const g = globalThis as Record<string, unknown>
+  return (g[key] ??= init()) as T
+}
+
+/** Deduplicate an array preserving insertion order. */
+export function dedup<T>(arr: T[]): T[] {
+  return [...new Set(arr)]
+}
+
+/** Deduplicate an array by a key function, keeping the first occurrence. */
+export function dedupBy<T>(arr: T[], key: (item: T) => string): T[] {
+  const seen = new Set<string>()
+  return arr.filter((item) => {
+    const k = key(item)
+    if (seen.has(k)) return false
+    seen.add(k)
+    return true
+  })
+}
+
+/** Promise-based sleep. Replaces `await new Promise(r => setTimeout(r, ms))`. */
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}

package/src/lib/tool-event-summary.ts

@@ -1,4 +1,5 @@
 import type { MessageToolEvent } from '@/types'
+import { dedup } from '@/lib/shared-utils'
 
 interface ToolEventAssistantSummaryOptions {
   interrupted?: boolean
@@ -13,7 +14,7 @@ export function buildToolEventAssistantSummary(
     : []
   if (events.length === 0) return ''
 
-  const uniqueNames = [...new Set(events.map((event) => event.name.trim()))]
+  const uniqueNames = dedup(events.map((event) => event.name.trim()))
   const visibleNames = uniqueNames.slice(0, 4).map((name) => `\`${name}\``).join(', ')
   const hiddenCount = Math.max(0, uniqueNames.length - 4)
   const pendingCount = events.filter((event) => !event.output).length

package/src/lib/view-routes.test.ts

@@ -0,0 +1,100 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { parsePath, buildPath, DEFAULT_VIEW, VIEW_TO_PATH, PATH_TO_VIEW } from './view-routes'
+
+describe('DEFAULT_VIEW', () => {
+  it('is home', () => {
+    assert.equal(DEFAULT_VIEW, 'home')
+  })
+})
+
+describe('VIEW_TO_PATH / PATH_TO_VIEW', () => {
+  it('has matching forward and reverse mappings', () => {
+    for (const [view, path] of Object.entries(VIEW_TO_PATH)) {
+      assert.equal(PATH_TO_VIEW[path], view, `PATH_TO_VIEW['${path}'] should be '${view}'`)
+    }
+  })
+
+  it('maps known views', () => {
+    assert.equal(VIEW_TO_PATH.home, '/')
+    assert.equal(VIEW_TO_PATH.agents, '/agents')
+    assert.equal(VIEW_TO_PATH.settings, '/settings')
+    assert.equal(VIEW_TO_PATH.mcp_servers, '/mcp-servers')
+  })
+})
+
+describe('parsePath', () => {
+  it('matches exact routes', () => {
+    assert.deepEqual(parsePath('/'), { view: 'home', id: null })
+    assert.deepEqual(parsePath('/agents'), { view: 'agents', id: null })
+    assert.deepEqual(parsePath('/settings'), { view: 'settings', id: null })
+    assert.deepEqual(parsePath('/mcp-servers'), { view: 'mcp_servers', id: null })
+  })
+
+  it('parses agents deep link with ID', () => {
+    assert.deepEqual(parsePath('/agents/abc123'), { view: 'agents', id: 'abc123' })
+  })
+
+  it('parses chatrooms deep link with ID', () => {
+    assert.deepEqual(parsePath('/chatrooms/room-1'), { view: 'chatrooms', id: 'room-1' })
+  })
+
+  it('decodes URI components in IDs', () => {
+    assert.deepEqual(
+      parsePath('/agents/hello%20world'),
+      { view: 'agents', id: 'hello world' },
+    )
+  })
+
+  it('returns null for malformed URI encoding', () => {
+    assert.equal(parsePath('/agents/%ZZ'), null)
+  })
+
+  it('rejects deep link for views that do not support IDs', () => {
+    assert.equal(parsePath('/settings/something'), null)
+    assert.equal(parsePath('/wallets/abc'), null)
+    assert.equal(parsePath('/tasks/123'), null)
+  })
+
+  it('rejects nested paths beyond one level', () => {
+    assert.equal(parsePath('/agents/abc/def'), null)
+  })
+
+  it('returns null for unknown paths', () => {
+    assert.equal(parsePath('/unknown'), null)
+    assert.equal(parsePath('/foo/bar'), null)
+  })
+
+  it('longest-path-first matching prevents prefix collisions', () => {
+    // /mcp-servers should not be matched as /m... prefix of something else
+    assert.deepEqual(parsePath('/mcp-servers'), { view: 'mcp_servers', id: null })
+  })
+})
+
+describe('buildPath', () => {
+  it('builds basic view paths', () => {
+    assert.equal(buildPath('home'), '/')
+    assert.equal(buildPath('agents'), '/agents')
+    assert.equal(buildPath('settings'), '/settings')
+  })
+
+  it('appends encoded ID for views that support it', () => {
+    assert.equal(buildPath('agents', 'abc123'), '/agents/abc123')
+    assert.equal(buildPath('chatrooms', 'room-1'), '/chatrooms/room-1')
+  })
+
+  it('encodes special characters in ID', () => {
+    assert.equal(buildPath('agents', 'hello world'), '/agents/hello%20world')
+    assert.equal(buildPath('agents', 'a/b'), '/agents/a%2Fb')
+  })
+
+  it('ignores ID for views that do not support it', () => {
+    assert.equal(buildPath('settings', 'ignored'), '/settings')
+    assert.equal(buildPath('wallets', 'ignored'), '/wallets')
+  })
+
+  it('ignores null/empty ID', () => {
+    assert.equal(buildPath('agents', null), '/agents')
+    assert.equal(buildPath('agents', ''), '/agents')
+  })
+})