npm - @qearlyao/familiar - Versions diffs - 0.2.4 → 0.2.5 - Mend

@qearlyao/familiar 0.2.4 → 0.2.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/browser-tools.js CHANGED Viewed

@@ -192,6 +192,15 @@ function parseJson(text) {
         return undefined;
     }
 }
+function parseOpenCliJsonOutput(result, context) {
+    if (result.json !== undefined)
+        return result.json;
+    const output = result.stdout.trim();
+    if (!output)
+        throw new Error(`OpenCLI ${context} returned no JSON output.`);
+    const tail = output.slice(-120).replace(/\s+/g, " ").trim();
+    throw new Error(`OpenCLI ${context} returned malformed JSON output near: ${tail || "(empty)"}`);
+}
 function stringArg(value) {
     if (value === undefined || value === null)
         return undefined;
@@ -522,24 +531,47 @@ function assertSiteAllowed(config, site) {
     if (!config.browser.allowedSites[site])
         throw new Error(`OpenCLI site is not allowlisted: ${site}`);
 }
+function commandInfoFromJson(json) {
+    if (!isRecord(json))
+        return undefined;
+    const name = stringArg(json.name);
+    if (!name)
+        return undefined;
+    return {
+        name,
+        access: stringArg(json.access) ?? "unknown",
+        description: stringArg(json.description),
+        usage: stringArg(json.usage),
+    };
+}
 function parseSiteCommands(json) {
     const commands = isRecord(json) && Array.isArray(json.commands) ? json.commands : [];
-    return commands.flatMap((command) => {
-        if (!isRecord(command))
-            return [];
-        const name = stringArg(command.name);
-        if (!name)
+    return {
+        commands: commands.flatMap((command) => {
+            const info = commandInfoFromJson(command);
+            return info ? [info] : [];
+        }),
+        complete: true,
+    };
+}
+function parsePlainSiteHelp(site, text) {
+    const commandSection = text.match(/Commands:\n(?<body>[\s\S]*?)(?:\n\n[A-Z][^\n]* options:|\n\nCommon options:|\n\nBrowser common options:|\n\nAgent tip:|$)/);
+    const body = commandSection?.groups?.body;
+    if (!body)
+        return undefined;
+    const commands = body.split("\n").flatMap((line) => {
+        const match = line.match(/^\s{2}(?<name>[A-Za-z0-9._-]+)\b.*\[(?<access>read|write|admin)\]/);
+        if (!match?.groups)
             return [];
-        const access = stringArg(command.access) ?? "unknown";
         return [
             {
-                name,
-                access,
-                description: stringArg(command.description),
-                usage: stringArg(command.usage),
+                name: match.groups.name,
+                access: match.groups.access,
+                usage: `opencli ${site} ${match.groups.name}`,
             },
         ];
     });
+    return { commands, complete: false };
 }
 async function loadSiteCommands(site, config, runner, signal) {
     const result = await runner(openCliSpec(config, [...baseArgs(config), site, "--help", "-f", "json"]), {
@@ -548,13 +580,33 @@ async function loadSiteCommands(site, config, runner, signal) {
     });
     if (!result.ok)
         throw new Error(formatBrowserResult(result, config.browser.maxOutputChars).text);
-    return parseSiteCommands(result.json);
+    try {
+        return parseSiteCommands(parseOpenCliJsonOutput(result, `${site} metadata`));
+    }
+    catch (error) {
+        const plainResult = await runner(openCliSpec(config, [...baseArgs(config), site, "--help"]), {
+            timeoutMs: config.browser.timeoutMs,
+            signal,
+        });
+        if (!plainResult.ok)
+            throw error;
+        const plainListing = parsePlainSiteHelp(site, plainResult.stdout);
+        if (!plainListing)
+            throw error;
+        return plainListing;
+    }
 }
-function findSiteCommand(commands, site, command) {
-    const match = commands.find((item) => item.name === command);
-    if (!match)
+async function loadSiteCommand(site, command, config, runner, signal) {
+    const result = await runner(openCliSpec(config, [...baseArgs(config), site, command, "--help", "-f", "json"]), {
+        timeoutMs: config.browser.timeoutMs,
+        signal,
+    });
+    if (!result.ok)
+        throw new Error(formatBrowserResult(result, config.browser.maxOutputChars).text);
+    const info = commandInfoFromJson(parseOpenCliJsonOutput(result, `${site} ${command} metadata`));
+    if (!info || info.name !== command)
         throw new Error(`OpenCLI site command is not available: ${site} ${command}`);
-    return match;
+    return info;
 }
 function buildSiteArgs(input, config, commandInfo) {
     const site = stringArg(input.site);
@@ -603,8 +655,8 @@ async function buildSiteRunSpec(input, config, runner, signal) {
     assertSafeName(site, "browser.site");
     assertSafeName(command, "browser.command");
     assertSiteAllowed(config, site);
-    const commands = await loadSiteCommands(site, config, runner, signal);
-    return openCliSpec(config, buildSiteArgs(input, config, findSiteCommand(commands, site, command)));
+    const commandInfo = await loadSiteCommand(site, command, config, runner, signal);
+    return openCliSpec(config, buildSiteArgs(input, config, commandInfo));
 }
 function buildRunSpec(input, config) {
     const backend = pageBackend(input, config);
@@ -622,15 +674,16 @@ async function listCommands(input, config, runner, signal) {
     const sites = site ? [site] : Object.keys(config.browser.allowedSites);
     const lines = ["allowlisted site commands:"];
     for (const name of sites) {
-        const commands = await loadSiteCommands(name, config, runner, signal);
+        const listing = await loadSiteCommands(name, config, runner, signal);
         const groups = new Map();
-        for (const command of commands) {
+        for (const command of listing.commands) {
             const names = groups.get(command.access) ?? [];
             names.push(command.name);
             groups.set(command.access, names);
         }
         const parts = Array.from(groups.entries()).map(([access, names]) => `${access}=[${names.join(", ")}]`);
-        lines.push(`- ${name}: ${parts.join(" ")}`);
+        const suffix = listing.complete ? "" : " (from plain help)";
+        lines.push(`- ${name}: ${parts.join(" ")}${suffix}`);
     }
     return lines.join("\n");
 }

package/dist/image-gen.js CHANGED Viewed

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { lstat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
 import { basename, isAbsolute, relative, resolve } from "node:path";
 import { findEnvKeys, generateImages, getEnvApiKey, getImageModels, getImageProviders, } from "@earendil-works/pi-ai";
 import { Type } from "typebox";
@@ -13,9 +14,10 @@ const OPENROUTER_IMAGE_BASE_URL = "https://openrouter.ai/api/v1";
 const imageGenSchema = Type.Object({
     prompt: Type.String({ description: "Image generation prompt." }),
     referenceImages: Type.Optional(Type.Array(Type.String(), {
-        description: "Optional. Image attachment IDs or names, or workspace-relative image file paths, to use as visual references. Prefer IDs from the attachment tags when available.",
+        description: "Optional. Image attachment IDs or names, or workspace-relative, absolute, or ~/ image file paths, to use as visual references. Prefer IDs from the attachment tags when available.",
     })),
 }, { additionalProperties: false });
+const MAX_REMOTE_IMAGE_BYTES = 12 * 1024 * 1024;
 function formatImageGenNotice(name) {
     return `${IMAGE_GEN_NOTICE_PREFIX} ${name}`;
 }
@@ -116,7 +118,7 @@ function recoveredImageFromBase64(value) {
         data,
     };
 }
-function recoveredImageFromText(text) {
+function recoveredInlineImageFromText(text) {
     const trimmed = text.trim();
     const dataUrlMatch = trimmed.match(/^data:(image\/[^;]+);base64,([A-Za-z0-9+/]+={0,2})$/);
     if (dataUrlMatch)
@@ -127,7 +129,80 @@ function recoveredImageFromText(text) {
     }
     return recoveredImageFromBase64(trimmed);
 }
-function normalizeCompatibleImageText(result) {
+function imageUrlFromMarkdownText(text) {
+    const match = text.match(/!\[[^\]]*]\((https?:\/\/[^)\s]+)\)/i);
+    if (!match?.[1])
+        return undefined;
+    try {
+        const url = new URL(match[1]);
+        if (url.protocol !== "https:" && url.protocol !== "http:")
+            return undefined;
+        return url;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readBoundedResponseBody(response, maxBytes) {
+    const reader = response.body?.getReader();
+    if (!reader) {
+        const buffer = Buffer.from(await response.arrayBuffer());
+        return buffer.byteLength > maxBytes ? undefined : buffer;
+    }
+    const chunks = [];
+    let total = 0;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            const chunk = Buffer.from(value);
+            total += chunk.byteLength;
+            if (total > maxBytes)
+                return undefined;
+            chunks.push(chunk);
+        }
+        return Buffer.concat(chunks);
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+async function recoveredImageFromRemoteUrl(url, options) {
+    try {
+        const response = await fetch(url, { signal: options.signal });
+        if (!response.ok)
+            return undefined;
+        const contentLength = Number(response.headers.get("content-length") ?? 0);
+        if (contentLength > MAX_REMOTE_IMAGE_BYTES)
+            return undefined;
+        const bytes = await readBoundedResponseBody(response, MAX_REMOTE_IMAGE_BYTES);
+        if (!bytes)
+            return undefined;
+        const detectedMimeType = sniffImageMimeType(bytes);
+        if (!detectedMimeType)
+            return undefined;
+        return {
+            mimeType: detectedMimeType,
+            data: bytes.toString("base64"),
+        };
+    }
+    catch (error) {
+        if (options.signal?.aborted)
+            throw error;
+        return undefined;
+    }
+}
+async function recoveredImageFromText(text, options) {
+    const inlineImage = recoveredInlineImageFromText(text);
+    if (inlineImage)
+        return inlineImage;
+    const url = imageUrlFromMarkdownText(text);
+    if (!url)
+        return undefined;
+    return recoveredImageFromRemoteUrl(url, options);
+}
+async function normalizeCompatibleImageText(result, options) {
     if (result.output.some((item) => item.type === "image"))
         return result;
     const output = [];
@@ -136,7 +211,7 @@ function normalizeCompatibleImageText(result) {
             output.push(item);
             continue;
         }
-        const recovered = recoveredImageFromText(item.text);
+        const recovered = await recoveredImageFromText(item.text, options);
         if (!recovered) {
             output.push(item);
             continue;
@@ -148,7 +223,11 @@ function normalizeCompatibleImageText(result) {
     return { ...result, output };
 }
 function resolveWorkspaceReferencePath(config, rawRef) {
-    const path = isAbsolute(rawRef) ? resolve(rawRef) : resolve(config.workspacePath, rawRef);
+    if (rawRef === "~" || rawRef.startsWith("~/"))
+        return resolve(homedir(), rawRef.slice(2));
+    if (isAbsolute(rawRef))
+        return resolve(rawRef);
+    const path = resolve(config.workspacePath, rawRef);
     const workspaceRelative = relative(config.workspacePath, path);
     if (!workspaceRelative || workspaceRelative.startsWith("..") || isAbsolute(workspaceRelative)) {
         throw new Error(`Reference image path must be inside the workspace: ${rawRef}`);
@@ -304,13 +383,14 @@ async function writeGeneratedImages(config, mediaSink, result) {
 async function tryGenerateImages(config, ref, prompt, references, workspaceRefs, signal, generate) {
     const model = resolveImageModel(config, ref);
     const context = await buildImageContext(model, prompt, references, workspaceRefs, config);
+    const result = await generate(model, context, {
+        apiKey: resolveImageModelApiKey(config, model),
+        signal,
+        timeoutMs: config.imageGen.timeoutMs,
+    });
     return {
         model,
-        result: normalizeCompatibleImageText(await generate(model, context, {
-            apiKey: resolveImageModelApiKey(config, model),
-            signal,
-            timeoutMs: config.imageGen.timeoutMs,
-        })),
+        result: await normalizeCompatibleImageText(result, { signal }),
     };
 }
 function attemptDetails(model, result) {

package/dist/util/fs.js CHANGED Viewed

@@ -14,7 +14,7 @@ export async function readFileOrNull(path, encoding) {
     }
 }
 async function fsyncFile(path) {
-    const handle = await open(path, "r");
+    const handle = await open(path, "r+");
     try {
         await handle.sync();
     }

package/npm-shrinkwrap.json CHANGED Viewed

@@ -1,12 +1,12 @@
 {
 	"name": "@qearlyao/familiar",
-	"version": "0.2.4",
+	"version": "0.2.5",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "@qearlyao/familiar",
-			"version": "0.2.4",
+			"version": "0.2.5",
 			"license": "MIT",
 			"dependencies": {
 				"@earendil-works/pi-agent-core": "0.75.5",

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
 	"name": "@qearlyao/familiar",
-	"version": "0.2.4",
+	"version": "0.2.5",
 	"license": "MIT",
 	"type": "module",
 	"repository": {