@ronkovic/aad 0.3.0

package/src/modules/persistence/file-lock.ts

@@ -0,0 +1,158 @@
+import { mkdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import type { Logger } from "pino";
+import { FileLockError } from "@aad/shared/errors";
+
+export interface FileLockOptions {
+  lockDir: string;
+  timeout?: number;
+  retryInterval?: number;
+  logger?: Logger;
+}
+
+/**
+ * mkdir-based atomic file lock (Bash互換)
+ * PID file for stale lock detection
+ */
+export class FileLock {
+  private lockDir: string;
+  private pidFile: string;
+  private timeout: number;
+  private retryInterval: number;
+  private logger?: Logger;
+  private acquired: boolean = false;
+
+  constructor(options: FileLockOptions) {
+    this.lockDir = options.lockDir;
+    this.pidFile = join(options.lockDir, "pid");
+    this.timeout = options.timeout ?? 30000; // 30s default
+    this.retryInterval = options.retryInterval ?? 100; // 100ms default
+    this.logger = options.logger;
+  }
+
+  async acquire(): Promise<void> {
+    const startTime = Date.now();
+
+    while (true) {
+      try {
+        // Try mkdir (atomic operation)
+        await mkdir(this.lockDir, { recursive: false });
+
+        // Write PID file
+        await Bun.write(this.pidFile, `${process.pid}`);
+
+        this.acquired = true;
+        this.logger?.debug({ lockDir: this.lockDir, pid: process.pid }, "Lock acquired");
+        return;
+      } catch (error) {
+        const err = error as NodeJS.ErrnoException;
+
+        if (err.code !== "EEXIST") {
+          throw new FileLockError("Failed to create lock directory", {
+            lockDir: this.lockDir,
+            error: err.message,
+          });
+        }
+
+        // Lock exists, check if stale
+        const isStale = await this.isLockStale();
+        if (isStale) {
+          this.logger?.warn({ lockDir: this.lockDir }, "Removing stale lock");
+          await this.forceRelease();
+          continue;
+        }
+
+        // Check timeout
+        const elapsed = Date.now() - startTime;
+        if (elapsed >= this.timeout) {
+          const holder = await this.getLockHolder();
+          throw new FileLockError("Lock acquisition timeout", {
+            lockDir: this.lockDir,
+            timeout: this.timeout,
+            holder,
+          });
+        }
+
+        // Wait and retry
+        await Bun.sleep(this.retryInterval);
+      }
+    }
+  }
+
+  async release(): Promise<void> {
+    if (!this.acquired) {
+      return;
+    }
+
+    try {
+      await rm(this.lockDir, { recursive: true, force: true });
+      this.acquired = false;
+      this.logger?.debug({ lockDir: this.lockDir }, "Lock released");
+    } catch (error) {
+      const err = error as NodeJS.ErrnoException;
+      throw new FileLockError("Failed to release lock", {
+        lockDir: this.lockDir,
+        error: err.message,
+      });
+    }
+  }
+
+  async forceRelease(): Promise<void> {
+    try {
+      await rm(this.lockDir, { recursive: true, force: true });
+    } catch (error) {
+      this.logger?.debug({ error, lockDir: this.lockDir }, "Failed to force release lock (ignored)");
+    }
+  }
+
+  private async isLockStale(): Promise<boolean> {
+    try {
+      const pidContent = await Bun.file(this.pidFile).text();
+      const pid = Number.parseInt(pidContent.trim(), 10);
+
+      if (Number.isNaN(pid)) {
+        return true;
+      }
+
+      // Check if process exists (signal 0 = test existence)
+      try {
+        process.kill(pid);
+        return false; // Process exists
+      } catch (error) {
+        this.logger?.debug({ error, pid }, "Process does not exist (stale lock)");
+        return true; // Process doesn't exist
+      }
+    } catch (error) {
+      this.logger?.debug({ error, pidFile: this.pidFile }, "PID file not readable (stale lock)");
+      return true;
+    }
+  }
+
+  private async getLockHolder(): Promise<number | null> {
+    try {
+      const pidContent = await Bun.file(this.pidFile).text();
+      const pid = Number.parseInt(pidContent.trim(), 10);
+      return Number.isNaN(pid) ? null : pid;
+    } catch (error) {
+      this.logger?.debug({ error, pidFile: this.pidFile }, "Failed to read lock holder PID");
+      return null;
+    }
+  }
+}
+
+/**
+ * Helper for using FileLock with automatic cleanup
+ */
+export async function withFileLock<T>(
+  options: FileLockOptions,
+  fn: () => Promise<T>
+): Promise<T> {
+  const lock = new FileLock(options);
+
+  try {
+    await lock.acquire();
+    return await fn();
+  } finally {
+    await lock.release();
+  }
+}

package/src/modules/persistence/fs-run-store.ts

@@ -0,0 +1,73 @@
+import { mkdir, rename } from "node:fs/promises";
+import { join } from "node:path";
+import type { Logger } from "pino";
+import type { RunState, RunId } from "@aad/shared/types";
+import { PersistenceError } from "@aad/shared/errors";
+import { RunStateSchema, type RunStore } from "./stores.port";
+
+export interface FSRunStoreOptions {
+  basePath: string;
+  logger?: Logger;
+}
+
+/**
+ * File system adapter for RunStore
+ * Structure: {basePath}/progress.json
+ */
+export class FSRunStore implements RunStore {
+  private basePath: string;
+  private progressFile: string;
+  private logger?: Logger;
+
+  constructor(options: FSRunStoreOptions) {
+    this.basePath = options.basePath;
+    this.progressFile = join(this.basePath, "progress.json");
+    this.logger = options.logger;
+  }
+
+  async get(runId: RunId): Promise<RunState | null> {
+    try {
+      const content = await Bun.file(this.progressFile).text();
+      const data = JSON.parse(content);
+      const state = RunStateSchema.parse(data) as RunState;
+
+      // Return only if runId matches
+      if (state.runId === runId) {
+        return state;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  async getLatest(): Promise<RunState | null> {
+    try {
+      const content = await Bun.file(this.progressFile).text();
+      const data = JSON.parse(content);
+      const state = RunStateSchema.parse(data) as RunState;
+      return state;
+    } catch {
+      return null;
+    }
+  }
+
+  async save(state: RunState): Promise<void> {
+    try {
+      await mkdir(this.basePath, { recursive: true });
+
+      // Atomic write: write to temp file, then rename
+      const tempPath = `${this.progressFile}.tmp`;
+      await Bun.write(tempPath, JSON.stringify(state, null, 2));
+      await rename(tempPath, this.progressFile);
+
+      this.logger?.debug({ runId: state.runId }, "Run state saved");
+    } catch (error) {
+      const err = error as Error;
+      throw new PersistenceError("Failed to save run state", {
+        runId: state.runId,
+        error: err.message,
+      });
+    }
+  }
+}

package/src/modules/persistence/fs-task-store.ts

@@ -0,0 +1,152 @@
+import { mkdir, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { Glob } from "bun";
+import type { Logger } from "pino";
+import type { Task, TaskId, TaskStatus } from "@aad/shared/types";
+import { PersistenceError } from "@aad/shared/errors";
+import { TaskSchema, type TaskStore } from "./stores.port";
+
+export interface FSTaskStoreOptions {
+  basePath: string;
+  logger?: Logger;
+}
+
+/**
+ * File system adapter for TaskStore
+ * Structure: {basePath}/queue/{status}/{taskId}.json
+ */
+export class FSTaskStore implements TaskStore {
+  private basePath: string;
+  private logger?: Logger;
+
+  constructor(options: FSTaskStoreOptions) {
+    this.basePath = options.basePath;
+    this.logger = options.logger;
+  }
+
+  async get(taskId: TaskId): Promise<Task | null> {
+    // Search in all status directories
+    for (const status of ["pending", "running", "completed", "failed"]) {
+      const filePath = this.getTaskPath(status as TaskStatus, taskId);
+      try {
+        const content = await Bun.file(filePath).text();
+        const data = JSON.parse(content);
+        return TaskSchema.parse(data) as Task;
+      } catch {
+        // File not found or parse error, continue
+      }
+    }
+    return null;
+  }
+
+  async getAll(): Promise<Task[]> {
+    const tasks: Task[] = [];
+
+    for (const status of ["pending", "running", "completed", "failed"]) {
+      const statusTasks = await this.getByStatus(status as TaskStatus);
+      tasks.push(...statusTasks);
+    }
+
+    return tasks;
+  }
+
+  async getByStatus(status: TaskStatus): Promise<Task[]> {
+    const statusDir = this.getStatusDir(status);
+    const tasks: Task[] = [];
+
+    try {
+      await mkdir(statusDir, { recursive: true });
+
+      const glob = new Glob("*.json");
+      const files = glob.scanSync(statusDir);
+
+      for (const file of files) {
+        // Null byte防御: 空、null byteを含むエントリ、または.jsonで終わらないエントリをスキップ
+        if (!file || file.includes('\0') || !file.endsWith('.json')) {
+          this.logger?.warn({ file }, "Skipping invalid file entry");
+          continue;
+        }
+
+        try {
+          const filePath = join(statusDir, file);
+          const content = await Bun.file(filePath).text();
+          const data = JSON.parse(content);
+          const task = TaskSchema.parse(data) as Task;
+          tasks.push(task);
+        } catch (error) {
+          this.logger?.warn({ file, error }, "Failed to parse task file");
+          // Continue to next file instead of throwing
+        }
+      }
+    } catch (error) {
+      const err = error as Error;
+      // Log error but return empty array instead of throwing
+      this.logger?.error({ status, statusDir, error: err.message }, "Failed to read status directory");
+      return [];
+    }
+
+    return tasks;
+  }
+
+  async save(task: Task): Promise<void> {
+    const filePath = this.getTaskPath(task.status, task.taskId);
+    const statusDir = this.getStatusDir(task.status);
+
+    try {
+      await mkdir(statusDir, { recursive: true });
+
+      // Atomic write: write to temp file, then rename
+      const tempPath = `${filePath}.tmp`;
+      await Bun.write(tempPath, JSON.stringify(task, null, 2));
+      await rename(tempPath, filePath);
+
+      // Clean up old status files (if status changed)
+      await this.cleanupOldStatusFiles(task.taskId, task.status);
+
+      this.logger?.debug({ taskId: task.taskId, status: task.status }, "Task saved");
+    } catch (error) {
+      const err = error as Error;
+      throw new PersistenceError("Failed to save task", {
+        taskId: task.taskId,
+        status: task.status,
+        error: err.message,
+      });
+    }
+  }
+
+  async delete(taskId: TaskId): Promise<void> {
+    // Remove from all status directories
+    for (const status of ["pending", "running", "completed", "failed"]) {
+      const filePath = this.getTaskPath(status as TaskStatus, taskId);
+      try {
+        await rm(filePath, { force: true });
+      } catch {
+        // Ignore if file doesn't exist
+      }
+    }
+
+    this.logger?.debug({ taskId }, "Task deleted");
+  }
+
+  private getStatusDir(status: TaskStatus): string {
+    return join(this.basePath, "queue", status);
+  }
+
+  private getTaskPath(status: TaskStatus, taskId: TaskId): string {
+    return join(this.getStatusDir(status), `${taskId as string}.json`);
+  }
+
+  private async cleanupOldStatusFiles(taskId: TaskId, currentStatus: TaskStatus): Promise<void> {
+    const statuses: TaskStatus[] = ["pending", "running", "completed", "failed"];
+    for (const status of statuses) {
+      if (status !== currentStatus) {
+        const filePath = this.getTaskPath(status, taskId);
+        try {
+          await rm(filePath, { force: true });
+        } catch {
+          // Ignore errors
+        }
+      }
+    }
+  }
+}

package/src/modules/persistence/fs-worker-store.ts

@@ -0,0 +1,116 @@
+import { mkdir, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { Glob } from "bun";
+import type { Logger } from "pino";
+import type { Worker, WorkerId } from "@aad/shared/types";
+import { PersistenceError } from "@aad/shared/errors";
+import { WorkerSchema, type WorkerStore } from "./stores.port";
+
+export interface FSWorkerStoreOptions {
+  basePath: string;
+  logger?: Logger;
+}
+
+/**
+ * File system adapter for WorkerStore
+ * Structure: {basePath}/workers/worker-{id}.json
+ */
+export class FSWorkerStore implements WorkerStore {
+  private basePath: string;
+  private workersDir: string;
+  private logger?: Logger;
+
+  constructor(options: FSWorkerStoreOptions) {
+    this.basePath = options.basePath;
+    this.workersDir = join(this.basePath, "workers");
+    this.logger = options.logger;
+  }
+
+  async get(workerId: WorkerId): Promise<Worker | null> {
+    const filePath = this.getWorkerPath(workerId);
+
+    try {
+      const content = await Bun.file(filePath).text();
+      const data = JSON.parse(content);
+      return WorkerSchema.parse(data) as Worker;
+    } catch {
+      return null;
+    }
+  }
+
+  async getAll(): Promise<Worker[]> {
+    const workers: Worker[] = [];
+
+    try {
+      await mkdir(this.workersDir, { recursive: true });
+
+      const glob = new Glob("worker-*.json");
+      const files = glob.scanSync(this.workersDir);
+
+      for (const file of files) {
+        try {
+          const filePath = join(this.workersDir, file);
+          const content = await Bun.file(filePath).text();
+          const data = JSON.parse(content);
+          const worker = WorkerSchema.parse(data) as Worker;
+          workers.push(worker);
+        } catch (error) {
+          this.logger?.warn({ file, error }, "Failed to parse worker file");
+        }
+      }
+    } catch (error) {
+      const err = error as Error;
+      throw new PersistenceError("Failed to read workers", {
+        workersDir: this.workersDir,
+        error: err.message,
+      });
+    }
+
+    return workers;
+  }
+
+  async getIdle(): Promise<Worker[]> {
+    const allWorkers = await this.getAll();
+    return allWorkers.filter((worker) => worker.status === "idle");
+  }
+
+  async save(worker: Worker): Promise<void> {
+    const filePath = this.getWorkerPath(worker.workerId);
+
+    try {
+      await mkdir(this.workersDir, { recursive: true });
+
+      // Atomic write: write to temp file, then rename
+      const tempPath = `${filePath}.tmp`;
+      await Bun.write(tempPath, JSON.stringify(worker, null, 2));
+      await rename(tempPath, filePath);
+
+      this.logger?.debug({ workerId: worker.workerId, status: worker.status }, "Worker saved");
+    } catch (error) {
+      const err = error as Error;
+      throw new PersistenceError("Failed to save worker", {
+        workerId: worker.workerId,
+        error: err.message,
+      });
+    }
+  }
+
+  async delete(workerId: WorkerId): Promise<void> {
+    const filePath = this.getWorkerPath(workerId);
+
+    try {
+      await rm(filePath, { force: true });
+      this.logger?.debug({ workerId }, "Worker deleted");
+    } catch (error) {
+      const err = error as Error;
+      throw new PersistenceError("Failed to delete worker", {
+        workerId,
+        error: err.message,
+      });
+    }
+  }
+
+  private getWorkerPath(workerId: WorkerId): string {
+    return join(this.workersDir, `${workerId as string}.json`);
+  }
+}

package/src/modules/persistence/in-memory-stores.ts

@@ -0,0 +1,98 @@
+import type { Task, TaskId, TaskStatus, Worker, WorkerId, RunState, RunId } from "@aad/shared/types";
+import type { TaskStore, WorkerStore, RunStore } from "./stores.port";
+
+export class InMemoryTaskStore implements TaskStore {
+  private tasks: Map<string, Task> = new Map();
+
+  get(taskId: TaskId): Promise<Task | null> {
+    return Promise.resolve(this.tasks.get(taskId as string) ?? null);
+  }
+
+  getAll(): Promise<Task[]> {
+    return Promise.resolve(Array.from(this.tasks.values()));
+  }
+
+  getByStatus(status: TaskStatus): Promise<Task[]> {
+    return Promise.resolve(Array.from(this.tasks.values()).filter((task) => task.status === status));
+  }
+
+  save(task: Task): Promise<void> {
+    this.tasks.set(task.taskId as string, { ...task });
+    return Promise.resolve();
+  }
+
+  delete(taskId: TaskId): Promise<void> {
+    this.tasks.delete(taskId as string);
+    return Promise.resolve();
+  }
+
+  // Test helper
+  clear(): void {
+    this.tasks.clear();
+  }
+}
+
+export class InMemoryWorkerStore implements WorkerStore {
+  private workers: Map<string, Worker> = new Map();
+
+  get(workerId: WorkerId): Promise<Worker | null> {
+    return Promise.resolve(this.workers.get(workerId as string) ?? null);
+  }
+
+  getAll(): Promise<Worker[]> {
+    return Promise.resolve(Array.from(this.workers.values()));
+  }
+
+  getIdle(): Promise<Worker[]> {
+    return Promise.resolve(Array.from(this.workers.values()).filter((worker) => worker.status === "idle"));
+  }
+
+  save(worker: Worker): Promise<void> {
+    this.workers.set(worker.workerId as string, { ...worker });
+    return Promise.resolve();
+  }
+
+  delete(workerId: WorkerId): Promise<void> {
+    this.workers.delete(workerId as string);
+    return Promise.resolve();
+  }
+
+  // Test helper
+  clear(): void {
+    this.workers.clear();
+  }
+}
+
+export class InMemoryRunStore implements RunStore {
+  private states: Map<string, RunState> = new Map();
+
+  get(runId: RunId): Promise<RunState | null> {
+    return Promise.resolve(this.states.get(runId as string) ?? null);
+  }
+
+  getLatest(): Promise<RunState | null> {
+    const allStates = Array.from(this.states.values());
+    if (allStates.length === 0) {
+      return Promise.resolve(null);
+    }
+
+    // Sort by startTime descending (newest first)
+    allStates.sort((a, b) => {
+      const timeA = new Date(a.startTime).getTime();
+      const timeB = new Date(b.startTime).getTime();
+      return timeB - timeA;
+    });
+
+    return Promise.resolve(allStates[0] ?? null);
+  }
+
+  save(state: RunState): Promise<void> {
+    this.states.set(state.runId as string, { ...state });
+    return Promise.resolve();
+  }
+
+  // Test helper
+  clear(): void {
+    this.states.clear();
+  }
+}

package/src/modules/persistence/index.ts

@@ -0,0 +1,60 @@
+import type { Logger } from "pino";
+import type { TaskStore, WorkerStore, RunStore } from "./stores.port";
+import { InMemoryTaskStore, InMemoryWorkerStore, InMemoryRunStore } from "./in-memory-stores";
+import { FSTaskStore } from "./fs-task-store";
+import { FSWorkerStore } from "./fs-worker-store";
+import { FSRunStore } from "./fs-run-store";
+
+export type { TaskStore, WorkerStore, RunStore } from "./stores.port";
+export { TaskSchema, WorkerSchema, RunStateSchema } from "./stores.port";
+export { FileLock, withFileLock } from "./file-lock";
+export type { FileLockOptions } from "./file-lock";
+
+export interface StoresOptions {
+  basePath?: string;
+  logger?: Logger;
+}
+
+export interface Stores {
+  taskStore: TaskStore;
+  workerStore: WorkerStore;
+  runStore: RunStore;
+}
+
+/**
+ * Factory function to create persistence stores
+ * @param mode - "memory" for in-memory stores, "fs" for file system stores
+ * @param options - Configuration options
+ */
+export function createStores(mode: "memory" | "fs", options: StoresOptions = {}): Stores {
+  if (mode === "memory") {
+    return {
+      taskStore: new InMemoryTaskStore(),
+      workerStore: new InMemoryWorkerStore(),
+      runStore: new InMemoryRunStore(),
+    };
+  }
+
+  if (mode === "fs") {
+    if (!options.basePath) {
+      throw new Error("basePath is required for fs mode");
+    }
+
+    return {
+      taskStore: new FSTaskStore({
+        basePath: options.basePath,
+        logger: options.logger?.child({ adapter: "FSTaskStore" }),
+      }),
+      workerStore: new FSWorkerStore({
+        basePath: options.basePath,
+        logger: options.logger?.child({ adapter: "FSWorkerStore" }),
+      }),
+      runStore: new FSRunStore({
+        basePath: options.basePath,
+        logger: options.logger?.child({ adapter: "FSRunStore" }),
+      }),
+    };
+  }
+
+  throw new Error(`Unknown store mode: ${mode}`);
+}