auvrynt 1.0.2 → 1.0.5

package/dist/session-registry.js

@@ -0,0 +1 @@
+export * from "./auth/session-registry.js";

package/dist/shutdown.js

@@ -0,0 +1 @@
+export * from "./infrastructure/shutdown.js";

package/dist/skills.js

@@ -1,45 +1 @@
-import { homedir } from "node:os";
-import { resolve, sep } from "node:path";
-import { loadSkills, } from "@earendil-works/pi-coding-agent";
-import { expandHomePath, isPathInsideRoot } from "./roots.js";
-export function loadWorkspaceSkills(config, cwd) {
-    if (!config.skillsEnabled)
-        return { skills: [], diagnostics: [] };
-    return loadSkills({
-        cwd,
-        agentDir: config.agentDir,
-        skillPaths: config.skillPaths,
-        includeDefaults: true,
-    });
-}
-export function resolveSkillReadPath(skills, activatedSkillDirs, inputPath) {
-    const absolutePath = resolve(expandHomePath(inputPath));
-    for (const skill of skills) {
-        const skillFilePath = resolve(skill.filePath);
-        if (absolutePath === skillFilePath) {
-            return { absolutePath, skill, isSkillFile: true };
-        }
-    }
-    for (const skill of skills) {
-        const baseDir = resolve(skill.baseDir);
-        if (!activatedSkillDirs.has(baseDir))
-            continue;
-        if (!isPathInsideRoot(absolutePath, baseDir))
-            continue;
-        return { absolutePath, skill, isSkillFile: false };
-    }
-    return undefined;
-}
-export function markSkillActivated(activatedSkillDirs, skill) {
-    activatedSkillDirs.add(resolve(skill.baseDir));
-}
-export function formatPathForPrompt(path) {
-    const home = resolve(homedir());
-    const resolvedPath = resolve(path);
-    if (resolvedPath === home)
-        return "~";
-    if (resolvedPath.startsWith(`${home}${sep}`)) {
-        return `~/${resolvedPath.slice(home.length + 1).split(sep).join("/")}`;
-    }
-    return resolvedPath.split(sep).join("/");
-}
+export * from "./workspace/skills.js";

package/dist/sse-heartbeat.js

@@ -0,0 +1 @@
+export * from "./infrastructure/sse-heartbeat.js";

package/dist/tool-capabilities.js

@@ -0,0 +1 @@
+export * from "./infrastructure/tool-capabilities.js";

package/dist/tool-result-budget.js

@@ -0,0 +1 @@
+export * from "./infrastructure/tool-result-budget.js";

package/dist/tools/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);
+}

package/dist/tunnels/cloudflare-tunnel.js

