kennel 0.1.8 → 0.2.0

package/node_modules/@raggle-ai/local/dist/adapters/turso-project-source.js

@@ -0,0 +1,579 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCachedTursoProjectRows = readCachedTursoProjectRows;
+exports.writeCachedTursoProjectRows = writeCachedTursoProjectRows;
+exports.testTursoProjectSource = testTursoProjectSource;
+exports.readTursoProjectRows = readTursoProjectRows;
+exports.upsertTursoProjectRow = upsertTursoProjectRow;
+exports.replaceTursoProjectUrl = replaceTursoProjectUrl;
+exports.reconcileTursoProjectRemote = reconcileTursoProjectRemote;
+exports.deleteTursoProjectRow = deleteTursoProjectRow;
+exports.setTursoProjectDeviceFavorite = setTursoProjectDeviceFavorite;
+exports.setTursoProjectName = setTursoProjectName;
+exports.importTursoProjectRows = importTursoProjectRows;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const libsql_client_1 = require("./libsql-client");
+const import_1 = require("./import");
+const git_repository_1 = require("./git-repository");
+const native_bridge_1 = require("../native-bridge");
+const native_bridge_2 = require("../native-bridge");
+const native_bridge_3 = require("../native-bridge");
+function requireTursoDatabaseUrl(settings) {
+    const url = settings.tursoDatabaseUrl?.trim();
+    if (!url)
+        throw new Error("Set the Turso database URL in Project Settings");
+    return url;
+}
+function tursoRowsCacheKey(settings) {
+    return (0, node_crypto_1.createHash)("sha256").update(requireTursoDatabaseUrl(settings)).digest("hex");
+}
+function readTursoRowsCacheFile(cachePath) {
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(cachePath, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeTursoRowsCacheFile(cachePath, cache) {
+    (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(cachePath), { recursive: true });
+    (0, node_fs_1.writeFileSync)(cachePath, JSON.stringify(cache), "utf8");
+}
+function tursoClonePathTemplate(input, cloneDirectory) {
+    const clonePathTemplate = (0, import_1.normalizeClonePathTemplate)(input);
+    if (!clonePathTemplate)
+        return undefined;
+    if (!node_path_1.default.isAbsolute(clonePathTemplate))
+        return clonePathTemplate;
+    if (!cloneDirectory)
+        return undefined;
+    const relativePath = node_path_1.default.relative(cloneDirectory, clonePathTemplate);
+    if (!relativePath || relativePath.startsWith("..") || node_path_1.default.isAbsolute(relativePath))
+        return undefined;
+    return (0, import_1.normalizeClonePathTemplate)(relativePath);
+}
+function tursoStorageRow(settings, row) {
+    const clonePathTemplate = tursoClonePathTemplate(row.clonePathTemplate, settings.cloneDirectory);
+    const nextRow = { ...row };
+    if (clonePathTemplate)
+        nextRow.clonePathTemplate = clonePathTemplate;
+    else
+        delete nextRow.clonePathTemplate;
+    return nextRow;
+}
+function readCachedTursoProjectRows(settings) {
+    const cached = readTursoRowsCacheFile(settings.cachePath)[tursoRowsCacheKey(settings)];
+    if (!cached || !Array.isArray(cached.rows))
+        return undefined;
+    return {
+        ...cached,
+        rows: cached.rows.map((row) => tursoStorageRow(settings, row)),
+    };
+}
+function writeCachedTursoProjectRows(settings, rows) {
+    const cache = readTursoRowsCacheFile(settings.cachePath);
+    cache[tursoRowsCacheKey(settings)] = {
+        generatedAt: Date.now(),
+        rows: rows.map((row) => tursoStorageRow(settings, row)),
+    };
+    writeTursoRowsCacheFile(settings.cachePath, cache);
+}
+function tursoClient(settings) {
+    return (0, libsql_client_1.createLibsqlClient)({
+        url: requireTursoDatabaseUrl(settings),
+        authToken: settings.tursoAuthToken?.trim() || undefined,
+    });
+}
+function isUnauthorizedError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes("HTTP status 401") || message.includes("SERVER_ERROR: Server returned HTTP status 401");
+}
+function tursoError(error) {
+    if (isUnauthorizedError(error)) {
+        return new Error("Turso authentication failed. Add a database auth token in Project Settings, or create one with `turso db tokens create <database>`.");
+    }
+    return error;
+}
+async function withTursoErrors(operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        throw tursoError(error);
+    }
+}
+function parseStringArray(input) {
+    if (!input)
+        return [];
+    try {
+        const parsed = JSON.parse(input);
+        return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+function parseSubpaths(input) {
+    if (!input)
+        return [];
+    try {
+        return (0, native_bridge_3.normalizeSubpaths)(JSON.parse(input));
+    }
+    catch {
+        return [];
+    }
+}
+function rowToImportedRepository(settings, row) {
+    const clonePathTemplate = tursoClonePathTemplate(row.clone_path_template, settings.cloneDirectory);
+    return {
+        url: row.url,
+        ...(row.name ? { name: row.name } : {}),
+        ...(row.description ? { description: row.description } : {}),
+        tags: parseStringArray(row.tags_json),
+        folders: parseStringArray(row.folders_json),
+        subpaths: parseSubpaths(row.subpaths_json),
+        ...(clonePathTemplate ? { clonePathTemplate } : {}),
+        ...(row.all_subpath ? { allSubpath: true } : {}),
+        ...(row.remove_path_from_name ? { removePathFromName: true } : {}),
+    };
+}
+function importedRepositoryToSqlRow(settings, input) {
+    const row = tursoStorageRow(settings, input);
+    const normalizedUrl = (0, git_repository_1.normalizeRepositoryUrl)(row.url);
+    const name = typeof row.name === "string" && row.name.trim() ? row.name.trim() : null;
+    const description = typeof row.description === "string" && row.description.trim() ? row.description.trim() : null;
+    const remoteMetadata = (0, native_bridge_2.repositoryRemoteMetadata)(normalizedUrl);
+    return {
+        id: normalizedUrl,
+        url: normalizedUrl,
+        name,
+        description,
+        tagsJson: JSON.stringify((0, native_bridge_1.normalizeTags)(row.tags)),
+        foldersJson: JSON.stringify((0, native_bridge_1.normalizeFolders)(row.folders)),
+        subpathsJson: JSON.stringify((0, native_bridge_3.normalizeSubpaths)(row.subpaths)),
+        cloneTemplate: (0, import_1.normalizeClonePathTemplate)(row.clonePathTemplate) ?? null,
+        allSubpath: row.allSubpath === true ? 1 : 0,
+        removePathFromName: row.removePathFromName === true ? 1 : 0,
+        provider: remoteMetadata?.provider ?? null,
+        host: remoteMetadata?.host ?? null,
+        owner: remoteMetadata?.owner ?? null,
+        repo: remoteMetadata?.repository ?? null,
+        now: new Date().toISOString(),
+    };
+}
+async function migrate(client) {
+    await client.batch([
+        `create table if not exists projects (
+        id text primary key,
+        url text not null unique,
+        name text,
+        description text,
+        tags_json text not null default '[]',
+        folders_json text not null default '[]',
+        subpaths_json text not null default '[]',
+        clone_path_template text,
+        all_subpath integer not null default 0,
+        remove_path_from_name integer not null default 0,
+        created_at text not null,
+        updated_at text not null,
+        deleted_at text
+      )`,
+        `create table if not exists devices (
+        id text primary key,
+        name text not null,
+        hostname text,
+        clone_directory text,
+        open_in_target text,
+        created_at text not null,
+        updated_at text not null
+      )`,
+        `create table if not exists project_device_overrides (
+        project_id text not null references projects(id),
+        device_id text not null references devices(id),
+        clone_path text,
+        favorite integer,
+        sort_order integer,
+        hidden integer,
+        updated_at text not null,
+        primary key (project_id, device_id)
+      )`,
+        `create table if not exists changes (
+        id text primary key,
+        entity text not null,
+        entity_id text not null,
+        operation text not null,
+        payload_json text not null,
+        device_id text,
+        created_at text not null
+      )`,
+        `create table if not exists metadata (
+        key text primary key,
+        value text not null
+      )`,
+    ], "write");
+    await client.execute("alter table projects add column all_subpath integer not null default 0").catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!message.includes("duplicate column name"))
+            throw error;
+    });
+    for (const column of [
+        "description text",
+        "provider text",
+        "host text",
+        "owner text",
+        "repo text",
+        "remote_checked_at text",
+        "icon_source text",
+        "icon_checked_at text",
+    ]) {
+        await client.execute(`alter table projects add column ${column}`).catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!message.includes("duplicate column name"))
+                throw error;
+        });
+    }
+}
+async function recordChange(client, settings, operation, entityId, payload) {
+    const now = new Date().toISOString();
+    const id = `${now}:${operation}:${entityId}:${(0, node_crypto_1.randomUUID)()}`;
+    await client.execute({
+        sql: `insert into changes (id, entity, entity_id, operation, payload_json, device_id, created_at)
+      values (?, 'project', ?, ?, ?, ?, ?)`,
+        args: [id, entityId, operation, JSON.stringify(payload), settings.deviceName ?? null, now],
+    });
+}
+async function testTursoProjectSource(settings) {
+    return withTursoErrors(async () => {
+        const client = tursoClient(settings);
+        await migrate(client);
+        await client.execute("select 1");
+    });
+}
+async function readTursoProjectRows(settings) {
+    return withTursoErrors(async () => {
+        const client = tursoClient(settings);
+        await migrate(client);
+        const result = await client.execute(`select url, name, description, tags_json, folders_json, subpaths_json, clone_path_template, all_subpath, remove_path_from_name
+      from projects
+      where deleted_at is null
+      order by coalesce(name, url), url`);
+        const rows = result.rows.map((row) => rowToImportedRepository(settings, row));
+        writeCachedTursoProjectRows(settings, rows);
+        return rows;
+    });
+}
+async function upsertTursoProjectRow(settings, row) {
+    await withTursoErrors(async () => {
+        const client = tursoClient(settings);
+        await migrate(client);
+        const storageRow = tursoStorageRow(settings, row);
+        const sqlRow = importedRepositoryToSqlRow(settings, storageRow);
+        await client.execute({
+            sql: `insert into projects (
+        id, url, name, description, tags_json, folders_json, subpaths_json, clone_path_template, all_subpath,
+        remove_path_from_name, provider, host, owner, repo, remote_checked_at, created_at, updated_at, deleted_at
+      )
+      values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, null)
+      on conflict(url) do update set
+        name = excluded.name,
+        description = excluded.description,
+        tags_json = excluded.tags_json,
+        folders_json = excluded.folders_json,
+        subpaths_json = excluded.subpaths_json,
+        clone_path_template = excluded.clone_path_template,
+        all_subpath = excluded.all_subpath,
+        remove_path_from_name = excluded.remove_path_from_name,
+        provider = excluded.provider,
+        host = excluded.host,
+        owner = excluded.owner,
+        repo = excluded.repo,
+        remote_checked_at = excluded.remote_checked_at,
+        updated_at = excluded.updated_at,
+        deleted_at = null`,
+            args: [
+                sqlRow.id,
+                sqlRow.url,
+                sqlRow.name,
+                sqlRow.description,
+                sqlRow.tagsJson,
+                sqlRow.foldersJson,
+                sqlRow.subpathsJson,
+                sqlRow.cloneTemplate,
+                sqlRow.allSubpath,
+                sqlRow.removePathFromName,
+                sqlRow.provider,
+                sqlRow.host,
+                sqlRow.owner,
+                sqlRow.repo,
+                sqlRow.now,
+                sqlRow.now,
+                sqlRow.now,
+            ],
+        });
+        await recordChange(client, settings, "upsert", sqlRow.id, storageRow);
+        writeCachedTursoProjectRows(settings, await readTursoProjectRows(settings));
+    });
+}
+async function replaceTursoProjectUrl(settings, previousUrl, row) {
+    const normalizedPreviousUrl = (0, git_repository_1.normalizeRepositoryUrl)(previousUrl);
+    const normalizedNextUrl = (0, git_repository_1.normalizeRepositoryUrl)(row.url);
+    if (normalizedPreviousUrl !== normalizedNextUrl) {
+        await deleteTursoProjectRow(settings, normalizedPreviousUrl);
+    }
+    await upsertTursoProjectRow(settings, row);
+}
+async function reconcileTursoProjectRemote(settings, previousUrl, actualRemoteUrl) {
+    const normalizedPreviousUrl = (0, git_repository_1.normalizeRepositoryUrl)(previousUrl);
+    const normalizedActualUrl = (0, git_repository_1.normalizeRepositoryUrl)(actualRemoteUrl);
+    if (normalizedPreviousUrl === normalizedActualUrl)
+        return false;
+    await withTursoErrors(async () => {
+        const client = tursoClient(settings);
+        await migrate(client);
+        const result = await client.execute({
+            sql: `select url, name, description, tags_json, folders_json, subpaths_json, clone_path_template, all_subpath, remove_path_from_name
+      from projects
+      where url = ? and deleted_at is null
+      limit 1`,
+            args: [normalizedPreviousUrl],
+        });
+        const row = result.rows[0];
+        if (!row)
+            return false;
+        const existingActualResult = await client.execute({
+            sql: "select deleted_at from projects where url = ? limit 1",
+            args: [normalizedActualUrl],
+        });
+        if (existingActualResult.rows.length) {
+            const now = new Date().toISOString();
+            const existingActual = existingActualResult.rows[0];
+            if (existingActual.deleted_at) {
+                const nextRow = importedRepositoryToSqlRow(settings, {
+                    ...rowToImportedRepository(settings, row),
+                    url: normalizedActualUrl,
+                });
+                await client.execute({
+                    sql: `update projects set
+            name = ?,
+            description = ?,
+            tags_json = ?,
+            folders_json = ?,
+            subpaths_json = ?,
+            clone_path_template = ?,
+            all_subpath = ?,
+            remove_path_from_name = ?,
+            provider = ?,
+            host = ?,
+            owner = ?,
+            repo = ?,
+            remote_checked_at = ?,
+            updated_at = ?,
+            deleted_at = null
+          where url = ?`,
+                    args: [
+                        nextRow.name,
+                        nextRow.description,
+                        nextRow.tagsJson,
+                        nextRow.foldersJson,
+                        nextRow.subpathsJson,
+                        nextRow.cloneTemplate,
+                        nextRow.allSubpath,
+                        nextRow.removePathFromName,
+                        nextRow.provider,
+                        nextRow.host,
+                        nextRow.owner,
+                        nextRow.repo,
+                        nextRow.now,
+                        nextRow.now,
+                        normalizedActualUrl,
+                    ],
+                });
+            }
+            await client.execute({
+                sql: "update projects set deleted_at = ?, updated_at = ? where url = ? and deleted_at is null",
+                args: [now, now, normalizedPreviousUrl],
+            });
+            await recordChange(client, settings, "reconcile-remote-delete-duplicate", normalizedPreviousUrl, {
+                previousUrl: normalizedPreviousUrl,
+                actualRemoteUrl: normalizedActualUrl,
+            });
+            writeCachedTursoProjectRows(settings, await readTursoProjectRows(settings));
+            return true;
+        }
+        const nextRow = importedRepositoryToSqlRow(settings, {
+            ...rowToImportedRepository(settings, row),
+            url: normalizedActualUrl,
+        });
+        await client.execute({
+            sql: `update projects set
+        id = ?,
+        url = ?,
+        provider = ?,
+        host = ?,
+        owner = ?,
+        repo = ?,
+        remote_checked_at = ?,
+        icon_source = null,
+        icon_checked_at = null,
+        updated_at = ?
+      where url = ? and deleted_at is null`,
+            args: [
+                nextRow.id,
+                nextRow.url,
+                nextRow.provider,
+                nextRow.host,
+                nextRow.owner,
+                nextRow.repo,
+                nextRow.now,
+                nextRow.now,
+                normalizedPreviousUrl,
+            ],
+        });
+        await recordChange(client, settings, "reconcile-remote", nextRow.id, {
+            previousUrl: normalizedPreviousUrl,
+            actualRemoteUrl: normalizedActualUrl,
+        });
+        writeCachedTursoProjectRows(settings, await readTursoProjectRows(settings));
+        return true;
+    });
+}
+async function deleteTursoProjectRow(settings, url) {
+    await withTursoErrors(async () => {
+        const client = tursoClient(settings);
+        await migrate(client);
+        const normalizedUrl = (0, git_repository_1.normalizeRepositoryUrl)(url);
+        const now = new Date().toISOString();
+        await client.execute({
+            sql: "update projects set deleted_at = ?, updated_at = ? where url = ? and deleted_at is null",
+            args: [now, now, normalizedUrl],
+        });
+        await recordChange(client, settings, "delete", normalizedUrl, { url: normalizedUrl });
+        writeCachedTursoProjectRows(settings, await readTursoProjectRows(settings));
+    });
+}
+async function setTursoProjectDeviceFavorite(settings, url, favorite) {
+    return withTursoErrors(async () => {
+        const client = tursoClient(settings);
+        await migrate(client);
+        const normalizedUrl = (0, git_repository_1.normalizeRepositoryUrl)(url);
+        const deviceId = settings.deviceName?.trim() || "local";
+        const now = new Date().toISOString();
+        const nextFavorite = favorite ? 1 : 0;
+        const previous = await client.execute({
+            sql: `select favorite from project_device_overrides
+        where project_id = ? and device_id = ?
+        limit 1`,
+            args: [normalizedUrl, deviceId],
+        });
+        const previousFavorite = previous.rows[0]?.favorite;
+        const changed = previousFavorite !== nextFavorite;
+        await client.execute({
+            sql: `insert into devices (id, name, hostname, clone_directory, open_in_target, created_at, updated_at)
+        values (?, ?, null, ?, null, ?, ?)
+        on conflict(id) do update set
+          name = excluded.name,
+          clone_directory = excluded.clone_directory,
+          updated_at = excluded.updated_at`,
+            args: [deviceId, deviceId, settings.cloneDirectory ?? null, now, now],
+        });
+        await client.execute({
+            sql: `insert into project_device_overrides (project_id, device_id, favorite, updated_at)
+        values (?, ?, ?, ?)
+        on conflict(project_id, device_id) do update set
+          favorite = excluded.favorite,
+          updated_at = excluded.updated_at`,
+            args: [normalizedUrl, deviceId, nextFavorite, now],
+        });
+        if (changed) {
+            await recordChange(client, settings, "set-device-favorite", normalizedUrl, {
+                url: normalizedUrl,
+                favorite,
+                deviceId,
+            });
+        }
+        return changed;
+    });
+}
+async function setTursoProjectName(settings, url, name) {
+    return withTursoErrors(async () => {
+        const client = tursoClient(settings);
+        await migrate(client);
+        const normalizedUrl = (0, git_repository_1.normalizeRepositoryUrl)(url);
+        const nextName = name.trim() || null;
+        const now = new Date().toISOString();
+        const existing = await client.execute({
+            sql: "select name from projects where url = ? and deleted_at is null limit 1",
+            args: [normalizedUrl],
+        });
+        const previous = existing.rows[0]?.name ?? null;
+        if (previous === nextName)
+            return false;
+        if (!existing.rows.length)
+            return false;
+        await client.execute({
+            sql: "update projects set name = ?, updated_at = ? where url = ? and deleted_at is null",
+            args: [nextName, now, normalizedUrl],
+        });
+        await recordChange(client, settings, "rename", normalizedUrl, { url: normalizedUrl, name: nextName });
+        writeCachedTursoProjectRows(settings, await readTursoProjectRows(settings));
+        return true;
+    });
+}
+async function importTursoProjectRows(settings, rows) {
+    await withTursoErrors(async () => {
+        const client = tursoClient(settings);
+        await migrate(client);
+        for (const row of rows) {
+            const sqlRow = importedRepositoryToSqlRow(settings, row);
+            await client.execute({
+                sql: `insert into projects (
+          id, url, name, description, tags_json, folders_json, subpaths_json, clone_path_template, all_subpath,
+          remove_path_from_name, provider, host, owner, repo, remote_checked_at, created_at, updated_at, deleted_at
+        )
+        values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, null)
+        on conflict(url) do update set
+          name = excluded.name,
+          description = excluded.description,
+          tags_json = excluded.tags_json,
+          folders_json = excluded.folders_json,
+          subpaths_json = excluded.subpaths_json,
+          clone_path_template = excluded.clone_path_template,
+          all_subpath = excluded.all_subpath,
+          remove_path_from_name = excluded.remove_path_from_name,
+          provider = excluded.provider,
+          host = excluded.host,
+          owner = excluded.owner,
+          repo = excluded.repo,
+          remote_checked_at = excluded.remote_checked_at,
+          updated_at = excluded.updated_at,
+          deleted_at = null`,
+                args: [
+                    sqlRow.id,
+                    sqlRow.url,
+                    sqlRow.name,
+                    sqlRow.description,
+                    sqlRow.tagsJson,
+                    sqlRow.foldersJson,
+                    sqlRow.subpathsJson,
+                    sqlRow.cloneTemplate,
+                    sqlRow.allSubpath,
+                    sqlRow.removePathFromName,
+                    sqlRow.provider,
+                    sqlRow.host,
+                    sqlRow.owner,
+                    sqlRow.repo,
+                    sqlRow.now,
+                    sqlRow.now,
+                    sqlRow.now,
+                ],
+            });
+        }
+        await recordChange(client, settings, "import", "projects", { count: rows.length });
+        writeCachedTursoProjectRows(settings, await readTursoProjectRows(settings));
+    });
+}

