@frontera-sdk/cli 1.53.23 → 1.53.24

package/src/local/local-docker.ts

@@ -65,6 +65,17 @@ export function dockerAvailable(): { ok: true } | { ok: false; reason: string }
   }
 }
 
+/** The memory Docker's engine has for all its containers, in bytes; null when it does not say. */
+export function dockerMemoryBytes(): number | null {
+  try {
+    const r = docker(['info', '--format', '{{.MemTotal}}'])
+    const bytes = Number(r.out)
+    return r.ok && r.out && Number.isFinite(bytes) && bytes > 0 ? bytes : null
+  } catch {
+    return null
+  }
+}
+
 export function imagePresent(image: string): boolean {
   return docker(['image', 'inspect', image, '--format', '{{.Id}}']).ok
 }
@@ -242,13 +253,17 @@ export const dbVolumeName = (projectId: string) => `frontera-${projectId}-db`
 /** A local runtime's file storage volume, by its id. */
 export const storageVolumeName = (projectId: string) => `frontera-${projectId}-storage`
 
+/** A local runtime's search index volume, by its id. */
+export const searchIndexVolumeName = (projectId: string) => `frontera-${projectId}-search-index`
+
 /**
  * Delete a local runtime's containers and volumes, by its id: the containers
- * labelled for it, running or not, and its database and storage volumes. Its
+ * labelled for it, running or not, and its database, storage and search index volumes. Its
  * data is gone afterwards.
  */
 export function removeRuntimeResources(projectId: string): void {
   for (const name of containersForProject(projectId)) removeContainer(name)
   removeVolume(dbVolumeName(projectId))
   removeVolume(storageVolumeName(projectId))
+  removeVolume(searchIndexVolumeName(projectId))
 }

package/src/local/local-env.ts

@@ -37,6 +37,8 @@ export interface LocalConfig {
   /** Where image mode pulls the platform images from: a registry host and namespace. */
   registry?: string
   exclude: string[]
+  /** Components that run only when asked (`--with`): the search index, in a project without `knowledge-base/`. */
+  with?: string[]
 }
 
 const secretsFile = (project: LocalProject) => join(project.stateDir, 'secrets.json')
@@ -116,6 +118,7 @@ export const SERVICE_OUTBOUND = [
   'S3_ENDPOINT',
   'INNGEST_BASE_URL',
   'AUTOMATION_RUNNER_URL',
+  'KNOWLEDGE_SEARCH_URL',
 ] as const
 
 /** The service's settings for a hosted key custodian (OpenBao / Vault transit), blanked on the local runtime. */
