@xfey/tutti 0.1.0

package/dist/skills/zip-import.js

@@ -0,0 +1,241 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import * as yauzl from "yauzl";
+import { MAX_SKILL_DIRECTORY_DEPTH, MAX_SKILL_FILE_BYTES, MAX_SKILL_FILE_COUNT, MAX_SKILL_TOTAL_UNCOMPRESSED_BYTES, MAX_SKILL_ZIP_BYTES, SKILL_MD_FILE_NAME, } from "./constants.js";
+import { SkillServiceError } from "./errors.js";
+import { isValidSkillName, parseSkillMarkdown } from "./metadata.js";
+const ZIP_MAGIC = Buffer.from([0x50, 0x4b, 0x03, 0x04]);
+const UNIX_FILE_TYPE_MASK = 0o170000;
+const UNIX_REGULAR_FILE = 0o100000;
+const UNIX_DIRECTORY = 0o040000;
+const UNIX_SYMLINK = 0o120000;
+const INSTALL_FILE_MODE = 0o600;
+const INSTALL_EXECUTABLE_FILE_MODE = 0o700;
+export async function prepareUserSkillZipImport(options) {
+    validateZipUpload(options.zipBuffer);
+    if (!options.fileName.toLowerCase().endsWith(".zip")) {
+        throw new SkillServiceError("validation_failed", "Skill upload must be a zip file");
+    }
+    const entries = await readZipEntries(options.zipBuffer);
+    return buildImportCandidate(entries);
+}
+export function writeCandidateFiles(destinationRoot, candidate) {
+    mkdirSync(destinationRoot, { recursive: true, mode: 0o700 });
+    for (const file of candidate.files) {
+        const relativePath = candidate.rootPrefix === "" ? file.path : file.path.slice(candidate.rootPrefix.length + 1);
+        if (relativePath === "" || (relativePath === file.path && candidate.rootPrefix !== "")) {
+            throw new SkillServiceError("validation_failed", "Skill zip path is invalid");
+        }
+        const destination = join(destinationRoot, relativePath);
+        ensureInside(destinationRoot, destination);
+        mkdirSync(dirname(destination), { recursive: true, mode: 0o700 });
+        writeFileSync(destination, file.data, { mode: installModeForEntry(file.mode) });
+    }
+}
+function ensureInside(parent, child) {
+    const parentPath = resolve(parent);
+    const childPath = resolve(child);
+    if (childPath !== parentPath && !childPath.startsWith(`${parentPath}/`)) {
+        throw new SkillServiceError("validation_failed", "Skill path is invalid");
+    }
+}
+function toError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+function validateZipUpload(zipBuffer) {
+    if (zipBuffer.byteLength === 0 || zipBuffer.byteLength > MAX_SKILL_ZIP_BYTES) {
+        throw new SkillServiceError("invalid_zip", "Skill zip is invalid");
+    }
+    if (zipBuffer.subarray(0, 4).compare(ZIP_MAGIC) !== 0) {
+        throw new SkillServiceError("invalid_zip", "Skill zip is invalid");
+    }
+}
+async function readZipEntries(zipBuffer) {
+    const zipFile = await openZipFromBuffer(zipBuffer);
+    const entries = [];
+    let totalUncompressedBytes = 0;
+    try {
+        return await new Promise((resolvePromise, rejectPromise) => {
+            function reject(error) {
+                zipFile.close();
+                rejectPromise(toError(error));
+            }
+            zipFile.on("entry", (entry) => {
+                try {
+                    const metadata = validateZipEntry(entry);
+                    if (entries.length >= MAX_SKILL_FILE_COUNT) {
+                        throw new SkillServiceError("validation_failed", "Skill zip has too many files");
+                    }
+                    if (entry.uncompressedSize > MAX_SKILL_FILE_BYTES) {
+                        throw new SkillServiceError("validation_failed", "Skill file is too large");
+                    }
+                    totalUncompressedBytes += entry.uncompressedSize;
+                    if (totalUncompressedBytes > MAX_SKILL_TOTAL_UNCOMPRESSED_BYTES) {
+                        throw new SkillServiceError("validation_failed", "Skill zip is too large");
+                    }
+                    if (metadata.directory) {
+                        entries.push(metadata);
+                        zipFile.readEntry();
+                        return;
+                    }
+                    zipFile.openReadStream(entry, (error, stream) => {
+                        if (error !== null || stream === undefined) {
+                            reject(error ?? new SkillServiceError("invalid_zip", "Skill zip is invalid"));
+                            return;
+                        }
+                        collectStream(stream)
+                            .then((data) => {
+                            entries.push({ path: metadata.path, mode: metadata.mode, data });
+                            zipFile.readEntry();
+                        })
+                            .catch(reject);
+                    });
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+            zipFile.once("end", () => {
+                zipFile.close();
+                if (entries.length === 0) {
+                    rejectPromise(new SkillServiceError("invalid_zip", "Skill zip is empty"));
+                    return;
+                }
+                resolvePromise(entries);
+            });
+            zipFile.once("error", (error) => reject(error));
+            zipFile.readEntry();
+        });
+    }
+    catch (error) {
+        if (error instanceof SkillServiceError) {
+            throw error;
+        }
+        if (isYauzlPathValidationError(error)) {
+            throw new SkillServiceError("validation_failed", "Skill zip path is invalid");
+        }
+        throw new SkillServiceError("invalid_zip", "Skill zip is invalid");
+    }
+}
+function isYauzlPathValidationError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return (error.message.includes("invalid relative path") ||
+        error.message.includes("absolute path") ||
+        error.message.includes("invalid characters in fileName"));
+}
+async function openZipFromBuffer(zipBuffer) {
+    return await new Promise((resolvePromise, rejectPromise) => {
+        yauzl.fromBuffer(zipBuffer, { lazyEntries: true, validateEntrySizes: true, strictFileNames: false }, (error, zipFile) => {
+            if (error !== null || zipFile === undefined) {
+                rejectPromise(new SkillServiceError("invalid_zip", "Skill zip is invalid"));
+                return;
+            }
+            resolvePromise(zipFile);
+        });
+    });
+}
+function validateZipEntry(entry) {
+    if (entry.isEncrypted()) {
+        throw new SkillServiceError("validation_failed", "Encrypted skill zips are not supported");
+    }
+    validateZipPath(entry.fileName);
+    const path = entry.fileName.replace(/\/+$/u, "");
+    const mode = (entry.externalFileAttributes >>> 16) & 0xffff;
+    const isDirectory = entry.fileName.endsWith("/");
+    const fileType = mode & UNIX_FILE_TYPE_MASK;
+    if (fileType === UNIX_SYMLINK) {
+        throw new SkillServiceError("validation_failed", "Skill zip contains a symlink");
+    }
+    if (fileType !== 0 && fileType !== UNIX_REGULAR_FILE && fileType !== UNIX_DIRECTORY) {
+        throw new SkillServiceError("validation_failed", "Skill zip contains a special file");
+    }
+    if (!isDirectory && fileType === UNIX_DIRECTORY) {
+        throw new SkillServiceError("validation_failed", "Skill zip contains an invalid entry");
+    }
+    if (isDirectory) {
+        return { path, directory: true, mode };
+    }
+    return { path, directory: false, mode };
+}
+function validateZipPath(path) {
+    if (path.length === 0 ||
+        path.startsWith("/") ||
+        /^[A-Za-z]:[\\/]/u.test(path) ||
+        path.includes("\\") ||
+        containsControlCharacter(path)) {
+        throw new SkillServiceError("validation_failed", "Skill zip path is invalid");
+    }
+    const normalized = path.replace(/\/+$/u, "");
+    const segments = normalized.split("/");
+    if (segments.length > MAX_SKILL_DIRECTORY_DEPTH) {
+        throw new SkillServiceError("validation_failed", "Skill zip path is too deep");
+    }
+    for (const segment of segments) {
+        if (segment === "" || segment === "." || segment === "..") {
+            throw new SkillServiceError("validation_failed", "Skill zip path is invalid");
+        }
+    }
+}
+function containsControlCharacter(value) {
+    for (const character of value) {
+        const codePoint = character.codePointAt(0);
+        if (codePoint !== undefined && (codePoint <= 0x1f || codePoint === 0x7f)) {
+            return true;
+        }
+    }
+    return false;
+}
+async function collectStream(stream) {
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+}
+function installModeForEntry(mode) {
+    return (mode & 0o111) === 0 ? INSTALL_FILE_MODE : INSTALL_EXECUTABLE_FILE_MODE;
+}
+function buildImportCandidate(entries) {
+    const files = entries.filter((entry) => !("directory" in entry));
+    if (files.length === 0) {
+        throw new SkillServiceError("invalid_zip", "Skill zip is empty");
+    }
+    const rootSkill = files.find((entry) => entry.path === SKILL_MD_FILE_NAME);
+    const rootPrefix = rootSkill === undefined ? inferSingleRoot(files.map((entry) => entry.path)) : "";
+    const skillPath = rootPrefix === "" ? SKILL_MD_FILE_NAME : `${rootPrefix}/${SKILL_MD_FILE_NAME}`;
+    const skillMd = files.find((entry) => entry.path === skillPath);
+    if (skillMd === undefined) {
+        throw new SkillServiceError("validation_failed", "SKILL.md is missing");
+    }
+    const metadata = parseSkillMarkdown(skillMd.data.toString("utf8"));
+    if (rootPrefix !== "" && rootPrefix !== metadata.name) {
+        throw new SkillServiceError("validation_failed", "Skill root does not match skill name");
+    }
+    return {
+        skillName: metadata.name,
+        rootPrefix,
+        files,
+        metadata,
+    };
+}
+function inferSingleRoot(paths) {
+    const roots = new Set();
+    for (const path of paths) {
+        const [root] = path.split("/");
+        if (root === undefined || root === SKILL_MD_FILE_NAME) {
+            throw new SkillServiceError("validation_failed", "Skill zip root is invalid");
+        }
+        roots.add(root);
+    }
+    if (roots.size !== 1) {
+        throw new SkillServiceError("validation_failed", "Skill zip must contain one skill root");
+    }
+    const [root] = [...roots];
+    if (root === undefined || !isValidSkillName(root)) {
+        throw new SkillServiceError("validation_failed", "Skill root is invalid");
+    }
+    return root;
+}
+//# sourceMappingURL=zip-import.js.map

package/dist/store/command-recovery.d.ts

@@ -0,0 +1,26 @@
+import type { SqliteDatabase } from "./sqlite.js";
+export type InProgressCommandIdempotencyRecord = {
+    command_id: string;
+    command_name: string;
+    target_ref: string | null;
+    request_hash: string;
+    updated_at: string;
+};
+export type CommandRecoveryResolution = {
+    status: "completed" | "failed";
+    disposition: unknown;
+};
+export type CommandRecoveryResolver = (db: SqliteDatabase, record: InProgressCommandIdempotencyRecord) => CommandRecoveryResolution | null;
+export type CommandRecoveryScanResult = {
+    total_count: number;
+    completed_count: number;
+    failed_count: number;
+    interrupted_count: number;
+};
+export declare function readInProgressCommandIdempotencyRecords(db: SqliteDatabase): InProgressCommandIdempotencyRecord[];
+export declare function finalizeCommandIdempotencyRecordAsInterrupted(db: SqliteDatabase, commandId: string, now?: () => Date): boolean;
+export declare function recoverInProgressCommandIdempotencyRecords(db: SqliteDatabase, input?: {
+    resolve?: CommandRecoveryResolver;
+    now?: () => Date;
+}): CommandRecoveryScanResult;
+//# sourceMappingURL=command-recovery.d.ts.map

package/dist/store/command-recovery.js

@@ -0,0 +1,71 @@
+import { createInterruptedCommandDisposition, redactCommandDisposition, } from "@tutti/shared/utils/command-idempotency";
+export function readInProgressCommandIdempotencyRecords(db) {
+    return db
+        .prepare(`
+        SELECT command_id, command_name, target_ref, request_hash, updated_at
+        FROM command_idempotency_records
+        WHERE status = 'in_progress'
+        ORDER BY updated_at ASC, command_name ASC, command_id ASC
+      `)
+        .all();
+}
+function finalizeCommandIdempotencyRecord(options) {
+    const completedAt = options.now().toISOString();
+    const dispositionJson = JSON.stringify(redactCommandDisposition(options.disposition));
+    const result = options.db
+        .prepare(`
+        UPDATE command_idempotency_records
+        SET status = ?,
+            disposition_json = ?,
+            updated_at = ?,
+            completed_at = ?
+        WHERE command_id = ?
+          AND status = 'in_progress'
+      `)
+        .run(options.status, dispositionJson, completedAt, completedAt, options.commandId);
+    return result.changes > 0;
+}
+export function finalizeCommandIdempotencyRecordAsInterrupted(db, commandId, now = () => new Date()) {
+    return finalizeCommandIdempotencyRecord({
+        db,
+        commandId,
+        status: "failed",
+        disposition: createInterruptedCommandDisposition(),
+        now,
+    });
+}
+export function recoverInProgressCommandIdempotencyRecords(db, input = {}) {
+    const records = readInProgressCommandIdempotencyRecords(db);
+    const now = input.now ?? (() => new Date());
+    const result = {
+        total_count: records.length,
+        completed_count: 0,
+        failed_count: 0,
+        interrupted_count: 0,
+    };
+    for (const record of records) {
+        const resolution = input.resolve?.(db, record) ?? null;
+        if (resolution !== null) {
+            if (finalizeCommandIdempotencyRecord({
+                db,
+                commandId: record.command_id,
+                status: resolution.status,
+                disposition: resolution.disposition,
+                now,
+            })) {
+                if (resolution.status === "completed") {
+                    result.completed_count += 1;
+                }
+                else {
+                    result.failed_count += 1;
+                }
+            }
+            continue;
+        }
+        if (finalizeCommandIdempotencyRecordAsInterrupted(db, record.command_id, now)) {
+            result.interrupted_count += 1;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=command-recovery.js.map

package/dist/store/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./command-recovery.js";
+export * from "./lifecycle.js";
+export * from "./metadata.js";
+export * from "./migrations.js";
+export * from "./sqlite.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/store/index.js

@@ -0,0 +1,6 @@
+export * from "./command-recovery.js";
+export * from "./lifecycle.js";
+export * from "./metadata.js";
+export * from "./migrations.js";
+export * from "./sqlite.js";
+//# sourceMappingURL=index.js.map

package/dist/store/lifecycle.d.ts

@@ -0,0 +1,23 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import { type CommandRecoveryResolver, type CommandRecoveryScanResult } from "./command-recovery.js";
+import { type HostStoreMetadata } from "./metadata.js";
+import { type AppliedStoreMigration } from "./migrations.js";
+import { type SqliteDatabase } from "./sqlite.js";
+export type HostProjectStore = {
+    db: SqliteDatabase;
+    database_path: string;
+    metadata: HostStoreMetadata;
+    applied_migrations: AppliedStoreMigration[];
+    command_recovery: CommandRecoveryScanResult;
+    interrupted_command_count: number;
+    close: () => void;
+};
+export type OpenHostProjectStoreOptions = {
+    localStoreRoot: string;
+    projectId: ProjectId;
+    migrationsDirectory?: string;
+    commandRecoveryResolver?: CommandRecoveryResolver;
+    now?: () => Date;
+};
+export declare function openHostProjectStore(options: OpenHostProjectStoreOptions): HostProjectStore;
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/store/lifecycle.js

@@ -0,0 +1,53 @@
+import { mkdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { join } from "node:path";
+import { recoverInProgressCommandIdempotencyRecords, } from "./command-recovery.js";
+import { initializeHostStoreMetadata } from "./metadata.js";
+import { applyStoreMigrations, loadStoreMigrations, } from "./migrations.js";
+import { openHostProjectDatabase } from "./sqlite.js";
+const defaultMigrationsDirectory = fileURLToPath(new URL("../../migrations", import.meta.url));
+function ensureLocalStoreRoot(localStoreRoot) {
+    mkdirSync(localStoreRoot, { recursive: true, mode: 0o700 });
+}
+export function openHostProjectStore(options) {
+    const now = options.now ?? (() => new Date());
+    const migrationsDirectory = options.migrationsDirectory ?? defaultMigrationsDirectory;
+    ensureLocalStoreRoot(options.localStoreRoot);
+    const databasePath = join(options.localStoreRoot, "tutti.sqlite");
+    const db = openHostProjectDatabase({ databasePath });
+    let opened = true;
+    try {
+        const appliedMigrations = applyStoreMigrations(db, loadStoreMigrations(migrationsDirectory), now);
+        const metadata = initializeHostStoreMetadata(db, {
+            projectId: options.projectId,
+            now,
+        });
+        const commandRecovery = recoverInProgressCommandIdempotencyRecords(db, {
+            ...(options.commandRecoveryResolver === undefined
+                ? {}
+                : { resolve: options.commandRecoveryResolver }),
+            now,
+        });
+        return {
+            db,
+            database_path: databasePath,
+            metadata,
+            applied_migrations: appliedMigrations,
+            command_recovery: commandRecovery,
+            interrupted_command_count: commandRecovery.interrupted_count,
+            close: () => {
+                if (!opened) {
+                    return;
+                }
+                opened = false;
+                db.close();
+            },
+        };
+    }
+    catch (error) {
+        db.close();
+        opened = false;
+        throw error;
+    }
+}
+//# sourceMappingURL=lifecycle.js.map

package/dist/store/metadata.d.ts

@@ -0,0 +1,18 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import type { SqliteDatabase } from "./sqlite.js";
+export type HostStoreMetadata = {
+    project_id: ProjectId;
+    schema_version: number;
+    created_at: string;
+    updated_at: string;
+};
+export type InitializeHostStoreMetadataOptions = {
+    projectId: ProjectId;
+    schemaVersion?: number;
+    now?: () => Date;
+};
+export declare class HostStoreMetadataMismatchError extends Error {
+    constructor(expectedProjectId: ProjectId, actualProjectId: string);
+}
+export declare function initializeHostStoreMetadata(db: SqliteDatabase, options: InitializeHostStoreMetadataOptions): HostStoreMetadata;
+//# sourceMappingURL=metadata.d.ts.map

package/dist/store/metadata.js

@@ -0,0 +1,30 @@
+export class HostStoreMetadataMismatchError extends Error {
+    constructor(expectedProjectId, actualProjectId) {
+        super(`Host store metadata project_id mismatch: expected ${expectedProjectId}, got ${actualProjectId}`);
+        this.name = "HostStoreMetadataMismatchError";
+    }
+}
+export function initializeHostStoreMetadata(db, options) {
+    const schemaVersion = options.schemaVersion ?? 1;
+    const now = (options.now ?? (() => new Date()))().toISOString();
+    const existing = db
+        .prepare("SELECT project_id, schema_version, created_at, updated_at FROM store_metadata WHERE id = 'current'")
+        .get();
+    if (existing !== undefined) {
+        if (existing.project_id !== options.projectId) {
+            throw new HostStoreMetadataMismatchError(options.projectId, existing.project_id);
+        }
+        return existing;
+    }
+    db.prepare(`
+      INSERT INTO store_metadata (id, project_id, schema_version, created_at, updated_at)
+      VALUES ('current', ?, ?, ?, ?)
+    `).run(options.projectId, schemaVersion, now, now);
+    return {
+        project_id: options.projectId,
+        schema_version: schemaVersion,
+        created_at: now,
+        updated_at: now,
+    };
+}
+//# sourceMappingURL=metadata.js.map

package/dist/store/migrations.d.ts

@@ -0,0 +1,20 @@
+import type { SqliteDatabase } from "./sqlite.js";
+export type StoreMigration = {
+    version: string;
+    filename: string;
+    sql: string;
+    checksum: string;
+};
+export type AppliedStoreMigration = {
+    version: string;
+    checksum: string;
+    applied_at: string;
+};
+export declare class StoreMigrationChecksumMismatchError extends Error {
+    constructor(version: string);
+}
+export declare function createMigrationChecksum(sql: string): string;
+export declare function migrationVersionFromFilename(filename: string): string;
+export declare function loadStoreMigrations(migrationsDirectory: string): StoreMigration[];
+export declare function applyStoreMigrations(db: SqliteDatabase, migrations: readonly StoreMigration[], now?: () => Date): AppliedStoreMigration[];
+//# sourceMappingURL=migrations.d.ts.map

package/dist/store/migrations.js

@@ -0,0 +1,76 @@
+import { createHash } from "node:crypto";
+import { readdirSync, readFileSync } from "node:fs";
+import { basename, join } from "node:path";
+const MIGRATION_FILENAME_PATTERN = /^\d{4}_[a-z0-9_]+\.sql$/u;
+export class StoreMigrationChecksumMismatchError extends Error {
+    constructor(version) {
+        super(`Migration ${version} checksum does not match recorded schema_migrations row`);
+        this.name = "StoreMigrationChecksumMismatchError";
+    }
+}
+export function createMigrationChecksum(sql) {
+    return `sha256:${createHash("sha256").update(sql, "utf8").digest("hex")}`;
+}
+export function migrationVersionFromFilename(filename) {
+    if (!MIGRATION_FILENAME_PATTERN.test(filename)) {
+        throw new Error(`Invalid migration filename: ${filename}`);
+    }
+    return basename(filename, ".sql");
+}
+export function loadStoreMigrations(migrationsDirectory) {
+    return readdirSync(migrationsDirectory)
+        .filter((filename) => MIGRATION_FILENAME_PATTERN.test(filename))
+        .sort()
+        .map((filename) => {
+        const sql = readFileSync(join(migrationsDirectory, filename), "utf8");
+        return {
+            version: migrationVersionFromFilename(filename),
+            filename,
+            sql,
+            checksum: createMigrationChecksum(sql),
+        };
+    });
+}
+function ensureSchemaMigrationsTable(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+      version TEXT PRIMARY KEY,
+      checksum TEXT NOT NULL,
+      applied_at TEXT NOT NULL
+    );
+  `);
+}
+function readAppliedMigrationRows(db) {
+    const rows = db
+        .prepare("SELECT version, checksum FROM schema_migrations")
+        .all();
+    return new Map(rows.map((row) => [row.version, row]));
+}
+export function applyStoreMigrations(db, migrations, now = () => new Date()) {
+    ensureSchemaMigrationsTable(db);
+    const appliedRows = readAppliedMigrationRows(db);
+    const appliedMigrations = [];
+    const insertMigration = db.prepare("INSERT INTO schema_migrations (version, checksum, applied_at) VALUES (?, ?, ?)");
+    const applyMigration = db.transaction((migration, appliedAt) => {
+        db.exec(migration.sql);
+        insertMigration.run(migration.version, migration.checksum, appliedAt);
+    });
+    for (const migration of migrations) {
+        const applied = appliedRows.get(migration.version);
+        if (applied !== undefined) {
+            if (applied.checksum !== migration.checksum) {
+                throw new StoreMigrationChecksumMismatchError(migration.version);
+            }
+            continue;
+        }
+        const appliedAt = now().toISOString();
+        applyMigration(migration, appliedAt);
+        appliedMigrations.push({
+            version: migration.version,
+            checksum: migration.checksum,
+            applied_at: appliedAt,
+        });
+    }
+    return appliedMigrations;
+}
+//# sourceMappingURL=migrations.js.map

package/dist/store/sqlite.d.ts

@@ -0,0 +1,11 @@
+import type { Database as BetterSqlite3Database, Options as BetterSqlite3Options } from "better-sqlite3";
+export type SqliteDatabase = BetterSqlite3Database;
+export type SqliteOpenOptions = BetterSqlite3Options;
+export type OpenHostProjectDatabaseOptions = {
+    databasePath: string;
+    readonly?: boolean;
+};
+export declare function initializeSqliteConnection(db: SqliteDatabase): void;
+export declare function openHostProjectDatabase(options: OpenHostProjectDatabaseOptions): SqliteDatabase;
+export declare function withHostStoreTransaction<T>(db: SqliteDatabase, operation: (tx: SqliteDatabase) => T): T;
+//# sourceMappingURL=sqlite.d.ts.map

package/dist/store/sqlite.js

@@ -0,0 +1,21 @@
+import { createRequire } from "node:module";
+const loadNativeModule = createRequire(import.meta.url);
+const Database = loadNativeModule("better-sqlite3");
+export function initializeSqliteConnection(db) {
+    db.pragma("foreign_keys = ON");
+    db.pragma("journal_mode = WAL");
+    db.pragma("busy_timeout = 5000");
+}
+export function openHostProjectDatabase(options) {
+    const openOptions = {};
+    if (options.readonly !== undefined) {
+        openOptions.readonly = options.readonly;
+    }
+    const db = new Database(options.databasePath, openOptions);
+    initializeSqliteConnection(db);
+    return db;
+}
+export function withHostStoreTransaction(db, operation) {
+    return db.transaction(() => operation(db))();
+}
+//# sourceMappingURL=sqlite.js.map

package/dist/workspace-ops/constants.d.ts

@@ -0,0 +1,15 @@
+export declare const WORKSPACE_OPS_MAINLINE_BRANCH: "tutti/mainline";
+export declare const DEFAULT_VIEWER_MAX_BYTES = 204800;
+export declare const MAX_VIEWER_MAX_BYTES = 1048576;
+export declare const VIEWER_HARD_READ_LIMIT_BYTES: number;
+export declare const REFERENCE_DIRECTORY_PATH: "docs/reference";
+export declare const REFERENCE_FILES_DIRECTORY_PATH: "docs/reference/files";
+export declare const REFERENCE_IMAGES_DIRECTORY_PATH: "docs/reference/images";
+export declare const REFERENCE_INDEX_PATH: "docs/reference/README.md";
+export declare const MAX_REFERENCE_UPLOAD_BYTES: number;
+export declare const VIEWER_ASSET_READ_LIMIT_BYTES: number;
+export declare const REFERENCE_IMAGE_ASSET_CACHE_VERSION: "reference-image-v1";
+export declare const REFERENCE_IMAGE_THUMBNAIL_MAX_EDGE_PX = 512;
+export declare const REFERENCE_IMAGE_PREVIEW_MAX_EDGE_PX = 1440;
+export declare const PROJECT_DOC_PATHS: readonly ["product.md", "tech.md", "structure.md", "architecture-principles.md"];
+//# sourceMappingURL=constants.d.ts.map

package/dist/workspace-ops/constants.js

@@ -0,0 +1,20 @@
+export const WORKSPACE_OPS_MAINLINE_BRANCH = "tutti/mainline";
+export const DEFAULT_VIEWER_MAX_BYTES = 204_800;
+export const MAX_VIEWER_MAX_BYTES = 1_048_576;
+export const VIEWER_HARD_READ_LIMIT_BYTES = 5 * 1024 * 1024;
+export const REFERENCE_DIRECTORY_PATH = "docs/reference";
+export const REFERENCE_FILES_DIRECTORY_PATH = "docs/reference/files";
+export const REFERENCE_IMAGES_DIRECTORY_PATH = "docs/reference/images";
+export const REFERENCE_INDEX_PATH = "docs/reference/README.md";
+export const MAX_REFERENCE_UPLOAD_BYTES = 10 * 1024 * 1024;
+export const VIEWER_ASSET_READ_LIMIT_BYTES = MAX_REFERENCE_UPLOAD_BYTES;
+export const REFERENCE_IMAGE_ASSET_CACHE_VERSION = "reference-image-v1";
+export const REFERENCE_IMAGE_THUMBNAIL_MAX_EDGE_PX = 512;
+export const REFERENCE_IMAGE_PREVIEW_MAX_EDGE_PX = 1440;
+export const PROJECT_DOC_PATHS = [
+    "product.md",
+    "tech.md",
+    "structure.md",
+    "architecture-principles.md",
+];
+//# sourceMappingURL=constants.js.map

package/dist/workspace-ops/errors.d.ts

@@ -0,0 +1,8 @@
+export type WorkspaceOpsErrorCode = "bad_request" | "forbidden" | "not_found" | "conflict" | "validation_failed" | "repo_snapshot_unavailable" | "git_failed";
+export declare class WorkspaceOpsError extends Error {
+    readonly code: WorkspaceOpsErrorCode;
+    readonly statusCode: number;
+    readonly details?: unknown;
+    constructor(code: WorkspaceOpsErrorCode, message: string, details?: unknown);
+}
+//# sourceMappingURL=errors.d.ts.map