kennel 0.1.8 → 0.2.0

package/node_modules/@raggle-ai/local/dist/adapters/relation-annotations-api.js

@@ -0,0 +1,207 @@
+"use strict";
+// Small typed HTTP adapter for the SaaS relation-annotations API.
+//
+// Mirror of the generated contract in `raggle-ai-saas` at
+//   openapi/raggle-api.json
+//   packages/raggle-otel-ts/src/generated/api.ts
+// Scout must not depend on the SaaS package, so this adapter reproduces the
+// exact method, path, header, and payload shapes. `scripts/test-relation-contract.mjs`
+// asserts parity against `scripts/fixtures/relation-annotations-contract.json`.
+//
+// Auth: a dashboard-created, user-owned machine token with `relations:read` and
+// `relations:write`. The token is read from the environment only; it is never
+// written to disk. The default base URL is the SaaS service declared in the
+// OpenAPI `servers` list (https://otelapi.raggle.co); it is an override, not a
+// claim about any live deployment.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationsApiError = exports.updateRelationAnnotationRequestFields = exports.createRelationAnnotationRequestFields = exports.relationAnnotationFieldNames = exports.relationAnnotationEdgeOrigins = exports.relationAnnotationDirections = exports.relationAnnotationTypes = exports.delRelationAnnotationPath = exports.updateRelationAnnotationPath = exports.postRelationAnnotationPath = exports.listRelationAnnotationsPath = exports.RELATIONS_API_BASE_URL_ENV = exports.RELATIONS_API_TOKEN_ENV = exports.DEFAULT_RELATIONS_API_BASE_URL = void 0;
+exports.readRelationsApiCredentials = readRelationsApiCredentials;
+exports.listRelationAnnotations = listRelationAnnotations;
+exports.createRelationAnnotation = createRelationAnnotation;
+exports.updateRelationAnnotation = updateRelationAnnotation;
+exports.deleteRelationAnnotation = deleteRelationAnnotation;
+const node_os_1 = __importDefault(require("node:os"));
+exports.DEFAULT_RELATIONS_API_BASE_URL = "https://otelapi.raggle.co";
+exports.RELATIONS_API_TOKEN_ENV = "RAGGLE_RELATIONS_API_TOKEN";
+exports.RELATIONS_API_BASE_URL_ENV = "RAGGLE_RELATIONS_API_BASE_URL";
+const DEFAULT_TIMEOUT_SECONDS = 10;
+exports.listRelationAnnotationsPath = "/v1/relation-annotations";
+exports.postRelationAnnotationPath = "/v1/relation-annotations";
+exports.updateRelationAnnotationPath = "/v1/relation-annotations/{id}";
+exports.delRelationAnnotationPath = "/v1/relation-annotations/{id}";
+exports.relationAnnotationTypes = ["notes", "implementation", "dependency"];
+exports.relationAnnotationDirections = ["incoming", "outgoing"];
+exports.relationAnnotationEdgeOrigins = ["core", "personal"];
+exports.relationAnnotationFieldNames = [
+    "id",
+    "ownerUserId",
+    "organizationId",
+    "sourceProjectId",
+    "targetId",
+    "direction",
+    "relationType",
+    "edgeOrigin",
+    "reason",
+    "createdAt",
+    "updatedAt",
+];
+exports.createRelationAnnotationRequestFields = [
+    "sourceProjectId",
+    "targetId",
+    "direction",
+    "relationType",
+    "edgeOrigin",
+    "reason",
+];
+exports.updateRelationAnnotationRequestFields = ["reason", "direction", "relationType", "edgeOrigin"];
+class RelationsApiError extends Error {
+    constructor(message, status, code) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = "RelationsApiError";
+    }
+}
+exports.RelationsApiError = RelationsApiError;
+/** Reads sync credentials from the environment. The token never touches disk. */
+function readRelationsApiCredentials(options = {}) {
+    const baseUrl = (options.baseUrl ?? process.env[exports.RELATIONS_API_BASE_URL_ENV] ?? exports.DEFAULT_RELATIONS_API_BASE_URL)
+        .trim()
+        .replace(/\/+$/, "");
+    const token = process.env[exports.RELATIONS_API_TOKEN_ENV]?.trim() || undefined;
+    return { baseUrl, token };
+}
+function isRelationType(value) {
+    return typeof value === "string" && exports.relationAnnotationTypes.includes(value);
+}
+function isDirection(value) {
+    return typeof value === "string" && exports.relationAnnotationDirections.includes(value);
+}
+function isEdgeOrigin(value) {
+    return typeof value === "string" && exports.relationAnnotationEdgeOrigins.includes(value);
+}
+function invalidData() {
+    return new RelationsApiError("Relations API returned invalid annotation data.", 0, "invalid_cloud_data");
+}
+function parseAnnotation(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw invalidData();
+    const record = value;
+    if (typeof record.id !== "string" ||
+        typeof record.ownerUserId !== "string" ||
+        (record.organizationId !== null && typeof record.organizationId !== "string") ||
+        typeof record.sourceProjectId !== "string" ||
+        typeof record.targetId !== "string" ||
+        !isDirection(record.direction) ||
+        !isRelationType(record.relationType) ||
+        !isEdgeOrigin(record.edgeOrigin) ||
+        typeof record.reason !== "string" ||
+        typeof record.createdAt !== "string" ||
+        typeof record.updatedAt !== "string") {
+        throw invalidData();
+    }
+    return {
+        id: record.id,
+        ownerUserId: record.ownerUserId,
+        organizationId: record.organizationId,
+        sourceProjectId: record.sourceProjectId,
+        targetId: record.targetId,
+        direction: record.direction,
+        relationType: record.relationType,
+        edgeOrigin: record.edgeOrigin,
+        reason: record.reason,
+        createdAt: record.createdAt,
+        updatedAt: record.updatedAt,
+    };
+}
+function errorMessage(status, code) {
+    if (status === 401) {
+        return `Relations API authentication failed (HTTP 401). Check that ${exports.RELATIONS_API_TOKEN_ENV} is a valid machine token.`;
+    }
+    if (status === 403) {
+        return `Relations API rejected the token (HTTP 403${code ? `: ${code}` : ""}). The token must be user-owned and carry relations:read and relations:write.`;
+    }
+    if (status === 404)
+        return "Relation annotation not found (HTTP 404).";
+    if (status === 409)
+        return "Relation annotation already exists (HTTP 409). A conflicting annotation is already present; re-run sync to reconcile.";
+    if (status === 400)
+        return `Relations API rejected the payload (HTTP 400${code ? `: ${code}` : ""}).`;
+    return `Relations API request failed (HTTP ${status}).`;
+}
+async function request(client, method, path, body) {
+    const fetchImpl = client.fetchImpl ?? fetch;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), Math.round((client.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS) * 1000));
+    try {
+        let response;
+        try {
+            response = await fetchImpl(`${client.baseUrl}${path}`, {
+                method,
+                headers: {
+                    Authorization: `Bearer ${client.apiToken}`,
+                    Accept: "application/json",
+                    "Content-Type": "application/json",
+                    "User-Agent": `raggle-local/${node_os_1.default.platform()}`,
+                },
+                ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+                signal: controller.signal,
+            });
+        }
+        catch (error) {
+            if (error.name === "AbortError") {
+                throw new RelationsApiError(`Relations API request timed out after ${client.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS}s.`, 0, "timeout");
+            }
+            throw new RelationsApiError(`Relations API request failed: ${error.message}`, 0, "network");
+        }
+        const text = await response.text();
+        let payload;
+        if (text) {
+            try {
+                payload = JSON.parse(text);
+            }
+            catch {
+                payload = undefined;
+            }
+        }
+        if (response.status >= 200 && response.status < 300)
+            return payload;
+        const code = payload && typeof payload === "object" && !Array.isArray(payload)
+            ? payload.error
+            : undefined;
+        throw new RelationsApiError(errorMessage(response.status, typeof code === "string" ? code : undefined), response.status, typeof code === "string" ? code : undefined);
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function listRelationAnnotations(client) {
+    return request(client, "GET", exports.listRelationAnnotationsPath).then((payload) => {
+        if (!payload || typeof payload !== "object" || Array.isArray(payload))
+            throw invalidData();
+        const annotations = payload.annotations;
+        if (!Array.isArray(annotations))
+            throw invalidData();
+        return annotations.map(parseAnnotation);
+    });
+}
+function createRelationAnnotation(client, body) {
+    return request(client, "POST", exports.postRelationAnnotationPath, body).then((payload) => {
+        if (!payload || typeof payload !== "object" || Array.isArray(payload))
+            throw invalidData();
+        return parseAnnotation(payload.annotation);
+    });
+}
+function updateRelationAnnotation(client, id, body) {
+    return request(client, "PATCH", `/v1/relation-annotations/${encodeURIComponent(id)}`, body).then((payload) => {
+        if (!payload || typeof payload !== "object" || Array.isArray(payload))
+            throw invalidData();
+        return parseAnnotation(payload.annotation);
+    });
+}
+function deleteRelationAnnotation(client, id) {
+    return request(client, "DELETE", `/v1/relation-annotations/${encodeURIComponent(id)}`).then(() => undefined);
+}

package/node_modules/@raggle-ai/local/dist/adapters/remote-repository-config.d.ts

@@ -0,0 +1,19 @@
+import { normalizeSubpaths } from "../native-bridge";
+export type RemoteRepositoryConfig = {
+    repository: string;
+    source: "remote-database";
+    name?: string;
+    description?: string;
+    tags: string[];
+    folders: string[];
+    subpaths: ReturnType<typeof normalizeSubpaths>;
+    allSubpaths: boolean;
+    clonePathTemplate?: string;
+    removePathFromName: boolean;
+};
+export declare function normalizeRepositoryReference(input: string): string;
+export declare function readRemoteRepositoryConfig(options: {
+    repository: string;
+    databaseUrl: string;
+    authToken?: string;
+}): Promise<RemoteRepositoryConfig | undefined>;

package/node_modules/@raggle-ai/local/dist/adapters/remote-repository-config.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRepositoryReference = normalizeRepositoryReference;
+exports.readRemoteRepositoryConfig = readRemoteRepositoryConfig;
+const native_bridge_1 = require("../native-bridge");
+const native_bridge_2 = require("../native-bridge");
+const import_1 = require("./import");
+const git_repository_1 = require("./git-repository");
+const libsql_client_1 = require("./libsql-client");
+function parseJson(input) {
+    if (!input)
+        return [];
+    try {
+        return JSON.parse(input);
+    }
+    catch {
+        return [];
+    }
+}
+function normalizeRepositoryReference(input) {
+    const reference = input.trim();
+    if (/^[^\s/:]+\/[^\s/]+$/.test(reference))
+        return (0, git_repository_1.normalizeRepositoryUrl)(`https://github.com/${reference}`);
+    return (0, git_repository_1.normalizeRepositoryUrl)(reference);
+}
+async function readRemoteRepositoryConfig(options) {
+    const repository = normalizeRepositoryReference(options.repository);
+    const databaseUrl = options.databaseUrl.trim();
+    if (!databaseUrl)
+        throw new Error("A database URL is required");
+    const client = (0, libsql_client_1.createLibsqlClient)({
+        url: databaseUrl,
+        authToken: options.authToken?.trim() || undefined,
+    });
+    try {
+        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: [repository],
+        });
+        const row = result.rows[0];
+        if (!row)
+            return undefined;
+        const clonePathTemplate = (0, import_1.normalizeClonePathTemplate)(row.clone_path_template);
+        return {
+            repository: (0, git_repository_1.normalizeRepositoryUrl)(row.url),
+            source: "remote-database",
+            ...(row.name ? { name: row.name } : {}),
+            ...(row.description ? { description: row.description } : {}),
+            tags: (0, native_bridge_1.normalizeTags)(parseJson(row.tags_json)),
+            folders: (0, native_bridge_1.normalizeFolders)(parseJson(row.folders_json)),
+            subpaths: (0, native_bridge_2.normalizeSubpaths)(parseJson(row.subpaths_json)),
+            allSubpaths: Boolean(row.all_subpath),
+            ...(clonePathTemplate ? { clonePathTemplate } : {}),
+            removePathFromName: Boolean(row.remove_path_from_name),
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("HTTP status 401")) {
+            throw new Error("Remote database authentication failed. Set TURSO_AUTH_TOKEN.");
+        }
+        throw error;
+    }
+    finally {
+        client.close();
+    }
+}

