@revealui/harnesses 0.1.7 → 0.1.9

package/dist/chunk-ANX4L2PF.js

@@ -0,0 +1,651 @@
+// src/storage/schema.ts
+var SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS agent_sessions (
+    id            TEXT PRIMARY KEY,
+    env           TEXT NOT NULL DEFAULT '',
+    task          TEXT NOT NULL DEFAULT '(starting)',
+    files         TEXT NOT NULL DEFAULT '',
+    pid           INTEGER,
+    started_at    TIMESTAMP NOT NULL DEFAULT NOW(),
+    updated_at    TIMESTAMP NOT NULL DEFAULT NOW(),
+    ended_at      TIMESTAMP,
+    exit_summary  TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS agent_messages (
+    id            SERIAL PRIMARY KEY,
+    from_agent    TEXT NOT NULL,
+    to_agent      TEXT NOT NULL,
+    subject       TEXT NOT NULL DEFAULT '',
+    body          TEXT NOT NULL DEFAULT '',
+    read          BOOLEAN NOT NULL DEFAULT FALSE,
+    created_at    TIMESTAMP NOT NULL DEFAULT NOW()
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_messages_to_unread
+    ON agent_messages (to_agent, read) WHERE read = FALSE;
+
+  CREATE TABLE IF NOT EXISTS file_reservations (
+    file_path     TEXT PRIMARY KEY,
+    agent_id      TEXT NOT NULL,
+    reserved_at   TIMESTAMP NOT NULL DEFAULT NOW(),
+    expires_at    TIMESTAMP NOT NULL,
+    reason        TEXT NOT NULL DEFAULT ''
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_reservations_agent
+    ON file_reservations (agent_id);
+
+  CREATE TABLE IF NOT EXISTS tasks (
+    id            TEXT PRIMARY KEY,
+    description   TEXT NOT NULL DEFAULT '',
+    status        TEXT NOT NULL DEFAULT 'open',
+    owner         TEXT,
+    claimed_at    TIMESTAMP,
+    completed_at  TIMESTAMP,
+    created_at    TIMESTAMP NOT NULL DEFAULT NOW()
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_tasks_status
+    ON tasks (status);
+
+  CREATE INDEX IF NOT EXISTS idx_tasks_owner
+    ON tasks (owner) WHERE owner IS NOT NULL;
+
+  CREATE TABLE IF NOT EXISTS events (
+    id            SERIAL PRIMARY KEY,
+    agent_id      TEXT NOT NULL,
+    event_type    TEXT NOT NULL,
+    payload       JSONB NOT NULL DEFAULT '{}',
+    created_at    TIMESTAMP NOT NULL DEFAULT NOW()
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_events_agent
+    ON events (agent_id, created_at DESC);
+
+  CREATE TABLE IF NOT EXISTS worktrees (
+    agent_id      TEXT PRIMARY KEY,
+    branch        TEXT NOT NULL,
+    worktree_path TEXT NOT NULL,
+    base_branch   TEXT NOT NULL DEFAULT 'test',
+    status        TEXT NOT NULL DEFAULT 'active',
+    created_at    TIMESTAMP NOT NULL DEFAULT NOW()
+  );
+
+  CREATE TABLE IF NOT EXISTS agent_memory (
+    id            SERIAL PRIMARY KEY,
+    agent_id      TEXT NOT NULL,
+    memory_type   TEXT NOT NULL,
+    content       TEXT NOT NULL,
+    metadata      JSONB NOT NULL DEFAULT '{}',
+    created_at    TIMESTAMP NOT NULL DEFAULT NOW()
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_memory_agent_type
+    ON agent_memory (agent_id, memory_type, created_at DESC);
+
+  CREATE TABLE IF NOT EXISTS merge_requests (
+    id            TEXT PRIMARY KEY,
+    agent_id      TEXT NOT NULL,
+    task_id       TEXT,
+    source_branch TEXT NOT NULL,
+    base_branch   TEXT NOT NULL DEFAULT 'test',
+    status        TEXT NOT NULL DEFAULT 'pending',
+    pr_number     INTEGER,
+    pr_url        TEXT,
+    retry_count   INTEGER NOT NULL DEFAULT 0,
+    error_message TEXT,
+    ci_output     TEXT,
+    created_at    TIMESTAMP NOT NULL DEFAULT NOW(),
+    updated_at    TIMESTAMP NOT NULL DEFAULT NOW()
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_merge_requests_agent
+    ON merge_requests (agent_id, status);
+
+  CREATE INDEX IF NOT EXISTS idx_merge_requests_branch
+    ON merge_requests (source_branch);
+
+  CREATE INDEX IF NOT EXISTS idx_merge_requests_pr
+    ON merge_requests (pr_number) WHERE pr_number IS NOT NULL;
+`;
+
+// src/storage/daemon-store.ts
+var DaemonStore = class {
+  db = null;
+  dataDir;
+  constructor(config) {
+    this.dataDir = config.dataDir;
+  }
+  /** Initialize PGlite and create tables. */
+  async init() {
+    const { PGlite: PGliteClass } = await import("@electric-sql/pglite");
+    this.db = new PGliteClass(this.dataDir);
+    await this.db.exec(SCHEMA_SQL);
+  }
+  /** Shut down the database. */
+  async close() {
+    if (this.db) {
+      await this.db.close();
+      this.db = null;
+    }
+  }
+  getDb() {
+    if (!this.db) throw new Error("DaemonStore not initialized  -  call init() first");
+    return this.db;
+  }
+  // ---------------------------------------------------------------------------
+  // Sessions
+  // ---------------------------------------------------------------------------
+  /** Register or update an agent session. */
+  async registerSession(session) {
+    const db = this.getDb();
+    const result = await db.query(
+      `INSERT INTO agent_sessions (id, env, task, pid)
+       VALUES ($1, $2, $3, $4)
+       ON CONFLICT (id) DO UPDATE SET
+         env = EXCLUDED.env,
+         task = COALESCE(EXCLUDED.task, agent_sessions.task),
+         pid = COALESCE(EXCLUDED.pid, agent_sessions.pid),
+         updated_at = NOW(),
+         ended_at = NULL
+       RETURNING *`,
+      [session.id, session.env, session.task ?? "(starting)", session.pid ?? null]
+    );
+    return result.rows[0];
+  }
+  /** Update a session's task and/or files. */
+  async updateSession(id, updates) {
+    const db = this.getDb();
+    const sets = ["updated_at = NOW()"];
+    const params = [];
+    let paramIdx = 1;
+    if (updates.task !== void 0) {
+      sets.push(`task = $${paramIdx++}`);
+      params.push(updates.task);
+    }
+    if (updates.files !== void 0) {
+      sets.push(`files = $${paramIdx++}`);
+      params.push(updates.files);
+    }
+    params.push(id);
+    const result = await db.query(
+      `UPDATE agent_sessions SET ${sets.join(", ")} WHERE id = $${paramIdx} RETURNING *`,
+      params
+    );
+    return result.rows[0] ?? null;
+  }
+  /** End a session (mark ended_at, record exit summary). */
+  async endSession(id, exitSummary) {
+    const db = this.getDb();
+    await db.query(
+      `UPDATE agent_sessions SET ended_at = NOW(), exit_summary = $2, updated_at = NOW()
+       WHERE id = $1`,
+      [id, exitSummary ?? null]
+    );
+  }
+  /** Get all active sessions (ended_at IS NULL). */
+  async getActiveSessions() {
+    const db = this.getDb();
+    const result = await db.query(
+      "SELECT * FROM agent_sessions WHERE ended_at IS NULL ORDER BY started_at"
+    );
+    return result.rows;
+  }
+  /** Get session history for an agent (most recent first). */
+  async getSessionHistory(agentId, limit) {
+    const db = this.getDb();
+    const result = await db.query(
+      "SELECT * FROM agent_sessions WHERE id = $1 ORDER BY started_at DESC LIMIT $2",
+      [agentId, limit]
+    );
+    return result.rows;
+  }
+  // ---------------------------------------------------------------------------
+  // Messages
+  // ---------------------------------------------------------------------------
+  /** Send a message from one agent to another. */
+  async sendMessage(msg) {
+    const db = this.getDb();
+    const result = await db.query(
+      `INSERT INTO agent_messages (from_agent, to_agent, subject, body)
+       VALUES ($1, $2, $3, $4)
+       RETURNING *`,
+      [msg.fromAgent, msg.toAgent, msg.subject, msg.body ?? ""]
+    );
+    return result.rows[0];
+  }
+  /** Broadcast a message to all active agents (except sender). */
+  async broadcastMessage(msg) {
+    const active = await this.getActiveSessions();
+    let sent = 0;
+    for (const session of active) {
+      if (session.id === msg.fromAgent) continue;
+      await this.sendMessage({
+        fromAgent: msg.fromAgent,
+        toAgent: session.id,
+        subject: msg.subject,
+        body: msg.body
+      });
+      sent++;
+    }
+    return sent;
+  }
+  /** Get unread messages for an agent. */
+  async getInbox(agentId, unreadOnly) {
+    const db = this.getDb();
+    const whereClause = unreadOnly ? "WHERE to_agent = $1 AND read = FALSE" : "WHERE to_agent = $1";
+    const result = await db.query(
+      `SELECT * FROM agent_messages ${whereClause} ORDER BY created_at DESC LIMIT 50`,
+      [agentId]
+    );
+    return result.rows;
+  }
+  /** Mark messages as read. */
+  async markRead(messageIds) {
+    if (messageIds.length === 0) return;
+    const db = this.getDb();
+    const placeholders = messageIds.map((_, i) => `$${i + 1}`).join(", ");
+    await db.query(
+      `UPDATE agent_messages SET read = TRUE WHERE id IN (${placeholders})`,
+      messageIds
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // File Reservations
+  // ---------------------------------------------------------------------------
+  /** Reserve a file for an agent (CAS: fails if already reserved by another). */
+  async reserveFile(reservation) {
+    const db = this.getDb();
+    await db.query("DELETE FROM file_reservations WHERE expires_at < NOW()");
+    const result = await db.query(
+      `INSERT INTO file_reservations (file_path, agent_id, expires_at, reason)
+       VALUES ($1, $2, NOW() + ($3 || ' seconds')::INTERVAL, $4)
+       ON CONFLICT (file_path) DO UPDATE SET
+         agent_id = EXCLUDED.agent_id,
+         reserved_at = NOW(),
+         expires_at = EXCLUDED.expires_at,
+         reason = EXCLUDED.reason
+       WHERE file_reservations.agent_id = $2 OR file_reservations.expires_at < NOW()
+       RETURNING *`,
+      [
+        reservation.filePath,
+        reservation.agentId,
+        String(reservation.ttlSeconds),
+        reservation.reason ?? ""
+      ]
+    );
+    if (result.rows.length > 0) {
+      return { success: true };
+    }
+    const existing = await db.query(
+      "SELECT agent_id FROM file_reservations WHERE file_path = $1",
+      [reservation.filePath]
+    );
+    return { success: false, holder: existing.rows[0]?.agent_id };
+  }
+  /** Check who holds a file reservation. */
+  async checkReservation(filePath) {
+    const db = this.getDb();
+    await db.query("DELETE FROM file_reservations WHERE expires_at < NOW()");
+    const result = await db.query(
+      "SELECT * FROM file_reservations WHERE file_path = $1",
+      [filePath]
+    );
+    return result.rows[0] ?? null;
+  }
+  /** Release all reservations held by an agent. */
+  async releaseAllReservations(agentId) {
+    const db = this.getDb();
+    const result = await db.query("DELETE FROM file_reservations WHERE agent_id = $1", [agentId]);
+    return result.affectedRows ?? 0;
+  }
+  /** Get all reservations for an agent. */
+  async getReservations(agentId) {
+    const db = this.getDb();
+    await db.query("DELETE FROM file_reservations WHERE expires_at < NOW()");
+    const result = await db.query(
+      "SELECT * FROM file_reservations WHERE agent_id = $1 ORDER BY reserved_at",
+      [agentId]
+    );
+    return result.rows;
+  }
+  // ---------------------------------------------------------------------------
+  // Tasks
+  // ---------------------------------------------------------------------------
+  /** Create a new task. */
+  async createTask(task) {
+    const db = this.getDb();
+    const result = await db.query(
+      `INSERT INTO tasks (id, description) VALUES ($1, $2)
+       ON CONFLICT (id) DO UPDATE SET description = EXCLUDED.description
+       RETURNING *`,
+      [task.id, task.description]
+    );
+    return result.rows[0];
+  }
+  /** Claim a task atomically (CAS: fails if already claimed by another agent). */
+  async claimTask(taskId, agentId) {
+    const db = this.getDb();
+    const result = await db.query(
+      `UPDATE tasks SET status = 'claimed', owner = $2, claimed_at = NOW()
+       WHERE id = $1 AND (status = 'open' OR owner = $2)
+       RETURNING *`,
+      [taskId, agentId]
+    );
+    if (result.rows.length > 0) {
+      return { success: true };
+    }
+    const existing = await db.query("SELECT owner FROM tasks WHERE id = $1", [taskId]);
+    if (existing.rows.length === 0) {
+      return { success: false, owner: void 0 };
+    }
+    return { success: false, owner: existing.rows[0].owner ?? void 0 };
+  }
+  /** Complete a task (only the owner can complete it). */
+  async completeTask(taskId, agentId) {
+    const db = this.getDb();
+    const result = await db.query(
+      `UPDATE tasks SET status = 'completed', completed_at = NOW()
+       WHERE id = $1 AND owner = $2
+       RETURNING id`,
+      [taskId, agentId]
+    );
+    return (result.rows?.length ?? 0) > 0;
+  }
+  /** Release a claimed task back to open (only the owner can release). */
+  async releaseTask(taskId, agentId) {
+    const db = this.getDb();
+    const result = await db.query(
+      `UPDATE tasks SET status = 'open', owner = NULL, claimed_at = NULL
+       WHERE id = $1 AND owner = $2
+       RETURNING id`,
+      [taskId, agentId]
+    );
+    return (result.rows?.length ?? 0) > 0;
+  }
+  /** List tasks, optionally filtered by status and/or owner. */
+  async listTasks(filter) {
+    const db = this.getDb();
+    const conditions = [];
+    const params = [];
+    let paramIdx = 1;
+    if (filter?.status) {
+      conditions.push(`status = $${paramIdx++}`);
+      params.push(filter.status);
+    }
+    if (filter?.owner) {
+      conditions.push(`owner = $${paramIdx++}`);
+      params.push(filter.owner);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = await db.query(
+      `SELECT * FROM tasks ${where} ORDER BY created_at`,
+      params
+    );
+    return result.rows;
+  }
+  // ---------------------------------------------------------------------------
+  // Events
+  // ---------------------------------------------------------------------------
+  /** Append an event to the audit log. */
+  async logEvent(event) {
+    const db = this.getDb();
+    const result = await db.query(
+      `INSERT INTO events (agent_id, event_type, payload)
+       VALUES ($1, $2, $3)
+       RETURNING *`,
+      [event.agentId, event.eventType, JSON.stringify(event.payload ?? {})]
+    );
+    return result.rows[0];
+  }
+  /** Get recent events (newest first). */
+  async getRecentEvents(limit) {
+    const db = this.getDb();
+    const result = await db.query(
+      "SELECT * FROM events ORDER BY created_at DESC LIMIT $1",
+      [limit]
+    );
+    return result.rows;
+  }
+  /** Prune events older than a given number of days. */
+  async pruneEvents(olderThanDays) {
+    const db = this.getDb();
+    const result = await db.query(
+      `DELETE FROM events WHERE created_at < NOW() - ($1 || ' days')::INTERVAL`,
+      [String(olderThanDays)]
+    );
+    return result.affectedRows ?? 0;
+  }
+  // ---------------------------------------------------------------------------
+  // Worktrees
+  // ---------------------------------------------------------------------------
+  /** Register a worktree for an agent. */
+  async registerWorktree(wt) {
+    const db = this.getDb();
+    const result = await db.query(
+      `INSERT INTO worktrees (agent_id, branch, worktree_path, base_branch)
+       VALUES ($1, $2, $3, $4)
+       ON CONFLICT (agent_id) DO UPDATE SET
+         branch = EXCLUDED.branch,
+         worktree_path = EXCLUDED.worktree_path,
+         base_branch = EXCLUDED.base_branch,
+         status = 'active'
+       RETURNING *`,
+      [wt.agentId, wt.branch, wt.worktreePath, wt.baseBranch ?? "test"]
+    );
+    return result.rows[0];
+  }
+  /** Get a worktree by agent ID. */
+  async getWorktree(agentId) {
+    const db = this.getDb();
+    const result = await db.query("SELECT * FROM worktrees WHERE agent_id = $1", [
+      agentId
+    ]);
+    return result.rows[0] ?? null;
+  }
+  /** List all active worktrees. */
+  async getActiveWorktrees() {
+    const db = this.getDb();
+    const result = await db.query(
+      "SELECT * FROM worktrees WHERE status = 'active' ORDER BY created_at"
+    );
+    return result.rows;
+  }
+  /** Update worktree status (active → merged | abandoned). */
+  async updateWorktreeStatus(agentId, status) {
+    const db = this.getDb();
+    const result = await db.query(
+      "UPDATE worktrees SET status = $2 WHERE agent_id = $1 RETURNING agent_id",
+      [agentId, status]
+    );
+    return (result.rows?.length ?? 0) > 0;
+  }
+  /** Remove a worktree record. */
+  async removeWorktree(agentId) {
+    const db = this.getDb();
+    const result = await db.query("DELETE FROM worktrees WHERE agent_id = $1 RETURNING agent_id", [
+      agentId
+    ]);
+    return (result.rows?.length ?? 0) > 0;
+  }
+  // ---------------------------------------------------------------------------
+  // Agent Memory
+  // ---------------------------------------------------------------------------
+  /** Store a memory entry. */
+  async storeMemory(entry) {
+    const db = this.getDb();
+    const result = await db.query(
+      `INSERT INTO agent_memory (agent_id, memory_type, content, metadata)
+       VALUES ($1, $2, $3, $4)
+       RETURNING *`,
+      [entry.agentId, entry.memoryType, entry.content, JSON.stringify(entry.metadata ?? {})]
+    );
+    return result.rows[0];
+  }
+  /** Recall memory entries by agent and type (newest first). */
+  async recallMemory(query) {
+    const db = this.getDb();
+    const conditions = [];
+    const params = [];
+    let paramIdx = 1;
+    if (query.agentId) {
+      conditions.push(`agent_id = $${paramIdx++}`);
+      params.push(query.agentId);
+    }
+    if (query.memoryType) {
+      conditions.push(`memory_type = $${paramIdx++}`);
+      params.push(query.memoryType);
+    }
+    if (query.keyword) {
+      conditions.push(`content ILIKE $${paramIdx++}`);
+      params.push(`%${query.keyword}%`);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = query.limit ?? 20;
+    params.push(limit);
+    const result = await db.query(
+      `SELECT * FROM agent_memory ${where} ORDER BY created_at DESC LIMIT $${paramIdx}`,
+      params
+    );
+    return result.rows;
+  }
+  /** Get a summary of recent memory (last N per type for context injection). */
+  async summarizeMemory(agentId, perType) {
+    const db = this.getDb();
+    const result = await db.query(
+      `SELECT * FROM (
+         SELECT *, ROW_NUMBER() OVER (PARTITION BY memory_type ORDER BY created_at DESC) AS rn
+         FROM agent_memory WHERE agent_id = $1
+       ) sub WHERE rn <= $2
+       ORDER BY memory_type, created_at DESC`,
+      [agentId, perType]
+    );
+    return result.rows;
+  }
+  /** Prune old memory entries (keep last N per agent). */
+  async pruneMemory(keepPerAgent) {
+    const db = this.getDb();
+    const result = await db.query(
+      `DELETE FROM agent_memory WHERE id IN (
+         SELECT id FROM (
+           SELECT id, ROW_NUMBER() OVER (PARTITION BY agent_id ORDER BY created_at DESC) AS rn
+           FROM agent_memory
+         ) sub WHERE rn > $1
+       )`,
+      [keepPerAgent]
+    );
+    return result.affectedRows ?? 0;
+  }
+  // ---------------------------------------------------------------------------
+  // Merge Requests
+  // ---------------------------------------------------------------------------
+  /** Create a merge request for an agent's branch. */
+  async createMergeRequest(mr) {
+    const db = this.getDb();
+    const result = await db.query(
+      `INSERT INTO merge_requests (id, agent_id, task_id, source_branch, base_branch)
+       VALUES ($1, $2, $3, $4, $5)
+       ON CONFLICT (id) DO UPDATE SET
+         status = 'pending',
+         retry_count = merge_requests.retry_count,
+         updated_at = NOW()
+       RETURNING *`,
+      [mr.id, mr.agentId, mr.taskId ?? null, mr.sourceBranch, mr.baseBranch ?? "test"]
+    );
+    return result.rows[0];
+  }
+  /** Get a merge request by ID. */
+  async getMergeRequest(id) {
+    const db = this.getDb();
+    const result = await db.query("SELECT * FROM merge_requests WHERE id = $1", [id]);
+    return result.rows[0] ?? null;
+  }
+  /** Get a merge request by source branch. */
+  async getMergeRequestByBranch(branch) {
+    const db = this.getDb();
+    const result = await db.query(
+      "SELECT * FROM merge_requests WHERE source_branch = $1 AND status NOT IN ('merged', 'escalated') ORDER BY created_at DESC LIMIT 1",
+      [branch]
+    );
+    return result.rows[0] ?? null;
+  }
+  /** Get a merge request by PR number. */
+  async getMergeRequestByPr(prNumber) {
+    const db = this.getDb();
+    const result = await db.query(
+      "SELECT * FROM merge_requests WHERE pr_number = $1 ORDER BY created_at DESC LIMIT 1",
+      [prNumber]
+    );
+    return result.rows[0] ?? null;
+  }
+  /** Update a merge request's fields. */
+  async updateMergeRequest(id, updates) {
+    const db = this.getDb();
+    const sets = ["updated_at = NOW()"];
+    const params = [];
+    let paramIdx = 1;
+    if (updates.status !== void 0) {
+      sets.push(`status = $${paramIdx++}`);
+      params.push(updates.status);
+    }
+    if (updates.prNumber !== void 0) {
+      sets.push(`pr_number = $${paramIdx++}`);
+      params.push(updates.prNumber);
+    }
+    if (updates.prUrl !== void 0) {
+      sets.push(`pr_url = $${paramIdx++}`);
+      params.push(updates.prUrl);
+    }
+    if (updates.errorMessage !== void 0) {
+      sets.push(`error_message = $${paramIdx++}`);
+      params.push(updates.errorMessage);
+    }
+    if (updates.ciOutput !== void 0) {
+      sets.push(`ci_output = $${paramIdx++}`);
+      params.push(updates.ciOutput);
+    }
+    params.push(id);
+    const result = await db.query(
+      `UPDATE merge_requests SET ${sets.join(", ")} WHERE id = $${paramIdx} RETURNING *`,
+      params
+    );
+    return result.rows[0] ?? null;
+  }
+  /** Increment the retry count for a merge request. */
+  async incrementMergeRetry(id) {
+    const db = this.getDb();
+    const result = await db.query(
+      `UPDATE merge_requests SET retry_count = retry_count + 1, updated_at = NOW()
+       WHERE id = $1 RETURNING retry_count`,
+      [id]
+    );
+    return result.rows[0]?.retry_count ?? 0;
+  }
+  /** List merge requests, optionally filtered by status and/or agent. */
+  async listMergeRequests(filter) {
+    const db = this.getDb();
+    const conditions = [];
+    const params = [];
+    let paramIdx = 1;
+    if (filter?.status) {
+      conditions.push(`status = $${paramIdx++}`);
+      params.push(filter.status);
+    }
+    if (filter?.agentId) {
+      conditions.push(`agent_id = $${paramIdx++}`);
+      params.push(filter.agentId);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const result = await db.query(
+      `SELECT * FROM merge_requests ${where} ORDER BY created_at DESC`,
+      params
+    );
+    return result.rows;
+  }
+};
+
+export {
+  SCHEMA_SQL,
+  DaemonStore
+};