minimal-agent 0.10.0 → 0.12.0

package/src/memory/fileStore.js

@@ -0,0 +1,148 @@
+import { randomUUID } from 'node:crypto';
+import { chmod, mkdir, open, readFile, rename, rm, stat, unlink, writeFile, } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { agentStateDir } from '../context/agentHome.js';
+import { CATEGORY_DIR, MEMORY_ID_PATTERN } from './constants.js';
+const LOCK_STALE_MS = 120_000;
+const LOCK_WAIT_MS = 15_000;
+let mutationQueue = Promise.resolve();
+export function memoryRootDir() {
+    return join(agentStateDir(), 'memory');
+}
+export function globalMemoryDir() {
+    return join(memoryRootDir(), 'global');
+}
+export function personaFilePath() {
+    return join(globalMemoryDir(), 'persona.md');
+}
+export function settingsFilePath() {
+    return join(memoryRootDir(), 'settings.json');
+}
+export function auditFilePath() {
+    return join(memoryRootDir(), 'audit.jsonl');
+}
+export function scopeDirectory(scope, workspaceId) {
+    if (scope === 'personal')
+        return globalMemoryDir();
+    if (!workspaceId || !/^[a-zA-Z0-9_-]{1,128}$/.test(workspaceId)) {
+        throw new Error('工作区记忆需要有效的 workspaceId');
+    }
+    return join(memoryRootDir(), 'workspaces', workspaceId);
+}
+export function memoryRecordPath(record) {
+    if (!MEMORY_ID_PATTERN.test(record.id))
+        throw new Error('记忆 ID 必须是 UUID');
+    return join(scopeDirectory(record.scope, record.workspaceId), CATEGORY_DIR[record.category], `${record.id}.md`);
+}
+export async function ensurePrivateDir(path) {
+    await mkdir(path, { recursive: true, mode: 0o700 });
+    await chmod(path, 0o700).catch(() => undefined);
+}
+export async function pathExists(path) {
+    try {
+        await readFile(path, 'utf8');
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+export async function acquireFileLock(path) {
+    const lock = `${path}.lock`;
+    await ensurePrivateDir(dirname(path));
+    const deadline = Date.now() + LOCK_WAIT_MS;
+    while (true) {
+        try {
+            const handle = await open(lock, 'wx', 0o600);
+            await handle.writeFile(`${process.pid}:${Date.now()}\n`);
+            await handle.close();
+            return async () => {
+                await unlink(lock).catch(() => { });
+            };
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            const raw = await readFile(lock, 'utf8').catch(() => '');
+            const createdAt = Number(raw.split(':')[1]);
+            const lockInfo = await stat(lock).catch(() => null);
+            if ((Number.isFinite(createdAt) && Date.now() - createdAt > LOCK_STALE_MS) ||
+                (!Number.isFinite(createdAt)
+                    && lockInfo !== null
+                    && Date.now() - lockInfo.mtimeMs > LOCK_STALE_MS)) {
+                await unlink(lock).catch(() => { });
+                continue;
+            }
+            if (Date.now() >= deadline)
+                throw new Error('等待记忆文件锁超时');
+            await new Promise((resolve) => setTimeout(resolve, 40));
+        }
+    }
+}
+export async function atomicWriteFile(path, content) {
+    await ensurePrivateDir(dirname(path));
+    const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temp, content, { mode: 0o600 });
+        await rename(temp, path);
+        await chmod(path, 0o600).catch(() => undefined);
+    }
+    finally {
+        await rm(temp, { force: true }).catch(() => { });
+    }
+}
+export function enqueueMemoryMutation(operation) {
+    let resolveResult;
+    let rejectResult;
+    const result = new Promise((resolve, reject) => {
+        resolveResult = resolve;
+        rejectResult = reject;
+    });
+    mutationQueue = mutationQueue
+        .catch(() => { })
+        .then(async () => {
+        try {
+            resolveResult(await operation());
+        }
+        catch (error) {
+            rejectResult(error);
+        }
+    });
+    return result;
+}
+export async function appendPrivateLine(path, line, options) {
+    const release = await acquireFileLock(path);
+    try {
+        await ensurePrivateDir(dirname(path));
+        if (options?.maxBytes)
+            await rotateIfLarge(path, options.maxBytes);
+        const handle = await open(path, 'a', 0o600);
+        try {
+            await handle.writeFile(`${line.replace(/[\r\n]+$/g, '')}\n`);
+        }
+        finally {
+            await handle.close();
+        }
+        await chmod(path, 0o600).catch(() => undefined);
+    }
+    finally {
+        await release();
+    }
+}
+/**
+ * 超限就把当前文件挪成 `.1`（覆盖上一代），与 `vision/telemetry.ts::rotateIfLarge` 同款。
+ * 失败静默——轮转不了也要能继续写，日志不该反过来拖垮功能。
+ */
+async function rotateIfLarge(path, maxBytes) {
+    try {
+        const info = await stat(path);
+        if (info.size < maxBytes)
+            return;
+        await rename(path, `${path}.1`);
+    }
+    catch {
+        /* 文件不存在或挪不动，都不影响追加 */
+    }
+}

package/src/memory/fileStore.ts