package/node_modules/@raggle-ai/local/dist/adapters/session-resolvers.d.ts

@@ -0,0 +1,8 @@
+import type { AiChatClientId } from "@raggle-ai/clients";
+export type SessionResolverResult = {
+    sessionId: string;
+    worktree?: string;
+};
+export declare function latestCodexSessionForWorktree(worktree: string): SessionResolverResult | undefined;
+export declare function latestOpencodeSessionIdForWorktree(worktree: string): Promise<SessionResolverResult | undefined>;
+export declare const sessionResolvers: Partial<Record<AiChatClientId, (worktree: string) => SessionResolverResult | undefined | Promise<SessionResolverResult | undefined>>>;

package/node_modules/@raggle-ai/local/dist/adapters/session-resolvers.js

@@ -0,0 +1,225 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionResolvers = void 0;
+exports.latestCodexSessionForWorktree = latestCodexSessionForWorktree;
+exports.latestOpencodeSessionIdForWorktree = latestOpencodeSessionIdForWorktree;
+const node_fs_1 = require("node:fs");
+const node_child_process_1 = require("node:child_process");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const opencode_local_1 = require("./opencode-local");
+const macos_apps_1 = require("./macos-apps");
+const maxSessionMetaBytes = 2 * 1024 * 1024;
+const maxSessionTailBytes = 1024 * 1024;
+const maxOpencodeSessionListBytes = 1024 * 1024 * 8;
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function codexHome() {
+    return process.env.CODEX_HOME || node_path_1.default.join(node_os_1.default.homedir(), ".codex");
+}
+function safeRealpath(item) {
+    try {
+        return (0, node_fs_1.realpathSync)(item);
+    }
+    catch {
+        return node_path_1.default.resolve(item);
+    }
+}
+function matchesWorktree(candidateWorktree, targetWorktree) {
+    return candidateWorktree === targetWorktree || candidateWorktree.startsWith(`${targetWorktree}${node_path_1.default.sep}`);
+}
+function readJsonLines(filePath) {
+    try {
+        if (!(0, node_fs_1.existsSync)(filePath))
+            return [];
+        return (0, node_fs_1.readFileSync)(filePath, "utf8")
+            .split("\n")
+            .filter(Boolean)
+            .flatMap((line) => {
+            try {
+                return [JSON.parse(line)];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function readFirstLine(filePath) {
+    let fd;
+    try {
+        fd = (0, node_fs_1.openSync)(filePath, "r");
+        const chunks = [];
+        let bytesReadTotal = 0;
+        while (bytesReadTotal < maxSessionMetaBytes) {
+            const buffer = Buffer.alloc(8192);
+            const bytesRead = (0, node_fs_1.readSync)(fd, buffer, 0, buffer.length, null);
+            if (bytesRead === 0)
+                break;
+            const next = buffer.subarray(0, bytesRead);
+            const newlineIndex = next.indexOf(10);
+            if (newlineIndex >= 0) {
+                chunks.push(next.subarray(0, newlineIndex));
+                break;
+            }
+            chunks.push(next);
+            bytesReadTotal += bytesRead;
+        }
+        return Buffer.concat(chunks).toString("utf8");
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (fd !== undefined)
+            (0, node_fs_1.closeSync)(fd);
+    }
+}
+function readSessionMeta(filePath) {
+    const firstLine = readFirstLine(filePath);
+    if (!firstLine)
+        return undefined;
+    try {
+        const parsed = JSON.parse(firstLine);
+        return parsed.type === "session_meta" ? parsed.payload : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseTimestampMs(timestamp) {
+    if (!timestamp)
+        return undefined;
+    const parsed = Date.parse(timestamp);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function newestTimestampMs(...timestamps) {
+    return Math.max(...timestamps.flatMap((timestamp) => parseTimestampMs(timestamp) ?? []));
+}
+function readLastSessionTimestamp(filePath) {
+    let fd;
+    try {
+        const stat = (0, node_fs_1.statSync)(filePath);
+        const byteLength = Math.min(stat.size, maxSessionTailBytes);
+        const buffer = Buffer.alloc(byteLength);
+        fd = (0, node_fs_1.openSync)(filePath, "r");
+        (0, node_fs_1.readSync)(fd, buffer, 0, byteLength, Math.max(0, stat.size - byteLength));
+        const lines = buffer.toString("utf8").trim().split("\n").filter(Boolean);
+        for (let index = lines.length - 1; index >= 0; index -= 1) {
+            try {
+                const parsed = JSON.parse(lines[index]);
+                if (parsed.timestamp)
+                    return parsed.timestamp;
+            }
+            catch {
+                // Keep scanning in case the tail starts mid-line.
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (fd !== undefined)
+            (0, node_fs_1.closeSync)(fd);
+    }
+    return undefined;
+}
+function sessionFilesById(dirPath) {
+    const filesById = new Map();
+    function visit(currentPath) {
+        let entries;
+        try {
+            entries = (0, node_fs_1.readdirSync)(currentPath, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const entryPath = node_path_1.default.join(currentPath, entry.name);
+            if (entry.isDirectory()) {
+                visit(entryPath);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith(".jsonl"))
+                continue;
+            const match = entry.name.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
+            if (match)
+                filesById.set(match[1], entryPath);
+        }
+    }
+    visit(dirPath);
+    return filesById;
+}
+function latestCodexSessionForWorktree(worktree) {
+    const home = codexHome();
+    const indexPath = node_path_1.default.join(home, "session_index.jsonl");
+    const sessionsPath = node_path_1.default.join(home, "sessions");
+    if (!(0, node_fs_1.existsSync)(indexPath) || !(0, node_fs_1.existsSync)(sessionsPath))
+        return undefined;
+    const targetWorktree = safeRealpath(worktree);
+    const indexedSessionsById = new Map(readJsonLines(indexPath)
+        .filter((entry) => Boolean(entry.id))
+        .map((entry) => [entry.id, entry]));
+    const filesById = sessionFilesById(sessionsPath);
+    let latestSession;
+    for (const [id, filePath] of filesById.entries()) {
+        const meta = readSessionMeta(filePath);
+        if (meta?.id !== id || !meta.cwd)
+            continue;
+        const sessionWorktree = safeRealpath(meta.cwd);
+        if (!matchesWorktree(sessionWorktree, targetWorktree))
+            continue;
+        const updatedAtMs = newestTimestampMs(readLastSessionTimestamp(filePath), indexedSessionsById.get(id)?.updated_at, meta.timestamp);
+        if (!Number.isFinite(updatedAtMs))
+            continue;
+        if (!latestSession || updatedAtMs > latestSession.updatedAtMs)
+            latestSession = { id, updatedAtMs };
+    }
+    return latestSession ? { sessionId: latestSession.id, worktree: targetWorktree } : undefined;
+}
+async function readOpencodeSessionList() {
+    const { stdout } = await execFileAsync((0, macos_apps_1.opencodePath)(), ["session", "list", "--format", "json"], {
+        maxBuffer: maxOpencodeSessionListBytes,
+    });
+    const parsed = JSON.parse(stdout);
+    return Array.isArray(parsed) ? parsed : [];
+}
+async function latestOpencodeSessionIdForWorktree(worktree) {
+    const targetWorktree = safeRealpath(worktree);
+    try {
+        const latestSession = (await readOpencodeSessionList()).reduce((latest, session) => {
+            const updatedAtMs = typeof session.updated === "number" && Number.isFinite(session.updated) ? session.updated : undefined;
+            if (!session.id || !session.directory || updatedAtMs === undefined)
+                return latest;
+            const sessionWorktree = safeRealpath(session.directory);
+            if (!matchesWorktree(sessionWorktree, targetWorktree))
+                return latest;
+            const candidate = { sessionId: session.id, updatedAtMs, worktree: sessionWorktree };
+            if (!latest || candidate.updatedAtMs > latest.updatedAtMs)
+                return candidate;
+            return latest;
+        }, undefined);
+        if (latestSession) {
+            return {
+                sessionId: latestSession.sessionId,
+                worktree: latestSession.worktree,
+            };
+        }
+        return undefined;
+    }
+    catch {
+        const session = await (0, opencode_local_1.latestSessionForWorktree)(worktree).catch(() => undefined);
+        return session ? { sessionId: session.id, worktree: session.directory } : undefined;
+    }
+}
+exports.sessionResolvers = {
+    codex: latestCodexSessionForWorktree,
+    opencode: latestOpencodeSessionIdForWorktree,
+};

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

@@ -0,0 +1,22 @@
+import { type ImportedRepositoryRow } from "./import";
+export type TursoProjectSourceSettings = {
+    tursoDatabaseUrl?: string;
+    tursoAuthToken?: string;
+    cloneDirectory?: string;
+    deviceName?: string;
+    cachePath: string;
+};
+export declare function readCachedTursoProjectRows(settings: TursoProjectSourceSettings): {
+    rows: ImportedRepositoryRow[];
+    generatedAt: number;
+} | undefined;
+export declare function writeCachedTursoProjectRows(settings: TursoProjectSourceSettings, rows: ImportedRepositoryRow[]): void;
+export declare function testTursoProjectSource(settings: TursoProjectSourceSettings): Promise<void>;
+export declare function readTursoProjectRows(settings: TursoProjectSourceSettings): Promise<ImportedRepositoryRow[]>;
+export declare function upsertTursoProjectRow(settings: TursoProjectSourceSettings, row: ImportedRepositoryRow): Promise<void>;
+export declare function replaceTursoProjectUrl(settings: TursoProjectSourceSettings, previousUrl: string, row: ImportedRepositoryRow): Promise<void>;
+export declare function reconcileTursoProjectRemote(settings: TursoProjectSourceSettings, previousUrl: string, actualRemoteUrl: string): Promise<false | undefined>;
+export declare function deleteTursoProjectRow(settings: TursoProjectSourceSettings, url: string): Promise<void>;
+export declare function setTursoProjectDeviceFavorite(settings: TursoProjectSourceSettings, url: string, favorite: boolean): Promise<boolean>;
+export declare function setTursoProjectName(settings: TursoProjectSourceSettings, url: string, name: string): Promise<boolean>;
+export declare function importTursoProjectRows(settings: TursoProjectSourceSettings, rows: ImportedRepositoryRow[]): Promise<void>;