@standardagents/builder 0.20.0 → 0.21.0

package/dist/built-in-routes.js

@@ -2521,7 +2521,9 @@ __export(files_exports, {
   dirname: () => dirname,
   isTextMimeType: () => isTextMimeType,
   normalizePath: () => normalizePath,
-  rowToFileRecord: () => rowToFileRecord
+  resolveRenameDestination: () => resolveRenameDestination,
+  rowToFileRecord: () => rowToFileRecord,
+  validateMovePaths: () => validateMovePaths
 });
 function isTextMimeType(mimeType) {
   if (mimeType.startsWith("text/")) return true;
@@ -2554,6 +2556,33 @@ function dirname(path9) {
   if (lastSlash <= 0) return "/";
   return normalized.slice(0, lastSlash);
 }
+function validateMovePaths(source, destination, isDirectory) {
+  if (source === "/") {
+    throw new Error("Cannot move the root directory");
+  }
+  if (destination === "/") {
+    throw new Error("Cannot move over the root directory");
+  }
+  if (isDirectory && destination.startsWith(source + "/")) {
+    throw new Error(
+      "Cannot move a directory into itself or one of its descendants"
+    );
+  }
+}
+function resolveRenameDestination(path9, newName) {
+  if (typeof newName !== "string" || newName.length === 0) {
+    throw new Error("New name must be a non-empty string");
+  }
+  if (newName.includes("/")) {
+    throw new Error("New name must not contain path separators");
+  }
+  if (newName === "." || newName === "..") {
+    throw new Error("New name must not be '.' or '..'");
+  }
+  const normalized = normalizePath(path9);
+  const parent = dirname(normalized);
+  return parent === "/" ? `/${newName}` : `${parent}/${newName}`;
+}
 function rowToFileRecord(row) {
   return {
     path: row.path,
@@ -3030,6 +3059,94 @@ var init_files = __esm({
           normalizedPath
         );
       }
+      /**
+       * Move (or rename) a file or directory from one path to another.
+       *
+       * Works for inline files, chunked files, and directories. Moving a
+       * directory relocates the directory marker and every descendant entry,
+       * preserving their relative layout. The destination must not already
+       * exist, and a directory cannot be moved into itself or one of its own
+       * descendants.
+       *
+       * Implementation note: the `file_chunks` table has a foreign key on
+       * `files(path)` with `ON DELETE CASCADE`, and there is no `ON UPDATE`
+       * action. To keep referential integrity intact (foreign key enforcement
+       * is on in Durable Object SQLite), we copy the affected rows to their new
+       * paths first, then delete the originals — the cascade removes the old
+       * chunks, while the freshly copied chunks already point at the new file
+       * rows. This never leaves an orphaned chunk mid-operation.
+       */
+      async move(sourcePath, destinationPath) {
+        const source = normalizePath(sourcePath);
+        const destination = normalizePath(destinationPath);
+        if (source === destination) {
+          const existing = await this.stat(source);
+          if (!existing) {
+            throw new Error(`Source path does not exist: ${source}`);
+          }
+          return existing;
+        }
+        const record24 = await this.stat(source);
+        if (!record24) {
+          throw new Error(`Source path does not exist: ${source}`);
+        }
+        validateMovePaths(source, destination, record24.isDirectory);
+        const destPrefix = destination + "/";
+        const collision = await this.sql.exec(
+          `SELECT COUNT(*) as count FROM files WHERE path = ? OR path LIKE ? || '%'`,
+          destination,
+          destPrefix
+        );
+        if (collision.one().count > 0) {
+          throw new Error(`Destination already exists: ${destination}`);
+        }
+        const sourcePrefix = source + "/";
+        const sourceLen = source.length;
+        const destName = basename(destination);
+        await this.sql.exec(
+          `INSERT INTO files (path, name, mime_type, storage, location, data, content, size, metadata, thumbnail, is_directory, created_at, width, height, is_chunked, chunk_count)
+       SELECT ? || SUBSTR(path, ? + 1), name, mime_type, storage, location, data, content, size, metadata, thumbnail, is_directory, created_at, width, height, is_chunked, chunk_count
+       FROM files
+       WHERE path = ? OR path LIKE ? || '%'`,
+          destination,
+          sourceLen,
+          source,
+          sourcePrefix
+        );
+        await this.sql.exec(
+          `INSERT INTO file_chunks (file_path, chunk_index, data)
+       SELECT ? || SUBSTR(file_path, ? + 1), chunk_index, data
+       FROM file_chunks
+       WHERE file_path = ? OR file_path LIKE ? || '%'`,
+          destination,
+          sourceLen,
+          source,
+          sourcePrefix
+        );
+        await this.sql.exec(
+          `DELETE FROM files WHERE path = ? OR path LIKE ? || '%'`,
+          source,
+          sourcePrefix
+        );
+        await this.sql.exec(
+          `UPDATE files SET name = ? WHERE path = ?`,
+          destName,
+          destination
+        );
+        const moved = await this.stat(destination);
+        if (!moved) {
+          throw new Error(`Failed to move ${source} to ${destination}`);
+        }
+        return moved;
+      }
+      /**
+       * Rename a file or directory in place, keeping it in the same parent
+       * directory. `newName` must be a bare file name with no path separators.
+       */
+      async rename(path9, newName) {
+        const destination = resolveRenameDestination(path9, newName);
+        return this.move(normalizePath(path9), destination);
+      }
       /**
        * Get storage statistics
        */
@@ -12127,6 +12244,20 @@ var init_ThreadStateImpl = __esm({
       async rmdirFile(path9) {
         await this._threadInstance.rmdirFile(path9);
       }
+      async moveFile(sourcePath, destinationPath) {
+        const result = await this._threadInstance.moveFile(sourcePath, destinationPath);
+        if (!result.success || !result.file) {
+          throw new Error(result.error || "Failed to move file");
+        }
+        return this._mapFileRecord(result.file);
+      }
+      async renameFile(path9, newName) {
+        const result = await this._threadInstance.renameFile(path9, newName);
+        if (!result.success || !result.file) {
+          throw new Error(result.error || "Failed to rename file");
+        }
+        return this._mapFileRecord(result.file);
+      }
       async getFileStats() {
         const stats = await this._threadInstance.getFileStats();
         return {
@@ -69648,6 +69779,13 @@ async function handlePost2(stub, path9, req) {
   const contentType = req.headers.get("Content-Type") || "";
   if (contentType.includes("application/json")) {
     const body = await req.json();
+    if (body.action === "move" || body.action === "rename") {
+      const result2 = body.action === "move" ? await stub.moveFile(path9, body.destination) : await stub.renameFile(path9, body.newName);
+      if (!result2.success) {
+        return Response.json({ error: result2.error }, { status: 400 });
+      }
+      return Response.json(toAttachmentRef(result2.file), { status: 200 });
+    }
     if (body.type === "directory") {
       const result2 = await stub.mkdirFile(path9);
       if (!result2.success) {