agent-office 0.2.3 → 0.3.0

package/dist/commands/serve.d.ts

@@ -1,10 +1,11 @@
 interface ServeOptions {
     databaseUrl?: string;
-    opencodeUrl: string;
+    sqlite?: string;
     host: string;
     port: string;
     memoryPath: string;
     password?: string;
+    opencodeUrl: string;
 }
 export declare function serve(options: ServeOptions): Promise<void>;
 export {};

package/dist/commands/serve.js

@@ -1,4 +1,4 @@
-import { createDb } from "../db/index.js";
+import { createPostgresqlStorage, createSqliteStorage } from "../db/index.js";
 import { runMigrations } from "../db/migrate.js";
 import { OpenCodeCodingServer } from "../lib/opencode-coding-server.js";
 import { createApp } from "../server/index.js";
@@ -10,32 +10,39 @@ export async function serve(options) {
         console.error("Error: --password is required (or set AGENT_OFFICE_PASSWORD)");
         process.exit(1);
     }
-    const databaseUrl = options.databaseUrl;
-    if (!databaseUrl) {
-        console.error("Error: --database-url is required (or set DATABASE_URL)");
-        process.exit(1);
-    }
     const port = parseInt(options.port, 10);
     if (isNaN(port) || port < 1 || port > 65535) {
         console.error(`Error: invalid port "${options.port}"`);
         process.exit(1);
     }
-    // Connect to DB
-    console.log("Connecting to database...");
-    const sql = createDb(databaseUrl);
+    // Determine storage backend
+    let storage;
+    if (options.sqlite) {
+        console.log(`Connecting to SQLite database at ${options.sqlite}...`);
+        storage = createSqliteStorage(options.sqlite);
+    }
+    else if (options.databaseUrl) {
+        console.log("Connecting to PostgreSQL database...");
+        storage = createPostgresqlStorage(options.databaseUrl);
+    }
+    else {
+        console.error("Error: either --database-url (or DATABASE_URL) or --sqlite (or AGENT_OFFICE_SQLITE) is required");
+        process.exit(1);
+    }
     // Run migrations
     console.log("Running migrations...");
     try {
-        await runMigrations(sql);
+        await runMigrations(storage);
         console.log("Migrations complete.");
     }
     catch (err) {
         console.error("Migration failed:", err);
-        await sql.end();
+        await storage.close();
         process.exit(1);
     }
     // Init agentic coding server (OpenCode implementation)
     const agenticCodingServer = new OpenCodeCodingServer(options.opencodeUrl);
+    console.log(`Connecting to OpenCode server at ${options.opencodeUrl}...`);
     const serverUrl = `http://${options.host}:${port}`;
     // Create memory manager and verify embedding model
     const memoryManager = new MemoryManager(options.memoryPath);
@@ -49,15 +56,15 @@ export async function serve(options) {
         console.error("Try deleting the model cache and restarting:");
         console.error(`  rm -rf ${options.memoryPath}/.model-cache`);
         memoryManager.closeAll();
-        await sql.end();
+        await storage.close();
         process.exit(1);
     }
     // Create cron scheduler
     const cronScheduler = new CronScheduler();
     // Create Express app
-    const app = createApp(sql, agenticCodingServer, password, serverUrl, cronScheduler, memoryManager);
+    const app = createApp(storage, agenticCodingServer, password, serverUrl, cronScheduler, memoryManager);
     // Start cron scheduler