@@ -150,6 +153,8 @@ export function serviceEnv(args: {
   runnerEnabled: boolean
   jobsEnabled: boolean
   storageEnabled: boolean
+  /** The search index runs: the Knowledge app is on. */
+  searchIndexEnabled?: boolean
   /** Point the service's OpenAI client at the keyless local embeddings (no OpenAI key stored). */
   keylessEmbeddings?: boolean
   /** The customer documentation publication the service serves to coding agents. */
@@ -225,9 +230,23 @@ export function serviceEnv(args: {
   if (args.keylessEmbeddings) env.OPENAI_BASE_URL = `http://127.0.0.1:${ports.embeddings}/v1`
   if (args.runnerEnabled) env.AUTOMATION_RUNNER_URL = `http://127.0.0.1:${ports.runner}`
   if (args.storageEnabled) Object.assign(env, storageEnv(secrets, ports))
+  if (args.searchIndexEnabled) Object.assign(env, searchIndexEnv(ports))
   return env
 }
 
+/**
+ * The Knowledge app: its search index, and its own bucket in the runtime's
+ * object storage, created on first use. The service refuses a Knowledge bucket
+ * that is the public uploads bucket (`S3_BUCKET`).
+ */
+export function searchIndexEnv(ports: PortBlock): Record<string, string> {
+  return {
+    KNOWLEDGE_SEARCH_URL: `http://127.0.0.1:${ports['search-index']}`,
+    KNOWLEDGE_BUCKET: 'frontera-local-knowledge',
+    KNOWLEDGE_BUCKET_CREATE: 'true',
+  }
+}
+
 /**
  * Object storage (RustFS): Function bundles, uploads, managed datasets. Buckets
  * are created on first write. Managed datasets also need their catalog

package/src/local/local-file-checks.ts

@@ -1,15 +1,17 @@
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
+import { readdirSync, readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
 
 import matter from 'gray-matter'
 
+import { KNOWLEDGE_BASE_SOURCES_DIR } from './local-knowledge-base-files'
+import { agentPicks, hasKnowledgeBaseFolder } from './local-knowledge-base-apply'
 import { checkAgainstSchema, type SchemaProblem } from './local-schema-check'
 import { cliSchema, type SchemaKind } from './local-schemas'
 
 /**
- * A Chat App file, a knowledge base's `knowledge.json` and a skill's
- * `SKILL.md` front matter, checked against `frontera local schema <kind>`
- * before `local dev` applies them.
+ * A Chat App file, a knowledge base's `knowledge.json`, a skill's `SKILL.md`
+ * front matter, and the Knowledge app's files (`knowledge-base/`), checked
+ * against `frontera local schema <kind>` before `local dev` applies them.
  *
  * The platform keeps only the keys it knows and drops the rest without a word
  * (a Chat App's `experience` block applied "✓" and was gone), so a key the
@@ -82,10 +84,53 @@ export function skillFileChecks(file: string, text: string): FileChecks {
   return { errors, warnings }
 }
 
-/** The checks for one target's file, read from the project; nothing for a kind these do not cover. */
-export function projectFileChecks(root: string, target: { kind: string; file?: string }): FileChecks {
+type JsonSchema = Record<string, unknown>
+
+const refused = (file: string, problems: SchemaProblem[]) => problems.map((p) => `${file} ${p.path || '(the file)'}: ${p.message}`)
+
+/**
+ * A Knowledge app base: its knowledge-base.json, and each source file against
+ * the service's format when `local start` kept it. Every key in these files
+ * means something (a workspace base's `sharing` would share nothing), so any
+ * problem refuses the base.
+ */
+export function knowledgeBaseFileChecks(root: string, file: string, doc: unknown, sourceSchema: JsonSchema | null): FileChecks {
+  const errors = refused(file, checkAgainstSchema(doc, cliSchema('knowledge-base')!))
+  const sources = join(dirname(file), KNOWLEDGE_BASE_SOURCES_DIR)
+  let names: string[] = []
+  try {
+    names = readdirSync(join(root, sources)).filter((n) => n.endsWith('.json')).sort()
+  } catch {
+    // No sources/ folder: a base without API sources.
+  }
+  for (const name of names) {
+    const rel = join(sources, name)
+    try {
+      const spec = JSON.parse(readFileSync(join(root, rel), 'utf8')) as unknown
+      if (sourceSchema) errors.push(...refused(rel, checkAgainstSchema(spec, sourceSchema)))
+    } catch (err) {
+      errors.push(`${rel}: is not valid JSON: ${(err as Error).message}`)
+    }
+  }
+  return { errors, warnings: [] }
+}
+
+/** An Agent's picks (`knowledgeBases`): each names a base folder the project has, or the Agent goes without it. */
+export function agentPickChecks(root: string, file: string, doc: unknown): FileChecks {
+  const warnings = (agentPicks(doc) ?? [])
+    .filter((ref) => !hasKnowledgeBaseFolder(root, ref))
+    .map((ref) => `  warning: ${file} knowledgeBases: ${ref} is not a knowledge base in this project (${ref}/knowledge-base.json), so the Agent goes without it`)
+  return { errors: [], warnings }
+}
+
+/**
+ * The checks for one target's file, read from the project; nothing for a kind
+ * these do not cover. `keptSchema` reads a service-owned format `local start`
+ * kept (a knowledge base's source); without it, the service checks those.
+ */
+export function projectFileChecks(root: string, target: { kind: string; file?: string }, keptSchema: (kind: SchemaKind) => JsonSchema | null = () => null): FileChecks {
   const none = { errors: [], warnings: [] }
-  if (!target.file || !['chat-app', 'knowledge', 'skill'].includes(target.kind)) return none
+  if (!target.file || !['chat-app', 'knowledge', 'skill', 'knowledge-base', 'knowledge-base-settings', 'agent'].includes(target.kind)) return none
   let text: string
   try {
     text = readFileSync(join(root, target.file), 'utf8')
@@ -100,5 +145,8 @@ export function projectFileChecks(root: string, target: { kind: string; file?: s
     // Unreadable: the apply says so with the file's own error.
     return none
   }
+  if (target.kind === 'knowledge-base') return knowledgeBaseFileChecks(root, target.file, doc, keptSchema('knowledge-base-source'))
+  if (target.kind === 'knowledge-base-settings') return { errors: refused(target.file, checkAgainstSchema(doc, cliSchema('knowledge-base-settings')!)), warnings: [] }
+  if (target.kind === 'agent') return agentPickChecks(root, target.file, doc)
   return target.kind === 'chat-app' ? chatAppFileChecks(target.file, doc) : knowledgeFileChecks(target.file, doc)
 }