@chvor/cli 0.1.0

package/dist/commands/onboard.js

@@ -0,0 +1,84 @@
+import { randomBytes } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { input, select, password } from "@inquirer/prompts";
+import { writeConfig } from "../lib/config.js";
+import { validatePort } from "../lib/validate.js";
+import { getDataDir, ensureDir } from "../lib/paths.js";
+import { downloadRelease } from "../lib/download.js";
+import { spawnServer, pollHealth } from "../lib/process.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, "../../package.json"), "utf8"));
+export async function onboard() {
+    console.log("\n  Welcome to chvor \u2014 your own AI.\n  Let's get you set up.\n");
+    const userName = await input({ message: "What's your name?" });
+    const detectedTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const timezone = await input({
+        message: "Your timezone?",
+        default: detectedTimezone,
+    });
+    const provider = await select({
+        message: "LLM provider?",
+        choices: [
+            { name: "Anthropic (Claude)", value: "anthropic" },
+            { name: "OpenAI (GPT)", value: "openai" },
+            { name: "Google (Gemini)", value: "google-ai" },
+        ],
+    });
+    const apiKey = await password({ message: "API key:" });
+    const port = validatePort(await input({ message: "Port?", default: "3001" }));
+    const token = randomBytes(32).toString("hex");
+    writeConfig({
+        port,
+        token,
+        onboarded: true,
+        llmProvider: provider,
+    });
+    ensureDir(getDataDir());
+    const version = pkg.version;
+    await downloadRelease(version);
+    await spawnServer({ port });
+    await pollHealth(port, token);
+    const providerNames = {
+        anthropic: "Anthropic",
+        openai: "OpenAI",
+        "google-ai": "Google AI",
+    };
+    const credRes = await fetch(`http://localhost:${port}/api/credentials`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({
+            name: providerNames[provider],
+            type: provider,
+            data: { apiKey },
+        }),
+    });
+    if (!credRes.ok) {
+        console.warn(`Warning: failed to save credentials (${credRes.status}). You can add them later in the UI.`);
+    }
+    const personaRes = await fetch(`http://localhost:${port}/api/persona`, {
+        method: "PATCH",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({
+            name: userName,
+            timezone,
+            onboarded: true,
+        }),
+    });
+    if (!personaRes.ok) {
+        console.warn(`Warning: failed to save persona (${personaRes.status}). You can update it later in the UI.`);
+    }
+    console.log(`\n  chvor is running at http://localhost:${port}`);
+    console.log("  Open this URL in your browser to get started.\n");
+    console.log("  Useful commands:");
+    console.log("    chvor stop     Stop the server");
+    console.log("    chvor start    Start the server");
+    console.log("    chvor update   Update to latest version\n");
+}

package/dist/commands/skill.js

