@qearlyao/familiar 0.2.3 → 0.2.5

package/dist/memory/lcm/indexer.js

@@ -8,11 +8,7 @@ export async function projectNormalizedLcmBatch(options) {
     }
     const storedRecords = [];
     for (const record of options.batch.records) {
-        const id = options.lcmStore.insertRecord(record);
-        const stored = options.lcmStore.getRecord(id);
-        if (!stored)
-            throw new Error(`Failed to read projected LCM record: ${id}`);
-        storedRecords.push(stored);
+        storedRecords.push(options.lcmStore.insertRecordReturningStored(record).record);
     }
     return {
         segmentIds,

package/dist/memory/lcm/normalize.js

@@ -59,7 +59,7 @@ export function normalizeChatRecords(chatRecords, options) {
                     kind: "tool_result",
                     toolCallId: record.event.toolCallId,
                     toolName: record.event.toolName,
-                    output: record.event.result,
+                    output: toolResultVisibleOutput(record.event.result),
                     ...(record.event.isError ? { isError: true } : {}),
                 },
             ];
@@ -191,6 +191,27 @@ function briefJson(value, maxLength = 160) {
     const compact = text.replace(/\s+/g, " ").trim();
     return compact.length > maxLength ? `${compact.slice(0, maxLength - 1)}...` : compact;
 }
