@framers/agentos 0.13.64 → 0.13.66

package/dist/core/utils/linkFreeWrite.js

@@ -0,0 +1,140 @@
+/**
+ * @fileoverview Writing below a folder whose contents another process may change: folders are made one name at a
+ * time and never through a link, and a file is opened for writing never through a link, never waiting, and only
+ * when it is a regular file with one name.
+ *
+ * The Markdown and Obsidian memory exporters write a file per trace below an export folder, and the skill exporter
+ * writes a tool's files below a skills folder. Whoever can write below such a folder could put there a link that
+ * leads elsewhere, a second name for a file elsewhere, or a named pipe that holds a writer up, so both write
+ * through the functions here. The folder itself is the caller's and may be a link. The checks run as each folder
+ * is made and each file opened; Node has no `openat`, so a process that swaps a folder for a link between a check
+ * and the write is outside what they stop.
+ *
+ * @module agentos/core/utils/linkFreeWrite
+ */
+import fs from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import path from 'node:path';
+/**
+ * The flags a file is opened with: for writing, made when missing, and, where the platform has each flag (Windows
+ * has neither), never through a symbolic link in the file's own place (`O_NOFOLLOW`) and never waiting
+ * (`O_NONBLOCK`). Without `O_NONBLOCK`, an open for writing of a named pipe that no process reads waits for a
+ * reader that may never come. The file is not emptied by the open: the caller empties it once the open file shows
+ * it is a regular file with no second name.
+ */
+const OPEN_FLAGS = fsConstants.O_WRONLY |
+    fsConstants.O_CREAT |
+    (fsConstants.O_NOFOLLOW !== undefined ? fsConstants.O_NOFOLLOW : 0) |
+    (fsConstants.O_NONBLOCK !== undefined ? fsConstants.O_NONBLOCK : 0);
+/** The codes an open with `O_NOFOLLOW` fails with when a symbolic link holds the file's place (EMLINK on FreeBSD). */
+const LINK_OPEN_CODES = new Set(['ELOOP', 'EMLINK']);
+/**
+ * The codes an open for writing fails with when something other than a regular file holds the file's place:
+ * EISDIR for a folder; ENXIO for a named pipe that no process reads (under `O_NONBLOCK`), a device with no driver,
+ * or, on Linux, a socket; EOPNOTSUPP for a socket on macOS.
+ */
+const SPECIAL_OPEN_CODES = new Set(['EISDIR', 'ENXIO', 'EOPNOTSUPP']);
+/**
+ * Make the folders `relative` names under `root`, one name at a time, and stop at a link. A folder this makes is
+ * never a link, so a file written into it stays under `root`.
+ *
+ * @param root     - The folder the others are made in. It may itself be a link.
+ * @param relative - The folders' path under `root`.
+ * @returns True when every folder is in place and none of them is a link.
+ */
+export async function makeFoldersOutsideLinks(root, relative) {
+    let dir = root;
+    for (const name of relative.split(path.sep).filter((part) => part.length > 0)) {
+        dir = path.join(dir, name);
+        const entry = await lstatOrNull(dir);
+        if (entry) {
+            if (entry.isSymbolicLink())
+                return false;
+            continue;
+        }
+        try {
+            await fs.mkdir(dir);
+        }
+        catch (err) {
+            if (err.code !== 'EEXIST')
+                throw err;
+            // Something was put there since the look: look again.
+            if ((await fs.lstat(dir)).isSymbolicLink())
+                return false;
+        }
+    }
+    return true;
+}
+/**
+ * Look at a file's place without opening it. A caller that writes several files, all of them or none, looks at
+ * every place before it opens any file, so a refusal makes no file. The look does not see a change made after it;
+ * {@link openFileOutsideLinks} checks again.
+ *
+ * @param file - Absolute path of the file.
+ * @returns `link` when a symbolic link holds the place or the file there has a second name, `special` when
+ *   something other than a regular file holds it, or null when the place is free or holds a regular file with one
+ *   name.
+ * @throws Any error the look meets other than a missing file.
+ */
+export async function lookOutsideLinks(file) {
+    const entry = await lstatOrNull(file);
+    if (entry === null)
+        return null;
+    if (entry.isSymbolicLink())
+        return 'link';
+    if (!entry.isFile())
+        return 'special';
+    return entry.nlink > 1 ? 'link' : null;
+}
+/**
+ * Open a file for writing, in a folder already made, and check what the open reached. A symbolic link in the
+ * file's place is refused before the open, and where the platform has `O_NOFOLLOW` the open refuses one put there
+ * since. A folder fails the open, and where the platform has `O_NONBLOCK` so does a named pipe that no process
+ * reads, at once. An open file that is not a regular file (a named pipe that a process reads, a device) is refused,
+ * and so is a file with a second name (a hard link), which is the same file as that name and may lie outside the
+ * folder. Nothing is emptied or written here; a refused file is closed.
+ *
+ * @param file - Absolute path of the file.
+ * @returns The open file and its identity, or the refusal.
+ * @throws Any other error the look or the open meets.
+ */
+export async function openFileOutsideLinks(file) {
+    if ((await lstatOrNull(file))?.isSymbolicLink())
+        return 'link';
+    const handle = await fs.open(file, OPEN_FLAGS).catch((err) => {
+        const code = String(err.code);
+        if (LINK_OPEN_CODES.has(code))
+            return 'link';
+        if (SPECIAL_OPEN_CODES.has(code))
+            return 'special';
+        throw err;
+    });
+    if (typeof handle === 'string')
+        return handle;
+    let handedOver = false;
+    try {
+        const stat = await handle.stat({ bigint: true });
+        if (!stat.isFile())
+            return 'special';
+        if (stat.nlink > 1n)
+            return 'link';
+        handedOver = true;
+        return { handle, identity: stat.ino === 0n ? null : `${stat.dev}:${stat.ino}` };
+    }
+    finally {
+        if (!handedOver)
+            await handle.close();
+    }
+}
+/** The entry at `file` itself, a link not followed, or null when there is none. */
+async function lstatOrNull(file) {
+    try {
+        return await fs.lstat(file);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+//# sourceMappingURL=linkFreeWrite.js.map

package/dist/core/utils/linkFreeWrite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"linkFreeWrite.js","sourceRoot":"","sources":["../../../src/core/utils/linkFreeWrite.ts"],"names":[],"mappings":"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"}

package/dist/core/utils/pathName.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @fileoverview The rule for a file or folder name built from data, and the check that a path built from such
+ * names lies inside its folder.
+ *
+ * The memory wiki builds a page's path from its id, the Markdown and Obsidian memory exporters build a trace's
+ * path from its scope, type and id, and the skill exporter builds a forged tool's folder from its name. Those
+ * values come from files, imports and models, so every name taken from them is checked against one rule here,
+ * and every path built from them is checked to lie inside the folder it is written to.
+ *
+ * @module agentos/core/utils/pathName
+ */
+import * as path from 'node:path';
+/**
+ * The most bytes, in UTF-8, one name may hold. Linux allows 255 bytes in a name, and Windows usually 255 UTF-16
+ * code units; a name never holds more code units than bytes, so 200 fits both and leaves room for the extension a
+ * caller adds, such as `.md`.
+ */
+export declare const MAX_PATH_NAME_BYTES = 200;
+/**
+ * Why a name was refused:
+ * - `'empty'`: the name is empty.
+ * - `'character'`: it holds a slash, a backslash, a colon, one of `"`, `*`, `<`, `>`, `?` and `|`, or a control
+ *   character (U+0000 to U+001F, or U+007F), a NUL byte among them. A slash or a backslash separates folders; on
+ *   Windows a colon names a drive (`C:name`) or a file's stream (`name:stream`), and Windows refuses the other six
+ *   in a name.
+ * - `'dot'`: it starts with a dot, so it is `.`, `..` or a hidden name.
+ * - `'edge'`: it starts or ends with a space, or ends with a dot. Windows drops those from a name, so the name
+ *   would be another's (`notes.` is `notes` there).
+ * - `'length'`: it holds more than {@link MAX_PATH_NAME_BYTES} bytes in UTF-8.
+ */
+export type PathNameProblem = 'empty' | 'character' | 'dot' | 'edge' | 'length';
+/**
+ * A refused value as an error message shows it: a string quoted and escaped, cut to its first 64 characters, or
+ * the type of any other value.
+ *
+ * @param value - The refused value.
+ */
+export declare function describeRefusedName(value: unknown): string;
+/**
+ * True when the character whose UTF-16 code is `code` may appear neither in a name nor anywhere in a path whose
+ * names are joined with `/`: a backslash, a colon, one of `"`, `*`, `<`, `>`, `?` and `|`, or a control character
+ * (U+0000 to U+001F, or U+007F).
+ */
+export declare function isRefusedPathCharacter(code: number): boolean;
+/**
+ * The part of the name rule `name` breaks, or null when `name` may name one file or folder. A name the rule
+ * accepts holds no separator, is never `.` or `..`, and names no drive or file stream, so a path built from such
+ * names stays under the folder it starts from.
+ *
+ * @param name - The name to check.
+ */
+export declare function pathNameProblem(name: string): PathNameProblem | null;
+/**
+ * The path that `relative` names under the folder `root`, resolved, or null when that path is not inside `root`.
+ * The paths are compared resolved, with the separator after the folder's own path, so a sibling folder whose name
+ * starts with the folder's (`/srv/memory-old` beside `/srv/memory`) is not inside it, and neither is the folder
+ * itself. The check is on the path as written: a link inside the folder is not followed.
+ *
+ * @param root - The folder.
+ * @param relative - The parts of the path under `root`, in order, as `path.resolve` takes them.
+ * @param paths - The path functions to resolve with: the platform's by default, `path.win32` or `path.posix` to
+ *   pick one.
+ * @returns The absolute path, or null when it is outside `root`.
+ */
+export declare function resolveInsideFolder(root: string, relative: readonly string[], paths?: Pick<path.PlatformPath, 'resolve' | 'sep'>): string | null;
+//# sourceMappingURL=pathName.d.ts.map

package/dist/core/utils/pathName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathName.d.ts","sourceRoot":"","sources":["../../../src/core/utils/pathName.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAEvC;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,WAAW,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAC;AAmBhF;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAK1D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE5D;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAWpE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,KAAK,GAAE,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,KAAK,CAAQ,GACvD,MAAM,GAAG,IAAI,CAKf"}

package/dist/core/utils/pathName.js

@@ -0,0 +1,91 @@
+/**
+ * @fileoverview The rule for a file or folder name built from data, and the check that a path built from such
+ * names lies inside its folder.
+ *
+ * The memory wiki builds a page's path from its id, the Markdown and Obsidian memory exporters build a trace's
+ * path from its scope, type and id, and the skill exporter builds a forged tool's folder from its name. Those
+ * values come from files, imports and models, so every name taken from them is checked against one rule here,
+ * and every path built from them is checked to lie inside the folder it is written to.
+ *
+ * @module agentos/core/utils/pathName
+ */
+import * as path from 'node:path';
+/**
+ * The most bytes, in UTF-8, one name may hold. Linux allows 255 bytes in a name, and Windows usually 255 UTF-16
+ * code units; a name never holds more code units than bytes, so 200 fits both and leaves room for the extension a
+ * caller adds, such as `.md`.
+ */
+export const MAX_PATH_NAME_BYTES = 200;
+/** The slash's code: the folder separator everywhere. */
+const SLASH = 0x2f;
+/** The backslash's code: a folder separator on Windows. */
+const BACKSLASH = 0x5c;
+/** The colon's code: on Windows it names a drive (`C:name`) or a file's stream (`name:stream`). */
+const COLON = 0x3a;
+/** The codes of `"`, `*`, `<`, `>`, `?` and `|`, which Windows refuses in a name. */
+const WINDOWS_RESERVED = new Set([0x22, 0x2a, 0x3c, 0x3e, 0x3f, 0x7c]);
+const utf8 = new TextEncoder();
+/** The most characters of a refused name that an error message shows. */
+const SHOWN_NAME_CHARACTERS = 64;
+/**
+ * A refused value as an error message shows it: a string quoted and escaped, cut to its first 64 characters, or
+ * the type of any other value.
+ *
+ * @param value - The refused value.
+ */
+export function describeRefusedName(value) {
+    if (typeof value !== 'string')
+        return `of type ${value === null ? 'null' : typeof value}`;
+    return JSON.stringify(value.length > SHOWN_NAME_CHARACTERS ? `${value.slice(0, SHOWN_NAME_CHARACTERS)}...` : value);
+}
+/**
+ * True when the character whose UTF-16 code is `code` may appear neither in a name nor anywhere in a path whose
+ * names are joined with `/`: a backslash, a colon, one of `"`, `*`, `<`, `>`, `?` and `|`, or a control character
+ * (U+0000 to U+001F, or U+007F).
+ */
+export function isRefusedPathCharacter(code) {
+    return code <= 0x1f || code === 0x7f || code === BACKSLASH || code === COLON || WINDOWS_RESERVED.has(code);
+}
+/**
+ * The part of the name rule `name` breaks, or null when `name` may name one file or folder. A name the rule
+ * accepts holds no separator, is never `.` or `..`, and names no drive or file stream, so a path built from such
+ * names stays under the folder it starts from.
+ *
+ * @param name - The name to check.
+ */
+export function pathNameProblem(name) {
+    if (name.length === 0)
+        return 'empty';
+    for (let i = 0; i < name.length; i++) {
+        const code = name.charCodeAt(i);
+        if (code === SLASH || isRefusedPathCharacter(code))
+            return 'character';
+    }
+    if (name.startsWith('.'))
+        return 'dot';
+    if (name.startsWith(' ') || name.endsWith(' ') || name.endsWith('.'))
+        return 'edge';
+    // A string never has more UTF-16 code units than UTF-8 bytes, so a long one is refused before it is encoded.
+    if (name.length > MAX_PATH_NAME_BYTES || utf8.encode(name).byteLength > MAX_PATH_NAME_BYTES)
+        return 'length';
+    return null;
+}
+/**
+ * The path that `relative` names under the folder `root`, resolved, or null when that path is not inside `root`.
+ * The paths are compared resolved, with the separator after the folder's own path, so a sibling folder whose name
+ * starts with the folder's (`/srv/memory-old` beside `/srv/memory`) is not inside it, and neither is the folder
+ * itself. The check is on the path as written: a link inside the folder is not followed.
+ *
+ * @param root - The folder.
+ * @param relative - The parts of the path under `root`, in order, as `path.resolve` takes them.
+ * @param paths - The path functions to resolve with: the platform's by default, `path.win32` or `path.posix` to
+ *   pick one.
+ * @returns The absolute path, or null when it is outside `root`.
+ */
+export function resolveInsideFolder(root, relative, paths = path) {
+    const folder = paths.resolve(root);
+    const file = paths.resolve(folder, ...relative);
+    const inside = folder.endsWith(paths.sep) ? folder : folder + paths.sep;
+    return file.startsWith(inside) ? file : null;
+}
+//# sourceMappingURL=pathName.js.map

package/dist/core/utils/pathName.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathName.js","sourceRoot":"","sources":["../../../src/core/utils/pathName.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@framers/agentos",
-  "version": "0.13.64",
+  "version": "0.13.66",
   "description": "AgentOS: open-source TypeScript framework for autonomous AI agents. Unified graph orchestration, cognitive memory, runtime tool forging, multi-tier guardrails, voice pipeline, and 11 LLM providers.",
   "homepage": "https://agentos.sh",
   "repository": {