@@ -0,0 +1,340 @@
+import { readConfig } from "../lib/config.js";
+import { readFileSync } from "node:fs";
+import { validateSkillForPublishing } from "@chvor/shared";
+function getBaseUrl() {
+    const config = readConfig();
+    return `http://localhost:${config.port}`;
+}
+function getHeaders() {
+    const config = readConfig();
+    const headers = { "Content-Type": "application/json" };
+    if (config.token)
+        headers["Authorization"] = `Bearer ${config.token}`;
+    return headers;
+}
+async function apiRequest(path, init) {
+    const res = await fetch(`${getBaseUrl()}/api${path}`, {
+        ...init,
+        headers: { ...getHeaders(), ...init?.headers },
+    });
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+        throw new Error(body.error ?? `HTTP ${res.status}`);
+    }
+    const json = (await res.json());
+    return json.data;
+}
+// --- Skill commands ---
+export async function skillSearch(query) {
+    return registrySearch(query, "skill");
+}
+export async function skillInstall(name) {
+    return registryInstall(name, "skill");
+}
+export async function skillUninstall(name) {
+    return registryUninstall(name);
+}
+export async function skillUpdate(name) {
+    return registryUpdate(name);
+}
+export async function skillList() {
+    try {
+        const skills = await apiRequest("/skills");
+        if (skills.length === 0) {
+            console.log("No skills installed.");
+            return;
+        }
+        console.log(`\n${skills.length} skill(s) installed:\n`);
+        const maxName = Math.max(...skills.map((s) => s.metadata.name.length), 4);
+        console.log(`${"Name".padEnd(maxName)}  Version   Source     Enabled  Category`);
+        console.log("-".repeat(maxName + 50));
+        for (const s of skills) {
+            console.log(`${s.metadata.name.padEnd(maxName)}  ${(s.metadata.version ?? "").padEnd(9)} ${s.source.padEnd(10)} ${String(s.enabled).padEnd(8)} ${s.metadata.category ?? ""}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error("List failed:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+}
+export async function skillInfo(name) {
+    return registryInfo(name);
+}
+export async function skillPublish(filePath) {
+    try {
+        const content = readFileSync(filePath, "utf8");
+        const result = validateSkillForPublishing(content);
+        if (result.warnings.length > 0) {
+            console.log("\nWarnings:");
+            for (const w of result.warnings)
+                console.log(`  - ${w}`);
+        }
+        if (!result.valid) {
+            console.log("\nValidation errors:");
+            for (const e of result.errors)
+                console.log(`  - ${e}`);
+            console.log("\nFix these issues before publishing.");
+            process.exit(1);
+        }
+        console.log("\nSkill file is valid for publishing.");
+        // Try to submit to registry
+        const registryUrl = getRegistryUrl();
+        await submitToRegistry(registryUrl, content, "skill");
+    }
+    catch (err) {
+        console.error("Publish failed:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+}
+export async function toolPublish(filePath) {
+    try {
+        const content = readFileSync(filePath, "utf8");
+        // Use same validation — tools also need frontmatter with name/description/version/author
+        const result = validateSkillForPublishing(content);
+        if (result.warnings.length > 0) {
+            console.log("\nWarnings:");
+            for (const w of result.warnings)
+                console.log(`  - ${w}`);
+        }
+        if (!result.valid) {
+            console.log("\nValidation errors:");
+            for (const e of result.errors)
+                console.log(`  - ${e}`);
+            console.log("\nFix these issues before publishing.");
+            process.exit(1);
+        }
+        console.log("\nTool file is valid for publishing.");
+        const registryUrl = getRegistryUrl();
+        await submitToRegistry(registryUrl, content, "tool");
+    }
+    catch (err) {
+        console.error("Publish failed:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+}
+function getRegistryUrl() {
+    return process.env.CHVOR_REGISTRY_URL || "https://raw.githubusercontent.com/chvor-community/skill-registry/main";
+}
+function assertValidRegistryUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new Error(`Invalid registry URL: "${url}"`);
+    }
+    const isLocalhost = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
+    if (parsed.protocol !== "https:" && !(parsed.protocol === "http:" && isLocalhost)) {
+        throw new Error(`Registry URL must use HTTPS (got ${parsed.protocol}). HTTP is only allowed for localhost.`);
+    }
+}
+async function submitToRegistry(registryUrl, content, kind) {
+    assertValidRegistryUrl(registryUrl);
+    const { getRegistryToken, authenticate } = await import("../lib/registry-auth.js");
+    // Check if registry supports submissions
+    let supportsSubmissions = false;
+    try {
+        const healthRes = await fetch(`${registryUrl.replace(/\/v1$/, "")}/health`, { method: "GET" });
+        supportsSubmissions = healthRes.ok;
+    }
+    catch {
+        // Registry not reachable — show fallback message
+    }
+    if (!supportsSubmissions) {
+        console.log("\nThe community registry is not yet available for submissions.");
+        const dir = kind === "tool" ? "~/.chvor/tools/" : "~/.chvor/skills/";
+        console.log(`For now, you can use this file locally by placing it in ${dir}`);
+        console.log();
+        return;
+    }
+    // Authenticate if needed
+    let token = getRegistryToken(registryUrl);
+    if (!token) {
+        console.log("\nYou need to authenticate to publish.\n");
+        const auth = await authenticate(registryUrl);
+        token = auth.token;
+    }
+    // Extract ID from frontmatter
+    const idMatch = content.match(/^---[\s\S]*?name:\s*["']?(.+?)["']?\s*$/m);
+    const nameRaw = idMatch?.[1] ?? "untitled";
+    const id = nameRaw.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    // Submit
+    console.log(`\nSubmitting ${kind} "${id}" to registry...`);
+    const res = await fetch(`${registryUrl}/submissions`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${token}`,
+        },
+        body: JSON.stringify({ id, kind, content }),
+    });
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+        const errObj = body;
+        const msg = typeof errObj.error === "object" ? errObj.error?.message : errObj.error;
+        throw new Error(`Submission failed: ${msg ?? `HTTP ${res.status}`}`);
+    }
+    const data = await res.json();
+    console.log(`\nSubmission created (ID: ${data.id})`);
+    console.log(`Status: ${data.status}`);
+    console.log("\nYour submission will be reviewed by the registry maintainers.");
+    console.log("Track its status at the creator portal.");
+    console.log();
+}
+// --- Tool commands ---
+export async function toolSearch(query) {
+    return registrySearch(query, "tool");
+}
+export async function toolInstall(name) {
+    return registryInstall(name, "tool");
+}
+export async function toolUninstall(name) {
+    return registryUninstall(name);
+}
+export async function toolUpdate(name) {
+    return registryUpdate(name);
+}
+export async function toolList() {
+    try {
+        const tools = await apiRequest("/tools");
+        if (tools.length === 0) {
+            console.log("No tools installed.");
+            return;
+        }
+        console.log(`\n${tools.length} tool(s) installed:\n`);
+        const maxName = Math.max(...tools.map((t) => t.metadata.name.length), 4);
+        console.log(`${"Name".padEnd(maxName)}  Version   Source     Enabled  Category`);
+        console.log("-".repeat(maxName + 50));
+        for (const t of tools) {
+            console.log(`${t.metadata.name.padEnd(maxName)}  ${(t.metadata.version ?? "").padEnd(9)} ${t.source.padEnd(10)} ${String(t.enabled).padEnd(8)} ${t.metadata.category ?? ""}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error("List failed:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+}
+export async function toolInfo(name) {
+    return registryInfo(name);
+}
+// --- Shared registry operations ---
+async function registrySearch(query, kind) {
+    try {
+        const results = await apiRequest(`/registry/search?q=${encodeURIComponent(query)}&kind=${kind}`);
+        if (results.length === 0) {
+            console.log(`No ${kind}s found matching your query.`);
+            return;
+        }
+        console.log(`\nFound ${results.length} ${kind}(s):\n`);
+        const maxName = Math.max(...results.map((r) => r.name.length), 4);
+        const maxVer = Math.max(...results.map((r) => r.version.length), 7);
+        console.log(`${"Name".padEnd(maxName)}  ${"Version".padEnd(maxVer)}  Status       Category    Description`);
+        console.log("-".repeat(maxName + maxVer + 60));
+        for (const r of results) {
+            const status = r.installed
+                ? r.installedVersion !== r.version
+                    ? `update ${r.installedVersion}`
+                    : "installed"
+                : "available";
+            console.log(`${r.name.padEnd(maxName)}  ${r.version.padEnd(maxVer)}  ${status.padEnd(12)} ${(r.category ?? "").padEnd(11)} ${r.description.slice(0, 50)}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error("Search failed:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+}
+async function registryInstall(name, kind) {
+    try {
+        console.log(`Installing "${name}" from registry...`);
+        const result = await apiRequest("/registry/install", {
+            method: "POST",
+            body: JSON.stringify({ id: name, kind }),
+        });
+        const installed = result.entry ?? result.skill;
+        console.log(`Installed ${installed.metadata.name} v${installed.metadata.version}`);
+        if (result.dependencies.length > 0) {
+            console.log(`  Dependencies installed: ${result.dependencies.join(", ")}`);
+        }
+    }
+    catch (err) {
+        console.error("Install failed:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+}
+async function registryUninstall(name) {
+    try {
+        await apiRequest(`/registry/entry/${encodeURIComponent(name)}`, { method: "DELETE" });
+        console.log(`Uninstalled "${name}"`);
+    }
+    catch (err) {
+        console.error("Uninstall failed:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+}
+async function registryUpdate(name) {
+    try {
+        if (name) {
+            console.log(`Updating "${name}"...`);
+            const result = await apiRequest("/registry/update", { method: "POST", body: JSON.stringify({ id: name }) });
+            if (result.conflict) {
+                console.log(`Skipped — "${name}" was locally modified. Use --force to overwrite.`);
+            }
+            else if (result.updated) {
+                console.log(`Updated "${name}"`);
+            }
+            else {
+                console.log(`"${name}" is already up to date.`);
+            }
+        }
+        else {
+            console.log("Checking for updates...");
+            const results = await apiRequest("/registry/update", { method: "POST", body: JSON.stringify({ all: true }) });
+            const updated = results.filter((r) => r.updated);
+            const conflicts = results.filter((r) => r.conflict);
+            console.log(`Updated ${updated.length} entries`);
+            if (conflicts.length > 0) {
+                console.log(`Skipped ${conflicts.length} locally modified: ${conflicts.map((c) => c.id).join(", ")}`);
+            }
+        }
+    }
+    catch (err) {
+        console.error("Update failed:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+}
+async function registryInfo(name) {
+    try {
+        const entry = await apiRequest(`/registry/entry/${encodeURIComponent(name)}`).catch(() => null);
+        if (entry) {
+            console.log(`\n${entry.name} (${entry.id})`);
+            console.log(`  ${entry.description}`);
+            console.log(`  Kind:     ${entry.kind}`);
+            console.log(`  Version:  ${entry.version}`);
+            if (entry.author)
+                console.log(`  Author:   ${entry.author}`);
+            if (entry.category)
+                console.log(`  Category: ${entry.category}`);
+            if (entry.tags?.length)
+                console.log(`  Tags:     ${entry.tags.join(", ")}`);
+            if (entry.license)
+                console.log(`  License:  ${entry.license}`);
+            if (entry.downloads !== undefined)
+                console.log(`  Downloads: ${entry.downloads}`);
+            if (entry.dependencies?.length)
+                console.log(`  Depends:  ${entry.dependencies.join(", ")}`);
+            console.log(`  Status:   ${entry.installed ? `installed (v${entry.installedVersion})` : "not installed"}`);
+            console.log();
+        }
+        else {
+            console.log(`"${name}" not found in registry.`);
+        }
+    }
+    catch (err) {
+        console.error("Info failed:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+}

package/dist/commands/start.js

@@ -0,0 +1,19 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readConfig } from "../lib/config.js";
+import { downloadRelease, isInstalled } from "../lib/download.js";
+import { spawnServer } from "../lib/process.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, "../../package.json"), "utf8"));
+export async function start(opts) {
+    const config = readConfig();
+    const version = pkg.version;
+    if (!isInstalled(version)) {
+        await downloadRelease(version);
+    }
+    await spawnServer({
+        port: opts.port ?? config.port,
+        foreground: opts.foreground,
+    });
+}

package/dist/commands/stop.js

@@ -0,0 +1,4 @@
+import { stopServer } from "../lib/process.js";
+export async function stop() {
+    await stopServer();
+}

package/dist/commands/update.js

@@ -0,0 +1,23 @@
+import { rmSync } from "node:fs";
+import { readConfig, writeConfig } from "../lib/config.js";
+import { getAppDir } from "../lib/paths.js";
+import { downloadRelease } from "../lib/download.js";
+import { isServerRunning, stopServer } from "../lib/process.js";
+export async function update() {
+    const res = await fetch("https://api.github.com/repos/luka-zivkovic/chvor/releases/latest");
+    const release = (await res.json());
+    const version = release.tag_name.replace(/^v/, "");
+    const config = readConfig();
+    if (config.installedVersion === version) {
+        console.log("Already up to date.");
+        return;
+    }
+    if (isServerRunning().running) {
+        await stopServer();
+    }
+    rmSync(getAppDir(), { recursive: true, force: true });
+    await downloadRelease(version);
+    writeConfig({ ...config, installedVersion: version });
+    console.log(`Updated to v${version}.`);
+    console.log("Run `chvor start` to start the server.");
+}

package/dist/lib/config.js

@@ -0,0 +1,26 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { getConfigPath, ensureDir } from "./paths.js";
+const DEFAULTS = {
+    port: "3001",
+    onboarded: false,
+};
+export function readConfig() {
+    const configPath = getConfigPath();
+    try {
+        const raw = readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return { ...DEFAULTS, ...parsed };
+    }
+    catch {
+        return { ...DEFAULTS };
+    }
+}
+export function writeConfig(config) {
+    const configPath = getConfigPath();
+    ensureDir(dirname(configPath));
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", { encoding: "utf-8", mode: 0o600 });
+}
+export function isOnboarded() {
+    return readConfig().onboarded;
+}

package/dist/lib/download.js

@@ -0,0 +1,145 @@
+import { createWriteStream, createReadStream, existsSync } from "node:fs";
+import { join } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { getAppDir, getDownloadsDir, ensureDir } from "./paths.js";
+import { readConfig, writeConfig } from "./config.js";
+import { getAssetName, getPlatform } from "./platform.js";
+const GITHUB_API = "https://api.github.com";
+const REPO = "luka-zivkovic/chvor";
+export async function resolveRelease(version) {
+    const tag = `v${version}`;
+    const url = `${GITHUB_API}/repos/${REPO}/releases/tags/${tag}`;
+    const res = await fetch(url, {
+        headers: {
+            Accept: "application/vnd.github+json",
+            "User-Agent": "chvor-cli",
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`Failed to fetch release ${tag}: ${res.status} ${res.statusText}`);
+    }
+    const release = (await res.json());
+    const assetName = getAssetName(version);
+    const asset = release.assets.find((a) => a.name === assetName);
+    if (!asset) {
+        throw new Error(`Asset "${assetName}" not found in release ${tag}. ` +
+            `Available assets: ${release.assets.map((a) => a.name).join(", ")}`);
+    }
+    let checksum;
+    const checksumAsset = release.assets.find((a) => a.name === "SHA256SUMS.txt");
+    if (checksumAsset) {
+        const checksumRes = await fetch(checksumAsset.browser_download_url, {
+            headers: { "User-Agent": "chvor-cli" },
+        });
+        if (checksumRes.ok) {
+            const text = await checksumRes.text();
+            const line = text
+                .split("\n")
+                .find((l) => l.includes(assetName));
+            if (line) {
+                checksum = line.trim().split(/\s+/)[0];
+            }
+        }
+    }
+    return { url: asset.browser_download_url, checksum };
+}
+export function isInstalled(version) {
+    const appDir = getAppDir();
+    if (!existsSync(appDir))
+        return false;
+    const config = readConfig();
+    return config.installedVersion === version;
+}
+export async function downloadRelease(version) {
+    if (isInstalled(version)) {
+        console.log(`Chvor v${version} is already installed.`);
+        return;
+    }
+    console.log(`Resolving Chvor v${version} release...`);
+    const { url, checksum } = await resolveRelease(version);
+    const downloadsDir = getDownloadsDir();
+    ensureDir(downloadsDir);
+    const assetName = getAssetName(version);
+    const tarballPath = join(downloadsDir, assetName);
+    // Download the tarball
+    console.log(`Downloading ${assetName}...`);
+    const res = await fetch(url, {
+        headers: { "User-Agent": "chvor-cli" },
+    });
+    if (!res.ok) {
+        throw new Error(`Download failed: ${res.status} ${res.statusText}`);
+    }
+    if (!res.body) {
+        throw new Error("Download response has no body");
+    }
+    const fileStream = createWriteStream(tarballPath);
+    await pipeline(Readable.fromWeb(res.body), fileStream);
+    console.log("Download complete.");
+    // Verify checksum if available
+    if (checksum) {
+        console.log("Verifying checksum...");
+        const actual = await computeSha256(tarballPath);
+        if (actual !== checksum) {
+            throw new Error(`Checksum mismatch!\n  Expected: ${checksum}\n  Actual:   ${actual}`);
+        }
+        console.log("Checksum verified.");
+    }
+    // Extract
+    const appDir = getAppDir();
+    ensureDir(appDir);
+    console.log(`Extracting to ${appDir}...`);
+    if (getPlatform() === "win") {
+        execFileSync("powershell", [
+            "-NoProfile", "-Command",
+            `Expand-Archive -Path '${tarballPath}' -DestinationPath '${appDir}' -Force`,
+        ], { stdio: "inherit" });
+        // Move contents up from the nested directory (strip-components equivalent)
+        const nested = join(appDir, assetName.replace(/\.zip$/, ""));
+        if (existsSync(nested)) {
+            execFileSync("powershell", [
+                "-NoProfile", "-Command",
+                `Get-ChildItem -Path '${nested}' | Move-Item -Destination '${appDir}' -Force`,
+            ], { stdio: "inherit" });
+            execFileSync("powershell", [
+                "-NoProfile", "-Command",
+                `Remove-Item -Path '${nested}' -Recurse -Force`,
+            ], { stdio: "inherit" });
+        }
+    }
+    else {
+        execFileSync("tar", ["-xzf", tarballPath, "-C", appDir, "--strip-components=1"], {
+            stdio: "inherit",
+        });
+    }
+    console.log("Extraction complete.");
+    // Install Playwright's Chromium browser (required by browser agent / Stagehand)
+    console.log("Installing browser engine (Chromium)...");
+    try {
+        execFileSync("node", [
+            join(appDir, "node_modules", "@playwright", "test", "cli.js"),
+            "install", "chromium",
+        ], { stdio: "inherit", cwd: appDir });
+        console.log("Browser engine installed.");
+    }
+    catch (err) {
+        console.warn("Warning: failed to install browser engine. " +
+            "The web agent won't work until you run: npx playwright install chromium");
+    }
+    // Update config
+    const config = readConfig();
+    config.installedVersion = version;
+    writeConfig(config);
+    console.log(`Chvor v${version} installed successfully.`);
+}
+async function computeSha256(filePath) {
+    return new Promise((resolve, reject) => {
+        const hash = createHash("sha256");
+        const stream = createReadStream(filePath);
+        stream.on("data", (chunk) => hash.update(chunk));
+        stream.on("end", () => resolve(hash.digest("hex")));
+        stream.on("error", reject);
+    });
+}