@@ -0,0 +1,184 @@
+import { randomUUID } from 'node:crypto';
+import {
+  chmod,
+  mkdir,
+  open,
+  readFile,
+  rename,
+  rm,
+  stat,
+  unlink,
+  writeFile,
+} from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+
+import { agentStateDir } from '../context/agentHome.js';
+import { CATEGORY_DIR, MEMORY_ID_PATTERN } from './constants.js';
+import type { MemoryRecord, MemoryScope } from './types.js';
+
+const LOCK_STALE_MS = 120_000;
+const LOCK_WAIT_MS = 15_000;
+let mutationQueue: Promise<void> = Promise.resolve();
+
+export function memoryRootDir(): string {
+  return join(agentStateDir(), 'memory');
+}
+
+export function globalMemoryDir(): string {
+  return join(memoryRootDir(), 'global');
+}
+
+export function personaFilePath(): string {
+  return join(globalMemoryDir(), 'persona.md');
+}
+
+export function settingsFilePath(): string {
+  return join(memoryRootDir(), 'settings.json');
+}
+
+export function auditFilePath(): string {
+  return join(memoryRootDir(), 'audit.jsonl');
+}
+
+export function scopeDirectory(
+  scope: MemoryScope,
+  workspaceId?: string,
+): string {
+  if (scope === 'personal') return globalMemoryDir();
+  if (!workspaceId || !/^[a-zA-Z0-9_-]{1,128}$/.test(workspaceId)) {
+    throw new Error('工作区记忆需要有效的 workspaceId');
+  }
+  return join(memoryRootDir(), 'workspaces', workspaceId);
+}
+
+export function memoryRecordPath(
+  record: Pick<MemoryRecord, 'scope' | 'workspaceId' | 'category' | 'id'>,
+): string {
+  if (!MEMORY_ID_PATTERN.test(record.id))
+    throw new Error('记忆 ID 必须是 UUID');
+  return join(
+    scopeDirectory(record.scope, record.workspaceId),
+    CATEGORY_DIR[record.category],
+    `${record.id}.md`,
+  );
+}
+
+export async function ensurePrivateDir(path: string): Promise<void> {
+  await mkdir(path, { recursive: true, mode: 0o700 });
+  await chmod(path, 0o700).catch(() => undefined);
+}
+
+export async function pathExists(path: string): Promise<boolean> {
+  try {
+    await readFile(path, 'utf8');
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return false;
+    throw error;
+  }
+}
+
+export async function acquireFileLock(
+  path: string,
+): Promise<() => Promise<void>> {
+  const lock = `${path}.lock`;
+  await ensurePrivateDir(dirname(path));
+  const deadline = Date.now() + LOCK_WAIT_MS;
+  while (true) {
+    try {
+      const handle = await open(lock, 'wx', 0o600);
+      await handle.writeFile(`${process.pid}:${Date.now()}\n`);
+      await handle.close();
+      return async () => {
+        await unlink(lock).catch(() => {});
+      };
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+      const raw = await readFile(lock, 'utf8').catch(() => '');
+      const createdAt = Number(raw.split(':')[1]);
+      const lockInfo = await stat(lock).catch(() => null);
+      if (
+        (Number.isFinite(createdAt) && Date.now() - createdAt > LOCK_STALE_MS) ||
+        (!Number.isFinite(createdAt)
+          && lockInfo !== null
+          && Date.now() - lockInfo.mtimeMs > LOCK_STALE_MS)
+      ) {
+        await unlink(lock).catch(() => {});
+        continue;
+      }
+      if (Date.now() >= deadline) throw new Error('等待记忆文件锁超时');
+      await new Promise((resolve) => setTimeout(resolve, 40));
+    }
+  }
+}
+
+export async function atomicWriteFile(
+  path: string,
+  content: string,
+): Promise<void> {
+  await ensurePrivateDir(dirname(path));
+  const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temp, content, { mode: 0o600 });
+    await rename(temp, path);
+    await chmod(path, 0o600).catch(() => undefined);
+  } finally {
+    await rm(temp, { force: true }).catch(() => {});
+  }
+}
+
+export function enqueueMemoryMutation<T>(
+  operation: () => Promise<T>,
+): Promise<T> {
+  let resolveResult!: (value: T) => void;
+  let rejectResult!: (error: unknown) => void;
+  const result = new Promise<T>((resolve, reject) => {
+    resolveResult = resolve;
+    rejectResult = reject;
+  });
+  mutationQueue = mutationQueue
+    .catch(() => {})
+    .then(async () => {
+      try {
+        resolveResult(await operation());
+      } catch (error) {
+        rejectResult(error);
+      }
+    });
+  return result;
+}
+
+export async function appendPrivateLine(
+  path: string,
+  line: string,
+  options?: { maxBytes?: number },
+): Promise<void> {
+  const release = await acquireFileLock(path);
+  try {
+    await ensurePrivateDir(dirname(path));
+    if (options?.maxBytes) await rotateIfLarge(path, options.maxBytes);
+    const handle = await open(path, 'a', 0o600);
+    try {
+      await handle.writeFile(`${line.replace(/[\r\n]+$/g, '')}\n`);
+    } finally {
+      await handle.close();
+    }
+    await chmod(path, 0o600).catch(() => undefined);
+  } finally {
+    await release();
+  }
+}
+
+/**
+ * 超限就把当前文件挪成 `.1`（覆盖上一代），与 `vision/telemetry.ts::rotateIfLarge` 同款。
+ * 失败静默——轮转不了也要能继续写，日志不该反过来拖垮功能。
+ */
+async function rotateIfLarge(path: string, maxBytes: number): Promise<void> {
+  try {
+    const info = await stat(path);
+    if (info.size < maxBytes) return;
+    await rename(path, `${path}.1`);
+  } catch {
+    /* 文件不存在或挪不动，都不影响追加 */
+  }
+}