@agent-native/core 0.46.0 → 0.48.1

package/dist/workspace-files/schema.d.ts

@@ -0,0 +1,195 @@
+/**
+ * SQL schema for workspace_files — durable scratch storage for the agent.
+ *
+ * Files are scoped to either a user (scope="user", scope_id=email) or a
+ * workspace / org (scope="org", scope_id=orgId), mirroring the secrets table
+ * pattern. Paths are unique per scope+scope_id pair and may include path
+ * separators (e.g. "analysis/2026-q2/step1.md").
+ *
+ * Size limits:
+ *   - Per-file content: 2 MB (enforced in the store layer).
+ *   - Per-scope total: 200 MB (enforced in the store layer).
+ */
+export declare const workspaceFiles: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "workspace_files";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "workspace_files";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        scope: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "scope";
+            tableName: "workspace_files";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        scopeId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "scope_id";
+            tableName: "workspace_files";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        path: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "path";
+            tableName: "workspace_files";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        content: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "content";
+            tableName: "workspace_files";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        contentType: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "content_type";
+            tableName: "workspace_files";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        sizeBytes: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "size_bytes";
+            tableName: "workspace_files";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "workspace_files";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "workspace_files";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+/**
+ * Raw CREATE TABLE SQL used by the on-demand migration path.
+ * Written for SQLite; the migration runner adapts it for Postgres.
+ */
+export declare const WORKSPACE_FILES_CREATE_SQL = "CREATE TABLE IF NOT EXISTS workspace_files (\n  id TEXT PRIMARY KEY,\n  scope TEXT NOT NULL,\n  scope_id TEXT NOT NULL,\n  path TEXT NOT NULL,\n  content TEXT NOT NULL DEFAULT '',\n  content_type TEXT NOT NULL DEFAULT 'text/plain',\n  size_bytes INTEGER NOT NULL DEFAULT 0,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  UNIQUE(scope, scope_id, path)\n)";
+export declare const WORKSPACE_FILES_INDEX_SQL = "CREATE INDEX IF NOT EXISTS workspace_files_scope_idx ON workspace_files (scope, scope_id, updated_at)";
+//# sourceMappingURL=schema.d.ts.map

package/dist/workspace-files/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/workspace-files/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBzB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,0BAA0B,oXAWrC,CAAC;AAEH,eAAO,MAAM,yBAAyB,0GAA0G,CAAC"}

package/dist/workspace-files/schema.js

@@ -0,0 +1,48 @@
+/**
+ * SQL schema for workspace_files — durable scratch storage for the agent.
+ *
+ * Files are scoped to either a user (scope="user", scope_id=email) or a
+ * workspace / org (scope="org", scope_id=orgId), mirroring the secrets table
+ * pattern. Paths are unique per scope+scope_id pair and may include path
+ * separators (e.g. "analysis/2026-q2/step1.md").
+ *
+ * Size limits:
+ *   - Per-file content: 2 MB (enforced in the store layer).
+ *   - Per-scope total: 200 MB (enforced in the store layer).
+ */
+import { table, text, integer } from "../db/schema.js";
+export const workspaceFiles = table("workspace_files", {
+    id: text("id").primaryKey(),
+    /** "user" or "org" */
+    scope: text("scope").notNull(),
+    /** Email for user-scope; orgId for org-scope. */
+    scopeId: text("scope_id").notNull(),
+    /** Relative path within the scope, e.g. "memos/q2.md". Unique per scope+scopeId. */
+    path: text("path").notNull(),
+    /** File content (text). */
+    content: text("content").notNull().default(""),
+    /** MIME type, e.g. "text/plain", "application/json". */
+    contentType: text("content_type").notNull().default("text/plain"),
+    /** Byte length of content (utf-8). */
+    sizeBytes: integer("size_bytes").notNull().default(0),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+});
+/**
+ * Raw CREATE TABLE SQL used by the on-demand migration path.
+ * Written for SQLite; the migration runner adapts it for Postgres.
+ */
+export const WORKSPACE_FILES_CREATE_SQL = `CREATE TABLE IF NOT EXISTS workspace_files (
+  id TEXT PRIMARY KEY,
+  scope TEXT NOT NULL,
+  scope_id TEXT NOT NULL,
+  path TEXT NOT NULL,
+  content TEXT NOT NULL DEFAULT '',
+  content_type TEXT NOT NULL DEFAULT 'text/plain',
+  size_bytes INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  UNIQUE(scope, scope_id, path)
+)`;
+export const WORKSPACE_FILES_INDEX_SQL = `CREATE INDEX IF NOT EXISTS workspace_files_scope_idx ON workspace_files (scope, scope_id, updated_at)`;
+//# sourceMappingURL=schema.js.map