@@ -0,0 +1,217 @@
+import { createHash } from "node:crypto";
+import { execFileSync, spawn } from "node:child_process";
+import { closeSync, existsSync, openSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { isProcessRunning } from "../background-lifecycle.js";
+import { findCommand } from "./tunnel-utils.js";
+const MANAGED_CLOUDFLARED_VERSION = "2026.7.2";
+const CLOUDFLARE_URL_PATTERN = /https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/;
+const MAX_STARTUP_OUTPUT_BYTES = 1024 * 1024;
+export function extractCloudflarePublicUrl(output) {
+    return output.match(CLOUDFLARE_URL_PATTERN)?.[0];
+}
+async function installWindowsCloudflared() {
+    const targetDir = join(homedir(), ".auvrynt", "bin");
+    const executable = join(targetDir, "cloudflared.exe");
+    const artifact = process.arch === "arm64"
+        ? "cloudflared-windows-arm64.exe"
+        : process.arch === "ia32"
+            ? "cloudflared-windows-386.exe"
+            : "cloudflared-windows-amd64.exe";
+    const releaseUrl = `https://api.github.com/repos/cloudflare/cloudflared/releases/tags/${MANAGED_CLOUDFLARED_VERSION}`;
+    console.log(`cloudflared is not installed; downloading verified ${MANAGED_CLOUDFLARED_VERSION}...`);
+    const releaseResponse = await fetch(releaseUrl, {
+        headers: { Accept: "application/vnd.github+json", "User-Agent": "auvrynt-cloudflared-installer" },
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (!releaseResponse.ok)
+        throw new Error(`Could not load cloudflared release metadata (HTTP ${releaseResponse.status}).`);
+    const release = await releaseResponse.json();
+    if (release.tag_name !== MANAGED_CLOUDFLARED_VERSION || !Array.isArray(release.assets)) {
+        throw new Error("Cloudflared release metadata did not match the pinned release.");
+    }
+    const asset = release.assets.find((candidate) => candidate.name === artifact);
+    if (!asset || typeof asset.browser_download_url !== "string" || typeof asset.digest !== "string") {
+        throw new Error(`Cloudflared release ${MANAGED_CLOUDFLARED_VERSION} is missing ${artifact} or its SHA-256 digest.`);
+    }
+    const expectedPrefix = `https://github.com/cloudflare/cloudflared/releases/download/${MANAGED_CLOUDFLARED_VERSION}/`;
+    if (!asset.browser_download_url.startsWith(expectedPrefix) || !/^sha256:[0-9a-f]{64}$/i.test(asset.digest)) {
+        throw new Error("Cloudflared release asset metadata failed origin/digest validation.");
+    }
+    const response = await fetch(asset.browser_download_url, { signal: AbortSignal.timeout(120_000) });
+    if (!response.ok)
+        throw new Error(`Could not download cloudflared (HTTP ${response.status}).`);
+    const bytes = Buffer.from(await response.arrayBuffer());
+    const actualDigest = createHash("sha256").update(bytes).digest("hex");
+    const expectedDigest = asset.digest.slice("sha256:".length).toLowerCase();
+    if (actualDigest !== expectedDigest) {
+        throw new Error("Cloudflared SHA-256 verification failed; the downloaded binary was not installed.");
+    }
+    await mkdir(targetDir, { recursive: true });
+    await writeFile(executable, bytes, { mode: 0o755 });
+    execFileSync(executable, ["--version"], { stdio: "ignore", windowsHide: true });
+    return executable;
+}
+async function resolveCloudflaredExecutable() {
+    const found = findCommand("cloudflared");
+    if (found)
+        return found;
+    if (process.platform === "win32") {
+        const managedExecutable = join(homedir(), ".auvrynt", "bin", "cloudflared.exe");
+        if (existsSync(managedExecutable)) {
+            try {
+                execFileSync(managedExecutable, ["--version"], { stdio: "ignore", windowsHide: true });
+                return managedExecutable;
+            }
+            catch {
+                // A partial or corrupt managed binary is replaced by the verified installer.
+            }
+        }
+        return installWindowsCloudflared();
+    }
+    throw new Error("cloudflared is required for `auvrynt start`. Install it from https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/.");
+}
+export async function startCloudflareTunnel(port, options = {}) {
+    const executable = await resolveCloudflaredExecutable();
+    const args = options.cloudflareTunnelToken
+        ? ["tunnel", "--no-autoupdate", "run"]
+        : ["tunnel", "--no-autoupdate", "--url", `http://127.0.0.1:${port}`];
+    if (options.cloudflareTunnelToken && !options.publicUrl) {
+        throw new Error("A public URL is required when starting a Cloudflare Named Tunnel.");
+    }
+    if (options.cloudflareTunnelToken) {
+        let stdio = ["ignore", "pipe", "pipe"];
+        let logHandle;
+        if (options.detached && options.logPath) {
+            await writeFile(options.logPath, "", { mode: 0o600 });
+            logHandle = openSync(options.logPath, "a");
+            stdio = ["ignore", logHandle, logHandle];
+        }
+        const child = spawn(executable, args, {
+            stdio,
+            windowsHide: true,
+            detached: options.detached,
+            env: { ...process.env, TUNNEL_TOKEN: options.cloudflareTunnelToken },
+        });
+        if (logHandle !== undefined)
+            closeSync(logHandle);
+        try {
+            const deadline = Date.now() + (options.logPath ? 30_000 : 1_500);
+            let registered = !options.logPath;
+            while (Date.now() < deadline) {
+                if (!child.pid || !isProcessRunning(child.pid))
+                    throw new Error("Cloudflare Named Tunnel exited before connecting.");
+                if (options.logPath) {
+                    const output = await readFile(options.logPath, "utf8").catch(() => "");
+                    if (Buffer.byteLength(output, "utf8") > MAX_STARTUP_OUTPUT_BYTES) {
+                        throw new Error("Cloudflare Named Tunnel startup output exceeded 1 MB before registering.");
+                    }
+                    registered = /Registered tunnel connection/i.test(output);
+                }
+                if (registered)
+                    break;
+                await new Promise((resolveDelay) => setTimeout(resolveDelay, 250));
+            }
+            if (!registered)
+                throw new Error("Cloudflare Named Tunnel did not register with Cloudflare within 30 seconds.");
+            if (options.detached)
+                child.unref();
+            return { process: child, url: options.publicUrl };
+        }
+        catch (error) {
+            child.kill();
+            throw error;
+        }
+    }
+    if (options.detached && options.logPath) {
+        await writeFile(options.logPath, "", { mode: 0o600 });
+        const logHandle = openSync(options.logPath, "a");
+        const child = spawn(executable, args, {
+            stdio: ["ignore", logHandle, logHandle],
+            windowsHide: true,
+            detached: true,
+        });
+        closeSync(logHandle);
+        let spawnError;
+        child.once("error", (error) => { spawnError = error; });
+        const deadline = Date.now() + 90_000;
+        try {
+            while (Date.now() < deadline) {
+                if (spawnError)
+                    throw new Error(`Cloudflare tunnel failed to start: ${spawnError.message}`);
+                if (!child.pid || !isProcessRunning(child.pid))
+                    throw new Error("Cloudflare tunnel exited before connecting.");
+                const output = await readFile(options.logPath, "utf8").catch(() => "");
+                if (Buffer.byteLength(output, "utf8") > MAX_STARTUP_OUTPUT_BYTES) {
+                    throw new Error("Cloudflare tunnel startup output exceeded 1 MB before providing a public URL.");
+                }
+                const url = extractCloudflarePublicUrl(output);
+                if (url) {
+                    child.unref();
+                    return { process: child, url };
+                }
+                await new Promise((resolveDelay) => setTimeout(resolveDelay, 250));
+            }
+            throw new Error("Cloudflare tunnel did not provide a public URL within 90 seconds.");
+        }
+        catch (error) {
+            child.kill();
+            throw error;
+        }
+    }
+    const child = spawn(executable, args, {
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+        detached: options.detached,
+    });
+    const tunnelUrl = await new Promise((resolveUrl, reject) => {
+        let output = "";
+        let settled = false;
+        const cleanup = () => {
+            clearTimeout(timeout);
+            child.stdout?.off("data", onOutput);
+            child.stderr?.off("data", onOutput);
+            child.off("error", onError);
+            child.off("exit", onExit);
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(error);
+        };
+        const timeout = setTimeout(() => {
+            child.kill();
+            fail(new Error("Cloudflare tunnel did not provide a public URL within 30 seconds."));
+        }, 30_000);
+        const onOutput = (chunk) => {
+            if (settled)
+                return;
+            output += chunk.toString();
+            if (Buffer.byteLength(output, "utf8") > MAX_STARTUP_OUTPUT_BYTES) {
+                child.kill();
+                fail(new Error("Cloudflare tunnel startup output exceeded 1 MB before providing a public URL."));
+                return;
+            }
+            const url = extractCloudflarePublicUrl(output);
+            if (url) {
+                settled = true;
+                cleanup();
+                resolveUrl(url);
+            }
+        };
+        const onError = (error) => fail(new Error(`Cloudflare tunnel failed to start: ${error.message}`));
+        const onExit = (code) => {
+            if (code !== null)
+                fail(new Error(`Cloudflare tunnel exited before connecting (code ${code}).`));
+        };
+        child.stdout?.on("data", onOutput);
+        child.stderr?.on("data", onOutput);
+        child.once("error", onError);
+        child.once("exit", onExit);
+    });
+    return { process: child, url: tunnelUrl };
+}

package/dist/tunnels/cloudflared-service.js

@@ -0,0 +1,174 @@
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { loadAuvryntFiles } from "../user-config.js";
+const SERVICE_NAME = "cloudflared";
+const POLL_INTERVAL_MS = 250;
+const START_TIMEOUT_MS = 30_000;
+function queryService() {
+    return execFileSync("sc.exe", ["query", SERVICE_NAME], {
+        encoding: "utf8",
+        windowsHide: true,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+}
+function serviceState() {
+    if (process.platform !== "win32")
+        return "MISSING";
+    try {
+        const output = queryService();
+        if (/STATE\s+:\s+\d+\s+RUNNING/i.test(output))
+            return "RUNNING";
+        if (/STATE\s+:\s+\d+\s+STOPPED/i.test(output))
+            return "STOPPED";
+        return "OTHER";
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (/1060|does not exist|not found/i.test(message))
+            return "MISSING";
+        return "OTHER";
+    }
+}
+export function isCloudflaredProcessRunning() {
+    if (process.platform !== "win32")
+        return false;
+    try {
+        const output = execFileSync("tasklist.exe", ["/FI", "IMAGENAME eq cloudflared.exe", "/NH"], {
+            encoding: "utf8",
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        return /cloudflared\.exe/i.test(output);
+    }
+    catch {
+        return false;
+    }
+}
+export function findCloudflaredExecutable() {
+    if (process.platform !== "win32")
+        return null;
+    const commonPaths = [
+        "C:\\Program Files (x86)\\cloudflared\\cloudflared.exe",
+        "C:\\Program Files\\cloudflared\\cloudflared.exe",
+        join(homedir(), "bin", "cloudflared.exe"),
+        join(homedir(), "AppData", "Local", "Programs", "cloudflared", "cloudflared.exe"),
+    ];
+    for (const p of commonPaths) {
+        if (existsSync(p))
+            return p;
+    }
+    try {
+        const output = execFileSync("where.exe", ["cloudflared.exe"], {
+            encoding: "utf8",
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        }).trim();
+        const first = output.split(/\r?\n/)[0]?.trim();
+        if (first && existsSync(first))
+            return first;
+    }
+    catch {
+        // not in PATH
+    }
+    return null;
+}
+export function spawnUserCloudflaredProcess(token) {
+    const binary = findCloudflaredExecutable();
+    if (!binary)
+        return false;
+    try {
+        const child = spawn(binary, ["tunnel", "run", "--token", token], {
+            detached: true,
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForState(expected) {
+    const deadline = Date.now() + START_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        const current = serviceState();
+        if (current === expected)
+            return;
+        if (current === "MISSING")
+            throw new Error(`Windows service ${SERVICE_NAME} is not installed.`);
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    }
+    throw new Error(`Windows service ${SERVICE_NAME} did not become ${expected.toLowerCase()} within 30 seconds.`);
+}
+export async function startCloudflaredService() {
+    if (process.platform !== "win32")
+        return false;
+    // 1. Check if the Windows Service is already running
+    const current = serviceState();
+    if (current === "RUNNING")
+        return false;
+    // 2. Check if cloudflared is already running as a process (self-healed / user started)
+    if (isCloudflaredProcessRunning())
+        return false;
+    // 3. Try to start the Windows Service via sc.exe
+    let scFailed = false;
+    if (current !== "MISSING") {
+        try {
+            execFileSync("sc.exe", ["start", SERVICE_NAME], {
+                encoding: "utf8",
+                windowsHide: true,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            await waitForState("RUNNING");
+            return true;
+        }
+        catch {
+            scFailed = true;
+        }
+    }
+    else {
+        scFailed = true;
+    }
+    // 4. Self-healing fallback: If sc.exe failed (e.g. non-admin), try spawning user-space cloudflared with saved token
+    if (scFailed) {
+        if (isCloudflaredProcessRunning())
+            return false;
+        const files = loadAuvryntFiles();
+        const token = files.auth.cloudflareTunnelToken || process.env.CLOUDFLARE_TUNNEL_TOKEN;
+        if (token) {
+            const spawned = spawnUserCloudflaredProcess(token);
+            if (spawned) {
+                const deadline = Date.now() + 4_000;
+                while (Date.now() < deadline) {
+                    if (isCloudflaredProcessRunning())
+                        return true;
+                    await new Promise((resolve) => setTimeout(resolve, 250));
+                }
+                return true;
+            }
+        }
+        // If external tunnel is managed elsewhere or no token is provided, proceed gracefully
+        return false;
+    }
+    return false;
+}
+export async function stopCloudflaredService() {
+    if (process.platform !== "win32")
+        return false;
+    const current = serviceState();
+    if (current === "MISSING" || current === "STOPPED")
+        return false;
+    try {
+        execFileSync("sc.exe", ["stop", SERVICE_NAME], { encoding: "utf8", windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!/1062|not been started|already stopped/i.test(message))
+            throw new Error(`Could not stop Windows service ${SERVICE_NAME}: ${message}`);
+    }
+    await waitForState("STOPPED");
+    return true;
+}