tokwise 0.1.0

package/dist/jsonl.js

@@ -0,0 +1,51 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export async function readJsonl(filePath) {
+    let text;
+    try {
+        text = await fs.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    const rows = [];
+    for (const [idx, line] of text.split(/\r?\n/).entries()) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            rows.push(JSON.parse(trimmed));
+        }
+        catch (error) {
+            throw new Error(`Invalid JSONL at ${filePath}:${idx + 1}: ${error.message}`);
+        }
+    }
+    return rows;
+}
+export async function writeJsonl(filePath, rows) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const tmpPath = `${filePath}.tmp-${process.pid}`;
+    const body = rows.map((row) => JSON.stringify(row)).join("\n");
+    await fs.writeFile(tmpPath, body.length > 0 ? `${body}\n` : "", "utf8");
+    await fs.rename(tmpPath, filePath);
+}
+export async function readJsonFile(filePath, fallback) {
+    try {
+        return JSON.parse(await fs.readFile(filePath, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return fallback;
+        throw error;
+    }
+}
+export async function writeJsonFile(filePath, value, mode) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const tmpPath = `${filePath}.tmp-${process.pid}`;
+    await fs.writeFile(tmpPath, `${JSON.stringify(value, null, 2)}\n`, mode == null ? undefined : { mode });
+    await fs.rename(tmpPath, filePath);
+    if (mode != null)
+        await fs.chmod(filePath, mode);
+}

package/dist/library.js

@@ -0,0 +1,138 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { commandsDir, ensureDataDirs, libraryDir } from "./paths.js";
+import { readTextInput, resolveMaybeRelative } from "./store.js";
+import { tokenize } from "./search.js";
+export async function searchLibrary(query, limit = 20) {
+    ensureDataDirs();
+    const terms = new Set(tokenize(query));
+    const files = await listMarkdownFiles(libraryDir());
+    const results = [];
+    for (const file of files) {
+        const text = await fs.readFile(file, "utf8");
+        const tokens = tokenize(text);
+        const score = tokens.reduce((sum, token) => sum + (terms.has(token) ? 1 : 0), 0);
+        if (score > 0) {
+            results.push({
+                path: path.relative(libraryDir(), file),
+                score,
+                preview: text.replace(/\s+/g, " ").slice(0, 220),
+            });
+        }
+    }
+    return results.sort((a, b) => b.score - a.score).slice(0, limit);
+}
+export async function showLibraryPage(pagePath) {
+    const safePath = resolveUnder(libraryDir(), pagePath);
+    const body = await fs.readFile(safePath, "utf8");
+    return { path: path.relative(libraryDir(), safePath), sha256: sha256(body), body };
+}
+export async function createLibraryPage(pagePath, inputPath) {
+    const safePath = resolveUnder(libraryDir(), pagePath);
+    const body = await readTextInput(inputPath);
+    await fs.mkdir(path.dirname(safePath), { recursive: true });
+    await fs.writeFile(safePath, body, { encoding: "utf8", flag: "wx" });
+    return safePath;
+}
+export async function updateLibraryPage(pagePath, inputPath, expectedSha256) {
+    const safePath = resolveUnder(libraryDir(), pagePath);
+    const previous = await fs.readFile(safePath, "utf8");
+    if (expectedSha256 && sha256(previous) !== expectedSha256) {
+        throw new Error("Library page changed since it was read. Re-run show and pass the new sha256.");
+    }
+    const body = await readTextInput(inputPath);
+    await fs.writeFile(safePath, body, "utf8");
+    return safePath;
+}
+export async function deleteLibraryPage(pagePath) {
+    const safePath = resolveUnder(libraryDir(), pagePath);
+    const trashDir = path.join(libraryDir(), ".trash");
+    await fs.mkdir(trashDir, { recursive: true });
+    const target = path.join(trashDir, `${Date.now()}-${path.basename(pagePath)}`);
+    await fs.rename(safePath, target);
+    return target;
+}
+export async function listCommands() {
+    ensureDataDirs();
+    try {
+        return (await fs.readdir(commandsDir())).filter((name) => name.endsWith(".md")).sort();
+    }
+    catch {
+        return [];
+    }
+}
+export async function createCommand(name) {
+    ensureDataDirs();
+    const fileName = name.endsWith(".md") ? name : `${name}.md`;
+    const safePath = resolveUnder(commandsDir(), fileName);
+    const body = [
+        `# ${path.basename(fileName, ".md")}`,
+        "",
+        "## Purpose",
+        "",
+        "Describe the reusable workflow this command should run.",
+        "",
+        "## Steps",
+        "",
+        "1. Search the local Tokwise archive when relevant.",
+        "2. Ground claims in video ids or Markdown pages.",
+        "3. Report uncertainty clearly.",
+        "",
+    ].join("\n");
+    await fs.writeFile(safePath, body, { encoding: "utf8", flag: "wx" });
+    return safePath;
+}
+export async function validateCommands(name) {
+    const names = name ? [name.endsWith(".md") ? name : `${name}.md`] : await listCommands();
+    const ok = [];
+    const issues = [];
+    for (const commandName of names) {
+        const filePath = resolveUnder(commandsDir(), commandName);
+        try {
+            const body = await fs.readFile(filePath, "utf8");
+            if (!body.startsWith("# "))
+                issues.push(`${commandName}: missing title`);
+            else if (!body.includes("##"))
+                issues.push(`${commandName}: add at least one section heading`);
+            else
+                ok.push(commandName);
+        }
+        catch (error) {
+            issues.push(`${commandName}: ${error.message}`);
+        }
+    }
+    return { ok, issues };
+}
+function resolveUnder(root, requested) {
+    const resolved = path.resolve(root, requested);
+    const normalizedRoot = path.resolve(root);
+    if (!resolved.startsWith(`${normalizedRoot}${path.sep}`) && resolved !== normalizedRoot) {
+        throw new Error(`Path escapes ${root}: ${requested}`);
+    }
+    return resolved;
+}
+async function listMarkdownFiles(dir) {
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory() && entry.name !== ".trash")
+            files.push(...(await listMarkdownFiles(fullPath)));
+        else if (entry.isFile() && entry.name.endsWith(".md"))
+            files.push(fullPath);
+    }
+    return files;
+}
+function sha256(body) {
+    return crypto.createHash("sha256").update(body).digest("hex");
+}
+export function resolveExternalPath(filePath) {
+    return resolveMaybeRelative(filePath);
+}