package/dist/workspace-files/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/workspace-files/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAEvD,MAAM,CAAC,MAAM,cAAc,GAAG,KAAK,CAAC,iBAAiB,EAAE;IACrD,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE;IAC3B,sBAAsB;IACtB,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE;IAC9B,iDAAiD;IACjD,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,OAAO,EAAE;IACnC,oFAAoF;IACpF,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE;IAC5B,2BAA2B;IAC3B,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;IAC9C,wDAAwD;IACxD,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,YAAY,CAAC;IACjE,sCAAsC;IACtC,SAAS,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IACrD,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,OAAO,EAAE;IACvC,SAAS,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,OAAO,EAAE;CACxC,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG;;;;;;;;;;;EAWxC,CAAC;AAEH,MAAM,CAAC,MAAM,yBAAyB,GAAG,uGAAuG,CAAC","sourcesContent":["/**\n * SQL schema for workspace_files — durable scratch storage for the agent.\n *\n * Files are scoped to either a user (scope=\"user\", scope_id=email) or a\n * workspace / org (scope=\"org\", scope_id=orgId), mirroring the secrets table\n * pattern. Paths are unique per scope+scope_id pair and may include path\n * separators (e.g. \"analysis/2026-q2/step1.md\").\n *\n * Size limits:\n *   - Per-file content: 2 MB (enforced in the store layer).\n *   - Per-scope total: 200 MB (enforced in the store layer).\n */\n\nimport { table, text, integer } from \"../db/schema.js\";\n\nexport const workspaceFiles = table(\"workspace_files\", {\n  id: text(\"id\").primaryKey(),\n  /** \"user\" or \"org\" */\n  scope: text(\"scope\").notNull(),\n  /** Email for user-scope; orgId for org-scope. */\n  scopeId: text(\"scope_id\").notNull(),\n  /** Relative path within the scope, e.g. \"memos/q2.md\". Unique per scope+scopeId. */\n  path: text(\"path\").notNull(),\n  /** File content (text). */\n  content: text(\"content\").notNull().default(\"\"),\n  /** MIME type, e.g. \"text/plain\", \"application/json\". */\n  contentType: text(\"content_type\").notNull().default(\"text/plain\"),\n  /** Byte length of content (utf-8). */\n  sizeBytes: integer(\"size_bytes\").notNull().default(0),\n  createdAt: text(\"created_at\").notNull(),\n  updatedAt: text(\"updated_at\").notNull(),\n});\n\n/**\n * Raw CREATE TABLE SQL used by the on-demand migration path.\n * Written for SQLite; the migration runner adapts it for Postgres.\n */\nexport const WORKSPACE_FILES_CREATE_SQL = `CREATE TABLE IF NOT EXISTS workspace_files (\n  id TEXT PRIMARY KEY,\n  scope TEXT NOT NULL,\n  scope_id TEXT NOT NULL,\n  path TEXT NOT NULL,\n  content TEXT NOT NULL DEFAULT '',\n  content_type TEXT NOT NULL DEFAULT 'text/plain',\n  size_bytes INTEGER NOT NULL DEFAULT 0,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL,\n  UNIQUE(scope, scope_id, path)\n)`;\n\nexport const WORKSPACE_FILES_INDEX_SQL = `CREATE INDEX IF NOT EXISTS workspace_files_scope_idx ON workspace_files (scope, scope_id, updated_at)`;\n"]}

