doer-agent 0.5.9 → 0.6.0

package/dist/agent-settings-rpc.js

@@ -1,25 +1,15 @@
 import { readFile } from "node:fs/promises";
-import { createConnection as createMysqlConnection } from "mysql2/promise";
 import { StringCodec } from "nats";
-import { Client as PostgresClient } from "pg";
-import { normalizeAgentDatabaseConnection, normalizeAgentSettingsConfig, normalizeAgentSettingsPatch, readAgentSettingsConfig, resolveAgentDatabaseConnectionUrl, resolveAgentSettingsFilePath, toAgentSettingsPublic, writeAgentModelInstructions, writeAgentSettingsConfig, } from "./agent-settings.js";
+import { normalizeAgentSettingsConfig, normalizeAgentSettingsPatch, readAgentSettingsConfig, resolveAgentSettingsFilePath, toAgentSettingsPublic, writeAgentModelInstructions, writeAgentSettingsConfig, } from "./agent-settings.js";
 const settingsRpcCodec = StringCodec();
 function normalizeSettingsRpcRequest(args) {
     const requestId = typeof args.request.requestId === "string" ? args.request.requestId.trim() : "";
     const responseSubject = typeof args.request.responseSubject === "string" ? args.request.responseSubject.trim() : "";
     const requestAgentId = typeof args.request.agentId === "string" ? args.request.agentId.trim() : "";
-    const action = args.request.action === "update"
-        ? "update"
-        : args.request.action === "test_database_connection"
-            ? "test_database_connection"
-            : "get";
+    const action = args.request.action === "update" ? "update" : "get";
     if (!requestId || !responseSubject || !requestAgentId || requestAgentId !== args.agentId) {
         throw new Error("invalid settings rpc request");
     }
-    const connection = args.request.connection === undefined ? null : normalizeAgentDatabaseConnection(args.request.connection);
-    if (action === "test_database_connection" && !connection) {
-        throw new Error("invalid database connection test payload");
-    }
     return {
         requestId,
         responseSubject,
@@ -28,89 +18,20 @@ function normalizeSettingsRpcRequest(args) {
         defaults: args.request.defaults && typeof args.request.defaults === "object" && !Array.isArray(args.request.defaults)
             ? normalizeAgentSettingsConfig(args.request.defaults)
             : null,
-        connection,
     };
 }
 function publishSettingsRpcResponse(args) {
     args.nc.publish(args.responseSubject, settingsRpcCodec.encode(JSON.stringify(args.payload)));
 }
-async function testDatabaseConnection(connection) {
-    const connectionUrl = resolveAgentDatabaseConnectionUrl(connection);
-    if (!connectionUrl) {
-        if (connection.connection.mode === "env") {
-            throw new Error(`Database URL env is missing: ${connection.connection.urlEnv}`);
-        }
-        throw new Error(`Database URL is missing for connection: ${connection.id}`);
-    }
-    const startedAt = Date.now();
-    if (connection.provider === "mysql") {
-        const client = await createMysqlConnection({
-            uri: connectionUrl,
-            connectTimeout: 5_000,
-        });
-        try {
-            const [rows] = await client.query("SELECT DATABASE() AS database_name, VERSION() AS version");
-            const firstRow = Array.isArray(rows)
-                ? rows[0]
-                : undefined;
-            const latencyMs = Date.now() - startedAt;
-            const database = firstRow?.database_name ?? null;
-            const serverVersion = firstRow?.version ?? null;
-            return {
-                ok: true,
-                provider: connection.provider,
-                message: `Connected to MySQL${database ? ` (${database})` : ""} in ${latencyMs}ms`,
-                latencyMs,
-                database,
-                serverVersion,
-            };
-        }
-        finally {
-            await client.end().catch(() => undefined);
-        }
-    }
-    const client = new PostgresClient({
-        connectionString: connectionUrl,
-        connectionTimeoutMillis: 5_000,
-    });
-    await client.connect();
-    try {
-        const result = await client.query("SELECT current_database() AS database_name, version() AS version");
-        const firstRow = result.rows[0] ?? { database_name: null, version: null };
-        const latencyMs = Date.now() - startedAt;
-        return {
-            ok: true,
-            provider: connection.provider,
-            message: `Connected to PostgreSQL${firstRow.database_name ? ` (${firstRow.database_name})` : ""} in ${latencyMs}ms`,
-            latencyMs,
-            database: firstRow.database_name,
-            serverVersion: firstRow.version,
-        };
-    }
-    finally {
-        await client.end().catch(() => undefined);
-    }
-}
 export async function handleSettingsRpcMessage(args) {
     let requestId = "unknown";
     let responseSubject = "";
+    let didUpdateSettings = false;
     try {
         const payload = JSON.parse(settingsRpcCodec.decode(args.msg.data));
         const request = normalizeSettingsRpcRequest({ request: payload, agentId: args.agentId });
         requestId = request.requestId;
         responseSubject = request.responseSubject;
-        if (request.action === "test_database_connection") {
-            publishSettingsRpcResponse({
-                nc: args.nc,
-                responseSubject,
-                payload: {
-                    requestId,
-                    ok: true,
-                    testResult: await testDatabaseConnection(request.connection),
-                },
-            });
-            return;
-        }
         const existing = await readAgentSettingsConfig({ workspaceRoot: args.workspaceRoot, defaults: request.defaults });
         const next = request.action === "update" ? normalizeAgentSettingsConfig(request.patch, existing) : existing;
         if (request.action === "update") {
@@ -123,6 +44,7 @@ export async function handleSettingsRpcMessage(args) {
             if (customInstructions !== undefined) {
                 await writeAgentModelInstructions({ workspaceRoot: args.workspaceRoot, value: customInstructions });
             }
+            didUpdateSettings = true;
         }
         else if (request.defaults) {
             const filePath = resolveAgentSettingsFilePath(args.workspaceRoot);
@@ -140,6 +62,12 @@ export async function handleSettingsRpcMessage(args) {
                 settings: await toAgentSettingsPublic({ workspaceRoot: args.workspaceRoot, config: next }),
             },
         });
+        if (didUpdateSettings) {
+            await Promise.resolve(args.onSettingsUpdated?.()).catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                args.onError(`settings update hook failed requestId=${requestId} error=${message}`);
+            });
+        }
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);

