@ai-ecoverse/slicc-kernel 1.127.1 → 1.128.1

package/dist/node.js

@@ -4062,6 +4062,12 @@ var ProtectedFs = class {
           st && marked(`${dir}/${name2}`, st)
         ]);
       },
+      ...fs.copyFile ? {
+        async copyFile(...args) {
+          await check(args[1], false);
+          return fs.copyFile?.(...args);
+        }
+      } : {},
       ...fs.createExclusive ? {
         async createExclusive(...args) {
           await check(args[0], true);
@@ -5703,10 +5709,11 @@ var OpfsFs = class {
     return intents.length;
   }
   async settledRename(path) {
-    if (this.renamingDirs.size === 0 || typeof path !== "string") return;
+    if (this.renamingDirs.size === 0 && this.copying.size === 0 || typeof path !== "string")
+      return;
     const at = normalizePath(path);
     for (let real; ; ) {
-      const busy = this.renameAt(at) ?? (real === void 0 ? void 0 : this.renameAt(real));
+      const busy = this.busyAt(at) ?? (real === void 0 ? void 0 : this.busyAt(real));
       if (busy) {
         await busy.done;
         continue;
@@ -5717,6 +5724,62 @@ var OpfsFs = class {
       if (real === at) return;
     }
   }
+  busyAt(at) {
+    return this.renameAt(at) ?? this.copying.get(at);
+  }
+  copying = /* @__PURE__ */ new Map();
+  async copyFile(from, to, options) {
+    const source = await this.locate(from, true);
+    if (source.handle?.kind !== "file") throw fsError("EINVAL", `${from}: not a regular file`);
+    const [entry] = await this.meta.get([source.path]);
+    if (entry?.fifo || entry?.socket) throw fsError("EINVAL", `${from}: not a regular file`);
+    const parent = await this.locate(parentOf4(to), true);
+    if (parent.handle?.kind !== "directory") throw fsError("ENOTDIR", to);
+    const destination = resolvePath(parent.path, baseOf(to));
+    if (destination === source.path) throw fsError("EINVAL", `${from}: copied onto itself`);
+    const file = await this.reading(source.path, (handle) => handle.getFile());
+    const { promise, resolve: resolve2 } = Promise.withResolvers();
+    while (this.copying.has(destination)) await this.copying.get(destination)?.done;
+    this.copying.set(destination, { done: promise });
+    try {
+      await this.copyInto(file, destination, to, options);
+    } finally {
+      this.copying.delete(destination);
+      resolve2();
+    }
+  }
+  async copyInto(file, destination, to, options) {
+    let created4 = false;
+    if (options.exclusive) {
+      await this.createExclusive(destination, options.owner);
+      created4 = true;
+    }
+    let target = destination;
+    let writable2;
+    let handle;
+    try {
+      const [made2, existed, at] = await this.fileFor(destination);
+      handle = made2;
+      target = at;
+      if (!existed && !created4) {
+        created4 = true;
+        await this.stampNew(target, options.owner, false);
+      }
+      const [entry] = await this.meta.get([target]);
+      if (entry?.fifo || entry?.socket) throw fsError("ENXIO", to);
+      this.wrote(handle);
+      writable2 = await handle.createWritable();
+      await writable2.write(file);
+      await writable2.close();
+    } catch (err) {
+      await writable2?.abort().catch(() => void 0);
+      if (created4) await this.rm(target, { file: true }).catch(() => void 0);
+      throw translate(err, to, "commit", false);
+    } finally {
+      if (handle) this.wrote(handle);
+    }
+    this.committed(target);
+  }
   renameAt(at) {
     for (const m of this.renamingDirs) {
       if (within3(at, m.from) || within3(at, m.to) || at === parentOf4(m.from) || at === parentOf4(m.to))
@@ -5964,6 +6027,7 @@ var READS = [
   "readVersioned"
 ];
 var WRITES = [
+  "copyFile",
   "writeFile",
   "pwrite",
   "truncate",
@@ -7328,7 +7392,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.127.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.128.1" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -9593,6 +9657,7 @@ function withCommandDirs(fs, names2, userDir = async () => void 0, owners = fals
     ...fs.realpath ? { realpath: fs.realpath.bind(fs) } : {},
     ...fs.chown ? { chown: fs.chown.bind(fs) } : {},
     ...fs.createExclusive ? { createExclusive: fs.createExclusive.bind(fs) } : {},
+    ...fs.copyFile ? { copyFile: fs.copyFile.bind(fs) } : {},
     ...fs.ancestry ? { ancestry: fs.ancestry.bind(fs) } : {},
     ...fs.hasOwner ? { hasOwner: fs.hasOwner.bind(fs) } : {},
     chmod: (path, mode) => fs.chmod(path, mode),
@@ -9994,6 +10059,12 @@ var FsWatchers = class {
     const overrides = {
       writeFile: content(fs.writeFile.bind(fs), written2),
       ...fs.createExclusive ? { createExclusive: content(fs.createExclusive.bind(fs), () => ["rename"]) } : {},
+      ...fs.copyFile ? {
+        copyFile: (from, to, options) => content(
+          (_to) => fs.copyFile?.(from, to, options),
+          written2
+        )(to)
+      } : {},
       mkdir: async (path, options) => {
         const created4 = [];
         if (options?.recursive) {
@@ -10651,6 +10722,33 @@ var FifoTable = class {
   }
 };
 
+// src/fs/copy.ts
+async function present2(fs, path) {
+  return fs.lstat(path).then(
+    () => true,
+    (err) => {
+      if (err?.code === "ENOENT") return false;
+      throw err;
+    }
+  );
+}
+async function copyByBytes(fs, from, to, options) {
+  if (!(await fs.stat(from)).isFile) throw fsError("EINVAL", `${from}: not a regular file`);
+  const bytes = await fs.readFileBuffer(from);
+  let created4 = false;
+  if (options.exclusive) {
+    if (fs.createExclusive) await fs.createExclusive(to, options.owner);
+    else if (await present2(fs, to)) throw fsError("EEXIST", to);
+    created4 = true;
+  } else created4 = !await present2(fs, to);
+  try {
+    await fs.writeFile(to, bytes, options.owner);
+  } catch (err) {
+    if (created4) await fs.rm(to, { file: true }).catch(() => void 0);
+    throw err;
+  }
+}
+
 // src/mount/protocol.ts
 var DRIVER_PROTOCOL = [1, 3];
 function driverVersionError(theirs) {
@@ -11034,12 +11132,12 @@ var MountTable = class {
   }
   list() {
     const mounted = [...this.mounts.values()].map(
-      ({ type, source, target, options, state, error, present: present3 }) => ({
+      ({ type, source, target, options, state, error, present: present4 }) => ({
         type,
         source,
         target,
         options: { ...options },
-        state: state === "ok" && present3?.() === false ? "nomedium" : state,
+        state: state === "ok" && present4?.() === false ? "nomedium" : state,
         ...error ? { error } : {}
       })
     );
@@ -11714,6 +11812,23 @@ var MountFs = class _MountFs {
       throw err;
     }
   }
+  async copyFile(from, to, options, redirects = 0) {
+    const source = await realTarget(this, normalizePath(from));
+    const a = this.at(source);
+    const b = this.at(to);
+    const copy = this.base.copyFile?.bind(this.base);
+    if (!a && !b && copy) {
+      return this.based(
+        [source, to],
+        redirects,
+        () => copy(source, to, options),
+        ([f, t], n) => this.copyFile(f, t, options, n)
+      );
+    }
+    if (a?.mount !== b?.mount) throw errnoError("EXDEV", `${from} -> ${to}`);
+    if (a) this.writable(a.mount, normalizePath(to));
+    return copyByBytes(this, source, to, options);
+  }
   async createExclusive(path, owner, redirects = 0) {
     const exclusive = this.base.createExclusive?.bind(this.base);
     if (!this.at(path) && exclusive) {
@@ -12141,6 +12256,7 @@ var SYNC_FS_OPS = [
   "rm",
   "rename",
   "link",
+  "copy",
   "unlink",
   "rmdir",
   "symlink",
@@ -12340,6 +12456,8 @@ async function run(entry, path, req) {
     case "symlink":
       await fs.symlink(req.arg2 ?? "", path, ownerFor2(entry));
       return done;
+    case "copy":
+      return copyOp(entry, path, req);
     case "mkfifo": {
       const owner = ownerFor2(entry, req.mode ?? 438) ?? { uid: 0, gid: 0 };
       await createExclusive(fs, path, { ...owner, fifo: true });
@@ -12446,6 +12564,16 @@ async function guard(g, path, req, cwd) {
       const toWalked = await walkSafe(g, to, false);
       return { path: fromWalked, arg2: toWalked };
     }
+    case "copy": {
+      const to = other();
+      await readable(g, op, path);
+      const there = !req.exclusive && await g.fs.lstat(to).then(
+        () => true,
+        () => false
+      );
+      await (there ? writable(g, op, to) : inParent(g, op, to));
+      return { path: await walkSafe(g, path, true), arg2: await walkSafe(g, to, false) };
+    }
     case "link": {
       const to = other();
       const follow2 = req.mode === 1;
@@ -12546,6 +12674,9 @@ async function mayChange(entry, path, req) {
   const { mayChange: mayChange2 } = entry.fs;
   if (!mayChange2) return;
   const { op } = req;
+  if (op === "copy") {
+    return mayChange2.call(entry.fs, entry.fs.resolvePath(entry.cwd, req.arg2 ?? ""), false);
+  }
   if (CONTENT.has(op) && req.handle === void 0) return mayChange2.call(entry.fs, path, true);
   if (!CHANGING.has(op)) return;
   const follow2 = op === "utimes" || op === "chmod" || op === "chown";
@@ -12569,6 +12700,17 @@ async function guarded(entry, path, req) {
     return { refused: refused3 };
   }
 }
+async function copyOp(entry, path, req) {
+  const { fs, cwd } = entry;
+  const to = fs.resolvePath(cwd, req.arg2 ?? "");
+  const mode = (req.mode ?? 438) & 4095 & ~(entry.umask?.() ?? 18);
+  const owner = ownerFor2(entry, mode);
+  const options = { exclusive: req.exclusive === true, ...owner ? { owner } : {} };
+  await (fs.copyFile ? fs.copyFile(path, to, options) : copyByBytes(fs, path, to, options));
+  if (!owner) await fs.chmod(to, mode);
+  entry.fresh?.(to);
+  return done;
+}
 async function createExclusive(fs, path, owner) {
   if (fs.createExclusive) return fs.createExclusive(path, owner);
   if (await fs.lstat(path).then(
@@ -12743,7 +12885,7 @@ var CREATIONS = /* @__PURE__ */ new Set([
   "create",
   "mkfifo"
 ]);
-var NAMING = /* @__PURE__ */ new Set(["link", "rename"]);
+var NAMING = /* @__PURE__ */ new Set(["link", "rename", "copy"]);
 async function newDevName(entry, path, req) {
   const named = NAMING.has(req.op);
   if (!named && !CREATIONS.has(req.op)) return void 0;
@@ -19862,7 +20004,7 @@ var VfsNodes = class {
       if (held) throw fsError("EEXIST", path);
       const exclusive = this.fs.createExclusive;
       if (exclusive) return exclusive.call(this.fs, path, owner);
-      if (await present2(this.fs, path)) throw fsError("EEXIST", path);
+      if (await present3(this.fs, path)) throw fsError("EEXIST", path);
       await this.fs.writeFile(path, new Uint8Array(0), owner);
     });
   }
@@ -20093,7 +20235,7 @@ var VfsNodes = class {
     }
   }
 };
-async function present2(fs, path, follow2 = false) {
+async function present3(fs, path, follow2 = false) {
   const look = (follow2 ? void 0 : fs.lstat) ?? fs.stat;
   try {
     await (look ? look.call(fs, path) : fs.readFileBuffer(path));
@@ -20271,7 +20413,18 @@ function keepingOpen(fs, nodes, changed = () => {
       await nodes.onEntry(key, () => fs.link(from, to, follow2));
       await nodes.linked(at, key);
     },
-    mkdir: (path, options) => nodes.onEntry(fs.resolvePath("/", path), () => fs.mkdir(path, options))
+    mkdir: (path, options) => nodes.onEntry(fs.resolvePath("/", path), () => fs.mkdir(path, options)),
+    ...fs.copyFile ? {
+      async copyFile(from, to, options) {
+        const source = await nodes.targetKey(fs.resolvePath("/", from));
+        await nodes.flush(source);
+        await nodes.flushLinked(source);
+        const at = fs.resolvePath("/", to);
+        const key = await nodes.entryKey(at);
+        if (await heldAt(fs, nodes, at)) return copyByBytes(this, from, to, options);
+        await nodes.onEntry(key, () => fs.copyFile?.(from, to, options));
+      }
+    } : {}
   };
 }
 function vfsFile(fs, opts, nodes) {
@@ -21131,7 +21284,7 @@ var WasmProcess = class {
       } else if (req.create) {
         await nodes.onEntry(path, async () => {
           const marks = this.options.owners || plain2 !== void 0;
-          const fresh2 = marks && !await present2(fs, path, true);
+          const fresh2 = marks && !await present3(fs, path, true);
           this.fds.installAt(fd, this.openVfsFile(open, await nodes.identify(path), fs));
           await this.fds.get(fd).file.stat?.();
           if (fresh2 && plain2 !== void 0) await fs.chmod?.(path, plain2);
@@ -21150,7 +21303,7 @@ var WasmProcess = class {
           { at: path, gen }
         );
       }
-      if (req.existing && !await present2(fs, path, true)) {
+      if (req.existing && !await present3(fs, path, true)) {
         throw new KernelError("ENOENT");
       }
     } catch (err) {
@@ -21518,12 +21671,12 @@ var WasmProcess = class {
   async stillOpen(at, handle) {
     if (handle === void 0 || this.keptHandle?.(handle) !== void 0) return;
     if (this.holdsHandle?.(handle) !== false) return;
-    if (!await present2(this.options.fs, at, true)) throw new KernelError("ENOENT");
+    if (!await present3(this.options.fs, at, true)) throw new KernelError("ENOENT");
   }
   async keptOr(path, handle) {
     if (handle !== void 0) return this.keptHandle?.(handle) ?? path;
     const kept = this.keptPath?.(path);
-    return kept !== void 0 && !await present2(this.options.fs, path, true) ? kept : path;
+    return kept !== void 0 && !await present3(this.options.fs, path, true) ? kept : path;
   }
   async promote(req) {
     if (!this.fds.get(req.fd).file.held) throw new KernelError("EBADF");