iosm-cli 0.2.8 → 0.2.9

package/dist/core/tools/db-run.js

@@ -0,0 +1,690 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { Type } from "@sinclair/typebox";
+import { resolveToCwd } from "./path-utils.js";
+import { commandExists, detectPackageManager, ensureCommandOrThrow, formatVerificationOutput, readPackageJson, resolvePackageManagerRunInvocation, runVerificationCommand, } from "./verification-runner.js";
+const dbRunSchema = Type.Object({
+    action: Type.Optional(Type.Union([
+        Type.Literal("query"),
+        Type.Literal("exec"),
+        Type.Literal("schema"),
+        Type.Literal("migrate"),
+        Type.Literal("explain"),
+    ], { description: "DB action: query | exec | schema | migrate | explain (default: query)." })),
+    adapter: Type.Optional(Type.Union([
+        Type.Literal("auto"),
+        Type.Literal("postgres"),
+        Type.Literal("mysql"),
+        Type.Literal("sqlite"),
+        Type.Literal("mongodb"),
+        Type.Literal("redis"),
+    ], { description: "Database adapter: auto | postgres | mysql | sqlite | mongodb | redis" })),
+    connection: Type.Optional(Type.String({
+        description: "Named dbTools connection profile. Defaults to dbTools.defaultConnection.",
+    })),
+    statement: Type.Optional(Type.String({
+        description: "Query/command statement for query/exec/explain (optional for schema with adapter defaults).",
+    })),
+    format: Type.Optional(Type.Union([Type.Literal("table"), Type.Literal("json"), Type.Literal("raw")], {
+        description: "Output format hint: table | json | raw (default: table).",
+    })),
+    allow_write: Type.Optional(Type.Boolean({
+        description: "Allow write actions (required for exec/migrate). Defaults to false.",
+    })),
+    migrate_runner: Type.Optional(Type.Union([Type.Literal("auto"), Type.Literal("script")], {
+        description: "Migrate mode: auto | script (default: auto).",
+    })),
+    script: Type.Optional(Type.String({
+        description: "Package script for migrate_runner=script/auto (default: db:migrate).",
+    })),
+    args: Type.Optional(Type.Array(Type.String(), {
+        description: "Additional arguments forwarded to adapter CLI or migration script.",
+    })),
+    path: Type.Optional(Type.String({ description: "Working directory for db operations (default: current directory)." })),
+    timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (default: 300)." })),
+});
+export const DEFAULT_DB_RUN_TIMEOUT_SECONDS = 300;
+const defaultOps = {
+    runCommand: runVerificationCommand,
+    commandExists,
+};
+function normalizeTimeoutSeconds(raw) {
+    if (raw === undefined)
+        return DEFAULT_DB_RUN_TIMEOUT_SECONDS;
+    const value = Math.floor(raw);
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error("timeout must be a positive number.");
+    }
+    return value;
+}
+function normalizeStringArray(raw) {
+    return (raw ?? []).map((item) => String(item));
+}
+function normalizeAction(raw) {
+    return raw ?? "query";
+}
+function normalizeFormat(raw) {
+    return raw ?? "table";
+}
+function normalizeScriptName(raw) {
+    if (raw === undefined)
+        return undefined;
+    const script = raw.trim();
+    if (!script) {
+        throw new Error("script must not be empty.");
+    }
+    return script;
+}
+function normalizeConnectionName(raw) {
+    if (raw === undefined)
+        return undefined;
+    const value = raw.trim();
+    if (!value) {
+        throw new Error("connection must not be empty.");
+    }
+    return value;
+}
+function normalizeRuntimeConfig(raw) {
+    const connections = {};
+    for (const [name, connection] of Object.entries(raw?.connections ?? {})) {
+        const normalizedName = name.trim();
+        if (!normalizedName)
+            continue;
+        const adapter = connection?.adapter;
+        if (adapter !== "postgres" &&
+            adapter !== "mysql" &&
+            adapter !== "sqlite" &&
+            adapter !== "mongodb" &&
+            adapter !== "redis") {
+            continue;
+        }
+        connections[normalizedName] = {
+            name: normalizedName,
+            adapter,
+            dsnEnv: connection?.dsnEnv?.trim() || undefined,
+            sqlitePath: connection?.sqlitePath?.trim() || undefined,
+            clientArgs: normalizeStringArray(connection?.clientArgs),
+            migrate: {
+                script: connection?.migrate?.script?.trim() || undefined,
+                cwd: connection?.migrate?.cwd?.trim() || undefined,
+                args: normalizeStringArray(connection?.migrate?.args),
+            },
+        };
+    }
+    const defaultConnection = raw?.defaultConnection?.trim() || undefined;
+    return { defaultConnection, connections };
+}
+function isLikelyPathLikeConnection(value) {
+    const normalized = value.trim();
+    if (!normalized)
+        return false;
+    if (normalized.includes("/") || normalized.includes("\\") || normalized.startsWith(".") || normalized.startsWith("~")) {
+        return true;
+    }
+    return /\.(sqlite|sqlite3|db)$/i.test(normalized) || normalized.includes(":memory:");
+}
+function buildDbToolsSetupHint(sqlitePathHint) {
+    return [
+        'Configure a named profile in ".iosm/settings.json", for example:',
+        "{",
+        '  "dbTools": {',
+        '    "defaultConnection": "main",',
+        '    "connections": {',
+        `      "main": { "adapter": "sqlite", "sqlitePath": "${sqlitePathHint}" }`,
+        "    }",
+        "  }",
+        "}",
+        'Then call db_run with connection="main" (or omit connection when defaultConnection is set).',
+        "If you edited settings.json outside the current session, run /reload or restart the session before retrying.",
+    ].join("\n");
+}
+function resolveConnectionProfile(input) {
+    const effectiveConnection = normalizeConnectionName(input.connection) ?? input.runtimeConfig.defaultConnection;
+    if (!effectiveConnection) {
+        throw new Error([
+            "No db connection selected. Configure dbTools.defaultConnection or pass connection explicitly.",
+            buildDbToolsSetupHint("./test_database.sqlite"),
+        ].join("\n\n"));
+    }
+    const profile = input.runtimeConfig.connections[effectiveConnection];
+    if (!profile) {
+        if (isLikelyPathLikeConnection(effectiveConnection)) {
+            throw new Error([
+                `Connection profile "${effectiveConnection}" is not defined in settings dbTools.connections.`,
+                `The "connection" field expects a profile name, not a file path.`,
+                buildDbToolsSetupHint(effectiveConnection),
+            ].join("\n\n"));
+        }
+        throw new Error([
+            `Connection profile "${effectiveConnection}" is not defined in settings dbTools.connections.`,
+            buildDbToolsSetupHint("./test_database.sqlite"),
+        ].join("\n\n"));
+    }
+    if (input.adapter !== "auto" && input.adapter !== profile.adapter) {
+        throw new Error(`Adapter "${input.adapter}" does not match connection "${effectiveConnection}" adapter "${profile.adapter}".`);
+    }
+    if (profile.adapter === "sqlite") {
+        if (!profile.sqlitePath) {
+            throw new Error(`Connection "${effectiveConnection}" requires sqlitePath for sqlite adapter.`);
+        }
+    }
+    else if (!profile.dsnEnv) {
+        throw new Error(`Connection "${effectiveConnection}" requires dsnEnv for ${profile.adapter} adapter.`);
+    }
+    return profile;
+}
+function ensureWriteAllowed(action, allowWrite) {
+    if ((action === "exec" || action === "migrate") && !allowWrite) {
+        throw new Error(`Action "${action}" requires allow_write=true.`);
+    }
+}
+function normalizeStatement(statement) {
+    if (statement === undefined)
+        return undefined;
+    const normalized = statement.trim();
+    if (!normalized) {
+        throw new Error("statement must not be empty when provided.");
+    }
+    return normalized;
+}
+function isLikelyMutatingSql(statement) {
+    return /\b(insert|update|delete|drop|alter|create|truncate|replace|grant|revoke|merge|upsert)\b/i.test(statement);
+}
+function isLikelyMutatingMongo(statement) {
+    return /\b(insert|update|delete|drop|create|rename|set|remove|replace|findOneAndUpdate|findAndModify)\b/i.test(statement);
+}
+function isLikelyMutatingRedis(statement) {
+    const firstToken = statement.trim().split(/\s+/)[0]?.toUpperCase() ?? "";
+    const mutatingCommands = new Set([
+        "SET",
+        "DEL",
+        "HSET",
+        "HDEL",
+        "LPUSH",
+        "RPUSH",
+        "SADD",
+        "SREM",
+        "ZADD",
+        "ZREM",
+        "INCR",
+        "DECR",
+        "FLUSHDB",
+        "FLUSHALL",
+        "EXPIRE",
+        "PERSIST",
+    ]);
+    return mutatingCommands.has(firstToken);
+}
+function enforceReadFirstSafety(adapter, action, statement) {
+    if (action !== "query" || !statement)
+        return;
+    if (adapter === "postgres" || adapter === "mysql" || adapter === "sqlite") {
+        if (isLikelyMutatingSql(statement)) {
+            throw new Error('Mutating statement detected for action=query. Use action="exec" with allow_write=true.');
+        }
+        return;
+    }
+    if (adapter === "mongodb" && isLikelyMutatingMongo(statement)) {
+        throw new Error('Mutating statement detected for action=query. Use action="exec" with allow_write=true.');
+    }
+    if (adapter === "redis" && isLikelyMutatingRedis(statement)) {
+        throw new Error('Mutating statement detected for action=query. Use action="exec" with allow_write=true.');
+    }
+}
+function parseDsn(dsn, adapter) {
+    try {
+        const parsed = new URL(dsn);
+        const protocol = parsed.protocol.replace(":", "");
+        if (adapter === "postgres" && protocol !== "postgres" && protocol !== "postgresql") {
+            throw new Error("Expected postgres:// or postgresql:// DSN.");
+        }
+        if (adapter === "mysql" && protocol !== "mysql" && protocol !== "mariadb") {
+            throw new Error("Expected mysql:// or mariadb:// DSN.");
+        }
+        if (adapter === "mongodb" && protocol !== "mongodb" && protocol !== "mongodb+srv") {
+            throw new Error("Expected mongodb:// or mongodb+srv:// DSN.");
+        }
+        if (adapter === "redis" && protocol !== "redis" && protocol !== "rediss") {
+            throw new Error("Expected redis:// or rediss:// DSN.");
+        }
+        return parsed;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid DSN for ${adapter}: ${message}`);
+    }
+}
+function resolveSqlStatement(adapter, action, statement) {
+    const schemaDefaults = {
+        postgres: "SELECT table_schema, table_name FROM information_schema.tables WHERE table_schema NOT IN ('pg_catalog','information_schema') ORDER BY 1,2;",
+        mysql: "SELECT table_schema, table_name FROM information_schema.tables WHERE table_schema = DATABASE() ORDER BY 1,2;",
+        sqlite: "SELECT name, type FROM sqlite_master WHERE type IN ('table','view') ORDER BY name;",
+    };
+    if (action === "schema") {
+        return statement ?? schemaDefaults[adapter];
+    }
+    if (!statement) {
+        throw new Error(`Action "${action}" requires statement.`);
+    }
+    if (action === "explain") {
+        return /^\s*explain\b/i.test(statement) ? statement : `EXPLAIN ${statement}`;
+    }
+    return statement;
+}
+function resolveMongoStatement(action, statement) {
+    if (action === "schema") {
+        return statement ?? "db.getCollectionInfos()";
+    }
+    if (!statement) {
+        throw new Error(`Action "${action}" requires statement.`);
+    }
+    if (action === "explain") {
+        return statement;
+    }
+    return statement;
+}
+function resolveRedisStatement(action, statement) {
+    if (action === "schema") {
+        return statement ?? "INFO keyspace";
+    }
+    if (!statement) {
+        throw new Error(`Action "${action}" requires statement.`);
+    }
+    return statement;
+}
+function ensureAdapterCommandAvailable(ops, command, hint) {
+    if (ops.commandExists(command)) {
+        return;
+    }
+    throw new Error(hint);
+}
+function resolveSqlCommand(input) {
+    const statement = resolveSqlStatement(input.adapter, input.action, input.statement);
+    if (input.adapter === "postgres") {
+        ensureAdapterCommandAvailable(input.ops, "psql", 'Command "psql" is required for postgres adapter.');
+        const dsnValue = process.env[input.connection.dsnEnv];
+        if (!dsnValue) {
+            throw new Error(`Environment variable "${input.connection.dsnEnv}" is required for connection "${input.connection.name}".`);
+        }
+        const parsed = parseDsn(dsnValue, "postgres");
+        const env = {};
+        if (parsed.hostname)
+            env.PGHOST = parsed.hostname;
+        if (parsed.port)
+            env.PGPORT = parsed.port;
+        if (parsed.username)
+            env.PGUSER = decodeURIComponent(parsed.username);
+        if (parsed.password)
+            env.PGPASSWORD = decodeURIComponent(parsed.password);
+        const dbName = parsed.pathname.replace(/^\//, "");
+        if (dbName)
+            env.PGDATABASE = decodeURIComponent(dbName);
+        const sslMode = parsed.searchParams.get("sslmode");
+        if (sslMode)
+            env.PGSSLMODE = sslMode;
+        const args = [...input.connection.clientArgs];
+        if (input.format === "raw" || input.format === "json") {
+            args.push("-A", "-t");
+        }
+        args.push("-c", statement);
+        return {
+            command: "psql",
+            args,
+            env,
+            secretValues: [dsnValue, decodeURIComponent(parsed.password || "")].filter(Boolean),
+        };
+    }
+    if (input.adapter === "mysql") {
+        ensureAdapterCommandAvailable(input.ops, "mysql", 'Command "mysql" is required for mysql adapter.');
+        const dsnValue = process.env[input.connection.dsnEnv];
+        if (!dsnValue) {
+            throw new Error(`Environment variable "${input.connection.dsnEnv}" is required for connection "${input.connection.name}".`);
+        }
+        const parsed = parseDsn(dsnValue, "mysql");
+        const args = [...input.connection.clientArgs];
+        if (parsed.hostname)
+            args.push("--host", parsed.hostname);
+        if (parsed.port)
+            args.push("--port", parsed.port);
+        if (parsed.username)
+            args.push("--user", decodeURIComponent(parsed.username));
+        if (input.format === "raw" || input.format === "json") {
+            args.push("--batch", "--raw", "--skip-column-names");
+        }
+        const dbName = parsed.pathname.replace(/^\//, "");
+        if (dbName)
+            args.push(decodeURIComponent(dbName));
+        args.push("-e", statement);
+        const env = {};
+        if (parsed.password) {
+            env.MYSQL_PWD = decodeURIComponent(parsed.password);
+        }
+        return {
+            command: "mysql",
+            args,
+            env,
+            secretValues: [dsnValue, decodeURIComponent(parsed.password || "")].filter(Boolean),
+        };
+    }
+    ensureAdapterCommandAvailable(input.ops, "sqlite3", 'Command "sqlite3" is required for sqlite adapter.');
+    const sqlitePath = resolveToCwd(input.connection.sqlitePath, input.executionCwd);
+    const sqliteDir = join(sqlitePath, "..");
+    if (!existsSync(sqliteDir)) {
+        throw new Error(`sqlitePath parent directory does not exist: ${sqliteDir}`);
+    }
+    const args = [...input.connection.clientArgs];
+    if (input.format === "raw") {
+        args.push("-noheader");
+    }
+    if (input.format === "json") {
+        args.push("-json");
+    }
+    args.push(sqlitePath, statement);
+    return {
+        command: "sqlite3",
+        args,
+        secretValues: [],
+    };
+}
+function resolveMongoCommand(input) {
+    ensureAdapterCommandAvailable(input.ops, "mongosh", 'Command "mongosh" is required for mongodb adapter.');
+    const dsnValue = process.env[input.connection.dsnEnv];
+    if (!dsnValue) {
+        throw new Error(`Environment variable "${input.connection.dsnEnv}" is required for connection "${input.connection.name}".`);
+    }
+    parseDsn(dsnValue, "mongodb");
+    const statement = resolveMongoStatement(input.action, input.statement);
+    const args = [...input.connection.clientArgs, dsnValue, "--quiet", "--eval", statement];
+    return {
+        command: "mongosh",
+        args,
+        secretValues: [dsnValue],
+    };
+}
+function resolveRedisCommand(input) {
+    ensureAdapterCommandAvailable(input.ops, "redis-cli", 'Command "redis-cli" is required for redis adapter.');
+    const dsnValue = process.env[input.connection.dsnEnv];
+    if (!dsnValue) {
+        throw new Error(`Environment variable "${input.connection.dsnEnv}" is required for connection "${input.connection.name}".`);
+    }
+    const parsed = parseDsn(dsnValue, "redis");
+    const statement = resolveRedisStatement(input.action, input.statement);
+    const args = [...input.connection.clientArgs];
+    if (parsed.protocol === "rediss:") {
+        args.push("--tls");
+    }
+    if (parsed.hostname)
+        args.push("-h", parsed.hostname);
+    if (parsed.port)
+        args.push("-p", parsed.port);
+    if (parsed.username)
+        args.push("--user", decodeURIComponent(parsed.username));
+    const dbName = parsed.pathname.replace(/^\//, "");
+    if (dbName)
+        args.push("-n", decodeURIComponent(dbName));
+    if (input.format === "raw" || input.format === "json") {
+        args.push("--raw");
+    }
+    const env = {};
+    if (parsed.password) {
+        env.REDISCLI_AUTH = decodeURIComponent(parsed.password);
+    }
+    return {
+        command: "redis-cli",
+        args,
+        stdin: `${statement}\n`,
+        env,
+        secretValues: [dsnValue, decodeURIComponent(parsed.password || "")].filter(Boolean),
+    };
+}
+function resolveMigrateCommand(input) {
+    if (input.action !== "migrate") {
+        throw new Error("Internal error: resolveMigrateCommand called for non-migrate action.");
+    }
+    ensureWriteAllowed("migrate", input.allowWrite);
+    const migrateCwd = resolveToCwd(input.connection.migrate.cwd ?? ".", input.executionCwd);
+    const packageJson = readPackageJson(migrateCwd);
+    if (!packageJson) {
+        throw new Error("package.json is required for migrate action.");
+    }
+    const scriptCandidates = [];
+    if (input.script)
+        scriptCandidates.push(input.script);
+    if (input.connection.migrate.script)
+        scriptCandidates.push(input.connection.migrate.script);
+    if (input.migrateRunner === "auto") {
+        scriptCandidates.push("db:migrate", "migrate");
+    }
+    if (input.migrateRunner === "script" && scriptCandidates.length === 0) {
+        scriptCandidates.push("db:migrate");
+    }
+    const selectedScript = scriptCandidates.find((candidate) => packageJson.scripts[candidate]);
+    if (!selectedScript) {
+        throw new Error(`No migration script found. Checked: ${scriptCandidates.join(", ")} in ${packageJson.path}.`);
+    }
+    const packageManager = detectPackageManager(migrateCwd);
+    ensureCommandOrThrow(packageManager, `Command "${packageManager}" is required for migrate action.`);
+    const invocation = resolvePackageManagerRunInvocation(packageManager, selectedScript, [
+        ...input.connection.migrate.args,
+        ...input.args,
+    ]);
+    return {
+        cwd: migrateCwd,
+        command: {
+            command: invocation.command,
+            args: invocation.args,
+            secretValues: [],
+        },
+    };
+}
+function mapDbStatus(exitCode) {
+    if (exitCode === 0)
+        return "passed";
+    if (exitCode === 1)
+        return "failed";
+    return "error";
+}
+function redactArgs(args, secrets) {
+    const normalizedSecrets = secrets
+        .map((secret) => secret.trim())
+        .filter((secret) => secret.length > 0)
+        .sort((a, b) => b.length - a.length);
+    return args.map((arg) => {
+        let sanitized = arg;
+        for (const secret of normalizedSecrets) {
+            if (sanitized.includes(secret)) {
+                sanitized = sanitized.replaceAll(secret, "[REDACTED]");
+            }
+        }
+        if (/\b(password|passwd|pwd|token|secret)=/i.test(sanitized)) {
+            return sanitized.replace(/=(.+)$/i, "=[REDACTED]");
+        }
+        return sanitized;
+    });
+}
+function parseCounts(output) {
+    const selectMatch = output.match(/\bSELECT\s+(\d+)\b/i);
+    const updateMatch = output.match(/\b(?:UPDATE|DELETE)\s+(\d+)\b/i);
+    const insertMatch = output.match(/\bINSERT\s+\d+\s+(\d+)\b/i);
+    const rowsInSetMatch = output.match(/\b(\d+)\s+rows?\s+in set\b/i);
+    const mysqlChangedMatch = output.match(/\bRows matched:\s*(\d+)\s+Changed:\s*(\d+)\b/i);
+    const rowCount = selectMatch?.[1]
+        ? Number.parseInt(selectMatch[1], 10)
+        : rowsInSetMatch?.[1]
+            ? Number.parseInt(rowsInSetMatch[1], 10)
+            : undefined;
+    const affectedCount = updateMatch?.[1]
+        ? Number.parseInt(updateMatch[1], 10)
+        : insertMatch?.[1]
+            ? Number.parseInt(insertMatch[1], 10)
+            : mysqlChangedMatch?.[2]
+                ? Number.parseInt(mysqlChangedMatch[2], 10)
+                : undefined;
+    return {
+        rowCount: Number.isFinite(rowCount) ? rowCount : undefined,
+        affectedCount: Number.isFinite(affectedCount) ? affectedCount : undefined,
+    };
+}
+function renderSummary(details, output) {
+    const argsText = details.resolvedArgs.length > 0 ? ` ${details.resolvedArgs.join(" ")}` : "";
+    const lines = [
+        `db_run status: ${details.status}`,
+        `action: ${details.action}`,
+        `adapter: ${details.adapter}`,
+        `connection: ${details.connection}`,
+        `command: ${details.resolvedCommand}${argsText}`,
+        `cwd: ${details.cwd}`,
+        `write_requested: ${details.writeRequested ? "true" : "false"}`,
+        `write_allowed: ${details.writeAllowed ? "true" : "false"}`,
+        `exit_code: ${details.exitCode}`,
+        `duration_ms: ${details.durationMs}`,
+    ];
+    if (details.rowCount !== undefined) {
+        lines.push(`row_count: ${details.rowCount}`);
+    }
+    if (details.affectedCount !== undefined) {
+        lines.push(`affected_count: ${details.affectedCount}`);
+    }
+    lines.push("", output);
+    return lines.join("\n");
+}
+export function createDbRunTool(cwd, options) {
+    const permissionGuard = options?.permissionGuard;
+    const ops = {
+        ...defaultOps,
+        ...(options?.operations ?? {}),
+    };
+    return {
+        name: "db_run",
+        label: "db_run",
+        description: "Structured database operations across postgres/mysql/sqlite/mongodb/redis using named settings profiles with read-first safety and normalized status reporting.",
+        parameters: dbRunSchema,
+        execute: async (_toolCallId, input, signal) => {
+            const action = normalizeAction(input.action);
+            const requestedAdapter = input.adapter ?? "auto";
+            const format = normalizeFormat(input.format);
+            const allowWrite = input.allow_write === true;
+            const timeoutSeconds = normalizeTimeoutSeconds(input.timeout);
+            const statement = normalizeStatement(input.statement);
+            const args = normalizeStringArray(input.args);
+            const executionCwd = resolveToCwd(input.path || ".", cwd);
+            const migrateRunner = input.migrate_runner ?? "auto";
+            const script = normalizeScriptName(input.script);
+            const runtimeConfig = normalizeRuntimeConfig(options?.resolveRuntimeConfig?.());
+            const connection = resolveConnectionProfile({
+                runtimeConfig,
+                connection: input.connection,
+                adapter: requestedAdapter,
+            });
+            const resolvedAdapter = requestedAdapter === "auto" ? connection.adapter : requestedAdapter;
+            const writeRequested = action === "exec" || action === "migrate";
+            ensureWriteAllowed(action, allowWrite);
+            enforceReadFirstSafety(resolvedAdapter, action, statement);
+            if (permissionGuard) {
+                const allowed = await permissionGuard({
+                    toolName: "db_run",
+                    cwd: executionCwd,
+                    input: {
+                        action,
+                        adapter: resolvedAdapter,
+                        connection: connection.name,
+                        format,
+                        allowWrite,
+                        args,
+                    },
+                    summary: `${action} on ${connection.name} (${resolvedAdapter})`,
+                });
+                if (!allowed) {
+                    throw new Error("Permission denied for db_run operation.");
+                }
+            }
+            let commandCwd = executionCwd;
+            let resolvedCommand;
+            if (action === "migrate") {
+                const migrated = resolveMigrateCommand({
+                    action,
+                    allowWrite,
+                    executionCwd,
+                    migrateRunner,
+                    connection,
+                    script,
+                    args,
+                });
+                resolvedCommand = migrated.command;
+                commandCwd = migrated.cwd;
+            }
+            else if (resolvedAdapter === "postgres" || resolvedAdapter === "mysql" || resolvedAdapter === "sqlite") {
+                resolvedCommand = resolveSqlCommand({
+                    ops,
+                    adapter: resolvedAdapter,
+                    action,
+                    statement,
+                    format,
+                    executionCwd,
+                    connection,
+                });
+                if (args.length > 0) {
+                    resolvedCommand.args = [...resolvedCommand.args, ...args];
+                }
+            }
+            else if (resolvedAdapter === "mongodb") {
+                resolvedCommand = resolveMongoCommand({
+                    ops,
+                    action,
+                    statement,
+                    connection,
+                });
+                if (args.length > 0) {
+                    resolvedCommand.args = [...resolvedCommand.args, ...args];
+                }
+            }
+            else {
+                resolvedCommand = resolveRedisCommand({
+                    ops,
+                    action,
+                    statement,
+                    format,
+                    connection,
+                });
+                if (args.length > 0) {
+                    resolvedCommand.args = [...resolvedCommand.args, ...args];
+                }
+            }
+            const result = await ops.runCommand({
+                command: resolvedCommand.command,
+                args: resolvedCommand.args,
+                cwd: commandCwd,
+                timeoutMs: timeoutSeconds * 1000,
+                signal,
+                env: resolvedCommand.env,
+                stdin: resolvedCommand.stdin,
+            });
+            const status = mapDbStatus(result.exitCode);
+            const formatted = formatVerificationOutput(result.stdout, result.stderr, result.captureTruncated, "No database output");
+            const counts = parseCounts(`${result.stdout}\n${result.stderr}`);
+            const details = {
+                action,
+                adapter: resolvedAdapter,
+                connection: connection.name,
+                resolvedCommand: resolvedCommand.command,
+                resolvedArgs: redactArgs(resolvedCommand.args, resolvedCommand.secretValues),
+                cwd: commandCwd,
+                exitCode: result.exitCode,
+                status,
+                durationMs: result.durationMs,
+                rowCount: counts.rowCount,
+                affectedCount: counts.affectedCount,
+                writeRequested,
+                writeAllowed: allowWrite,
+                captureTruncated: result.captureTruncated || undefined,
+                truncation: formatted.truncation,
+            };
+            return {
+                content: [{ type: "text", text: renderSummary(details, formatted.text) }],
+                details,
+            };
+        },
+    };
+}
+export const dbRunTool = createDbRunTool(process.cwd());
+//# sourceMappingURL=db-run.js.map