package/dist/agent-settings.js

@@ -39,10 +39,6 @@ export function createDefaultAgentSettingsConfig() {
         env: {
             variables: [],
         },
-        databases: {
-            defaultConnectionId: null,
-            connections: [],
-        },
     };
 }
 function normalizeNullableString(value) {
@@ -58,16 +54,6 @@ function normalizeNullableString(value) {
 function normalizeCodexPersonality(value, fallback) {
     return value === "friendly" || value === "pragmatic" ? value : fallback;
 }
-function normalizeDatabaseConnectionId(value) {
-    if (typeof value !== "string") {
-        return null;
-    }
-    const trimmed = value.trim().toLowerCase();
-    if (!trimmed || !/^[a-z0-9][a-z0-9._-]{0,63}$/.test(trimmed)) {
-        return null;
-    }
-    return trimmed;
-}
 function normalizeEnvVarName(value) {
     if (typeof value !== "string") {
         return null;
@@ -78,71 +64,6 @@ function normalizeEnvVarName(value) {
     }
     return trimmed;
 }
-function normalizeAgentDatabaseProvider(value) {
-    return value === "mysql" ? "mysql" : "postgres";
-}
-function normalizeAgentDatabaseConnectionSecret(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return null;
-    }
-    const raw = value;
-    const mode = raw.mode === "env" ? "env" : raw.mode === "url" ? "url" : null;
-    if (mode === "env") {
-        const urlEnv = normalizeEnvVarName(raw.urlEnv);
-        return urlEnv ? { mode, urlEnv } : null;
-    }
-    if (mode === "url") {
-        const url = normalizeNullableString(raw.url);
-        return url ? { mode, url } : null;
-    }
-    return null;
-}
-export function normalizeAgentDatabaseConnection(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return null;
-    }
-    const raw = value;
-    const id = normalizeDatabaseConnectionId(raw.id);
-    const connection = normalizeAgentDatabaseConnectionSecret(raw.connection);
-    if (!id || !connection) {
-        return null;
-    }
-    return {
-        id,
-        description: raw.description === null ? null : normalizeNullableString(raw.description),
-        provider: normalizeAgentDatabaseProvider(raw.provider),
-        enabled: typeof raw.enabled === "boolean" ? raw.enabled : true,
-        readOnly: typeof raw.readOnly === "boolean" ? raw.readOnly : true,
-        connection,
-    };
-}
-function normalizeAgentDatabaseSettings(value, fallback) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return fallback;
-    }
-    const raw = value;
-    const connectionsRaw = Array.isArray(raw.connections) ? raw.connections : [];
-    const connections = [];
-    const seenIds = new Set();
-    for (const item of connectionsRaw) {
-        const normalized = normalizeAgentDatabaseConnection(item);
-        if (!normalized || seenIds.has(normalized.id)) {
-            continue;
-        }
-        seenIds.add(normalized.id);
-        connections.push(normalized);
-    }
-    const requestedDefault = raw.defaultConnectionId === null ? null : normalizeDatabaseConnectionId(raw.defaultConnectionId);
-    const defaultConnectionId = requestedDefault && connections.some((connection) => connection.id === requestedDefault)
-        ? requestedDefault
-        : connections.some((connection) => connection.id === fallback.defaultConnectionId)
-            ? fallback.defaultConnectionId
-            : connections[0]?.id ?? null;
-    return {
-        defaultConnectionId,
-        connections,
-    };
-}
 function normalizeAgentEnvironmentVariable(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return null;
@@ -175,20 +96,6 @@ function normalizeAgentEnvironmentSettings(value, fallback) {
     }
     return { variables };
 }