package/node_modules/@raggle-ai/local/dist/adapters/turso-provider.d.ts

@@ -0,0 +1,17 @@
+export type TursoCommandRunner = (args: string[]) => Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}>;
+export declare function runTursoCommand(args: string[]): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}>;
+export type TursoProvider = {
+    whoami(): Promise<string>;
+    databaseChoices(): Promise<string[]>;
+    databaseUrl(database: string): Promise<string>;
+    createDatabaseToken(database: string): Promise<string>;
+};
+export declare function createTursoProvider(runCommand: TursoCommandRunner): TursoProvider;

package/node_modules/@raggle-ai/local/dist/adapters/turso-provider.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTursoCommand = runTursoCommand;
+exports.createTursoProvider = createTursoProvider;
+const node_child_process_1 = require("node:child_process");
+async function runTursoCommand(args) {
+    return new Promise((resolve) => {
+        const child = (0, node_child_process_1.spawn)("turso", args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("close", (exitCode) => {
+            resolve({ stdout: stdout.trim(), stderr: stderr.trim(), exitCode: exitCode ?? 0 });
+        });
+        child.on("error", (error) => {
+            resolve({ stdout: "", stderr: error.message, exitCode: 1 });
+        });
+    });
+}
+function parseTursoDatabaseList(stdout) {
+    const lines = stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const headerIndex = lines.findIndex((line) => /^NAME\b/i.test(line));
+    if (headerIndex === -1) {
+        throw new Error("Unrecognized Turso database list output: missing NAME header.");
+    }
+    const headerLine = lines[headerIndex];
+    const firstNameMatch = headerLine.match(/\bNAME\b/i);
+    if (!firstNameMatch) {
+        throw new Error("Unrecognized Turso database list output: cannot locate NAME column.");
+    }
+    const nameColumnStart = firstNameMatch.index ?? 0;
+    const choices = [];
+    for (let index = headerIndex + 1; index < lines.length; index += 1) {
+        const line = lines[index];
+        const name = line.slice(nameColumnStart).trim().split(/\s+/)[0];
+        if (name)
+            choices.push(name);
+    }
+    if (!choices.length) {
+        throw new Error("No Turso databases found for the authenticated user.");
+    }
+    return [...new Set(choices)];
+}
+function createTursoProvider(runCommand) {
+    async function requireCommand(args, errorContext) {
+        const result = await runCommand(args);
+        if (result.exitCode !== 0) {
+            throw new Error(`Turso ${errorContext} failed (${result.exitCode}): ${result.stderr || result.stdout || "unknown error"}`);
+        }
+        return result.stdout;
+    }
+    async function requireAuthenticatedSession() {
+        const result = await runCommand(["auth", "whoami"]);
+        const output = `${result.stdout}\n${result.stderr}`.trim();
+        if (result.exitCode !== 0) {
+            throw new Error(`Turso authentication check failed (${result.exitCode}): ${result.stderr || result.stdout || "unknown error"}`);
+        }
+        if (/not logged in/i.test(output)) {
+            throw new Error("You are not logged in. Run 'turso auth login' before you use Turso.");
+        }
+        return result.stdout;
+    }
+    return {
+        async whoami() {
+            return requireAuthenticatedSession();
+        },
+        async databaseChoices() {
+            await requireAuthenticatedSession();
+            const stdout = await requireCommand(["db", "list"], "database list");
+            const choices = parseTursoDatabaseList(stdout);
+            if (!choices.length) {
+                throw new Error("No Turso databases found for the authenticated user.");
+            }
+            return choices;
+        },
+        async databaseUrl(database) {
+            const stdout = await requireCommand(["db", "show", database, "--url"], "database URL lookup");
+            const url = stdout.trim();
+            if (!url) {
+                throw new Error(`Turso database URL is empty for ${database}.`);
+            }
+            return url;
+        },
+        async createDatabaseToken(database) {
+            const stdout = await requireCommand(["db", "tokens", "create", database], "database token creation");
+            const token = stdout.trim();
+            if (!token) {
+                throw new Error(`Turso database token is empty for ${database}.`);
+            }
+            return token;
+        },
+    };
+}