@yeaft/webchat-agent 1.0.607 → 1.0.608

package/local-runtime/web/index.html

@@ -17,6 +17,6 @@
 </head>
 <body>
   <div id="app"></div>
-  <script type="module" src="app.bundle.js?v=e587d8c5"></script>
+  <script type="module" src="app.bundle.js?v=a6a675a2"></script>
 </body>
 </html>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "1.0.607",
+  "version": "1.0.608",
   "description": "Remote worker agent for Yeaft Web Code Agent — connects the native Yeaft engine, CLI providers, and workbench tools",
   "main": "index.js",
   "type": "module",
@@ -72,7 +72,6 @@
     "dotenv": "^16.3.1",
     "express": "^4.22.2",
     "jsonwebtoken": "^9.0.2",
-    "mongodb": "^6.21.0",
     "multer": "^2.2.0",
     "nodemailer": "^9.0.3",
     "puppeteer-core": "24.41.0",

package/yeaft/person/bridge.js

@@ -2,8 +2,8 @@ import { createHash } from 'node:crypto';
 import ctx from '../../context.js';
 import { sendToServer } from '../../connection/buffer.js';
 
-/** Lazy Person transport. Only deployment-local environment supplies database credentials.
- * Storage is lazy and instance-local by default; browser messages cannot choose a backend.
+/** Lazy Person transport. SQLite storage belongs to this Agent instance;
+ * browser messages cannot choose a storage authority or instance directory.
  */
 export function createPersonBridge({
   context = ctx, send = sendToServer, env = process.env,
@@ -32,7 +32,6 @@ export function createPersonBridge({
         await send({ ...response, ok: false, errorCode: 'invalid_request', error: 'Digital person request requires authenticated ownership' });
         return true;
       }
-      const uri = env.YEAFT_PERSON_MONGODB_URI;
       const agentId = context.agentId || context.AGENT_ID;
       if (!agentId || !context.CONFIG?.yeaftDir) throw new Error('identity');
       // Server+Agent is a storage boundary; a re-registration must not reuse the old runtime.
@@ -45,10 +44,7 @@ export function createPersonBridge({
       identity = namespace;
       if (!servicePromise) {
         servicePromise = Promise.resolve().then(() => createService({
-          uri,
-          storage: env.YEAFT_PERSON_STORAGE,
           embedding: { enabled: env.YEAFT_PERSON_EMBEDDING !== 'off', allowDownload: env.YEAFT_PERSON_EMBEDDING_DOWNLOAD !== '0' },
-          dbName: env.YEAFT_PERSON_MONGODB_DB || 'yeaft_person',
           namespace,
           yeaftDir: context.CONFIG.yeaftDir,
           workDir: context.CONFIG.workDir,
@@ -78,7 +74,7 @@ export function createPersonBridge({
         TASK_CONTROL_UNAVAILABLE: 'Task control could not be confirmed; refresh before retrying',
         STALE: 'Digital person state changed; refresh and try again',
         IDEMPOTENCY_CONFLICT: 'This message identifier already belongs to a different request',
-        STORAGE_MISMATCH: 'The configured storage differs from the existing Person authority; do not switch without a verified migration',
+        STORAGE_MISMATCH: 'Existing digital person storage is not a valid SQLite binding; check instance storage before retrying',
         UNSUPPORTED: 'This capability is not available in this digital person version',
       };
       const known = Object.hasOwn(safeErrors, error?.code);

package/yeaft/person/capabilities.js

@@ -83,7 +83,7 @@ export function inspectCapabilities(created, { cursor, limit }, nativeToolIds =
     contract.evidence = item.evidence;
     entries.push(item);
   }
-  // IDs are ASCII identifiers. Binary ordering matches SQLite and Mongo simple collation.
+  // IDs are ASCII identifiers. Binary ordering matches SQLite.
   const matches = entries.filter(entry => cursor === null || entry.id > cursor)
     .sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
   return inspectionPage(matches, limit, 'id');

package/yeaft/person/contracts.js

@@ -5,7 +5,7 @@ export const LIMITS = Object.freeze({ inputBytes: 8192, outputBytes: 65536, cont
 const ERRORS = {
   INVALID_REQUEST: 'Invalid digital person request.', NOT_CONFIGURED: 'Digital person storage configuration is missing.',
   STORAGE_UNAVAILABLE: 'Digital person storage is unavailable. Check instance storage and database configuration.',
-  STORAGE_MISMATCH: 'Person storage is already bound to another backend; a verified migration is required.',
+  STORAGE_MISMATCH: 'Existing digital person storage is not a valid SQLite binding.',
   NOT_OPEN: 'Open your digital person first.', BUSY: 'The digital person is already active.',
   IDEMPOTENCY_CONFLICT: 'This clientMessageId was already used for a different request.',
   STALE: 'The activity no longer owns the current person revision.', INVALID_PROPOSAL: 'The model returned an invalid cognitive proposal.',

package/yeaft/person/runtime.js

@@ -147,8 +147,8 @@ export class PersonRuntime {
     this.running = new Map(); this.pendingCancellations = new Map(); this.workerId = randomUUID(); this.closed = false;
   }
   tasks() {
-    // Construction/status/open do not touch task storage. Legacy direct Mongo
-    // embeddings without an instance root retain foreground-only host support.
+    // Construction/status/open do not touch task storage. An instance root is
+    // required before creating the durable task host.
     if (!this.toolOptions.yeaftDir) return null;
     return this.taskHost ??= new PersonTaskHost({ ...this.toolOptions, namespace: this.namespace });
   }

package/yeaft/person/service.js

@@ -1,7 +1,6 @@
-import { MongoPersonRepository } from './repository.js';
 import { SqlitePersonRepository } from './sqlite-repository.js';
 import { LocalPersonMemory } from './local-memory.js';
-import { selectPersonStorage, bindPersonStorage } from './storage.js';
+import { ensurePersonStorage } from './sqlite-storage.js';
 import { PersonRuntime } from './runtime.js';
 import { allowedNativeToolIds } from './native-tools.js';
 import { loadConfig } from '../config.js';
@@ -12,35 +11,31 @@ import { inspectRequest, personName, searchRequest } from './inspection.js';
 
 /**
  * One durable Person per (namespace, authenticated ownerId). The transport MUST
- * supply authenticated ownerId, never accept it from a browser payload. URI/provider
+ * supply authenticated ownerId, never accept it from a browser payload. Provider
  * secrets stay inside this Agent. Constructor and status never initiate model calls.
- * Native provider configuration is read from yeaftDir only (no Session initialization).
- * SQLite is the local default; an existing Mongo URI retains Mongo. No authority fallback.
+ * SQLite storage and native provider configuration belong to yeaftDir only
+ * (no Session initialization or alternate storage authority).
  */
 export function createPersonService(options = {}) {
-  const { uri, dbName = 'yeaft_person', namespace = 'default', yeaftDir, workDir, MongoClient, config, adapter, allowedModels } = options;
+  const { namespace = 'default', yeaftDir, workDir, config, adapter, allowedModels } = options;
   identifier(namespace);
-  if (typeof dbName !== 'string' || !/^[a-zA-Z0-9_-]{1,63}$/.test(dbName)) fail('INVALID_REQUEST');
-  if (uri != null && typeof uri !== 'string') fail('INVALID_REQUEST');
-  const { storage, configured } = selectPersonStorage({ ...options, yeaftDir });
+  const configured = typeof yeaftDir === 'string' && Boolean(yeaftDir.trim());
   const calls = options.maxCalls ?? LIMITS.calls;
   const timeoutMs = options.timeoutMs ?? LIMITS.timeoutMs;
   const leaseMs = options.leaseMs ?? LIMITS.leaseMs;
   if (!Number.isInteger(calls) || calls < 1 || calls > 32 || !Number.isInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > 300000 ||
       !Number.isInteger(leaseMs) || leaseMs < 300 || leaseMs > 60000) fail('INVALID_REQUEST');
   if (allowedModels != null && (!Array.isArray(allowedModels) || !allowedModels.length || allowedModels.some(m => typeof m !== 'string'))) fail('INVALID_REQUEST');
-  const repository = !configured ? null : storage === 'mongodb'
-    ? new MongoPersonRepository({ uri, dbName, namespace, MongoClient, leaseMs })
-    : new SqlitePersonRepository({ yeaftDir, namespace, leaseMs });
+  const repository = configured ? new SqlitePersonRepository({ yeaftDir, namespace, leaseMs }) : null;
   const initialize = repository?.init.bind(repository);
   let binding;
   if (repository) repository.init = async () => {
-    if (!binding) binding = bindPersonStorage(yeaftDir, namespace, storage).catch(error => { binding = null; throw error; });
+    if (!binding) binding = ensurePersonStorage(yeaftDir, namespace).catch(error => { binding = null; throw error; });
     await binding;
     return initialize();
   };
   const literalRecall = repository?.recall.bind(repository);
-  const memory = repository && storage === 'sqlite' ? new LocalPersonMemory({
+  const memory = repository ? new LocalPersonMemory({
     repository, literalRecall, yeaftDir, namespace, embedding: options.embedding,
   }) : null;
   if (memory) repository.recall = (ownerId, args = {}, { signal } = {}) => args.query?.trim()
@@ -58,7 +53,7 @@ export function createPersonService(options = {}) {
       object(payload, []);
       let agentDefaultModel = null;
       try { agentDefaultModel = resolveAgentDefaultModel(config ?? loadConfig({ dir: yeaftDir })); } catch { /* Invalid/missing native config. */ }
-      const status = { renameSupported: true, defaultModelSupported: true, configured, storage, modelReady: false,
+      const status = { renameSupported: true, defaultModelSupported: true, configured, storage: 'sqlite', modelReady: false,
         defaultModel: null, agentDefaultModel, modelCandidates: [], effectiveModelCandidates: [], effectiveDefaultModel: null };
       if (!configured) return { ...status, reason: 'Digital person storage configuration is missing.', storageReady: false };
       try { await repository.init(); }

package/yeaft/person/sqlite-storage.js

@@ -0,0 +1,24 @@
+import { mkdir, readFile, writeFile, link, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { digest, fail } from './contracts.js';
+
+/** Preserve existing instance bindings without silently creating a new authority.
+ * SQLite is the only supported storage; this marker is not a backend selector.
+ */
+export async function ensurePersonStorage(yeaftDir, namespace) {
+  const directory = join(yeaftDir, 'person');
+  await mkdir(directory, { recursive: true, mode: 0o700 });
+  const path = join(directory, `storage-${digest(namespace)}.json`);
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  await writeFile(temporary, JSON.stringify({ version: 1, storage: 'sqlite' }), { flag: 'wx', mode: 0o600 });
+  try {
+    // A fully written inode is linked atomically; competing openers never read partial JSON.
+    await link(temporary, path);
+  } catch (error) {
+    if (error.code !== 'EEXIST') throw error;
+    let binding;
+    try { binding = JSON.parse(await readFile(path, 'utf8')); } catch { fail('STORAGE_MISMATCH'); }
+    if (!binding || binding.version !== 1 || binding.storage !== 'sqlite') fail('STORAGE_MISMATCH');
+  } finally { await unlink(temporary).catch(() => {}); }
+}

package/yeaft/person/sqlite-store.js

@@ -448,9 +448,9 @@ export class SqlitePersonStore {
   list(ownerId, collection, { cursor = null, limit = 20 } = {}, filter = {}) {
     if (!['messages', 'traces'].includes(collection)) fail('INVALID_REQUEST');
     this.getPerson(ownerId); boundedLimit(limit);
-    if (Object.keys(filter).some(k => k !== 'text') || (filter.text && (typeof filter.text.$regex !== 'string' || filter.text.$options !== 'i'))) fail('INVALID_REQUEST');
-    // Compatibility for Mongo's literal recall filter only; arbitrary selectors are forbidden.
-    const query = filter.text?.$regex?.replace(/\\([.*+?^${}()|[\]\\])/g, '$1') ?? '';
+    if (Object.keys(filter).some(k => k !== 'query')) fail('INVALID_REQUEST');
+    const query = filter.query ?? '';
+    text(query, LIMITS.inputBytes, true);
     if (query && collection !== 'messages') fail('INVALID_REQUEST');
     let clause = '', params = [];
     if (cursor != null) { clause += ' AND seq < ?'; params.push(sequence(cursor)); }
@@ -460,7 +460,7 @@ export class SqlitePersonStore {
   }
   recall(ownerId, { kind = 'messages', query = '', cursor = null, limit = 5 } = {}) {
     memoryKind(kind); text(query, LIMITS.inputBytes, true); boundedLimit(limit);
-    if (kind === 'messages') return this.list(ownerId, kind, { cursor, limit }, query ? { text: { $regex: query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), $options: 'i' } } : {});
+    if (kind === 'messages') return this.list(ownerId, kind, { cursor, limit }, { query });
     this.getPerson(ownerId);
     if (cursor != null) text(cursor, 128);
     const docs = this.rows('concepts', this.scope(ownerId), ' AND (? IS NULL OR id > ?) AND instr(statement, ?) > 0 ORDER BY id ASC LIMIT ?', [cursor, cursor, query.toLowerCase(), limit + 1]);

package/yeaft/person/task-host.js

@@ -61,7 +61,7 @@ function privatePath(root, path) {
 // expose native command fallbacks; redact common sensitive forms before capping.
 function summary(value, maxBytes = 512) {
   const clean = String(value ?? '')
-    .replace(/https?:\/\/\S+|mongodb(?:\+srv)?:\/\/\S+/gi, '[url]')
+    .replace(/\b[a-z][a-z\d+.-]*:\/\/\S+/gi, '[url]')
     .replace(/(?:bearer\s+|(?:api[_-]?key|password|secret|token)\s*[:=]\s*)\S+/gi, '[redacted]')
     .replace(/\b(?:sk-[\w-]+|gh[pousr]_[\w]+|github_pat_[\w]+)\b/g, '[redacted]')
     .replace(/(?:\/[\w.@~+-]+)+(?:\/[^\s]*)?|(?:~|\.\.?|[A-Za-z]:)[\\/][^\s]+/g, '[path]')