-export function getAgentDatabaseConnectionById(config, connectionId) {
-    const normalizedId = normalizeDatabaseConnectionId(connectionId);
-    if (!normalizedId) {
-        return null;
-    }
-    return config.databases.connections.find((connection) => connection.id === normalizedId) ?? null;
-}
-export function resolveAgentDatabaseConnectionUrl(connection) {
-    if (connection.connection.mode === "url") {
-        return connection.connection.url.trim() || null;
-    }
-    const envValue = process.env[connection.connection.urlEnv]?.trim();
-    return envValue || null;
-}
 export function normalizeAgentSettingsConfig(value, fallback) {
     const base = fallback ?? createDefaultAgentSettingsConfig();
     const raw = value && typeof value === "object" && !Array.isArray(value) ? value : {};
@@ -197,14 +104,13 @@ export function normalizeAgentSettingsConfig(value, fallback) {
     const realtime = raw.realtime && typeof raw.realtime === "object" ? raw.realtime : {};
     const git = raw.git && typeof raw.git === "object" ? raw.git : {};
     const env = raw.env && typeof raw.env === "object" ? raw.env : null;
-    const databases = raw.databases && typeof raw.databases === "object" ? raw.databases : null;
     return {
         general: {
             personality: normalizeCodexPersonality(general.personality, base.general.personality),
         },
         codex: {
             model: typeof codex.model === "string" && codex.model.trim() ? codex.model.trim() : base.codex.model,
-            authMode: codex.authMode === "oauth" ? "oauth" : codex.authMode === "api_key" ? "api_key" : base.codex.authMode,
+            authMode: codex.authMode === "chatgpt" ? "chatgpt" : codex.authMode === "api_key" ? "api_key" : base.codex.authMode,
             computerUseEnabled: typeof codex.computerUseEnabled === "boolean" ? codex.computerUseEnabled : base.codex.computerUseEnabled,
             browserUseEnabled: typeof codex.browserUseEnabled === "boolean" ? codex.browserUseEnabled : base.codex.browserUseEnabled,
         },
@@ -225,7 +131,6 @@ export function normalizeAgentSettingsConfig(value, fallback) {
             oauthScope: git.oauthScope === null ? null : normalizeNullableString(git.oauthScope) ?? base.git.oauthScope,
         },
         env: normalizeAgentEnvironmentSettings(env, base.env),
-        databases: normalizeAgentDatabaseSettings(databases, base.databases),
     };
 }
 export async function readAgentSettingsConfig(args) {
@@ -317,25 +222,6 @@ export async function toAgentSettingsPublic(args) {
                 value: variable.value,
             })),
         },
-        databases: {
-            defaultConnectionId: args.config.databases.defaultConnectionId,
-            connections: args.config.databases.connections.map((connection) => ({
-                id: connection.id,
-                description: connection.description,
-                provider: connection.provider,
-                enabled: connection.enabled,
-                readOnly: connection.readOnly,
-                connection: connection.connection.mode === "url"
-                    ? {
-                        mode: "url",
-                        url: connection.connection.url,
-                    }
-                    : {
-                        mode: "env",
-                        urlEnv: connection.connection.urlEnv,
-                    },
-            })),
-        },
     };
 }
 export function normalizeAgentSettingsPatch(value) {