@swarmclawai/swarmclaw 1.2.4 → 1.2.6

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.
+  }
+}