@qearlyao/familiar 0.2.2 → 0.2.4

package/dist/tts.js

@@ -129,13 +129,7 @@ export function createTtsTool(config, mediaSink) {
             return {
                 content: [{ type: "text", text: formatTtsNotice(name) }],
                 details: {
-                    provider: "elevenlabs",
-                    voiceId,
-                    modelId: config.tts.modelId,
-                    outputFormat,
                     localPath,
-                    mimeType,
-                    size: buffer.length,
                 },
             };
         },

package/dist/util/fs.js

@@ -0,0 +1,41 @@
+import { mkdir, open, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+export function isEnoent(error) {
+    return !!error && typeof error === "object" && "code" in error && error.code === "ENOENT";
+}
+export async function readFileOrNull(path, encoding) {
+    try {
+        return await readFile(path, encoding);
+    }
+    catch (error) {
+        if (isEnoent(error))
+            return null;
+        throw error;
+    }
+}
+async function fsyncFile(path) {
+    const handle = await open(path, "r");
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function atomicWriteJson(path, value) {
+    await mkdir(dirname(path), { recursive: true });
+    const tmpPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tmpPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    await fsyncFile(tmpPath);
+    await rename(tmpPath, path);
+}
+export function createWriteQueue(logLabel) {
+    let queue = Promise.resolve();
+    return async (write) => {
+        const run = queue.then(write, write);
+        queue = run.then(() => undefined, (error) => {
+            console.error(`${logLabel} write failed`, error);
+        });
+        return run;
+    };
+}

package/dist/util/guards.js

@@ -0,0 +1,8 @@
+export function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+export function readEnum(value, path, allowed) {
+    if (typeof value === "string" && allowed.includes(value))
+        return value;
+    throw new Error(`Config value ${path} must be one of ${allowed.map((item) => JSON.stringify(item)).join(", ")}`);
+}

package/dist/util/image-mime.js

@@ -0,0 +1,31 @@
+import { extname } from "node:path";
+export const IMAGE_MIME_BY_EXTENSION = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+};
+export const IMAGE_EXTENSION_BY_MIME = {
+    "image/jpeg": ".jpg",
+    "image/png": ".png",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+};
+export function imageMimeTypeFromPath(path) {
+    return IMAGE_MIME_BY_EXTENSION[extname(path).toLowerCase()];
+}
+export function sniffImageMimeType(buffer) {
+    if (buffer.subarray(0, 3).equals(Buffer.from([0xff, 0xd8, 0xff])))
+        return "image/jpeg";
+    if (buffer.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) {
+        return "image/png";
+    }
+    if (buffer.subarray(0, 6).toString("ascii") === "GIF87a" || buffer.subarray(0, 6).toString("ascii") === "GIF89a") {
+        return "image/gif";
+    }
+    if (buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP") {
+        return "image/webp";
+    }
+    return undefined;
+}

package/dist/util/time.js

@@ -0,0 +1,29 @@
+export function toDate(value) {
+    if (value instanceof Date)
+        return value;
+    return new Date(value);
+}
+function formatOffset(date) {
+    const offsetMinutes = -date.getTimezoneOffset();
+    const sign = offsetMinutes >= 0 ? "+" : "-";
+    const absolute = Math.abs(offsetMinutes);
+    const hours = Math.floor(absolute / 60);
+    const minutes = absolute % 60;
+    return minutes === 0 ? `GMT${sign}${hours}` : `GMT${sign}${hours}:${String(minutes).padStart(2, "0")}`;
+}
+export function formatLocalTimestamp(value) {
+    const date = toDate(value);
+    if (Number.isNaN(date.getTime()))
+        return String(value);
+    const localDate = [
+        date.getFullYear(),
+        String(date.getMonth() + 1).padStart(2, "0"),
+        String(date.getDate()).padStart(2, "0"),
+    ].join("-");
+    const localTime = [
+        String(date.getHours()).padStart(2, "0"),
+        String(date.getMinutes()).padStart(2, "0"),
+        String(date.getSeconds()).padStart(2, "0"),
+    ].join(":");
+    return `${localDate} ${localTime} ${formatOffset(date)}`;
+}

package/dist/web-auth.js

@@ -11,7 +11,10 @@ function parseCookies(header) {
         const [name, ...valueParts] = part.trim().split("=");
         if (!name)
             continue;
-        cookies[name] = decodeURIComponent(valueParts.join("="));
+        try {
+            cookies[name] = decodeURIComponent(valueParts.join("="));
+        }
+        catch { }
     }
     return cookies;
 }

package/dist/web-static.js