package/dist/workspace-files/store.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Workspace-files store.
+ *
+ * Provides read/write/append/list/delete/grep operations over the
+ * `workspace_files` table. All writes enforce per-file (2 MB) and per-scope
+ * (200 MB) caps. The table is lazily migrated on first use.
+ */
+/** Max content size per file (bytes). */
+export declare const MAX_FILE_BYTES: number;
+/** Max total content size across all files in one scope (bytes). */
+export declare const MAX_SCOPE_BYTES: number;
+/** Max content size when saving via saveToFile from provider-api / fetch tool (bytes). */
+export declare const SAVE_TO_FILE_MAX_BYTES: number;
+export interface WorkspaceFilesScope {
+    scope: "user" | "org";
+    scopeId: string;
+}
+/**
+ * Validate a workspace file path.
+ * - Non-empty, no leading slash, no ".." components, no null bytes.
+ */
+export declare function validatePath(path: string): string | null;
+export interface WorkspaceFile {
+    id: string;
+    scope: string;
+    scopeId: string;
+    path: string;
+    content: string;
+    contentType: string;
+    sizeBytes: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface WorkspaceFileMeta {
+    id: string;
+    path: string;
+    contentType: string;
+    sizeBytes: number;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Write (create or overwrite) a workspace file.
+ * Enforces per-file (2 MB default; `saveToFile` callers may raise it up to
+ * 20 MB via `opts.maxFileBytes`) and per-scope (200 MB) caps.
+ */
+export declare function writeWorkspaceFile(scope: WorkspaceFilesScope, path: string, content: string, contentType?: string, opts?: {
+    maxFileBytes?: number;
+}): Promise<WorkspaceFileMeta>;
+/**
+ * Append text to an existing workspace file, or create it if it doesn't exist.
+ */
+export declare function appendWorkspaceFile(scope: WorkspaceFilesScope, path: string, text: string, contentType?: string): Promise<WorkspaceFileMeta>;
+/**
+ * Read a workspace file's content (with optional offset and maxChars for paging).
+ * Returns null if the file doesn't exist.
+ */
+export declare function readWorkspaceFile(scope: WorkspaceFilesScope, path: string, opts?: {
+    offset?: number;
+    maxChars?: number;
+}): Promise<WorkspaceFile | null>;
+/**
+ * Get file metadata without loading content.
+ */
+export declare function getWorkspaceFileMeta(scope: WorkspaceFilesScope, path: string): Promise<WorkspaceFileMeta | null>;
+/**
+ * List workspace files, optionally filtered by path prefix.
+ * Returns metadata only (no content).
+ */
+export declare function listWorkspaceFiles(scope: WorkspaceFilesScope, prefix?: string): Promise<WorkspaceFileMeta[]>;
+/**
+ * Delete a workspace file. Returns true if deleted, false if not found.
+ */
+export declare function deleteWorkspaceFile(scope: WorkspaceFilesScope, path: string): Promise<boolean>;
+/**
+ * Search file contents for a substring or regex pattern.
+ * Returns matching lines with path context.
+ */
+export declare function grepWorkspaceFiles(scope: WorkspaceFilesScope, pattern: string, opts?: {
+    pathPrefix?: string;
+    useRegex?: boolean;
+    maxMatchesPerFile?: number;
+    maxFiles?: number;
+}): Promise<Array<{
+    path: string;
+    lineNumber: number;
+    line: string;
+}>>;
+//# sourceMappingURL=store.d.ts.map

package/dist/workspace-files/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/workspace-files/store.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAaH,yCAAyC;AACzC,eAAO,MAAM,cAAc,QAAkB,CAAC;AAE9C,oEAAoE;AACpE,eAAO,MAAM,eAAe,QAAoB,CAAC;AAEjD,0FAA0F;AAC1F,eAAO,MAAM,sBAAsB,QAAmB,CAAC;AAoBvD,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAWxD;AAMD,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAMD;;;;GAIG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,mBAAmB,EAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,WAAW,SAAe,EAC1B,IAAI,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/B,OAAO,CAAC,iBAAiB,CAAC,CA4E5B;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,mBAAmB,EAC1B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,WAAW,SAAe,GACzB,OAAO,CAAC,iBAAiB,CAAC,CAQ5B;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,mBAAmB,EAC1B,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5C,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAkC/B;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,mBAAmB,EAC1B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAmBnC;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,mBAAmB,EAC1B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,iBAAiB,EAAE,CAAC,CA+B9B;AAED;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,mBAAmB,EAC1B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,CAAC,CAWlB;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,mBAAmB,EAC1B,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE;IACL,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GACA,OAAO,CAAC,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CA+BpE"}

package/dist/workspace-files/store.js

@@ -0,0 +1,298 @@
+/**
+ * Workspace-files store.
+ *
+ * Provides read/write/append/list/delete/grep operations over the
+ * `workspace_files` table. All writes enforce per-file (2 MB) and per-scope
+ * (200 MB) caps. The table is lazily migrated on first use.
+ */
+import crypto from "node:crypto";
+import { getDbExec } from "../db/client.js";
+import { WORKSPACE_FILES_CREATE_SQL, WORKSPACE_FILES_INDEX_SQL, } from "./schema.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** Max content size per file (bytes). */
+export const MAX_FILE_BYTES = 2 * 1024 * 1024; // 2 MB
+/** Max total content size across all files in one scope (bytes). */
+export const MAX_SCOPE_BYTES = 200 * 1024 * 1024; // 200 MB
+/** Max content size when saving via saveToFile from provider-api / fetch tool (bytes). */
+export const SAVE_TO_FILE_MAX_BYTES = 20 * 1024 * 1024; // 20 MB
+// ---------------------------------------------------------------------------
+// Lazy table init
+// ---------------------------------------------------------------------------
+let _tableReady = false;
+async function ensureTable() {
+    if (_tableReady)
+        return;
+    const db = getDbExec();
+    await db.execute(WORKSPACE_FILES_CREATE_SQL);
+    await db.execute(WORKSPACE_FILES_INDEX_SQL);
+    _tableReady = true;
+}
+/**
+ * Validate a workspace file path.
+ * - Non-empty, no leading slash, no ".." components, no null bytes.
+ */
+export function validatePath(path) {
+    if (!path || typeof path !== "string")
+        return "path is required";
+    if (path.startsWith("/"))
+        return 'path must not start with "/"';
+    if (path.includes("\0"))
+        return "path must not contain null bytes";
+    const parts = path.split("/");
+    for (const part of parts) {
+        if (part === "..")
+            return 'path must not contain ".." components';
+        if (part === "")
+            return 'path must not contain empty segments ("//" or trailing "/")';
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Store operations
+// ---------------------------------------------------------------------------
+/**
+ * Write (create or overwrite) a workspace file.
+ * Enforces per-file (2 MB default; `saveToFile` callers may raise it up to
+ * 20 MB via `opts.maxFileBytes`) and per-scope (200 MB) caps.
+ */
+export async function writeWorkspaceFile(scope, path, content, contentType = "text/plain", opts) {
+    const pathErr = validatePath(path);
+    if (pathErr)
+        throw new Error(`Invalid path: ${pathErr}`);
+    const maxFileBytes = Math.min(opts?.maxFileBytes ?? MAX_FILE_BYTES, SAVE_TO_FILE_MAX_BYTES);
+    const bytes = Buffer.byteLength(content, "utf8");
+    if (bytes > maxFileBytes) {
+        throw new Error(`File "${path}" would be ${(bytes / 1024 / 1024).toFixed(2)} MB, which exceeds the ${(maxFileBytes / 1024 / 1024).toFixed(0)} MB per-file limit.`);
+    }
+    await ensureTable();
+    const db = getDbExec();
+    // Check scope total (excluding current file's existing bytes).
+    const existing = await getWorkspaceFileMeta(scope, path);
+    const existingBytes = existing?.sizeBytes ?? 0;
+    const scopeTotal = await getScopeTotalBytes(scope);
+    const newTotal = scopeTotal - existingBytes + bytes;
+    if (newTotal > MAX_SCOPE_BYTES) {
+        throw new Error(`Writing "${path}" would bring the workspace total to ${(newTotal / 1024 / 1024).toFixed(1)} MB, exceeding the 200 MB limit.`);
+    }
+    const now = new Date().toISOString();
+    if (existing) {
+        await db.execute({
+            sql: `UPDATE workspace_files SET content = ?, content_type = ?, size_bytes = ?, updated_at = ? WHERE scope = ? AND scope_id = ? AND path = ?`,
+            args: [
+                content,
+                contentType,
+                bytes,
+                now,
+                scope.scope,
+                scope.scopeId,
+                path,
+            ],
+        });
+        return {
+            ...existing,
+            content: undefined,
+            contentType,
+            sizeBytes: bytes,
+            updatedAt: now,
+        };
+    }
+    const id = crypto.randomUUID();
+    await db.execute({
+        sql: `INSERT INTO workspace_files (id, scope, scope_id, path, content, content_type, size_bytes, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: [
+            id,
+            scope.scope,
+            scope.scopeId,
+            path,
+            content,
+            contentType,
+            bytes,
+            now,
+            now,
+        ],
+    });
+    return {
+        id,
+        path,
+        contentType,
+        sizeBytes: bytes,
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+/**
+ * Append text to an existing workspace file, or create it if it doesn't exist.
+ */
+export async function appendWorkspaceFile(scope, path, text, contentType = "text/plain") {
+    const pathErr = validatePath(path);
+    if (pathErr)
+        throw new Error(`Invalid path: ${pathErr}`);
+    await ensureTable();
+    const existing = await readWorkspaceFile(scope, path);
+    const newContent = existing ? existing.content + text : text;
+    return writeWorkspaceFile(scope, path, newContent, contentType);
+}
+/**
+ * Read a workspace file's content (with optional offset and maxChars for paging).
+ * Returns null if the file doesn't exist.
+ */
+export async function readWorkspaceFile(scope, path, opts) {
+    const pathErr = validatePath(path);
+    if (pathErr)
+        throw new Error(`Invalid path: ${pathErr}`);
+    await ensureTable();
+    const db = getDbExec();
+    const result = await db.execute({
+        sql: `SELECT id, scope, scope_id, path, content, content_type, size_bytes, created_at, updated_at FROM workspace_files WHERE scope = ? AND scope_id = ? AND path = ?`,
+        args: [scope.scope, scope.scopeId, path],
+    });
+    const row = result.rows[0];
+    if (!row)
+        return null;
+    let content = String(row[4] ?? "");
+    if (opts?.offset || opts?.maxChars) {
+        const off = opts.offset ?? 0;
+        content = content.slice(off, opts.maxChars !== undefined ? off + opts.maxChars : undefined);
+    }
+    return {
+        id: String(row[0]),
+        scope: String(row[1]),
+        scopeId: String(row[2]),
+        path: String(row[3]),
+        content,
+        contentType: String(row[5] ?? "text/plain"),
+        sizeBytes: Number(row[6] ?? 0),
+        createdAt: String(row[7]),
+        updatedAt: String(row[8]),
+    };
+}
+/**
+ * Get file metadata without loading content.
+ */
+export async function getWorkspaceFileMeta(scope, path) {
+    await ensureTable();
+    const db = getDbExec();
+    const result = await db.execute({
+        sql: `SELECT id, path, content_type, size_bytes, created_at, updated_at FROM workspace_files WHERE scope = ? AND scope_id = ? AND path = ?`,
+        args: [scope.scope, scope.scopeId, path],
+    });
+    const row = result.rows[0];
+    if (!row)
+        return null;
+    return {
+        id: String(row[0]),
+        path: String(row[1]),
+        contentType: String(row[2] ?? "text/plain"),
+        sizeBytes: Number(row[3] ?? 0),
+        createdAt: String(row[4]),
+        updatedAt: String(row[5]),
+    };
+}
+/**
+ * List workspace files, optionally filtered by path prefix.
+ * Returns metadata only (no content).
+ */
+export async function listWorkspaceFiles(scope, prefix) {
+    await ensureTable();
+    const db = getDbExec();
+    if (prefix) {
+        // Allow a trailing slash on list prefixes, but reject traversal and
+        // other invalid path shapes before they reach the LIKE pattern.
+        const normalizedPrefix = prefix.endsWith("/")
+            ? prefix.slice(0, -1)
+            : prefix;
+        const pathErr = validatePath(normalizedPrefix);
+        if (pathErr) {
+            throw new Error(pathErr);
+        }
+        const result = await db.execute({
+            sql: `SELECT id, path, content_type, size_bytes, created_at, updated_at FROM workspace_files WHERE scope = ? AND scope_id = ? AND (path = ? OR path LIKE ? ESCAPE '\\') ORDER BY path ASC`,
+            args: [
+                scope.scope,
+                scope.scopeId,
+                normalizedPrefix,
+                `${normalizedPrefix.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_")}/%`,
+            ],
+        });
+        return result.rows.map(rowToMeta);
+    }
+    const result = await db.execute({
+        sql: `SELECT id, path, content_type, size_bytes, created_at, updated_at FROM workspace_files WHERE scope = ? AND scope_id = ? ORDER BY path ASC`,
+        args: [scope.scope, scope.scopeId],
+    });
+    return result.rows.map(rowToMeta);
+}
+/**
+ * Delete a workspace file. Returns true if deleted, false if not found.
+ */
+export async function deleteWorkspaceFile(scope, path) {
+    const pathErr = validatePath(path);
+    if (pathErr)
+        throw new Error(`Invalid path: ${pathErr}`);
+    await ensureTable();
+    const db = getDbExec();
+    const result = await db.execute({
+        sql: `DELETE FROM workspace_files WHERE scope = ? AND scope_id = ? AND path = ?`,
+        args: [scope.scope, scope.scopeId, path],
+    });
+    return result.rowsAffected > 0;
+}
+/**
+ * Search file contents for a substring or regex pattern.
+ * Returns matching lines with path context.
+ */
+export async function grepWorkspaceFiles(scope, pattern, opts) {
+    const files = await listWorkspaceFiles(scope, opts?.pathPrefix);
+    const limited = files.slice(0, opts?.maxFiles ?? 50);
+    let regex;
+    try {
+        regex = opts?.useRegex
+            ? new RegExp(pattern, "i")
+            : new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
+    }
+    catch {
+        throw new Error(`Invalid regex pattern: ${pattern}`);
+    }
+    const results = [];
+    const maxPerFile = opts?.maxMatchesPerFile ?? 20;
+    for (const meta of limited) {
+        const file = await readWorkspaceFile(scope, meta.path);
+        if (!file)
+            continue;
+        const lines = file.content.split("\n");
+        let matchCount = 0;
+        for (let i = 0; i < lines.length; i++) {
+            if (regex.test(lines[i])) {
+                results.push({ path: meta.path, lineNumber: i + 1, line: lines[i] });
+                matchCount++;
+                if (matchCount >= maxPerFile)
+                    break;
+            }
+        }
+    }
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+async function getScopeTotalBytes(scope) {
+    const db = getDbExec();
+    const result = await db.execute({
+        sql: `SELECT COALESCE(SUM(size_bytes), 0) as total FROM workspace_files WHERE scope = ? AND scope_id = ?`,
+        args: [scope.scope, scope.scopeId],
+    });
+    return Number(result.rows[0]?.[0] ?? 0);
+}
+function rowToMeta(row) {
+    return {
+        id: String(row[0]),
+        path: String(row[1]),
+        contentType: String(row[2] ?? "text/plain"),
+        sizeBytes: Number(row[3] ?? 0),
+        createdAt: String(row[4]),
+        updatedAt: String(row[5]),
+    };
+}
+//# sourceMappingURL=store.js.map