+function toolResultVisibleOutput(result) {
+    if (!result || typeof result !== "object" || !("content" in result))
+        return result;
+    const content = result.content;
+    if (!Array.isArray(content))
+        return result;
+    return textFromToolResultContent(content);
+}
+function textFromToolResultContent(content) {
+    if (!Array.isArray(content))
+        return content;
+    return content
+        .map((item) => {
+        if (item && typeof item === "object" && item.type === "text") {
+            return item.text;
+        }
+        return "";
+    })
+        .filter((item) => typeof item === "string" && item.length > 0)
+        .join("\n");
+}
 function chatRecordSource(record, sourcePath) {
     const messageId = "messageId" in record && typeof record.messageId === "string"
         ? record.messageId

package/dist/memory/lcm/store.js

@@ -3,6 +3,7 @@ import { mkdirSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import Database from "better-sqlite3";
 import { normalizeFtsMatchQuery } from "../index/fts-query.js";
+import { runInTransaction } from "../util.js";
 import { readMeta, runLcmMigrations } from "./schema.js";
 export class LcmStore {
     db;
@@ -34,6 +35,9 @@ export class LcmStore {
         const raw = readMeta(this.db, "schema_version");
         return raw ? Number(raw) : null;
     }
+    computeRecordKey(input) {
+        return computeLcmRecordKey(input);
+    }
     ensureSegment(input) {
         const startedAt = input.startedAt ?? new Date().toISOString();
         this.db
@@ -68,6 +72,9 @@ export class LcmStore {
         return rows.map(segmentFromRow);
     }
     insertRecord(input) {
+        return this.insertRecordReturningStored(input).record.id;
+    }
+    insertRecordReturningStored(input) {
         const normalized = normalizeRecordInput(input);
         const runInsert = () => {
             this.ensureSegment({
@@ -76,14 +83,13 @@ export class LcmStore {
                 channelKey: normalized.channelKey,
                 startedAt: normalized.happenedAt,
             });
-            const existing = this.db
-                .prepare("SELECT id FROM lcm_records WHERE record_key = ?")
-                .get(normalized.recordKey);
+            const existing = this.db.prepare("SELECT * FROM lcm_records WHERE record_key = ?").get(normalized.recordKey);
             if (existing)
-                return existing.id;
-            return insertRecordPrepared(this.db, normalized);
+                return { record: recordFromRow(existing), inserted: false };
+            const inserted = insertRecordPrepared(this.db, normalized);
+            return { record: recordFromRow(inserted), inserted: true };
         };
-        return this.db.inTransaction ? runInsert() : this.db.transaction(runInsert).immediate();
+        return runInTransaction(this.db, runInsert);
     }
     getRecord(id) {
         const row = this.db.prepare("SELECT * FROM lcm_records WHERE id = ?").get(id);
@@ -132,7 +138,7 @@ export class LcmStore {
             this.insertSummarySources(id, sources);
             this.insertSummaryParents(id, parents);
         });
-        const result = this.db.inTransaction ? runInsert() : this.db.transaction(runInsert).immediate();
+        const result = runInTransaction(this.db, runInsert);
         return result;
     }
     getSummary(id) {
@@ -246,8 +252,14 @@ export class LcmStore {
                         .all(segmentId, retainDepth);
                     for (const summary of summaries) {
                         report.indexDeletes.push({ corpus: "lcm_summary", sourceId: lcmSummaryIndexSourceId(summary.id) });
-                        report.summaryFtsRowsDeleted += this.deleteSummaryFtsRow(summary.id);
                     }
+                    report.summaryFtsRowsDeleted += this.db
+                        .prepare(`DELETE FROM lcm_summaries_fts
+							 WHERE rowid IN (
+								SELECT id FROM lcm_summaries
+								WHERE segment_id = ? AND pinned = 0 AND depth < ?
+							 )`)
+                        .run(segmentId, retainDepth).changes;
                     report.summariesDeleted += this.db
                         .prepare("DELETE FROM lcm_summaries WHERE segment_id = ? AND pinned = 0 AND depth < ?")
                         .run(segmentId, retainDepth).changes;
@@ -257,8 +269,10 @@ export class LcmStore {
                 const records = this.db.prepare("SELECT id FROM lcm_records WHERE segment_id = ?").all(segmentId);
                 for (const record of records) {
                     report.indexDeletes.push({ corpus: "lcm_record", sourceId: lcmRecordIndexSourceId(record.id) });
-                    report.recordFtsRowsDeleted += this.deleteRecordFtsRow(record.id);
                 }
+                report.recordFtsRowsDeleted += this.db
+                    .prepare("DELETE FROM lcm_records_fts WHERE rowid IN (SELECT id FROM lcm_records WHERE segment_id = ?)")
+                    .run(segmentId).changes;
                 report.rawRecordsDeleted += this.db
                     .prepare("DELETE FROM lcm_records WHERE segment_id = ?")
                     .run(segmentId).changes;
@@ -318,20 +332,6 @@ export class LcmStore {
         }
         return map;
     }
-    deleteRecordFtsRow(id) {
-        const row = this.db.prepare("SELECT text_full FROM lcm_records WHERE id = ?").get(id);
-        if (!row)
-            return 0;
-        this.db.prepare("DELETE FROM lcm_records_fts WHERE rowid = ?").run(id);
-        return 1;
-    }
-    deleteSummaryFtsRow(id) {
-        const row = this.db.prepare("SELECT text_full FROM lcm_summaries WHERE id = ?").get(id);
-        if (!row)
-            return 0;
-        this.db.prepare("DELETE FROM lcm_summaries_fts WHERE rowid = ?").run(id);
-        return 1;
-    }
     snapshotSummariesForPrunedRecords(segmentId) {
         const summaries = this.db
             .prepare(`SELECT * FROM lcm_summaries
@@ -424,7 +424,10 @@ function insertRecordPrepared(db, normalized) {
     if (normalized.kind !== "boundary") {
         db.prepare("INSERT INTO lcm_records_fts(rowid, text_full) VALUES (?, ?)").run(id, normalized.text);
     }
-    return id;
+    const row = db.prepare("SELECT * FROM lcm_records WHERE id = ?").get(id);
+    if (!row)
+        throw new Error(`Failed to read inserted LCM record: ${id}`);
+    return row;
 }
 function normalizeSummaryInput(input) {
     const text = (input.text ?? "").trim();

package/dist/memory/operator.js

@@ -11,6 +11,7 @@ import { backfillFromChatLogs } from "./lcm/backfill.js";
 import { indexLcmRecords, indexLcmSummaries } from "./lcm/indexer.js";
 import { lcmRecordIndexSourceId, lcmSummaryIndexSourceId } from "./lcm/store.js";
 import { MemoryService } from "./service.js";
+import { runInTransaction } from "./util.js";
 export async function runMemoryOperator(config, argv) {
     const [command, ...args] = argv;
     if (!command || command === "--help" || command === "help") {
@@ -151,10 +152,7 @@ async function reindex(config, service, options, embeddingProvider, signal) {
         for (const corpus of corpora)
             deleteCorpus(service.memoryStore, corpus);
     };
-    if (service.memoryStore.db.inTransaction)
-        runDelete();
-    else
-        service.memoryStore.db.transaction(runDelete).immediate();
+    runInTransaction(service.memoryStore.db, runDelete);
     const indexer = options.force
         ? new ChunkIndexer({
             store: service.memoryStore,

package/dist/memory/service.js

@@ -1,5 +1,6 @@
 import { watch } from "node:fs";
 import { basename, resolve } from "node:path";
+import { isEnoent } from "../util/fs.js";
 import { __ambientDiaryInjectorTest, AmbientDiaryInjector } from "./diary/ambient-injector.js";
 import { DIARY_INDEX_FILE_RE, indexAllDiaryFiles, indexDiaryFile, removeDiaryFileIndex } from "./diary/indexer.js";
 import { ChunkIndexer } from "./index/chunk-indexer.js";
@@ -196,7 +197,4 @@ function parseIndexSourceId(value, prefix) {
     const id = Number(value.slice(prefix.length + 1));
     return Number.isInteger(id) && id > 0 ? id : null;
 }
-function isEnoent(error) {
-    return !!error && typeof error === "object" && "code" in error && error.code === "ENOENT";
-}
 export const __memoryServiceTest = __ambientDiaryInjectorTest;

package/dist/memory/tools.js

@@ -68,10 +68,6 @@ function makeMemoryRecallTool(deps) {
             return {
                 content: [{ type: "text", text: formatRecallResults(hits) }],
                 details: {
-                    query,
-                    scope,
-                    mode,
-                    limit,
                     resultCount: hits.length,
                     ids: hits.map((hit) => hit.id),
                 },

package/dist/memory/util.js

@@ -0,0 +1,6 @@
+export function positiveIntegerOrDefault(value, fallback) {
+    return value !== undefined && Number.isInteger(value) && value > 0 ? value : fallback;
+}
+export function runInTransaction(db, fn) {
+    return db.inTransaction ? fn() : db.transaction(fn).immediate();
+}

package/dist/models.js

@@ -95,6 +95,9 @@ export function createConfiguredModel(config) {
     }
     return resolveModel(ref, config);
 }
+export function resolveProviderSetting(records, provider, modelId) {
+    return records[`${provider}/${modelId}`] ?? records[provider];
+}
 export function resolveModelApiKey(config, model) {
     const configuredEnv = config.models.apiKeyEnvs[`${model.provider}/${model.id}`] ??
         config.models.apiKeyEnvs[model.provider] ??

package/dist/persona.js

@@ -1,23 +1,11 @@
 import { readFile } from "node:fs/promises";
-function isMissingFile(error) {
-    return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-async function readOptionalPersonaFile(path) {
-    try {
-        return await readFile(path, "utf8");
-    }
-    catch (error) {
-        if (isMissingFile(error))
-            return null;
-        throw error;
-    }
-}
+import { readFileOrNull } from "./util/fs.js";
 export async function loadPersona(config) {
     const [soul, user, memory, inner] = await Promise.all([
         readFile(config.persona.soul, "utf8"),
         readFile(config.persona.user, "utf8"),
         readFile(config.persona.memory, "utf8"),
-        readOptionalPersonaFile(config.persona.inner),
+        readFileOrNull(config.persona.inner, "utf8"),
     ]);
     return { soul, user, memory, inner };
 }

package/dist/runtime.js

@@ -1,31 +1,10 @@
 import { randomUUID } from "node:crypto";
 import { buildRecordBase, } from "./chat-log.js";
 import { promptAttachmentNotes } from "./inbound-attachments.js";
+import { formatLocalTimestamp } from "./util/time.js";
 function formatAuthor(authorName, authorId) {
     return authorName ? `${authorName} (uid:${authorId})` : `uid:${authorId}`;
 }
-function formatLocalTimestamp(ts) {
-    const date = new Date(ts);
-    if (Number.isNaN(date.getTime()))
-        return ts;
-    const offsetMinutes = -date.getTimezoneOffset();
-    const sign = offsetMinutes >= 0 ? "+" : "-";
-    const absolute = Math.abs(offsetMinutes);
-    const hours = Math.floor(absolute / 60);
-    const minutes = absolute % 60;
-    const offset = minutes === 0 ? `GMT${sign}${hours}` : `GMT${sign}${hours}:${String(minutes).padStart(2, "0")}`;
-    const local = [
-        date.getFullYear(),
-        String(date.getMonth() + 1).padStart(2, "0"),
-        String(date.getDate()).padStart(2, "0"),
-    ].join("-");
-    const time = [
-        String(date.getHours()).padStart(2, "0"),
-        String(date.getMinutes()).padStart(2, "0"),
-        String(date.getSeconds()).padStart(2, "0"),
-    ].join(":");
-    return `${local} ${time} ${offset}`;
-}
 function formatPromptRecord(record) {
     const text = record.text.trim() || "(no text)";
     const author = record.authorName?.trim()
@@ -365,7 +344,7 @@ export class ConversationRuntime {
     }
     async noteOutbound(options) {
         const text = options.text.trim();
-        if (!text && options.messageIds.length === 0)
+        if (!text && options.messageIds.length === 0 && !options.silent)
             return undefined;
         const record = {
             type: "outbound",

package/dist/scheduler.js

@@ -1,35 +1,9 @@
-import { appendFile, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, rename, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
+import { readFileOrNull } from "./util/fs.js";
+import { formatLocalTimestamp, toDate } from "./util/time.js";
+export { formatLocalTimestamp } from "./util/time.js";
 const stateWriteQueues = new Map();
-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)}`;
-}
 export function formatIdleDuration(ms) {
     if (!Number.isFinite(ms) || ms <= 0)
         return "0m";
@@ -53,9 +27,7 @@ export function buildHeartbeatInjectionText(options) {
     const body = options.body ??
         `hey~ been quiet for a bit. this is your time now.
 
-what you do with it is up to you — HEARTBEAT.md has the menu if you don't remember it. once you know the shape of it you don't have to re-read every fire, just trust what you remember and pick what fits.
-
-it's okay to sit one out, but only when that's actually the real answer — not when it's the easy one.`;
+what you do with it is up to you — HEARTBEAT.md has the menu if you don't remember it. once you know the shape of it you don't have to re-read every fire.`;
     return `<heartbeat local_time="${formatLocalTimestamp(nowDate)}" idle_duration="${formatIdleDuration(idleDurationMs)}" idle_minutes="${idleMinutes}">\n${body}\n</heartbeat>`;
 }
 function pad2(value) {
@@ -146,22 +118,16 @@ export function schedulerLogPath(dataDir, now = new Date()) {
     return resolve(dataDir, "scheduler", `${now.toISOString().slice(0, 10)}.jsonl`);
 }
 export async function loadSchedulerState(dataDir) {
-    const path = schedulerStatePath(dataDir);
-    try {
-        const raw = await readFile(path, "utf8");
-        const parsed = JSON.parse(raw);
-        return {
-            heartbeat: parsed.heartbeat && typeof parsed.heartbeat === "object" && !Array.isArray(parsed.heartbeat)
-                ? parsed.heartbeat
-                : undefined,
-            cron: parsed.cron && typeof parsed.cron === "object" && !Array.isArray(parsed.cron) ? parsed.cron : {},
-        };
-    }
-    catch (error) {
-        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
-            return { cron: {} };
-        throw error;
-    }
+    const raw = await readFileOrNull(schedulerStatePath(dataDir), "utf8");
+    if (raw === null)
+        return { cron: {} };
+    const parsed = JSON.parse(raw);
+    return {
+        heartbeat: parsed.heartbeat && typeof parsed.heartbeat === "object" && !Array.isArray(parsed.heartbeat)
+            ? parsed.heartbeat
+            : undefined,
+        cron: parsed.cron && typeof parsed.cron === "object" && !Array.isArray(parsed.cron) ? parsed.cron : {},
+    };
 }
 export async function saveSchedulerState(dataDir, state) {
     const path = schedulerStatePath(dataDir);

package/dist/service.js

@@ -141,6 +141,26 @@ async function run(command, args, options) {
     }
     await execFileAsync(command, args);
 }
+async function runInteractive(command, args, options, errorPrefix) {
+    const currentPlatform = options.platform ?? platform();
+    if (options.runCommand) {
+        await options.runCommand(command, args);
+        return;
+    }
+    await new Promise((resolveRun, rejectRun) => {
+        const child = spawn(command, args, {
+            shell: currentPlatform === "win32",
+            stdio: "inherit",
+        });
+        child.on("exit", (code) => {
+            if (code === 0)
+                resolveRun();
+            else
+                rejectRun(new Error(`${errorPrefix} failed with exit code ${code ?? "unknown"}`));
+        });
+        child.on("error", rejectRun);
+    });
+}
 async function capture(command, args, options) {
     if (options.captureCommand)
         return options.captureCommand(command, args);
@@ -254,22 +274,12 @@ async function supervisorState(spec, options) {
         return "not-loaded";
     }
 }
-export async function upgradeFamiliar(options = {}) {
+export async function upgradeFamiliar(workspacePath, options = {}) {
     const currentPlatform = options.platform ?? platform();
     const npmCommand = currentPlatform === "win32" ? "npm.cmd" : "npm";
-    await new Promise((resolveUpgrade, rejectUpgrade) => {
-        const child = spawn(npmCommand, ["install", "-g", "@qearlyao/familiar@latest"], {
-            shell: currentPlatform === "win32",
-            stdio: "inherit",
-        });
-        child.on("exit", (code) => {
-            if (code === 0)
-                resolveUpgrade();
-            else
-                rejectUpgrade(new Error(`npm upgrade failed with exit code ${code ?? "unknown"}`));
-        });
-        child.on("error", rejectUpgrade);
-    });
+    const familiarCommand = currentPlatform === "win32" ? "familiar.cmd" : "familiar";
+    await runInteractive(npmCommand, ["install", "-g", "@qearlyao/familiar@latest"], options, "npm upgrade");
+    await runInteractive(familiarCommand, ["init", workspacePath], options, "workspace default refresh");
 }
 export function formatServiceResult(result) {
     return [result.title, ...result.details].join("\n");

package/dist/settings.js

@@ -1,13 +1,6 @@
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
-function isThinkingLevel(value) {
-    return (value === "off" ||
-        value === "minimal" ||
-        value === "low" ||
-        value === "medium" ||
-        value === "high" ||
-        value === "xhigh");
-}
+import { resolve } from "node:path";
+import { isThinkingLevel } from "./models.js";
+import { atomicWriteJson, createWriteQueue, readFileOrNull } from "./util/fs.js";
 function isChannelTrigger(value) {
     return value === "mention" || value === "always";
 }
@@ -37,16 +30,8 @@ function normalizeSettingsFile(value) {
     return { version: 1, channels };
 }
 async function readSettingsFile(path) {
-    try {
-        const raw = await readFile(path, "utf8");
-        return normalizeSettingsFile(JSON.parse(raw));
-    }
-    catch (error) {
-        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
-            return { version: 1, channels: {} };
-        }
-        throw error;
-    }
+    const raw = await readFileOrNull(path, "utf8");
+    return raw === null ? { version: 1, channels: {} } : normalizeSettingsFile(JSON.parse(raw));
 }
 function pruneChannel(settings) {
     const pruned = {};
@@ -61,18 +46,8 @@ function pruneChannel(settings) {
 export async function loadSettingsStore(config) {
     const path = resolve(config.workspace.dataDir, "settings", "channel-overrides.json");
     let file = await readSettingsFile(path);
-    let writeQueue = Promise.resolve();
-    const persist = async () => {
-        await mkdir(dirname(path), { recursive: true });
-        const tmpPath = `${path}.${process.pid}.${Date.now()}.tmp`;
-        await writeFile(tmpPath, `${JSON.stringify(file, null, 2)}\n`, "utf8");
-        await rename(tmpPath, path);
-    };
-    const enqueuePersist = () => {
-        const run = writeQueue.then(persist, () => persist());
-        writeQueue = run.then(() => undefined, () => undefined);
-        return run;
-    };
+    const enqueueWrite = createWriteQueue("channel settings");
+    const enqueuePersist = () => enqueueWrite(() => atomicWriteJson(path, file));
     const updateChannel = async (channelKey, patch) => {
         const next = pruneChannel({ ...file.channels[channelKey], ...patch });
         const channels = { ...file.channels };

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;
 }