@swarmclawai/swarmclaw 1.2.3 → 1.2.5

package/src/lib/server/connectors/session-consolidation.ts

@@ -3,7 +3,9 @@
  * Populates the field from existing senderId, senderIdAlt, channelId, channelIdAlt, peerKey.
  */
 import { log } from '@/lib/server/logger'
-import { loadSessions, loadSettings, saveSettings, upsertStoredItem } from '../storage'
+import { saveSession, loadSessions } from '@/lib/server/sessions/session-repository'
+import { getMessages, getMessageCount, replaceAllMessages } from '@/lib/server/messages/message-repository'
+import { loadSettings, saveSettings } from '../settings/settings-repository'
 import type { Session } from '@/types'
 import { isDirectConnectorSession } from './session-kind'
 
@@ -38,7 +40,7 @@ export function backfillAllKnownPeerIds(): { migrated: number; skipped: boolean
       ...ctx,
       allKnownPeerIds: [...ids],
     }
-    upsertStoredItem('sessions', session.id, session)
+    saveSession(session.id, session)
     migrated++
   }
 
@@ -63,19 +65,21 @@ export function pruneThreadConnectorMirrors(): { cleanedSessions: number; remove
 
   for (const session of Object.values(sessions)) {
     if (isDirectConnectorSession(session)) continue
-    if (!Array.isArray(session.messages) || session.messages.length === 0) continue
+    const msgCount = getMessageCount(session.id)
+    if (msgCount === 0) continue
 
-    const filteredMessages = session.messages.filter((message) => !(
+    const allMessages = getMessages(session.id)
+    const filteredMessages = allMessages.filter((message) => !(
       message?.historyExcluded === true
       && typeof message?.source?.connectorId === 'string'
       && message.source.connectorId.trim().length > 0
     ))
 
-    const removed = session.messages.length - filteredMessages.length
+    const removed = allMessages.length - filteredMessages.length
     if (removed <= 0) continue
 
-    session.messages = filteredMessages
-    upsertStoredItem('sessions', session.id, session)
+    replaceAllMessages(session.id, filteredMessages)
+    saveSession(session.id, session)
     cleanedSessions += 1
     removedMessages += removed
   }

package/src/lib/server/connectors/session.ts

@@ -5,6 +5,10 @@ import { WORKSPACE_DIR } from '../data-dir'
 import { ensureAgentThreadSession } from '@/lib/server/agents/agent-thread-session'
 import { resolveEffectiveSessionMemoryScopeMode } from '@/lib/server/memory/session-memory-scope'
 import { syncSessionArchiveMemory } from '@/lib/server/memory/session-archive-memory'
+import {
+  appendMessage,
+  getLastMessage,
+} from '@/lib/server/messages/message-repository'
 import { loadAgents, loadSessions, loadStoredItem, upsertStoredItem } from '../storage'
 import { notify } from '../ws-hub'
 import {
@@ -416,7 +420,7 @@ function mirrorConnectorMessageToAgentThread(
     : ensureAgentThreadSession(session.agentId)
   if (!threadSession || threadSession.id === session.id) return
 
-  const last = Array.isArray(threadSession.messages) ? threadSession.messages[threadSession.messages.length - 1] : null
+  const last = getLastMessage(threadSession.id)
   const source = message.source as MessageSource | undefined
   const lastSource = (last?.source || null) as MessageSource | null
   if (
@@ -431,17 +435,16 @@ function mirrorConnectorMessageToAgentThread(
     return
   }
 
-  if (!Array.isArray(threadSession.messages)) threadSession.messages = []
-  threadSession.messages.push({
+  const mirrorMsg = {
     ...message,
     time: typeof message.time === 'number' ? message.time : Date.now(),
     historyExcluded: true,
-  } as Session['messages'][number])
+  } as Session['messages'][number]
+  appendMessage(threadSession.id, mirrorMsg)
   threadSession.lastActiveAt = Date.now()
 
   upsertStoredItem('sessions', threadSession.id, threadSession)
   notify('sessions')
-  notify(`messages:${threadSession.id}`)
 }
 
 export function pushSessionMessage(
@@ -451,9 +454,8 @@ export function pushSessionMessage(
   extra: Record<string, unknown> = {},
 ): void {
   if (!text.trim()) return
-  if (!Array.isArray(session.messages)) session.messages = []
   const message = { role, text: text.trim(), time: Date.now(), ...extra }
-  session.messages.push(message)
+  appendMessage(session.id, message as Session['messages'][number])
   session.lastActiveAt = Date.now()
   mirrorConnectorMessageToAgentThread(session, message)
 }

package/src/lib/server/connectors/voice-note.ts

@@ -1,8 +1,9 @@
 import fs from 'fs'
 import path from 'path'
 import { genId } from '@/lib/id'
-import { loadAgent, UPLOAD_DIR } from '../storage'
+import { loadAgent } from '@/lib/server/agents/agent-repository'
 import { synthesizeElevenLabsMp3 } from '../elevenlabs'
+import { UPLOAD_DIR } from '../upload-path'
 import { isAudioMime, mimeFromPath } from './media'
 
 export function resolveConnectorVoiceId(params: {

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

@@ -1,5 +1,7 @@
-import type { Message } from '@/types'
+import type { Message, Session } from '@/types'
 import { getMemoryDb } from '@/lib/server/memory/memory-db'
+import { extractFactsFromMessages, ensureRunContext, pruneRunContext } from '@/lib/server/run-context'
+import { getSession, saveSession } from '@/lib/server/sessions/session-repository'
 
 import { repairTranscriptConsistency } from './transcript-repair'
 
@@ -549,6 +551,23 @@ export async function llmCompact(opts: {
   const oldMessages = repaired.slice(0, -keepLastN)
   const recentMessages = repaired.slice(-keepLastN)
 
+  // 0. Extract facts from messages about to be dropped into RunContext (non-critical)
+  try {
+    const session = getSession(sessionId) as Session | undefined
+    if (session && oldMessages.length > 0) {
+      const extracted = extractFactsFromMessages(oldMessages)
+      if (extracted.keyFacts.length > 0 || extracted.failedApproaches.length > 0) {
+        const ctx = ensureRunContext(session.runContext)
+        ctx.keyFacts = [...ctx.keyFacts, ...extracted.keyFacts]
+        ctx.failedApproaches = [...ctx.failedApproaches, ...extracted.failedApproaches]
+        ctx.version++
+        ctx.updatedAt = Date.now()
+        session.runContext = pruneRunContext(ctx)
+        saveSession(sessionId, session)
+      }
+    }
+  } catch { /* non-critical — compaction continues even if extraction fails */ }
+
   // 1. Consolidate important info to memory
   const memoriesStored = consolidateToMemory(oldMessages, agentId, sessionId)
 

package/src/lib/server/cost.ts

@@ -1,4 +1,4 @@
-import type { Agent, UsageRecord, ExtensionDefinitionCost } from '@/types'
+import type { Agent, Session, UsageRecord, ExtensionDefinitionCost } from '@/types'
 import type { StructuredToolInterface } from '@langchain/core/tools'
 import { loadSessions, loadUsage } from './storage'
 
@@ -26,8 +26,7 @@ const MODEL_COSTS: Record<string, [number, number]> = {
 const ONE_HOUR_MS = 60 * 60 * 1000
 const WARNING_RATIO = 0.8
 
-type GenericRecord = Record<string, unknown>
-type SessionsMap = Record<string, GenericRecord>
+type SessionsMap = Record<string, Session | Record<string, unknown>>
 type UsageMap = Record<string, unknown>
 
 function parsePositiveBudget(value: unknown): number | null {

package/src/lib/server/credentials/credential-repository.ts

@@ -1,7 +1,46 @@
-export {
+import type { Credential } from '@/types'
+
+import {
   decryptKey,
-  deleteCredential,
+  deleteCredential as deleteStoredCredential,
   encryptKey,
-  loadCredentials,
-  saveCredentials,
+  loadCredentials as loadStoredCredentials,
+  saveCredentials as saveStoredCredentials,
+  upsertStoredItem,
 } from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+export type StoredCredential = Credential & {
+  encryptedKey?: string | null
+  updatedAt?: number
+  [key: string]: unknown
+}
+
+export const credentialRepository = createRecordRepository<StoredCredential>(
+  'credentials',
+  {
+    get(id) {
+      return (loadStoredCredentials() as Record<string, StoredCredential>)[id] || null
+    },
+    list() {
+      return loadStoredCredentials() as Record<string, StoredCredential>
+    },
+    upsert(id, value) {
+      upsertStoredItem('credentials', id, value)
+    },
+    replace(data) {
+      saveStoredCredentials(data)
+    },
+    delete(id) {
+      deleteStoredCredential(id)
+    },
+  },
+)
+
+export const loadCredentials = () => credentialRepository.list()
+export const loadCredential = (id: string) => credentialRepository.get(id)
+export const saveCredentials = (items: Record<string, StoredCredential | Record<string, unknown>>) => credentialRepository.replace(items as Record<string, StoredCredential>)
+export const saveCredential = (id: string, value: StoredCredential | Record<string, unknown>) => credentialRepository.upsert(id, value as StoredCredential)
+export const deleteCredential = (id: string) => credentialRepository.delete(id)
+
+export { decryptKey, encryptKey }

package/src/lib/server/credentials/credential-service.ts

@@ -0,0 +1,112 @@
+import type { Credential } from '@/types'
+
+import { genId } from '@/lib/id'
+import {
+  deleteCredential,
+  decryptKey,
+  encryptKey,
+  loadCredential,
+  loadCredentials,
+  saveCredential,
+} from '@/lib/server/credentials/credential-repository'
+
+export type CredentialSummary = Pick<Credential, 'id' | 'provider' | 'name' | 'createdAt'>
+
+function clean(value: string | null | undefined): string {
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+function toCredentialSummary(credential: Credential | null | undefined): CredentialSummary | null {
+  if (!credential) return null
+  return {
+    id: credential.id,
+    provider: credential.provider,
+    name: credential.name,
+    createdAt: credential.createdAt,
+  }
+}
+
+export function listCredentialSummaries(): Record<string, CredentialSummary> {
+  const credentials = loadCredentials()
+  const summaries: Record<string, CredentialSummary> = {}
+  for (const [id, credential] of Object.entries(credentials)) {
+    const summary = toCredentialSummary(credential)
+    if (summary) summaries[id] = summary
+  }
+  return summaries
+}
+
+export function getCredentialSummary(id: string): CredentialSummary | null {
+  return toCredentialSummary(loadCredential(id))
+}
+
+export function listCredentialIdsByProvider(provider: string): string[] {
+  const normalizedProvider = clean(provider)
+  if (!normalizedProvider) return []
+  return Object.entries(loadCredentials())
+    .filter(([, credential]) => credential?.provider === normalizedProvider)
+    .map(([id]) => id)
+}
+
+export function resolveCredentialSecret(credentialId: string | null | undefined): string | null {
+  const id = clean(credentialId)
+  if (!id) return null
+  const credential = loadCredential(id)
+  if (!credential?.encryptedKey) return null
+  try {
+    return decryptKey(credential.encryptedKey)
+  } catch {
+    return null
+  }
+}
+
+export function requireCredentialSecret(
+  credentialId: string | null | undefined,
+  missingMessage = 'Credential secret not found.',
+): string {
+  const id = clean(credentialId)
+  if (!id) throw new Error(missingMessage)
+  const credential = loadCredential(id)
+  if (!credential?.encryptedKey) throw new Error(missingMessage)
+  try {
+    return decryptKey(credential.encryptedKey)
+  } catch {
+    throw new Error(missingMessage)
+  }
+}
+
+export function createCredentialRecord(input: {
+  provider: string
+  name?: string | null
+  apiKey: string
+}): CredentialSummary {
+  const provider = clean(input.provider)
+  const apiKey = clean(input.apiKey)
+  if (!provider || !apiKey) {
+    throw new Error('provider and apiKey are required')
+  }
+  const id = `cred_${genId(6)}`
+  const createdAt = Date.now()
+  const credentialName = clean(input.name) || `${provider} key`
+  saveCredential(id, {
+    id,
+    provider,
+    name: credentialName,
+    encryptedKey: encryptKey(apiKey),
+    createdAt,
+  })
+  return {
+    id,
+    provider,
+    name: credentialName,
+    createdAt,
+  }
+}
+
+export function deleteCredentialRecord(id: string): boolean {
+  const credentialId = clean(id)
+  if (!credentialId) return false
+  if (!loadCredential(credentialId)) return false
+  deleteCredential(credentialId)
+  return true
+}

package/src/lib/server/daemon/admin-metadata.ts

@@ -0,0 +1,64 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+import { DATA_DIR } from '@/lib/server/data-dir'
+import type { DaemonAdminMetadata } from '@/lib/server/daemon/types'
+
+function resolveHomeDir(): string {
+  const configured = process.env.SWARMCLAW_HOME?.trim()
+  if (configured) return path.resolve(configured)
+  return path.dirname(DATA_DIR)
+}
+
+export const DAEMON_ADMIN_METADATA_PATH = path.join(resolveHomeDir(), 'daemon-admin.json')
+export const DAEMON_LOG_PATH = path.join(resolveHomeDir(), 'daemon.log')
+
+export function isProcessRunning(pid: number | null | undefined): boolean {
+  if (typeof pid !== 'number' || !Number.isFinite(pid) || pid <= 0) return false
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function normalizeMetadata(value: unknown): DaemonAdminMetadata | null {
+  if (!value || typeof value !== 'object') return null
+  const candidate = value as Partial<DaemonAdminMetadata>
+  const pid = typeof candidate.pid === 'number' && Number.isFinite(candidate.pid) ? Math.trunc(candidate.pid) : null
+  const port = typeof candidate.port === 'number' && Number.isFinite(candidate.port) ? Math.trunc(candidate.port) : null
+  const token = typeof candidate.token === 'string' ? candidate.token.trim() : ''
+  if (!pid || !port || !token) return null
+  return {
+    pid,
+    port,
+    token,
+    launchedAt: typeof candidate.launchedAt === 'number' && Number.isFinite(candidate.launchedAt)
+      ? Math.trunc(candidate.launchedAt)
+      : Date.now(),
+    source: typeof candidate.source === 'string' ? candidate.source : null,
+  }
+}
+
+export function readDaemonAdminMetadata(): DaemonAdminMetadata | null {
+  try {
+    const raw = JSON.parse(fs.readFileSync(DAEMON_ADMIN_METADATA_PATH, 'utf8'))
+    return normalizeMetadata(raw)
+  } catch {
+    return null
+  }
+}
+
+export function writeDaemonAdminMetadata(metadata: DaemonAdminMetadata): void {
+  fs.mkdirSync(path.dirname(DAEMON_ADMIN_METADATA_PATH), { recursive: true })
+  fs.writeFileSync(DAEMON_ADMIN_METADATA_PATH, `${JSON.stringify(metadata, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 })
+}
+
+export function clearDaemonAdminMetadata(): void {
+  try {
+    fs.unlinkSync(DAEMON_ADMIN_METADATA_PATH)
+  } catch {
+    // Ignore missing metadata file.
+  }
+}