-    await cronScheduler.start(sql, agenticCodingServer, serverUrl);
+    await cronScheduler.start(storage, agenticCodingServer, serverUrl);
     // Start server
     const server = app.listen(port, options.host, () => {
         console.log(`agent-office server listening on ${serverUrl}`);
@@ -68,7 +75,7 @@ export async function serve(options) {
         server.close(async () => {
             cronScheduler.stop();
             memoryManager.closeAll();
-            await sql.end();
+            await storage.close();
             console.log("Goodbye.");
             process.exit(0);
         });

package/dist/db/index.d.ts

@@ -1,6 +1,9 @@
 import postgres from "postgres";
 export type Sql = ReturnType<typeof postgres>;
 export declare function createDb(databaseUrl: string): Sql;
+export type { AgentOfficeStorage, WatchListener, WatchState, SenderInfo } from "./storage.js";
+export { AgentOfficePostgresqlStorage, createPostgresqlStorage } from "./postgresql-storage.js";
+export { AgentOfficeSqliteStorage, createSqliteStorage } from "./sqlite-storage.js";
 export interface SessionRow {
     id: number;
     name: string;

package/dist/db/index.js

@@ -7,3 +7,5 @@ export function createDb(databaseUrl) {
         onnotice: () => { },
     });
 }
+export { AgentOfficePostgresqlStorage, createPostgresqlStorage } from "./postgresql-storage.js";
+export { AgentOfficeSqliteStorage, createSqliteStorage } from "./sqlite-storage.js";

package/dist/db/migrate.d.ts

@@ -1,2 +1,2 @@
-import type { Sql } from "./index.js";
-export declare function runMigrations(sql: Sql): Promise<void>;
+import type { AgentOfficeStorage } from "./storage.js";
+export declare function runMigrations(storage: AgentOfficeStorage): Promise<void>;

package/dist/db/migrate.js

@@ -1,125 +1,3 @@
-const MIGRATIONS = [
-    {
-        version: 1,
-        name: "create_sessions",
-        sql: `
-      CREATE TABLE IF NOT EXISTS sessions (
-        id         SERIAL PRIMARY KEY,
-        name       VARCHAR(255) UNIQUE NOT NULL,
-        session_id VARCHAR(255) UNIQUE NOT NULL,
-        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-      );
-      CREATE INDEX IF NOT EXISTS idx_sessions_name ON sessions(name);
-    `,
-    },
-    {
-        version: 2,
-        name: "add_agent_code",
-        sql: `
-      ALTER TABLE sessions ADD COLUMN IF NOT EXISTS agent_code UUID NOT NULL DEFAULT gen_random_uuid();
-      CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_agent_code ON sessions(agent_code);
-    `,
-    },
-    {
-        version: 3,
-        name: "create_config_table",
-        sql: `
-      CREATE TABLE IF NOT EXISTS config (
-        key   VARCHAR(255) PRIMARY KEY,
-        value TEXT NOT NULL
-      );
-      INSERT INTO config (key, value) VALUES ('human_name', 'Human') ON CONFLICT DO NOTHING;
-      INSERT INTO config (key, value) VALUES ('human_description', '') ON CONFLICT DO NOTHING;
-    `,
-    },
-    {
-        version: 5,
-        name: "add_mode_to_sessions",
-        sql: `
-      ALTER TABLE sessions ADD COLUMN IF NOT EXISTS mode VARCHAR(255) NULL;
-    `,
-    },
-    {
-        version: 4,
-        name: "create_messages_table",
-        sql: `
-      CREATE TABLE IF NOT EXISTS messages (
-        id          SERIAL PRIMARY KEY,
-        from_name   VARCHAR(255) NOT NULL,
-        to_name     VARCHAR(255) NOT NULL,
-        body        TEXT NOT NULL,
-        read        BOOLEAN NOT NULL DEFAULT FALSE,
-        injected    BOOLEAN NOT NULL DEFAULT FALSE,
-        created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
-      );
-      CREATE INDEX IF NOT EXISTS idx_messages_to_name ON messages(to_name);
-      CREATE INDEX IF NOT EXISTS idx_messages_from_name ON messages(from_name);
-      CREATE INDEX IF NOT EXISTS idx_messages_read ON messages(read);
-    `,
-    },
-    {
-        version: 6,
-        name: "create_cron_tables",
-        sql: `
-      CREATE TABLE IF NOT EXISTS cron_jobs (
-        id            SERIAL PRIMARY KEY,
-        name          VARCHAR(255) NOT NULL,
-        session_name  VARCHAR(255) NOT NULL REFERENCES sessions(name) ON DELETE CASCADE,
-        schedule      TEXT NOT NULL,
-        timezone      VARCHAR(100),
-        message       TEXT NOT NULL,
-        enabled       BOOLEAN NOT NULL DEFAULT TRUE,
-        created_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-        last_run      TIMESTAMPTZ
-      );
-      CREATE UNIQUE INDEX IF NOT EXISTS idx_cron_jobs_name_session ON cron_jobs(name, session_name);
-      CREATE INDEX IF NOT EXISTS idx_cron_jobs_session_name ON cron_jobs(session_name);
-      CREATE INDEX IF NOT EXISTS idx_cron_jobs_enabled ON cron_jobs(enabled);
-
-      CREATE TABLE IF NOT EXISTS cron_history (
-        id             SERIAL PRIMARY KEY,
-        cron_job_id    INTEGER NOT NULL REFERENCES cron_jobs(id) ON DELETE CASCADE,
-        executed_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-        success        BOOLEAN NOT NULL DEFAULT TRUE,
-        error_message  TEXT
-      );
-      CREATE INDEX IF NOT EXISTS idx_cron_history_job_id ON cron_history(cron_job_id);
-    `,
-    },
-    {
-        version: 7,
-        name: "add_status_to_sessions",
-        sql: `
-      ALTER TABLE sessions ADD COLUMN IF NOT EXISTS status TEXT NULL;
-    `,
-    },
-    {
-        version: 8,
-        name: "rename_mode_to_agent",
-        sql: `
-      ALTER TABLE sessions RENAME COLUMN mode TO agent;
-    `,
-    },
-];
-export async function runMigrations(sql) {
-    await sql `
-    CREATE TABLE IF NOT EXISTS _migrations (
-      version    INTEGER PRIMARY KEY,
-      name       VARCHAR(255) NOT NULL,
-      applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-    )
-  `;
-    const applied = await sql `
-    SELECT version FROM _migrations ORDER BY version
-  `;
-    const appliedVersions = new Set(applied.map((r) => r.version));
-    for (const migration of MIGRATIONS) {
-        if (appliedVersions.has(migration.version))
-            continue;
-        console.log(`  Applying migration ${migration.version}: ${migration.name}`);
-        await sql.begin(async (tx) => {
-            await tx.unsafe(migration.sql);
-            await tx.unsafe(`INSERT INTO _migrations (version, name) VALUES ($1, $2)`, [migration.version, migration.name]);
-        });
-    }
+export async function runMigrations(storage) {
+    await storage.runMigrations();
 }

package/dist/db/postgresql-storage.d.ts

@@ -0,0 +1,41 @@
+import { AgentOfficeStorageBase } from "./storage-base.js";
+import type { SessionRow, ConfigRow, MessageRow, CronJobRow, CronHistoryRow, Sql } from "./index.js";
+export declare class AgentOfficePostgresqlStorage extends AgentOfficeStorageBase {
+    private sql;
+    constructor(sql: Sql);
+    close(): Promise<void>;
+    begin<T>(callback: (tx: import("./storage.js").AgentOfficeStorage) => Promise<T>): Promise<T>;
+    listSessions(): Promise<SessionRow[]>;
+    getSessionByName(name: string): Promise<SessionRow | null>;
+    getSessionByAgentCode(agentCode: string): Promise<SessionRow | null>;
+    getSessionIdByName(name: string): Promise<number | null>;
+    createSession(name: string, sessionId: string, agent: string): Promise<SessionRow>;
+    deleteSession(id: number): Promise<void>;
+    regenerateAgentCode(name: string): Promise<SessionRow>;
+    updateSessionAgent(name: string, agent: string): Promise<SessionRow>;
+    updateSessionStatus(agentCode: string, status: string | null): Promise<void>;
+    updateSessionId(name: string, sessionId: string): Promise<void>;
+    sessionExists(name: string): Promise<boolean>;
+    getAllConfig(): Promise<ConfigRow[]>;
+    getConfig(key: string): Promise<string | null>;
+    setConfig(key: string, value: string): Promise<void>;
+    listMessagesForRecipient(name: string, unreadOnly: boolean): Promise<MessageRow[]>;
+    listMessagesFromSender(name: string): Promise<MessageRow[]>;
+    createMessageImpl(from: string, to: string, body: string): Promise<MessageRow>;
+    markMessageAsRead(id: number): Promise<MessageRow | null>;
+    markMessageAsInjected(id: number): Promise<void>;
+    listCronJobs(): Promise<CronJobRow[]>;
+    listCronJobsForSession(sessionName: string): Promise<CronJobRow[]>;
+    getCronJobById(id: number): Promise<CronJobRow | null>;
+    getCronJobByNameAndSession(name: string, sessionName: string): Promise<CronJobRow | null>;
+    createCronJob(name: string, sessionName: string, schedule: string, timezone: string | null, message: string): Promise<CronJobRow>;
+    deleteCronJob(id: number): Promise<void>;
+    enableCronJob(id: number): Promise<void>;
+    disableCronJob(id: number): Promise<void>;
+    updateCronJobLastRun(id: number, lastRun: Date): Promise<void>;
+    cronJobExistsForSession(name: string, sessionName: string): Promise<boolean>;
+    listCronHistory(cronJobId: number, limit: number): Promise<CronHistoryRow[]>;
+    createCronHistory(cronJobId: number, executedAt: Date, success: boolean, errorMessage?: string): Promise<void>;
+    runMigrations(): Promise<void>;
+}
+export declare function createPostgresqlStorage(databaseUrl: string): AgentOfficePostgresqlStorage;

package/dist/db/postgresql-storage.js

@@ -0,0 +1,366 @@
+import postgres from "postgres";
+import { AgentOfficeStorageBase } from "./storage-base.js";
+export class AgentOfficePostgresqlStorage extends AgentOfficeStorageBase {
+    sql;
+    constructor(sql) {
+        super();
+        this.sql = sql;
+    }
+    async close() {
+        await this.sql.end();
+    }
+    async begin(callback) {
+        return this.sql.begin(async (tx) => {
+            const txStorage = new AgentOfficePostgresqlStorage(tx);
+            return callback(txStorage);
+        });
+    }
+    // Sessions
+    async listSessions() {
+        return this.sql `
+      SELECT id, name, session_id, agent_code, agent, status, created_at
+      FROM sessions
+      ORDER BY created_at DESC
+    `;
+    }
+    async getSessionByName(name) {
+        const [row] = await this.sql `
+      SELECT id, name, session_id, agent_code, agent, status, created_at
+      FROM sessions WHERE name = ${name}
+    `;
+        return row ?? null;
+    }
+    async getSessionByAgentCode(agentCode) {
+        const [row] = await this.sql `
+      SELECT id, name, session_id, agent_code, agent, status, created_at
+      FROM sessions WHERE agent_code = ${agentCode}
+    `;
+        return row ?? null;
+    }
+    async getSessionIdByName(name) {
+        const [row] = await this.sql `
+      SELECT id FROM sessions WHERE name = ${name}
+    `;
+        return row?.id ?? null;
+    }
+    async createSession(name, sessionId, agent) {
+        const [row] = await this.sql `
+      INSERT INTO sessions (name, session_id, agent)
+      VALUES (${name}, ${sessionId}, ${agent})
+      RETURNING id, name, session_id, agent_code, agent, status, created_at
+    `;
+        return row;
+    }
+    async deleteSession(id) {
+        await this.sql `DELETE FROM sessions WHERE id = ${id}`;
+    }
+    async regenerateAgentCode(name) {
+        const [row] = await this.sql `
+      UPDATE sessions
+      SET agent_code = gen_random_uuid()
+      WHERE name = ${name}
+      RETURNING id, name, session_id, agent_code, agent, status, created_at
+    `;
+        return row;
+    }
+    async updateSessionAgent(name, agent) {
+        const [row] = await this.sql `
+      UPDATE sessions
+      SET agent = ${agent}
+      WHERE name = ${name}
+      RETURNING id, name, session_id, agent_code, agent, status, created_at
+    `;
+        return row;
+    }
+    async updateSessionStatus(agentCode, status) {
+        await this.sql `
+      UPDATE sessions
+      SET status = ${status}
+      WHERE agent_code = ${agentCode}
+    `;
+    }
+    async updateSessionId(name, sessionId) {
+        await this.sql `
+      UPDATE sessions SET session_id = ${sessionId} WHERE name = ${name}
+    `;
+    }
+    async sessionExists(name) {
+        const [row] = await this.sql `
+      SELECT id FROM sessions WHERE name = ${name}
+    `;
+        return !!row;
+    }
+    // Config
+    async getAllConfig() {
+        return this.sql `SELECT key, value FROM config`;
+    }
+    async getConfig(key) {
+        const [row] = await this.sql `
+      SELECT value FROM config WHERE key = ${key}
+    `;
+        return row?.value ?? null;
+    }
+    async setConfig(key, value) {
+        await this.sql `
+      INSERT INTO config (key, value) VALUES (${key}, ${value})
+      ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value
+    `;
+    }
+    // Messages
+    async listMessagesForRecipient(name, unreadOnly) {
+        if (unreadOnly) {
+            return this.sql `
+        SELECT id, from_name, to_name, body, read, injected, created_at
+        FROM messages
+        WHERE to_name = ${name} AND read = FALSE
+        ORDER BY created_at DESC
+      `;
+        }
+        return this.sql `
+      SELECT id, from_name, to_name, body, read, injected, created_at
+      FROM messages
+      WHERE to_name = ${name}
+      ORDER BY created_at DESC
+    `;
+    }
+    async listMessagesFromSender(name) {
+        return this.sql `
+      SELECT id, from_name, to_name, body, read, injected, created_at
+      FROM messages
+      WHERE from_name = ${name}
+      ORDER BY created_at DESC
+    `;
+    }
+    async createMessageImpl(from, to, body) {
+        const [row] = await this.sql `
+      INSERT INTO messages (from_name, to_name, body)
+      VALUES (${from}, ${to}, ${body})
+      RETURNING id, from_name, to_name, body, read, injected, created_at
+    `;
+        return row;
+    }
+    async markMessageAsRead(id) {
+        const [row] = await this.sql `
+      UPDATE messages SET read = TRUE WHERE id = ${id}
+      RETURNING id, from_name, to_name, body, read, injected, created_at
+    `;
+        return row ?? null;
+    }
+    async markMessageAsInjected(id) {
+        await this.sql `UPDATE messages SET injected = TRUE WHERE id = ${id}`;
+    }
+    // Cron Jobs
+    async listCronJobs() {
+        return this.sql `
+      SELECT id, name, session_name, schedule, timezone, message, enabled, created_at, last_run
+      FROM cron_jobs
+      ORDER BY name
+    `;
+    }
+    async listCronJobsForSession(sessionName) {
+        return this.sql `
+      SELECT id, name, session_name, schedule, timezone, message, enabled, created_at, last_run
+      FROM cron_jobs
+      WHERE session_name = ${sessionName}
+      ORDER BY name
+    `;
+    }
+    async getCronJobById(id) {
+        const [row] = await this.sql `
+      SELECT id, name, session_name, schedule, timezone, message, enabled, created_at, last_run
+      FROM cron_jobs WHERE id = ${id}
+    `;
+        return row ?? null;
+    }
+    async getCronJobByNameAndSession(name, sessionName) {
+        const [row] = await this.sql `
+      SELECT id, name, session_name, schedule, timezone, message, enabled, created_at, last_run
+      FROM cron_jobs WHERE name = ${name} AND session_name = ${sessionName}
+    `;
+        return row ?? null;
+    }
+    async createCronJob(name, sessionName, schedule, timezone, message) {
+        const [row] = await this.sql `
+      INSERT INTO cron_jobs (name, session_name, schedule, timezone, message)
+      VALUES (${name}, ${sessionName}, ${schedule}, ${timezone}, ${message})
+      RETURNING id, name, session_name, schedule, timezone, message, enabled, created_at, last_run
+    `;
+        return row;
+    }
+    async deleteCronJob(id) {
+        await this.sql `DELETE FROM cron_jobs WHERE id = ${id}`;
+    }
+    async enableCronJob(id) {
+        await this.sql `UPDATE cron_jobs SET enabled = TRUE WHERE id = ${id}`;
+    }
+    async disableCronJob(id) {
+        await this.sql `UPDATE cron_jobs SET enabled = FALSE WHERE id = ${id}`;
+    }
+    async updateCronJobLastRun(id, lastRun) {
+        await this.sql `UPDATE cron_jobs SET last_run = ${lastRun} WHERE id = ${id}`;
+    }
+    async cronJobExistsForSession(name, sessionName) {
+        const [row] = await this.sql `
+      SELECT id FROM cron_jobs WHERE name = ${name} AND session_name = ${sessionName}
+    `;
+        return !!row;
+    }
+    // Cron History
+    async listCronHistory(cronJobId, limit) {
+        return this.sql `
+      SELECT id, cron_job_id, executed_at, success, error_message
+      FROM cron_history
+      WHERE cron_job_id = ${cronJobId}
+      ORDER BY executed_at DESC
+      LIMIT ${limit}
+    `;
+    }
+    async createCronHistory(cronJobId, executedAt, success, errorMessage) {
+        if (success) {
+            await this.sql `
+        INSERT INTO cron_history (cron_job_id, executed_at, success)
+        VALUES (${cronJobId}, ${executedAt}, TRUE)
+      `;
+        }
+        else {
+            await this.sql `
+        INSERT INTO cron_history (cron_job_id, executed_at, success, error_message)
+        VALUES (${cronJobId}, ${executedAt}, FALSE, ${errorMessage ?? null})
+      `;
+        }
+    }
+    async runMigrations() {
+        const MIGRATIONS = [
+            {
+                version: 1,
+                name: "create_sessions",
+                sql: `
+          CREATE TABLE IF NOT EXISTS sessions (
+            id         SERIAL PRIMARY KEY,
+            name       VARCHAR(255) UNIQUE NOT NULL,
+            session_id VARCHAR(255) UNIQUE NOT NULL,
+            created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+          );
+          CREATE INDEX IF NOT EXISTS idx_sessions_name ON sessions(name);
+        `,
+            },
+            {
+                version: 2,
+                name: "add_agent_code",
+                sql: `
+          ALTER TABLE sessions ADD COLUMN IF NOT EXISTS agent_code UUID NOT NULL DEFAULT gen_random_uuid();
+          CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_agent_code ON sessions(agent_code);
+        `,
+            },
+            {
+                version: 3,
+                name: "create_config_table",
+                sql: `
+          CREATE TABLE IF NOT EXISTS config (
+            key   VARCHAR(255) PRIMARY KEY,
+            value TEXT NOT NULL
+          );
+          INSERT INTO config (key, value) VALUES ('human_name', 'Human') ON CONFLICT DO NOTHING;
+          INSERT INTO config (key, value) VALUES ('human_description', '') ON CONFLICT DO NOTHING;
+        `,
+            },
+            {
+                version: 5,
+                name: "add_mode_to_sessions",
+                sql: `
+          ALTER TABLE sessions ADD COLUMN IF NOT EXISTS mode VARCHAR(255) NULL;
+        `,
+            },
+            {
+                version: 4,
+                name: "create_messages_table",
+                sql: `
+          CREATE TABLE IF NOT EXISTS messages (
+            id          SERIAL PRIMARY KEY,
+            from_name   VARCHAR(255) NOT NULL,
+            to_name     VARCHAR(255) NOT NULL,
+            body        TEXT NOT NULL,
+            read        BOOLEAN NOT NULL DEFAULT FALSE,
+            injected    BOOLEAN NOT NULL DEFAULT FALSE,
+            created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+          );
+          CREATE INDEX IF NOT EXISTS idx_messages_to_name ON messages(to_name);
+          CREATE INDEX IF NOT EXISTS idx_messages_from_name ON messages(from_name);
+          CREATE INDEX IF NOT EXISTS idx_messages_read ON messages(read);
+        `,
+            },
+            {
+                version: 6,
+                name: "create_cron_tables",
+                sql: `
+          CREATE TABLE IF NOT EXISTS cron_jobs (
+            id            SERIAL PRIMARY KEY,
+            name          VARCHAR(255) NOT NULL,
+            session_name  VARCHAR(255) NOT NULL REFERENCES sessions(name) ON DELETE CASCADE,
+            schedule      TEXT NOT NULL,
+            timezone      VARCHAR(100),
+            message       TEXT NOT NULL,
+            enabled       BOOLEAN NOT NULL DEFAULT TRUE,
+            created_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+            last_run      TIMESTAMPTZ
+          );
+          CREATE UNIQUE INDEX IF NOT EXISTS idx_cron_jobs_name_session ON cron_jobs(name, session_name);
+          CREATE INDEX IF NOT EXISTS idx_cron_jobs_session_name ON cron_jobs(session_name);
+          CREATE INDEX IF NOT EXISTS idx_cron_jobs_enabled ON cron_jobs(enabled);
+
+          CREATE TABLE IF NOT EXISTS cron_history (
+            id             SERIAL PRIMARY KEY,
+            cron_job_id    INTEGER NOT NULL REFERENCES cron_jobs(id) ON DELETE CASCADE,
+            executed_at    TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+            success        BOOLEAN NOT NULL DEFAULT TRUE,
+            error_message  TEXT
+          );
+          CREATE INDEX IF NOT EXISTS idx_cron_history_job_id ON cron_history(cron_job_id);
+        `,
+            },
+            {
+                version: 7,
+                name: "add_status_to_sessions",
+                sql: `
+          ALTER TABLE sessions ADD COLUMN IF NOT EXISTS status TEXT NULL;
+        `,
+            },
+            {
+                version: 8,
+                name: "rename_mode_to_agent",
+                sql: `
+          ALTER TABLE sessions RENAME COLUMN mode TO agent;
+        `,
+            },
+        ];
+        await this.sql `
+      CREATE TABLE IF NOT EXISTS _migrations (
+        version    INTEGER PRIMARY KEY,
+        name       VARCHAR(255) NOT NULL,
+        applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `;
+        const applied = await this.sql `
+      SELECT version FROM _migrations ORDER BY version
+    `;
+        const appliedVersions = new Set(applied.map((r) => r.version));
+        for (const migration of MIGRATIONS) {
+            if (appliedVersions.has(migration.version))
+                continue;
+            console.log(`  Applying migration ${migration.version}: ${migration.name}`);
+            await this.sql.begin(async (tx) => {
+                await tx.unsafe(migration.sql);
+                await tx.unsafe(`INSERT INTO _migrations (version, name) VALUES ($1, $2)`, [migration.version, migration.name]);
+            });
+        }
+    }
+}
+export function createPostgresqlStorage(databaseUrl) {
+    const sql = postgres(databaseUrl, {
+        max: 10,
+        idle_timeout: 30,
+        connect_timeout: 10,
+        onnotice: () => { },
+    });
+    return new AgentOfficePostgresqlStorage(sql);
+}