package/dist/markdown.js

@@ -0,0 +1,211 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ensureDataDirs, libraryDir, markdownCategoriesDir, markdownDomainsDir, markdownVideosDir, } from "./paths.js";
+import { sanitizeFilePart } from "./store.js";
+export async function exportMarkdown(videos, options) {
+    ensureDataDirs();
+    let written = 0;
+    let skipped = 0;
+    const files = [];
+    for (const video of videos) {
+        const filePath = videoMarkdownPath(video);
+        const body = renderVideoMarkdown(video);
+        if (options?.changedOnly && (await sameContent(filePath, body))) {
+            skipped += 1;
+            continue;
+        }
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, body, "utf8");
+        written += 1;
+        files.push(filePath);
+    }
+    return { written, skipped, files };
+}
+export async function compileWiki(videos) {
+    const exported = await exportMarkdown(videos);
+    await fs.mkdir(markdownCategoriesDir(), { recursive: true });
+    await fs.mkdir(markdownDomainsDir(), { recursive: true });
+    const byCategory = groupBy(videos, (video) => video.classification?.category ?? "uncategorized");
+    const byDomain = groupBy(videos, (video) => video.classification?.domain ?? "general");
+    const files = [...exported.files];
+    for (const [category, group] of byCategory) {
+        const filePath = path.join(markdownCategoriesDir(), `${sanitizeFilePart(category)}.md`);
+        await fs.writeFile(filePath, renderGroupPage("Category", category, group), "utf8");
+        files.push(filePath);
+    }
+    for (const [domain, group] of byDomain) {
+        const filePath = path.join(markdownDomainsDir(), `${sanitizeFilePart(domain)}.md`);
+        await fs.writeFile(filePath, renderGroupPage("Domain", domain, group), "utf8");
+        files.push(filePath);
+    }
+    const indexPath = path.join(libraryDir(), "index.md");
+    await fs.writeFile(indexPath, renderIndex(videos, byCategory, byDomain), "utf8");
+    files.push(indexPath);
+    return { written: files.length, skipped: exported.skipped, files };
+}
+export function videoMarkdownPath(video) {
+    return path.join(markdownVideosDir(), `${sanitizeFilePart(video.id)}.md`);
+}
+export function renderVideoMarkdown(video) {
+    const title = video.description?.split(/\r?\n/)[0]?.slice(0, 80) || `Clip ${video.id}`;
+    const category = video.classification?.category ?? "uncategorized";
+    const domain = video.classification?.domain ?? "general";
+    const topics = video.classification?.topics ?? [];
+    return [
+        "---",
+        `id: ${yamlString(video.id)}`,
+        `url: ${yamlString(video.canonicalUrl ?? video.url)}`,
+        `author: ${yamlString(video.author?.username ?? "")}`,
+        `created_at: ${yamlString(video.createdAt ?? "")}`,
+        `category: ${yamlString(category)}`,
+        `domain: ${yamlString(domain)}`,
+        `topics: [${topics.map(yamlString).join(", ")}]`,
+        "---",
+        "",
+        `# ${title}`,
+        "",
+        `Source: ${video.canonicalUrl ?? video.url}`,
+        video.author?.username ? `Author: @${video.author.username}` : "",
+        `Category: [[categories/${sanitizeFilePart(category)}|${category}]]`,
+        `Domain: [[domains/${sanitizeFilePart(domain)}|${domain}]]`,
+        "",
+        "## Summary",
+        "",
+        video.classification?.summary ?? "No summary yet.",
+        "",
+        "## Description",
+        "",
+        video.description ?? "",
+        "",
+        "## Transcript",
+        "",
+        video.transcript?.text ?? "_No transcript yet._",
+        "",
+        "## Metadata",
+        "",
+        `- Hashtags: ${video.hashtags.map((tag) => `#${tag}`).join(" ") || "none"}`,
+        `- Music: ${[video.music?.title, video.music?.author].filter(Boolean).join(" - ") || "unknown"}`,
+        `- Plays: ${video.stats?.plays ?? "unknown"}`,
+        `- Likes: ${video.stats?.likes ?? "unknown"}`,
+        "",
+    ]
+        .filter((line) => line !== "")
+        .join("\n");
+}
+export async function lintWiki(options) {
+    const files = await listMarkdownFiles(libraryDir());
+    const existing = new Set(files.map((file) => stripMd(path.relative(libraryDir(), file))));
+    const broken = [];
+    for (const file of files) {
+        const text = await fs.readFile(file, "utf8");
+        for (const link of extractWikiLinks(text)) {
+            const target = stripAlias(link);
+            if (/^https?:\/\//.test(target))
+                continue;
+            if (!existing.has(stripMd(target)))
+                broken.push(`${path.relative(libraryDir(), file)} -> ${target}`);
+        }
+    }
+    let fixed = 0;
+    if (options?.fix) {
+        for (const item of broken) {
+            const target = item.split(" -> ")[1];
+            if (!target)
+                continue;
+            const filePath = path.join(libraryDir(), `${stripMd(target)}.md`);
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            try {
+                await fs.access(filePath);
+            }
+            catch {
+                await fs.writeFile(filePath, `# ${path.basename(target)}\n\n`, "utf8");
+                fixed += 1;
+            }
+        }
+    }
+    return { broken, fixed };
+}
+function renderIndex(videos, byCategory, byDomain) {
+    return [
+        "# Tokwise Library",
+        "",
+        `${videos.length} videos. ${videos.filter((video) => video.transcript?.text).length} transcripts.`,
+        "",
+        "## Categories",
+        "",
+        ...[...byCategory.entries()]
+            .sort((a, b) => b[1].length - a[1].length)
+            .map(([category, group]) => `- [[categories/${sanitizeFilePart(category)}|${category}]] (${group.length})`),
+        "",
+        "## Domains",
+        "",
+        ...[...byDomain.entries()]
+            .sort((a, b) => b[1].length - a[1].length)
+            .map(([domain, group]) => `- [[domains/${sanitizeFilePart(domain)}|${domain}]] (${group.length})`),
+        "",
+        "## Recent Videos",
+        "",
+        ...videos.slice(0, 50).map((video) => `- [[videos/${sanitizeFilePart(video.id)}|${videoTitle(video)}]]`),
+        "",
+    ].join("\n");
+}
+function renderGroupPage(kind, name, videos) {
+    return [
+        `# ${kind}: ${name}`,
+        "",
+        `${videos.length} videos.`,
+        "",
+        ...videos.map((video) => `- [[videos/${sanitizeFilePart(video.id)}|${videoTitle(video)}]]`),
+        "",
+    ].join("\n");
+}
+function videoTitle(video) {
+    return video.description?.replace(/\s+/g, " ").slice(0, 80) || video.id;
+}
+function groupBy(items, keyFn) {
+    const groups = new Map();
+    for (const item of items) {
+        const key = keyFn(item);
+        groups.set(key, [...(groups.get(key) ?? []), item]);
+    }
+    return groups;
+}
+function yamlString(value) {
+    return JSON.stringify(value);
+}
+async function sameContent(filePath, body) {
+    try {
+        return crypto.createHash("sha256").update(await fs.readFile(filePath, "utf8")).digest("hex") === crypto.createHash("sha256").update(body).digest("hex");
+    }
+    catch {
+        return false;
+    }
+}
+async function listMarkdownFiles(dir) {
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory())
+            files.push(...(await listMarkdownFiles(fullPath)));
+        else if (entry.isFile() && entry.name.endsWith(".md"))
+            files.push(fullPath);
+    }
+    return files;
+}
+function extractWikiLinks(text) {
+    return [...text.matchAll(/\[\[([^\]]+)\]\]/g)].map((match) => match[1]).filter((value) => Boolean(value));
+}
+function stripAlias(link) {
+    return link.split("|")[0] ?? link;
+}
+function stripMd(link) {
+    return link.replace(/\.md$/i, "");
+}