@@ -54,7 +54,29 @@ export async function serveStatic(response, requestPath) {
     stream.pipe(response);
     return true;
 }
-export async function serveAttachment(config, response, requestPath) {
+function parseRangeHeader(rangeHeader, size) {
+    if (!rangeHeader)
+        return undefined;
+    const match = /^bytes=(\d*)-(\d*)$/.exec(rangeHeader.trim());
+    if (!match)
+        return undefined;
+    const [, rawStart, rawEnd] = match;
+    if (!rawStart && !rawEnd)
+        return undefined;
+    if (!rawStart) {
+        const suffixLength = Number(rawEnd);
+        if (!Number.isSafeInteger(suffixLength) || suffixLength <= 0)
+            return undefined;
+        return { start: Math.max(0, size - suffixLength), end: size - 1 };
+    }
+    const start = Number(rawStart);
+    const end = rawEnd ? Number(rawEnd) : size - 1;
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start || start >= size) {
+        return undefined;
+    }
+    return { start, end: Math.min(end, size - 1) };
+}
+export async function serveAttachment(config, response, requestPath, rangeHeader) {
     const relativePath = decodeURIComponent(requestPath.replace(/^\/api\/web\/attachments\/?/, ""));
     if (!relativePath) {
         sendText(response, 404, "Not found");
@@ -93,9 +115,22 @@ export async function serveAttachment(config, response, requestPath) {
         const fileStat = await stat(fileRealPath).catch(() => undefined);
         if (!fileStat?.isFile())
             continue;
+        const range = parseRangeHeader(rangeHeader, fileStat.size);
+        if (range) {
+            response.writeHead(206, {
+                "content-type": mimeType(filePath),
+                "content-length": String(range.end - range.start + 1),
+                "content-range": `bytes ${range.start}-${range.end}/${fileStat.size}`,
+                "accept-ranges": "bytes",
+                "cache-control": "private, max-age=31536000, immutable",
+            });
+            createReadStream(fileRealPath, { start: range.start, end: range.end }).pipe(response);
+            return true;
+        }
         response.writeHead(200, {
             "content-type": mimeType(filePath),
             "content-length": String(fileStat.size),
+            "accept-ranges": "bytes",
             "cache-control": "private, max-age=31536000, immutable",
         });
         createReadStream(fileRealPath).pipe(response);

package/dist/web-tools.js

@@ -69,7 +69,7 @@ class PageCache {
             this.entries.delete(url);
             return undefined;
         }
-        entry.fetchedAt = Date.now();
+        entry.lastAccessed = Date.now();
         this.entries.delete(url);
         this.entries.set(url, entry);
         return entry;
@@ -79,10 +79,12 @@ class PageCache {
             return;
         if (this.entries.has(url))
             this.entries.delete(url);
+        const now = Date.now();
         this.entries.set(url, {
             content,
             provider,
-            fetchedAt: Date.now(),
+            fetchedAt: now,
+            lastAccessed: now,
         });
         while (this.entries.size > this.capacity) {
             const oldest = this.entries.keys().next().value;
@@ -382,7 +384,7 @@ function formatFetchContent(url, provider, chunk) {
         chunk.text,
     ];
     if (chunk.hasMore && chunk.nextOffset !== undefined) {
-        lines.push("", `[More content available. Next chunk: web_fetch(url="${url}", offset=${chunk.nextOffset})]`);
+        lines.push("", `[More content available. Next chunk: fetch_web(url="${url}", offset=${chunk.nextOffset})]`);
     }
     return prefixUntrustedWebContent(lines.join("\n"));
 }
@@ -778,7 +780,7 @@ function makeSearchTool(config) {
     if (config.apiKeys.EXA_API_KEY)
         providers.exa = createExaProvider(config.apiKeys.EXA_API_KEY);
     return {
-        name: "web_search",
+        name: "search_web",
         label: "Web Search",
         description: "look something up on the open web. returns titles, urls, snippets, and dates when present. depth=thorough swaps brevity for inline excerpts.",
         parameters: webSearchSchema,
@@ -847,7 +849,7 @@ function makeSearchTool(config) {
 function makeFetchTool(config) {
     const providers = createFetchProviders(config);
     return {
-        name: "web_fetch",
+        name: "fetch_web",
         label: "Web Fetch",
         description: "pull a webpage down as clean markdown.",
         parameters: webFetchSchema,
@@ -923,6 +925,7 @@ export function createWebTools(_config) {
 }
 export const __webToolsTest = {
     PageCache,
+    createWebTools,
     createTestSearchProvider,
     createFetchProviders,
     formatFetchContent,