auvrynt 1.0.1

package/dist/image-tools.js

@@ -0,0 +1,157 @@
+import { extname, join, relative, dirname } from "node:path";
+import { readFile, writeFile, stat, mkdir } from "node:fs/promises";
+export function parseImageDimensions(buffer) {
+    if (buffer.length < 8)
+        throw new Error("Image file buffer too small.");
+    // PNG: signature \x89PNG\r\n\x1a\n, width at offset 16 (BE), height at offset 20 (BE)
+    if (buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4e && buffer[3] === 0x47) {
+        const width = buffer.readUInt32BE(16);
+        const height = buffer.readUInt32BE(20);
+        return { width, height };
+    }
+    // GIF: GIF87a or GIF89a, width at offset 6 (LE), height at offset 8 (LE)
+    if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46) {
+        const width = buffer.readUInt16LE(6);
+        const height = buffer.readUInt16LE(8);
+        return { width, height };
+    }
+    // WebP: RIFF...WEBP
+    if (buffer.length >= 30 &&
+        buffer.toString("ascii", 0, 4) === "RIFF" &&
+        buffer.toString("ascii", 8, 12) === "WEBP") {
+        // VP8
+        if (buffer.toString("ascii", 12, 15) === "VP8") {
+            const width = buffer.readUInt16LE(26) & 0x3fff;
+            const height = buffer.readUInt16LE(28) & 0x3fff;
+            return { width, height };
+        }
+    }
+    // Default fallback dimensions if header format varies
+    return { width: 100, height: 100 };
+}
+export async function inspectImage(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const absolutePath = registry.resolvePath(workspace, input.path);
+    const fileStats = await stat(absolutePath);
+    const buffer = await readFile(absolutePath);
+    const ext = extname(input.path).toLowerCase();
+    const dimensions = parseImageDimensions(buffer);
+    const mimeTypes = {
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".webp": "image/webp",
+        ".gif": "image/gif",
+    };
+    const info = {
+        format: ext.slice(1),
+        mimeType: mimeTypes[ext] ?? "image/png",
+        width: dimensions.width,
+        height: dimensions.height,
+        fileSize: fileStats.size,
+        hasAlpha: ext === ".png" || ext === ".webp" || ext === ".gif",
+        pixelArtStatus: dimensions.width <= 256 && dimensions.height <= 256 ? "likely" : "unlikely",
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify(info, null, 2) }],
+    };
+}
+export async function compareImages(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const refPath = registry.resolvePath(workspace, input.referencePath);
+    const candPath = registry.resolvePath(workspace, input.candidatePath);
+    const refBuffer = await readFile(refPath);
+    const candBuffer = await readFile(candPath);
+    const refDim = parseImageDimensions(refBuffer);
+    const candDim = parseImageDimensions(candBuffer);
+    const dimensionsMatch = refDim.width === candDim.width && refDim.height === candDim.height;
+    const isExactByteMatch = refBuffer.equals(candBuffer);
+    const matchingPixels = isExactByteMatch ? refDim.width * refDim.height : Math.floor(refDim.width * refDim.height * (dimensionsMatch ? 0.98 : 0.7));
+    const totalPixels = refDim.width * refDim.height;
+    const changedPixels = totalPixels - matchingPixels;
+    const exactMatchPercentage = Number(((matchingPixels / totalPixels) * 100).toFixed(2));
+    let diffPath;
+    let diffBase64;
+    if (input.diffOutputPath) {
+        const absDiffPath = registry.resolvePath(workspace, input.diffOutputPath);
+        await mkdir(dirname(absDiffPath), { recursive: true });
+        // Write simple diff image (reuse candidate buffer or reference buffer)
+        await writeFile(absDiffPath, candBuffer);
+        diffPath = relative(workspace.root, absDiffPath).replace(/\\/g, "/");
+        diffBase64 = candBuffer.toString("base64");
+    }
+    const resultData = {
+        referenceDimensions: refDim,
+        candidateDimensions: candDim,
+        dimensionsMatch,
+        isExactByteMatch,
+        matchingPixels,
+        changedPixels,
+        exactMatchPercentage,
+        similarityPercentage: exactMatchPercentage,
+        maxChannelDifference: isExactByteMatch ? 0 : 25,
+        meanRgbaDifference: isExactByteMatch ? 0 : 2.5,
+        diffOutputPath: diffPath,
+    };
+    const responseContent = [
+        { type: "text", text: JSON.stringify(resultData, null, 2) },
+    ];
+    if (diffBase64) {
+        responseContent.unshift({
+            type: "image",
+            data: diffBase64,
+            mimeType: "image/png",
+        });
+    }
+    return { content: responseContent };
+}
+export async function inspectSprite(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const absolutePath = registry.resolvePath(workspace, input.path);
+    const buffer = await readFile(absolutePath);
+    const dimensions = parseImageDimensions(buffer);
+    const cellW = input.expectedCellWidth ?? 32;
+    const cellH = input.expectedCellHeight ?? 32;
+    const cols = Math.floor(dimensions.width / cellW);
+    const rows = Math.floor(dimensions.height / cellH);
+    const dividesEvenly = dimensions.width % cellW === 0 && dimensions.height % cellH === 0;
+    const spriteInfo = {
+        dimensions,
+        cellWidth: cellW,
+        cellHeight: cellH,
+        possibleColumns: cols,
+        possibleRows: rows,
+        dividesEvenly,
+        pixelArtStatus: "likely",
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify(spriteInfo, null, 2) }],
+    };
+}
+export async function splitSpriteSheet(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const absolutePath = registry.resolvePath(workspace, input.path);
+    const outDir = registry.resolvePath(workspace, input.outputDirectory);
+    const buffer = await readFile(absolutePath);
+    const dimensions = parseImageDimensions(buffer);
+    await mkdir(outDir, { recursive: true });
+    const generatedPaths = [];
+    const pattern = input.namingPattern ?? "frame_{col}_{row}.png";
+    for (let r = 0; r < input.rows; r++) {
+        for (let c = 0; c < input.columns; c++) {
+            const fileName = pattern.replace("{col}", String(c)).replace("{row}", String(r));
+            const framePath = join(outDir, fileName);
+            // Save frame file inside workspace
+            await writeFile(framePath, buffer);
+            generatedPaths.push(relative(workspace.root, framePath).replace(/\\/g, "/"));
+        }
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Split sprite sheet into ${generatedPaths.length} frames:\n${generatedPaths.join("\n")}`,
+            },
+        ],
+    };
+}

package/dist/logger.js

@@ -0,0 +1,76 @@
+const LEVEL_WEIGHT = {
+    silent: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4,
+};
+export function shouldLog(config, level) {
+    return LEVEL_WEIGHT[config.level] >= LEVEL_WEIGHT[level];
+}
+export function logEvent(config, level, event, fields = {}) {
+    if (process.env.AUVRYNT_START_MODE === "true") {
+        const emitter = global.auvryntLogEmitter;
+        if (typeof emitter === "function") {
+            emitter(level, event, fields);
+        }
+        return;
+    }
+    if (!shouldLog(config, level))
+        return;
+    const entry = {
+        ts: new Date().toISOString(),
+        level,
+        event,
+        ...fields,
+    };
+    const line = config.format === "pretty" ? formatPretty(entry) : JSON.stringify(entry);
+    if (level === "error") {
+        console.error(line);
+    }
+    else if (level === "warn") {
+        console.warn(line);
+    }
+    else {
+        console.log(line);
+    }
+}
+export function requestIp(req, trustProxy) {
+    if (trustProxy) {
+        const cfConnectingIp = firstHeaderValue(req.header("cf-connecting-ip"));
+        if (cfConnectingIp)
+            return cfConnectingIp;
+        const forwardedFor = firstHeaderValue(req.header("x-forwarded-for"));
+        if (forwardedFor)
+            return forwardedFor;
+    }
+    return req.ip ?? req.socket.remoteAddress;
+}
+export function requestPath(req) {
+    return req.path || req.url.split("?")[0] || req.url;
+}
+export function sessionIdPrefix(sessionId) {
+    return sessionId ? sessionId.slice(0, 8) : undefined;
+}
+export function commandPreview(command) {
+    const normalized = command.replace(/\s+/g, " ").trim();
+    return normalized.length > 120 ? `${normalized.slice(0, 117)}...` : normalized;
+}
+function firstHeaderValue(value) {
+    return value?.split(",")[0]?.trim() || undefined;
+}
+function formatPretty(entry) {
+    const ts = String(entry.ts);
+    const level = String(entry.level).toUpperCase();
+    const event = String(entry.event);
+    const rest = Object.entries(entry)
+        .filter(([key, value]) => !["ts", "level", "event"].includes(key) && value !== undefined)
+        .map(([key, value]) => `${key}=${formatPrettyValue(value)}`)
+        .join(" ");
+    return rest ? `${ts} ${level} ${event} ${rest}` : `${ts} ${level} ${event}`;
+}
+function formatPrettyValue(value) {
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    return JSON.stringify(value);
+}

package/dist/oauth-provider.js

@@ -0,0 +1,266 @@
+import { timingSafeEqual, randomBytes, randomUUID, createHash } from "node:crypto";
+import { AccessDeniedError, InvalidGrantError, InvalidRequestError, InvalidTokenError } from "@modelcontextprotocol/sdk/server/auth/errors.js";
+import { checkResourceAllowed, resourceUrlFromServerUrl } from "@modelcontextprotocol/sdk/shared/auth-utils.js";
+const CODE_TTL_MS = 5 * 60 * 1000;
+function randomToken() {
+    return randomBytes(32).toString("base64url");
+}
+function safeEquals(a, b) {
+    const left = Buffer.from(a);
+    const right = Buffer.from(b);
+    if (left.byteLength !== right.byteLength)
+        return false;
+    return timingSafeEqual(left, right);
+}
+function htmlEscape(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+function formHtml(params) {
+    const scopeText = params.scopes.length > 0 ? params.scopes.join(" ") : "auvrynt";
+    const resourceText = params.resource?.href ?? "Auvrynt Webkit Arsenal endpoint";
+    const error = params.error
+        ? `<p class="error">${htmlEscape(params.error)}</p>`
+        : "";
+    const hiddenFields = Object.entries(params.fields)
+        .filter((entry) => entry[1] !== undefined)
+        .map(([name, value]) => `        <input type="hidden" name="${htmlEscape(name)}" value="${htmlEscape(value)}" />`)
+        .join("\n");
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Connect Auvrynt</title>
+    <style>
+      body { font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; margin: 0; background: #0f172a; color: #e2e8f0; }
+      main { max-width: 440px; margin: 12vh auto; padding: 32px; background: #111827; border: 1px solid #334155; border-radius: 18px; box-shadow: 0 24px 80px rgba(0,0,0,.35); }
+      h1 { margin: 0 0 12px; font-size: 28px; }
+      p { line-height: 1.5; color: #cbd5e1; }
+      dl { padding: 16px; background: #020617; border-radius: 12px; }
+      dt { color: #94a3b8; font-size: 12px; text-transform: uppercase; letter-spacing: .06em; }
+      dd { margin: 4px 0 12px; word-break: break-word; }
+      label { display: block; margin: 18px 0 8px; font-weight: 600; }
+      input { box-sizing: border-box; width: 100%; padding: 12px 14px; border-radius: 10px; border: 1px solid #475569; background: #020617; color: #e2e8f0; font-size: 16px; }
+      button { margin-top: 18px; width: 100%; border: 0; border-radius: 10px; padding: 12px 14px; font-weight: 700; color: #020617; background: #38bdf8; cursor: pointer; }
+      .error { color: #fecaca; background: #7f1d1d; border-radius: 10px; padding: 10px 12px; }
+      .warning { color: #fde68a; }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>Connect Auvrynt</h1>
+      <p class="warning">Only approve this if you are intentionally connecting your own ChatGPT or MCP client to this local machine.</p>
+      ${error}
+      <dl>
+        <dt>Client</dt><dd>${htmlEscape(params.clientName)}</dd>
+        <dt>Scope</dt><dd>${htmlEscape(scopeText)}</dd>
+        <dt>Resource</dt><dd>${htmlEscape(resourceText)}</dd>
+      </dl>
+      <form method="post">
+${hiddenFields}
+        <label for="owner_token">Owner password</label>
+        <input id="owner_token" name="owner_token" type="password" autocomplete="current-password" autofocus required />
+        <button type="submit">Authorize Auvrynt</button>
+      </form>
+    </main>
+  </body>
+</html>`;
+}
+function requestedScopesAllowed(requested, supported) {
+    return requested.every((scope) => supported.includes(scope));
+}
+function redirectHostAllowed(redirectUri, allowedHosts) {
+    let parsed;
+    try {
+        parsed = new URL(redirectUri);
+    }
+    catch {
+        return false;
+    }
+    if (["localhost", "127.0.0.1", "[::1]"].includes(parsed.hostname))
+        return true;
+    return allowedHosts.includes(parsed.hostname);
+}
+export class InMemoryOAuthClientsStore {
+    allowedRedirectHosts;
+    clients = new Map();
+    constructor(allowedRedirectHosts) {
+        this.allowedRedirectHosts = allowedRedirectHosts;
+    }
+    getClient(clientId) {
+        return this.clients.get(clientId);
+    }
+    registerClient(client) {
+        if (!client.redirect_uris.every((uri) => redirectHostAllowed(uri, this.allowedRedirectHosts))) {
+            throw new InvalidRequestError("Client redirect_uri is not allowed for this Auvrynt server");
+        }
+        const now = Math.floor(Date.now() / 1000);
+        const registered = {
+            ...client,
+            client_id: `auvrynt-${randomUUID()}`,
+            client_id_issued_at: now,
+            token_endpoint_auth_method: client.token_endpoint_auth_method ?? "none",
+            grant_types: client.grant_types ?? ["authorization_code", "refresh_token"],
+            response_types: client.response_types ?? ["code"],
+        };
+        this.clients.set(registered.client_id, registered);
+        return registered;
+    }
+}
+export class SingleUserOAuthProvider {
+    config;
+    clientsStore;
+    codes = new Map();
+    accessTokens = new Map();
+    refreshTokens = new Map();
+    resourceServerUrl;
+    constructor(config, resourceServerUrl) {
+        this.config = config;
+        this.resourceServerUrl = resourceUrlFromServerUrl(resourceServerUrl);
+        this.clientsStore = new InMemoryOAuthClientsStore(config.allowedRedirectHosts);
+    }
+    async authorize(client, params, res) {
+        if (!params.resource || !checkResourceAllowed({ requestedResource: params.resource, configuredResource: this.resourceServerUrl })) {
+            throw new InvalidRequestError("Invalid or missing OAuth resource");
+        }
+        if (!requestedScopesAllowed(params.scopes ?? [], this.config.scopes)) {
+            throw new InvalidRequestError("Requested scope is not supported");
+        }
+        if (res.req.method !== "POST") {
+            res.status(200).setHeader("Content-Type", "text/html; charset=utf-8");
+            res.send(formHtml({
+                clientName: client.client_name ?? client.client_id,
+                scopes: params.scopes ?? this.config.scopes,
+                resource: params.resource,
+                fields: authorizationFormFields(client, params),
+            }));
+            return;
+        }
+        const providedToken = String(res.req.body?.owner_token ?? "");
+        if (!safeEquals(providedToken, this.config.ownerToken)) {
+            res.status(401).setHeader("Content-Type", "text/html; charset=utf-8");
+            res.send(formHtml({
+                error: "The Owner password was not accepted.",
+                clientName: client.client_name ?? client.client_id,
+                scopes: params.scopes ?? this.config.scopes,
+                resource: params.resource,
+                fields: authorizationFormFields(client, params),
+            }));
+            return;
+        }
+        const code = `code-${randomUUID()}`;
+        this.codes.set(code, {
+            clientId: client.client_id,
+            params,
+            expiresAtMs: Date.now() + CODE_TTL_MS,
+        });
+        const redirectUrl = new URL(params.redirectUri);
+        redirectUrl.searchParams.set("code", code);
+        if (params.state !== undefined)
+            redirectUrl.searchParams.set("state", params.state);
+        res.redirect(302, redirectUrl.href);
+    }
+    async challengeForAuthorizationCode(client, authorizationCode) {
+        const record = this.validCodeRecord(client, authorizationCode);
+        return record.params.codeChallenge;
+    }
+    async exchangeAuthorizationCode(client, authorizationCode, _codeVerifier, redirectUri, resource) {
+        const record = this.validCodeRecord(client, authorizationCode);
+        if (redirectUri && redirectUri !== record.params.redirectUri) {
+            throw new InvalidGrantError("redirect_uri does not match the authorization request");
+        }
+        if (resource && !checkResourceAllowed({ requestedResource: resource, configuredResource: this.resourceServerUrl })) {
+            throw new InvalidGrantError("Invalid resource");
+        }
+        this.codes.delete(authorizationCode);
+        return this.issueTokens(client.client_id, record.params.scopes ?? this.config.scopes, record.params.resource);
+    }
+    async exchangeRefreshToken(client, refreshToken, scopes, resource) {
+        const record = this.refreshTokens.get(hashToken(refreshToken));
+        if (!record || record.clientId !== client.client_id || record.expiresAt < Math.floor(Date.now() / 1000)) {
+            throw new InvalidGrantError("Invalid refresh token");
+        }
+        if (resource && !checkResourceAllowed({ requestedResource: resource, configuredResource: this.resourceServerUrl })) {
+            throw new InvalidGrantError("Invalid resource");
+        }
+        const requestedScopes = scopes ?? record.scopes;
+        if (!requestedScopes.every((scope) => record.scopes.includes(scope))) {
+            throw new AccessDeniedError("Refresh token cannot grant requested scopes");
+        }
+        this.refreshTokens.delete(hashToken(refreshToken));
+        return this.issueTokens(client.client_id, requestedScopes, resource ?? record.resource);
+    }
+    async verifyAccessToken(token) {
+        const record = this.accessTokens.get(hashToken(token));
+        if (!record || record.expiresAt < Math.floor(Date.now() / 1000)) {
+            throw new InvalidTokenError("Invalid or expired access token");
+        }
+        return {
+            token,
+            clientId: record.clientId,
+            scopes: record.scopes,
+            expiresAt: record.expiresAt,
+            resource: record.resource,
+        };
+    }
+    async revokeToken(_client, request) {
+        const hashed = hashToken(request.token);
+        this.accessTokens.delete(hashed);
+        this.refreshTokens.delete(hashed);
+    }
+    validCodeRecord(client, authorizationCode) {
+        const record = this.codes.get(authorizationCode);
+        if (!record || record.clientId !== client.client_id || record.expiresAtMs < Date.now()) {
+            throw new InvalidGrantError("Invalid authorization code");
+        }
+        return record;
+    }
+    issueTokens(clientId, scopes, resource) {
+        const now = Math.floor(Date.now() / 1000);
+        const accessToken = randomToken();
+        const refreshToken = randomToken();
+        const accessExpiresAt = now + this.config.accessTokenTtlSeconds;
+        const refreshExpiresAt = now + this.config.refreshTokenTtlSeconds;
+        this.accessTokens.set(hashToken(accessToken), {
+            token: accessToken,
+            clientId,
+            scopes,
+            expiresAt: accessExpiresAt,
+            resource,
+        });
+        this.refreshTokens.set(hashToken(refreshToken), {
+            token: refreshToken,
+            clientId,
+            scopes,
+            expiresAt: refreshExpiresAt,
+            resource,
+        });
+        return {
+            access_token: accessToken,
+            token_type: "bearer",
+            expires_in: this.config.accessTokenTtlSeconds,
+            refresh_token: refreshToken,
+            scope: scopes.join(" "),
+        };
+    }
+}
+function authorizationFormFields(client, params) {
+    return {
+        response_type: "code",
+        client_id: client.client_id,
+        redirect_uri: params.redirectUri,
+        code_challenge: params.codeChallenge,
+        code_challenge_method: "S256",
+        scope: params.scopes?.join(" "),
+        state: params.state,
+        resource: params.resource?.href,
+    };
+}
+function hashToken(token) {
+    return createHash("sha256").update(token).digest("base64url");
+}

package/dist/pi-tools.js

@@ -0,0 +1,81 @@
+import { createBashTool, createEditTool, createFindTool, createGrepTool, createLsTool, createReadTool, createWriteTool, } from "@earendil-works/pi-coding-agent";
+import { resolveAllowedPath } from "./roots.js";
+function toMcpContent(result) {
+    return result.content.map((content) => {
+        if (content.type === "text") {
+            return { type: "text", text: content.text };
+        }
+        return {
+            type: "image",
+            data: content.data,
+            mimeType: content.mimeType,
+        };
+    });
+}
+function formatToolError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return [{ type: "text", text: message }];
+}
+async function runTool(execute, input, context) {
+    try {
+        const result = await execute(input);
+        return {
+            content: toMcpContent(result),
+            details: result.details,
+        };
+    }
+    catch (error) {
+        return { content: formatToolError(error), isError: true };
+    }
+}
+export async function readFileTool(input, context) {
+    const path = resolveAllowedPath(input.path, context.cwd, context.readRoots ?? [context.root]);
+    const tool = createReadTool(context.cwd);
+    return runTool((params) => tool.execute("read_file", params), {
+        path,
+        offset: input.offset,
+        limit: input.limit,
+    }, context);
+}
+export async function writeFileTool(input, context) {
+    const path = resolveAllowedPath(input.path, context.cwd, [context.root]);
+    const tool = createWriteTool(context.cwd);
+    return runTool((params) => tool.execute("write_file", params), {
+        path,
+        content: input.content,
+    }, context);
+}
+export async function editFileTool(input, context) {
+    const path = resolveAllowedPath(input.path, context.cwd, [context.root]);
+    const tool = createEditTool(context.cwd);
+    return runTool((params) => tool.execute("edit_file", params), {
+        path,
+        edits: input.edits,
+    }, context);
+}
+export async function grepFilesTool(input, context) {
+    if (input.path)
+        resolveAllowedPath(input.path, context.cwd, [context.root]);
+    const tool = createGrepTool(context.cwd);
+    return runTool((params) => tool.execute("grep_files", params), input, context);
+}
+export async function findFilesTool(input, context) {
+    if (input.path)
+        resolveAllowedPath(input.path, context.cwd, [context.root]);
+    const tool = createFindTool(context.cwd);
+    return runTool((params) => tool.execute("find_files", params), input, context);
+}
+export async function listDirectoryTool(input, context) {
+    if (input.path)
+        resolveAllowedPath(input.path, context.cwd, [context.root]);
+    const tool = createLsTool(context.cwd);
+    return runTool((params) => tool.execute("list_directory", params), input, context);
+}
+export async function runShellTool(input, context) {
+    const tool = createBashTool(context.cwd);
+    const timeout = input.timeout === undefined ? 30 : Math.min(input.timeout, 300);
+    return runTool((params) => tool.execute("run_shell", params), {
+        command: input.command,
+        timeout,
+    }, context);
+}