package/dist/media.js

@@ -0,0 +1,117 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { audioDir, ensureDataDirs, mediaDir } from "./paths.js";
+import { runProcess } from "./process.js";
+import { sanitizeFilePart } from "./store.js";
+// TikTok advertises aac on every format, but without yt-dlp impersonation its
+// HEVC (bytevc1) "best" formats download video-only. That breaks audio
+// extraction ("unable to obtain file audio codec") and yields silent videos.
+// h264 formats carry a real audio track, so prefer them and only fall back to
+// yt-dlp's default best when no h264 rendition exists.
+const PREFERRED_FORMAT = "b[vcodec^=h264]/b";
+export async function downloadMedia(video, options = {}) {
+    ensureDataDirs();
+    const command = options.ytDlp ?? "yt-dlp";
+    const outputDir = options.audioOnly ? audioDir() : mediaDir();
+    const safeId = sanitizeFilePart(video.id);
+    const existingPath = options.audioOnly ? video.media?.audioPath : video.media?.videoPath;
+    if (!options.force && existingPath && (await exists(existingPath))) {
+        return { id: video.id, changed: false, media: video.media ?? {} };
+    }
+    const before = new Set(await listFiles(outputDir));
+    const args = [
+        "--no-playlist",
+        "--restrict-filenames",
+        // Redownload instead of reusing a leftover intermediate. A prior failed
+        // audio extraction can leave a video-only <id>.mp4 behind; yt-dlp would
+        // otherwise treat it as "already downloaded" and keep failing to extract
+        // audio from that stale file on every subsequent run.
+        "--force-overwrites",
+        "-f",
+        PREFERRED_FORMAT,
+        "--print",
+        "after_move:filepath",
+        "-o",
+        path.join(outputDir, `${safeId}.%(ext)s`),
+    ];
+    if (options.proxy)
+        args.push("--proxy", options.proxy);
+    if (options.cookiesFile)
+        args.push("--cookies", options.cookiesFile);
+    if (options.cookiesFromBrowser)
+        args.push("--cookies-from-browser", options.cookiesFromBrowser);
+    if (options.audioOnly) {
+        args.push("-x", "--audio-format", options.audioFormat ?? "m4a");
+    }
+    else {
+        args.push("--write-info-json");
+    }
+    args.push(downloadTargetUrl(video));
+    const result = await runProcess(command, args);
+    if (result.code !== 0) {
+        throw new Error(`yt-dlp failed for ${video.id}: ${result.stderr || result.stdout}`);
+    }
+    const printed = result.stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .reverse()
+        .find((line) => path.isAbsolute(line));
+    const discovered = printed ?? (await newestCreatedFile(outputDir, before, safeId));
+    const nextMedia = { ...(video.media ?? {}), downloadedAt: new Date().toISOString() };
+    if (options.audioOnly)
+        nextMedia.audioPath = discovered;
+    else {
+        nextMedia.videoPath = discovered;
+        const infoPath = await findInfoJson(outputDir, safeId);
+        if (infoPath)
+            nextMedia.infoJsonPath = infoPath;
+    }
+    return { id: video.id, changed: true, media: nextMedia };
+}
+export function downloadTargetUrl(video) {
+    const target = video.canonicalUrl ?? video.url;
+    if (isMalformedTikTokVideoUrl(target)) {
+        throw new Error(`${video.id} does not have a valid source video URL (${target}). Remove this malformed record or resync the source with the latest CLI.`);
+    }
+    return target;
+}
+function isMalformedTikTokVideoUrl(url) {
+    if (!/https?:\/\/(?:www\.)?tiktok\.com\//i.test(url))
+        return false;
+    if (/\/404(?:[/?#]|$)/i.test(url))
+        return true;
+    const videoMatch = url.match(/\/video\/([^/?#]+)/i);
+    return Boolean(videoMatch && !/^\d{8,}$/.test(videoMatch[1] ?? ""));
+}
+async function listFiles(dir) {
+    try {
+        return (await fs.readdir(dir)).map((name) => path.join(dir, name));
+    }
+    catch {
+        return [];
+    }
+}
+async function exists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function newestCreatedFile(dir, before, prefix) {
+    const candidates = (await listFiles(dir)).filter((filePath) => !before.has(filePath) && path.basename(filePath).startsWith(prefix));
+    let newest;
+    for (const filePath of candidates) {
+        const stat = await fs.stat(filePath);
+        if (!newest || stat.mtimeMs > newest.mtimeMs)
+            newest = { filePath, mtimeMs: stat.mtimeMs };
+    }
+    return newest?.filePath;
+}
+async function findInfoJson(dir, prefix) {
+    const files = await listFiles(dir);
+    return files.find((filePath) => path.basename(filePath).startsWith(prefix) && filePath.endsWith(".info.json"));
+}

package/dist/paths.js

@@ -0,0 +1,87 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function expandHome(input) {
+    if (input === "~")
+        return os.homedir();
+    if (input.startsWith("~/"))
+        return path.join(os.homedir(), input.slice(2));
+    return input;
+}
+export function dataDir() {
+    const preferred = process.env.TOKWISE_DATA_DIR ?? process.env.TW_DATA_DIR;
+    if (preferred)
+        return path.resolve(expandHome(preferred));
+    const legacy = process.env.TT_DATA_DIR ?? process.env.TIKTOK_THEORY_DATA_DIR;
+    if (legacy)
+        return path.resolve(expandHome(legacy));
+    const defaultDir = path.join(os.homedir(), ".tokwise");
+    const legacyDir = path.join(os.homedir(), ".tiktoktheory");
+    if (!fs.existsSync(defaultDir) && fs.existsSync(legacyDir))
+        return legacyDir;
+    return path.resolve(expandHome("~/.tokwise"));
+}
+export function videosDir() {
+    return path.join(dataDir(), "videos");
+}
+export function mediaDir() {
+    return path.join(videosDir(), "media");
+}
+export function audioDir() {
+    return path.join(videosDir(), "audio");
+}
+export function transcriptDir() {
+    return path.join(videosDir(), "transcripts");
+}
+export function videosJsonlPath() {
+    return path.join(videosDir(), "videos.jsonl");
+}
+export function searchIndexPath() {
+    return path.join(videosDir(), "search-index.json");
+}
+export function authPath() {
+    return path.join(videosDir(), "auth.json");
+}
+export function preferencesPath() {
+    return path.join(dataDir(), "preferences.json");
+}
+export function libraryDir() {
+    return path.resolve(expandHome(process.env.TOKWISE_LIBRARY_DIR ?? process.env.TW_LIBRARY_DIR ?? process.env.TT_LIBRARY_DIR ?? path.join(dataDir(), "library")));
+}
+export function markdownVideosDir() {
+    return path.join(libraryDir(), "videos");
+}
+export function markdownCategoriesDir() {
+    return path.join(libraryDir(), "categories");
+}
+export function markdownDomainsDir() {
+    return path.join(libraryDir(), "domains");
+}
+export function commandsDir() {
+    return path.resolve(expandHome(process.env.TOKWISE_COMMANDS_DIR ?? process.env.TW_COMMANDS_DIR ?? process.env.TT_COMMANDS_DIR ?? path.join(dataDir(), "commands")));
+}
+export function ensureDir(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+export function ensureDataDirs() {
+    for (const dir of [
+        dataDir(),
+        videosDir(),
+        mediaDir(),
+        audioDir(),
+        transcriptDir(),
+        libraryDir(),
+        markdownVideosDir(),
+        markdownCategoriesDir(),
+        markdownDomainsDir(),
+        commandsDir(),
+    ]) {
+        ensureDir(dir);
+    }
+}
+export function toDisplayPath(filePath) {
+    if (!filePath)
+        return undefined;
+    const home = os.homedir();
+    return filePath.startsWith(home) ? `~${filePath.slice(home.length)}` : filePath;
+}

package/dist/process.js

@@ -0,0 +1,68 @@
+import { exec as execCallback } from "node:child_process";
+import { spawn } from "node:child_process";
+import { promisify } from "node:util";
+const exec = promisify(execCallback);
+export async function runProcess(command, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, { cwd: options?.cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let settled = false;
+        let stdout = "";
+        let stderr = "";
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            if (error.code === "ENOENT") {
+                resolve({
+                    code: 127,
+                    stdout,
+                    stderr: `Command not found: ${command}. Install it or pass a custom command path.`,
+                });
+                return;
+            }
+            if (error.code === "EACCES") {
+                resolve({
+                    code: 126,
+                    stdout,
+                    stderr: `Command is not executable: ${command}. Check permissions or pass a custom command path.`,
+                });
+                return;
+            }
+            reject(error);
+        });
+        child.on("close", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve({ code: code ?? 0, stdout, stderr });
+        });
+    });
+}
+export async function runShell(command, options) {
+    try {
+        const { stdout, stderr } = await exec(command, { cwd: options?.cwd, maxBuffer: 1024 * 1024 * 20 });
+        return { code: 0, stdout, stderr };
+    }
+    catch (error) {
+        const err = error;
+        return { code: err.code ?? 1, stdout: err.stdout ?? "", stderr: err.stderr ?? err.message };
+    }
+}
+export async function commandExists(command) {
+    const result = await runProcess(command, ["--version"]);
+    return result.code === 0;
+}
+export function quoteShell(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+export function templateCommand(template, values) {
+    return template.replace(/\{([a-zA-Z0-9_-]+)\}/g, (_match, key) => quoteShell(values[key] ?? ""));
+}