auvrynt 1.0.2 → 1.0.5

package/dist/cli/instance-lock.js

@@ -0,0 +1,123 @@
+import { randomBytes } from "node:crypto";
+import { chmod, mkdir, open, readFile, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { getProcessIdentity, isProcessRunning, processIdentityMatches, } from "../background-lifecycle.js";
+import { httpUrl, localProbeHost } from "./runtime-support.js";
+export async function acquireInstanceLock(stateDir, host, port, profiles, launchRoot) {
+    const lockPath = join(stateDir, "server.lock");
+    await mkdir(stateDir, { recursive: true, mode: 0o700 });
+    await chmod(stateDir, 0o700).catch(() => undefined);
+    const identity = getProcessIdentity(process.pid);
+    if (!identity)
+        throw new Error("Could not identify the Auvrynt server process.");
+    for (let attempt = 0; attempt < 3; attempt++) {
+        const instanceId = randomBytes(16).toString("hex");
+        try {
+            const handle = await open(lockPath, "wx", 0o600);
+            const record = {
+                instanceId,
+                pid: process.pid,
+                startedAt: new Date().toISOString(),
+                host,
+                port,
+                profiles,
+                launchRoot,
+                controlToken: process.env.AUVRYNT_CONTROL_TOKEN,
+                ...identity,
+            };
+            try {
+                await handle.writeFile(JSON.stringify(record));
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            return { release: () => releaseInstanceLock(lockPath, instanceId) };
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            let lock;
+            try {
+                lock = JSON.parse(await readFile(lockPath, "utf8"));
+            }
+            catch {
+                // A partially written or malformed lock is stale unless another contender replaces it first.
+            }
+            const ownerPid = Number.isInteger(lock?.pid) && Number(lock?.pid) > 0
+                ? Number(lock?.pid)
+                : undefined;
+            const hasIdentity = Boolean(lock?.processPath && lock?.processStartedAt);
+            const ownerMatches = ownerPid
+                ? hasIdentity
+                    ? processIdentityMatches(ownerPid, lock ?? {})
+                    : isProcessRunning(ownerPid)
+                : false;
+            if (ownerPid && ownerMatches) {
+                const lockHost = typeof lock?.host === "string" ? lock.host : host;
+                const candidateLockPort = lock?.port;
+                const lockPort = Number.isInteger(candidateLockPort)
+                    ? Number(candidateLockPort)
+                    : port;
+                const healthy = await isAuvryntHealthReachable(lockHost, lockPort);
+                const lockStartedAt = lock?.startedAt;
+                const lockAgeMs = typeof lockStartedAt === "string"
+                    ? Date.now() - Date.parse(lockStartedAt)
+                    : Number.POSITIVE_INFINITY;
+                if (healthy
+                    || (Number.isFinite(lockAgeMs) && lockAgeMs >= 0 && lockAgeMs < 30_000)) {
+                    throw new Error(`Auvrynt is already running (PID ${ownerPid}). Stop that instance before starting another.`);
+                }
+            }
+            await unlink(lockPath).catch((unlinkError) => {
+                if (unlinkError.code !== "ENOENT") {
+                    throw unlinkError;
+                }
+            });
+        }
+    }
+    throw new Error("Could not acquire the Auvrynt server lock after clearing stale lock state.");
+}
+export async function isAuvryntHealthReachable(host, port) {
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+        return false;
+    if (!host || /[\/@?#]/.test(host))
+        return false;
+    try {
+        const response = await fetch(httpUrl(localProbeHost(host), port, "/healthz"), {
+            signal: AbortSignal.timeout(750),
+        });
+        if (!response.ok)
+            return false;
+        const body = await response.json().catch(() => undefined);
+        return body?.ok === true && body?.name === "auvrynt";
+    }
+    catch {
+        return false;
+    }
+}
+async function releaseInstanceLock(lockPath, instanceId) {
+    let raw;
+    try {
+        raw = await readFile(lockPath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    let current;
+    try {
+        current = JSON.parse(raw);
+    }
+    catch {
+        // Do not delete a lock whose ownership cannot be proven.
+        return;
+    }
+    if (current.instanceId !== instanceId)
+        return;
+    await unlink(lockPath).catch((error) => {
+        if (error.code !== "ENOENT")
+            throw error;
+    });
+}

package/dist/cli/integration-bootstrap.js

@@ -0,0 +1,206 @@
+import { existsSync } from "node:fs";
+import { cp, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { execFileSync, spawn } from "node:child_process";
+import { expandHomePath } from "../roots.js";
+import { discoverLocalIntegrations, processDetected, } from "../integration-discovery.js";
+import { ensureGlobalGodotPlugin } from "../godot-tools.js";
+import { ensureGlobalAsepriteBridge } from "../integrations/aseprite/aseprite-live-tools.js";
+import { ensurePlaywrightRuntime } from "../playwright-runtime.js";
+import { findCommand } from "../tunnels/tunnel-utils.js";
+const MANAGED_SERENA_PACKAGE = "serena-agent==1.6.0";
+const MANAGED_UV_PACKAGE = "uv==0.11.32";
+const MAX_GODOT_PROJECTS = 64;
+const MAX_GODOT_PROJECT_DEPTH = 5;
+const GODOT_SCAN_EXCLUDED_DIRECTORIES = new Set([
+    ".git",
+    ".godot",
+    ".svn",
+    "auvrynt-logs",
+    "bin",
+    "node_modules",
+    "obj",
+]);
+function packageRoot() {
+    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+}
+async function ensureGodotPluginForLaunchRoot(launchRoot) {
+    const projectFile = join(launchRoot, "project.godot");
+    if (!existsSync(projectFile))
+        return;
+    const sourceDir = join(packageRoot(), "addons", "auvrynt_bridge");
+    if (!existsSync(sourceDir))
+        return;
+    const targetDir = join(launchRoot, "addons", "auvrynt_bridge");
+    await mkdir(dirname(targetDir), { recursive: true });
+    await cp(sourceDir, targetDir, { recursive: true, force: true });
+    const pluginPath = "res://addons/auvrynt_bridge/plugin.cfg";
+    let project = await readFile(projectFile, "utf8");
+    if (project.includes(`\"${pluginPath}\"`))
+        return;
+    const sectionPattern = /\[editor_plugins\][\s\S]*?(?=\r?\n\[[^\]]+\]|$)/;
+    const sectionMatch = project.match(sectionPattern);
+    if (sectionMatch) {
+        const section = sectionMatch[0];
+        const enabledPattern = /enabled\s*=\s*PackedStringArray\(([^)]*)\)/;
+        const enabledMatch = section.match(enabledPattern);
+        const updatedSection = enabledMatch
+            ? section.replace(enabledPattern, (_full, values) => {
+                const separator = values.trim() ? ", " : "";
+                return `enabled=PackedStringArray(${values}${separator}\"${pluginPath}\")`;
+            })
+            : `${section.trimEnd()}\r\nenabled=PackedStringArray(\"${pluginPath}\")\r\n`;
+        project = project.replace(section, updatedSection);
+    }
+    else {
+        project = `${project.trimEnd()}\r\n\r\n[editor_plugins]\r\n\r\nenabled=PackedStringArray(\"${pluginPath}\")\r\n`;
+    }
+    await writeFile(projectFile, project, "utf8");
+}
+export async function findGodotProjectRoots(launchRoot, maxDepth = MAX_GODOT_PROJECT_DEPTH) {
+    const projects = [];
+    const visit = async (directory, depth) => {
+        if (projects.length >= MAX_GODOT_PROJECTS || depth > maxDepth)
+            return;
+        if (existsSync(join(directory, "project.godot"))) {
+            projects.push(directory);
+            return;
+        }
+        let entries;
+        try {
+            entries = await readdir(directory, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        entries.sort((left, right) => left.name.localeCompare(right.name));
+        for (const entry of entries) {
+            if (projects.length >= MAX_GODOT_PROJECTS)
+                return;
+            if (!entry.isDirectory() || GODOT_SCAN_EXCLUDED_DIRECTORIES.has(entry.name.toLowerCase()))
+                continue;
+            await visit(join(directory, entry.name), depth + 1);
+        }
+    };
+    await visit(resolve(launchRoot), 0);
+    return projects;
+}
+export async function selfHealStartIntegrations(launchRoot, executables, integrations) {
+    let serenaExecutable;
+    if (integrations.serena) {
+        process.env.AUVRYNT_SERENA_ENABLED = "true";
+        serenaExecutable = await ensureSerenaExecutable();
+        process.env.AUVRYNT_SERENA_EXECUTABLE = serenaExecutable;
+        execFileSync(serenaExecutable, ["--version"], {
+            stdio: "ignore",
+            windowsHide: true,
+        });
+    }
+    else {
+        process.env.AUVRYNT_SERENA_ENABLED = "false";
+    }
+    if (integrations.playwright)
+        ensurePlaywrightRuntime();
+    if (integrations.aseprite) {
+        try {
+            await ensureGlobalAsepriteBridge();
+        }
+        catch (error) {
+            console.warn(`[auvrynt] Could not install the Aseprite live bridge: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (!integrations.godotGdscript && !integrations.godotCsharp) {
+        return { serenaExecutable };
+    }
+    ensureGlobalGodotPlugin();
+    const godotProjectRoots = await findGodotProjectRoots(launchRoot);
+    for (const projectRoot of godotProjectRoots) {
+        await ensureGodotPluginForLaunchRoot(projectRoot);
+    }
+    if (godotProjectRoots.length === 0) {
+        return { serenaExecutable };
+    }
+    let discovery = await discoverLocalIntegrations({ forceRefresh: true });
+    for (let attempt = 0; attempt < 4; attempt++) {
+        if (discovery.ports.auvrynt_godot_bridge)
+            return { serenaExecutable };
+        await new Promise((resolveDelay) => setTimeout(resolveDelay, 500));
+        discovery = await discoverLocalIntegrations({ forceRefresh: true });
+    }
+    if (processDetected(discovery, "godot")) {
+        console.warn(`[auvrynt] Installed/enabled the Auvrynt bridge in ${godotProjectRoots.length} workspace Godot project(s). `
+            + "Godot is already running but the bridge is not reachable; reopen the intended project editor once so Godot loads the addon.");
+        return { serenaExecutable };
+    }
+    const godotExecutable = integrations.godotCsharp
+        ? executables.godotCsharp
+            || executables.godot
+            || discovery.executables.godotCsharp
+            || discovery.executables.godot
+        : executables.godot || discovery.executables.godot;
+    const launchProjectRoot = godotProjectRoots.length === 1 ? godotProjectRoots[0] : undefined;
+    if (godotExecutable && existsSync(godotExecutable) && launchProjectRoot) {
+        const child = spawn(godotExecutable, ["--editor", "--path", launchProjectRoot], {
+            detached: true,
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        child.unref();
+        console.log("[auvrynt] Godot editor launched with Auvrynt bridge plugin.");
+    }
+    return { serenaExecutable };
+}
+async function ensureSerenaExecutable() {
+    const existing = findCommand("serena");
+    if (existing)
+        return existing;
+    const configuredLocalSource = process.env.AUVRYNT_SERENA_LOCAL_SOURCE?.trim();
+    const localSource = configuredLocalSource
+        ? resolve(expandHomePath(configuredLocalSource))
+        : undefined;
+    if (localSource && !existsSync(join(localSource, "pyproject.toml"))) {
+        throw new Error(`AUVRYNT_SERENA_LOCAL_SOURCE does not contain pyproject.toml: ${localSource}`);
+    }
+    const uv = await ensureUvExecutable();
+    console.log(localSource
+        ? `Serena is not installed; installing explicitly configured local source ${localSource}...`
+        : `Serena is not installed; installing pinned ${MANAGED_SERENA_PACKAGE}...`);
+    const installArgs = localSource
+        ? ["tool", "install", "--force", "--editable", localSource]
+        : ["tool", "install", "--force", MANAGED_SERENA_PACKAGE];
+    execFileSync(uv, installArgs, { stdio: "inherit", windowsHide: true });
+    const installed = findCommand("serena") ?? findInstalledExecutable("serena");
+    if (!installed) {
+        throw new Error("Serena installed but its executable is not available. Restart PowerShell and run `where.exe serena`.");
+    }
+    return installed;
+}
+async function ensureUvExecutable() {
+    const existing = findCommand("uv");
+    if (existing)
+        return existing;
+    const python = findCommand("py") ?? findCommand("python");
+    if (!python) {
+        throw new Error("Serena requires uv, and Python was not found to install it automatically.");
+    }
+    console.log(`uv is not installed; installing pinned ${MANAGED_UV_PACKAGE} for Serena...`);
+    execFileSync(python, ["-m", "pip", "install", "--user", MANAGED_UV_PACKAGE], { stdio: "inherit", windowsHide: true });
+    const installed = findCommand("uv") ?? findInstalledExecutable("uv");
+    if (!installed) {
+        throw new Error("uv was installed but its executable is not available. Restart PowerShell and run `uv --version`.");
+    }
+    return installed;
+}
+function findInstalledExecutable(name) {
+    const executable = process.platform === "win32" ? `${name}.exe` : name;
+    const candidates = [
+        join(homedir(), ".local", "bin", executable),
+        join(process.env.LOCALAPPDATA ?? "", "uv", "bin", executable),
+        join(process.env.APPDATA ?? "", "uv", "bin", executable),
+        join(process.env.APPDATA ?? "", "Python", "Python313", "Scripts", executable),
+        join(process.env.APPDATA ?? "", "Python", "Python312", "Scripts", executable),
+    ];
+    return candidates.find((candidate) => candidate && existsSync(candidate));
+}