mdtolink 0.1.0

package/dist/open-CyQVFp6V.mjs

@@ -0,0 +1,479 @@
+#!/usr/bin/env node
+import fs, { constants } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { Buffer } from "node:buffer";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import childProcess, { execFile } from "node:child_process";
+import fs$1 from "node:fs";
+
+//#region ../../node_modules/.pnpm/is-docker@3.0.0/node_modules/is-docker/index.js
+let isDockerCached;
+function hasDockerEnv() {
+	try {
+		fs$1.statSync("/.dockerenv");
+		return true;
+	} catch {
+		return false;
+	}
+}
+function hasDockerCGroup() {
+	try {
+		return fs$1.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+	} catch {
+		return false;
+	}
+}
+function isDocker() {
+	if (isDockerCached === void 0) isDockerCached = hasDockerEnv() || hasDockerCGroup();
+	return isDockerCached;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/is-inside-container@1.0.0/node_modules/is-inside-container/index.js
+let cachedResult;
+const hasContainerEnv = () => {
+	try {
+		fs$1.statSync("/run/.containerenv");
+		return true;
+	} catch {
+		return false;
+	}
+};
+function isInsideContainer() {
+	if (cachedResult === void 0) cachedResult = hasContainerEnv() || isDocker();
+	return cachedResult;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/is-wsl@3.1.1/node_modules/is-wsl/index.js
+const isWsl = () => {
+	if (process.platform !== "linux") return false;
+	if (os.release().toLowerCase().includes("microsoft")) {
+		if (isInsideContainer()) return false;
+		return true;
+	}
+	try {
+		if (fs$1.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) return !isInsideContainer();
+	} catch {}
+	if (fs$1.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || fs$1.existsSync("/run/WSL")) return !isInsideContainer();
+	return false;
+};
+var is_wsl_default = process.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+
+//#endregion
+//#region ../../node_modules/.pnpm/wsl-utils@0.1.0/node_modules/wsl-utils/index.js
+const wslDrivesMountPoint = (() => {
+	const defaultMountPoint = "/mnt/";
+	let mountPoint;
+	return async function() {
+		if (mountPoint) return mountPoint;
+		const configFilePath = "/etc/wsl.conf";
+		let isConfigFileExists = false;
+		try {
+			await fs.access(configFilePath, constants.F_OK);
+			isConfigFileExists = true;
+		} catch {}
+		if (!isConfigFileExists) return defaultMountPoint;
+		const configContent = await fs.readFile(configFilePath, { encoding: "utf8" });
+		const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
+		if (!configMountPoint) return defaultMountPoint;
+		mountPoint = configMountPoint.groups.mountPoint.trim();
+		mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+		return mountPoint;
+	};
+})();
+const powerShellPathFromWsl = async () => {
+	return `${await wslDrivesMountPoint()}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+};
+const powerShellPath = async () => {
+	if (is_wsl_default) return powerShellPathFromWsl();
+	return `${process.env.SYSTEMROOT || process.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/define-lazy-prop@3.0.0/node_modules/define-lazy-prop/index.js
+function defineLazyProperty(object, propertyName, valueGetter) {
+	const define = (value) => Object.defineProperty(object, propertyName, {
+		value,
+		enumerable: true,
+		writable: true
+	});
+	Object.defineProperty(object, propertyName, {
+		configurable: true,
+		enumerable: true,
+		get() {
+			const result = valueGetter();
+			define(result);
+			return result;
+		},
+		set(value) {
+			define(value);
+		}
+	});
+	return object;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/default-browser-id@5.0.1/node_modules/default-browser-id/index.js
+const execFileAsync$3 = promisify(execFile);
+async function defaultBrowserId() {
+	if (process.platform !== "darwin") throw new Error("macOS only");
+	const { stdout } = await execFileAsync$3("defaults", [
+		"read",
+		"com.apple.LaunchServices/com.apple.launchservices.secure",
+		"LSHandlers"
+	]);
+	const browserId = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout)?.groups.id ?? "com.apple.Safari";
+	if (browserId === "com.apple.safari") return "com.apple.Safari";
+	return browserId;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/run-applescript@7.1.0/node_modules/run-applescript/index.js
+const execFileAsync$2 = promisify(execFile);
+async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
+	if (process.platform !== "darwin") throw new Error("macOS only");
+	const outputArguments = humanReadableOutput ? [] : ["-ss"];
+	const execOptions = {};
+	if (signal) execOptions.signal = signal;
+	const { stdout } = await execFileAsync$2("osascript", [
+		"-e",
+		script,
+		outputArguments
+	], execOptions);
+	return stdout.trim();
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/bundle-name@4.1.0/node_modules/bundle-name/index.js
+async function bundleName(bundleId) {
+	return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string\ntell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/default-browser@5.5.0/node_modules/default-browser/windows.js
+const execFileAsync$1 = promisify(execFile);
+const windowsBrowserProgIds = {
+	MSEdgeHTM: {
+		name: "Edge",
+		id: "com.microsoft.edge"
+	},
+	MSEdgeBHTML: {
+		name: "Edge Beta",
+		id: "com.microsoft.edge.beta"
+	},
+	MSEdgeDHTML: {
+		name: "Edge Dev",
+		id: "com.microsoft.edge.dev"
+	},
+	AppXq0fevzme2pys62n3e0fbqa7peapykr8v: {
+		name: "Edge",
+		id: "com.microsoft.edge.old"
+	},
+	ChromeHTML: {
+		name: "Chrome",
+		id: "com.google.chrome"
+	},
+	ChromeBHTML: {
+		name: "Chrome Beta",
+		id: "com.google.chrome.beta"
+	},
+	ChromeDHTML: {
+		name: "Chrome Dev",
+		id: "com.google.chrome.dev"
+	},
+	ChromiumHTM: {
+		name: "Chromium",
+		id: "org.chromium.Chromium"
+	},
+	BraveHTML: {
+		name: "Brave",
+		id: "com.brave.Browser"
+	},
+	BraveBHTML: {
+		name: "Brave Beta",
+		id: "com.brave.Browser.beta"
+	},
+	BraveDHTML: {
+		name: "Brave Dev",
+		id: "com.brave.Browser.dev"
+	},
+	BraveSSHTM: {
+		name: "Brave Nightly",
+		id: "com.brave.Browser.nightly"
+	},
+	FirefoxURL: {
+		name: "Firefox",
+		id: "org.mozilla.firefox"
+	},
+	OperaStable: {
+		name: "Opera",
+		id: "com.operasoftware.Opera"
+	},
+	VivaldiHTM: {
+		name: "Vivaldi",
+		id: "com.vivaldi.Vivaldi"
+	},
+	"IE.HTTP": {
+		name: "Internet Explorer",
+		id: "com.microsoft.ie"
+	}
+};
+const _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
+var UnknownBrowserError = class extends Error {};
+async function defaultBrowser$1(_execFileAsync = execFileAsync$1) {
+	const { stdout } = await _execFileAsync("reg", [
+		"QUERY",
+		" HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
+		"/v",
+		"ProgId"
+	]);
+	const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+	if (!match) throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+	const { id } = match.groups;
+	const dotIndex = id.lastIndexOf(".");
+	const hyphenIndex = id.lastIndexOf("-");
+	const baseIdByDot = dotIndex === -1 ? void 0 : id.slice(0, dotIndex);
+	const baseIdByHyphen = hyphenIndex === -1 ? void 0 : id.slice(0, hyphenIndex);
+	return windowsBrowserProgIds[id] ?? windowsBrowserProgIds[baseIdByDot] ?? windowsBrowserProgIds[baseIdByHyphen] ?? {
+		name: id,
+		id
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/default-browser@5.5.0/node_modules/default-browser/index.js
+const execFileAsync = promisify(execFile);
+const titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+async function defaultBrowser() {
+	if (process.platform === "darwin") {
+		const id = await defaultBrowserId();
+		return {
+			name: await bundleName(id),
+			id
+		};
+	}
+	if (process.platform === "linux") {
+		const { stdout } = await execFileAsync("xdg-mime", [
+			"query",
+			"default",
+			"x-scheme-handler/http"
+		]);
+		const id = stdout.trim();
+		return {
+			name: titleize(id.replace(/.desktop$/, "").replace("-", " ")),
+			id
+		};
+	}
+	if (process.platform === "win32") return defaultBrowser$1();
+	throw new Error("Only macOS, Linux, and Windows are supported");
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/open@10.2.0/node_modules/open/index.js
+const execFile$1 = promisify(childProcess.execFile);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const localXdgOpenPath = path.join(__dirname, "xdg-open");
+const { platform, arch } = process;
+/**
+Get the default browser name in Windows from WSL.
+
+@returns {Promise<string>} Browser name.
+*/
+async function getWindowsDefaultBrowserFromWsl() {
+	const powershellPath = await powerShellPath();
+	const rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
+	const { stdout } = await execFile$1(powershellPath, [
+		"-NoProfile",
+		"-NonInteractive",
+		"-ExecutionPolicy",
+		"Bypass",
+		"-EncodedCommand",
+		Buffer.from(rawCommand, "utf16le").toString("base64")
+	], { encoding: "utf8" });
+	const progId = stdout.trim();
+	const browserMap = {
+		ChromeHTML: "com.google.chrome",
+		BraveHTML: "com.brave.Browser",
+		MSEdgeHTM: "com.microsoft.edge",
+		FirefoxURL: "org.mozilla.firefox"
+	};
+	return browserMap[progId] ? { id: browserMap[progId] } : {};
+}
+const pTryEach = async (array, mapper) => {
+	let latestError;
+	for (const item of array) try {
+		return await mapper(item);
+	} catch (error) {
+		latestError = error;
+	}
+	throw latestError;
+};
+const baseOpen = async (options) => {
+	options = {
+		wait: false,
+		background: false,
+		newInstance: false,
+		allowNonzeroExitCode: false,
+		...options
+	};
+	if (Array.isArray(options.app)) return pTryEach(options.app, (singleApp) => baseOpen({
+		...options,
+		app: singleApp
+	}));
+	let { name: app, arguments: appArguments = [] } = options.app ?? {};
+	appArguments = [...appArguments];
+	if (Array.isArray(app)) return pTryEach(app, (appName) => baseOpen({
+		...options,
+		app: {
+			name: appName,
+			arguments: appArguments
+		}
+	}));
+	if (app === "browser" || app === "browserPrivate") {
+		const ids = {
+			"com.google.chrome": "chrome",
+			"google-chrome.desktop": "chrome",
+			"com.brave.Browser": "brave",
+			"org.mozilla.firefox": "firefox",
+			"firefox.desktop": "firefox",
+			"com.microsoft.msedge": "edge",
+			"com.microsoft.edge": "edge",
+			"com.microsoft.edgemac": "edge",
+			"microsoft-edge.desktop": "edge"
+		};
+		const flags = {
+			chrome: "--incognito",
+			brave: "--incognito",
+			firefox: "--private-window",
+			edge: "--inPrivate"
+		};
+		const browser = is_wsl_default ? await getWindowsDefaultBrowserFromWsl() : await defaultBrowser();
+		if (browser.id in ids) {
+			const browserName = ids[browser.id];
+			if (app === "browserPrivate") appArguments.push(flags[browserName]);
+			return baseOpen({
+				...options,
+				app: {
+					name: apps[browserName],
+					arguments: appArguments
+				}
+			});
+		}
+		throw new Error(`${browser.name} is not supported as a default browser`);
+	}
+	let command;
+	const cliArguments = [];
+	const childProcessOptions = {};
+	if (platform === "darwin") {
+		command = "open";
+		if (options.wait) cliArguments.push("--wait-apps");
+		if (options.background) cliArguments.push("--background");
+		if (options.newInstance) cliArguments.push("--new");
+		if (app) cliArguments.push("-a", app);
+	} else if (platform === "win32" || is_wsl_default && !isInsideContainer() && !app) {
+		command = await powerShellPath();
+		cliArguments.push("-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-EncodedCommand");
+		if (!is_wsl_default) childProcessOptions.windowsVerbatimArguments = true;
+		const encodedArguments = ["Start"];
+		if (options.wait) encodedArguments.push("-Wait");
+		if (app) {
+			encodedArguments.push(`"\`"${app}\`""`);
+			if (options.target) appArguments.push(options.target);
+		} else if (options.target) encodedArguments.push(`"${options.target}"`);
+		if (appArguments.length > 0) {
+			appArguments = appArguments.map((argument) => `"\`"${argument}\`""`);
+			encodedArguments.push("-ArgumentList", appArguments.join(","));
+		}
+		options.target = Buffer.from(encodedArguments.join(" "), "utf16le").toString("base64");
+	} else {
+		if (app) command = app;
+		else {
+			const isBundled = !__dirname || __dirname === "/";
+			let exeLocalXdgOpen = false;
+			try {
+				await fs.access(localXdgOpenPath, constants.X_OK);
+				exeLocalXdgOpen = true;
+			} catch {}
+			command = process.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen) ? "xdg-open" : localXdgOpenPath;
+		}
+		if (appArguments.length > 0) cliArguments.push(...appArguments);
+		if (!options.wait) {
+			childProcessOptions.stdio = "ignore";
+			childProcessOptions.detached = true;
+		}
+	}
+	if (platform === "darwin" && appArguments.length > 0) cliArguments.push("--args", ...appArguments);
+	if (options.target) cliArguments.push(options.target);
+	const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
+	if (options.wait) return new Promise((resolve$1, reject) => {
+		subprocess.once("error", reject);
+		subprocess.once("close", (exitCode) => {
+			if (!options.allowNonzeroExitCode && exitCode > 0) {
+				reject(/* @__PURE__ */ new Error(`Exited with code ${exitCode}`));
+				return;
+			}
+			resolve$1(subprocess);
+		});
+	});
+	subprocess.unref();
+	return subprocess;
+};
+const open = (target, options) => {
+	if (typeof target !== "string") throw new TypeError("Expected a `target`");
+	return baseOpen({
+		...options,
+		target
+	});
+};
+function detectArchBinary(binary) {
+	if (typeof binary === "string" || Array.isArray(binary)) return binary;
+	const { [arch]: archBinary } = binary;
+	if (!archBinary) throw new Error(`${arch} is not supported`);
+	return archBinary;
+}
+function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
+	if (wsl && is_wsl_default) return detectArchBinary(wsl);
+	if (!platformBinary) throw new Error(`${platform} is not supported`);
+	return detectArchBinary(platformBinary);
+}
+const apps = {};
+defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+	darwin: "google chrome",
+	win32: "chrome",
+	linux: [
+		"google-chrome",
+		"google-chrome-stable",
+		"chromium"
+	]
+}, { wsl: {
+	ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+	x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+} }));
+defineLazyProperty(apps, "brave", () => detectPlatformBinary({
+	darwin: "brave browser",
+	win32: "brave",
+	linux: ["brave-browser", "brave"]
+}, { wsl: {
+	ia32: "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe",
+	x64: ["/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe", "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe"]
+} }));
+defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+	darwin: "firefox",
+	win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
+	linux: "firefox"
+}, { wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe" }));
+defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+	darwin: "microsoft edge",
+	win32: "msedge",
+	linux: ["microsoft-edge", "microsoft-edge-dev"]
+}, { wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe" }));
+defineLazyProperty(apps, "browser", () => "browser");
+defineLazyProperty(apps, "browserPrivate", () => "browserPrivate");
+var open_default = open;
+
+//#endregion
+export { open_default as default };

package/dist/publish-CBI8KFZ6.mjs

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+import { t as createApiClient } from "./api-CdA_O32l.mjs";
+import { a as getDocumentMap, l as setDocumentMapping, o as getToken } from "./config-CTqVqsq8.mjs";
+import { n as formatDocumentUrl } from "./format-C4j0hJTz.mjs";
+import { confirm, isCancel, log, spinner } from "@clack/prompts";
+import { access, readFile } from "node:fs/promises";
+import { basename, extname, resolve } from "node:path";
+
+//#region src/cli/commands/publish.ts
+async function publish(filePath, options) {
+	const absolutePath = resolve(filePath);
+	try {
+		await access(absolutePath);
+	} catch {
+		log.error(`File not found: ${absolutePath}`);
+		process.exitCode = 1;
+		return;
+	}
+	let token = await getToken();
+	if (!token) {
+		const shouldLogin = await confirm({ message: "You are not logged in. Would you like to authorize now?" });
+		if (isCancel(shouldLogin) || !shouldLogin) {
+			log.info("Publish cancelled. Run `mdtolink login` to authenticate.");
+			return;
+		}
+		const { login } = await import("./login-DhnCjQAQ.mjs");
+		await login();
+		token = await getToken();
+		if (!token) {
+			log.error("Authentication failed. Cannot publish.");
+			process.exitCode = 1;
+			return;
+		}
+	}
+	const content = await readFile(absolutePath, "utf-8");
+	if (content.trim().length === 0) {
+		log.error("File is empty.");
+		process.exitCode = 1;
+		return;
+	}
+	const title = options.title ?? basename(absolutePath, extname(absolutePath));
+	const existingMapping = (await getDocumentMap())[absolutePath];
+	const api = createApiClient(token);
+	const spin = spinner();
+	if (existingMapping) {
+		spin.start("Updating document...");
+		await updateExisting(api, absolutePath, existingMapping.documentId, content, title, options.slug, spin);
+	} else {
+		spin.start("Publishing document...");
+		await publishNew(api, absolutePath, content, title, options.slug, spin);
+	}
+}
+async function updateExisting(api, absolutePath, documentId, content, title, slug, spin) {
+	try {
+		const result = await api.documents.update({
+			params: { id: documentId },
+			body: {
+				content,
+				title,
+				slug
+			}
+		});
+		if (result.status === 200) {
+			const doc = result.body;
+			const url = formatDocumentUrl(doc);
+			await setDocumentMapping(absolutePath, {
+				documentId: doc.id,
+				slug: doc.slug,
+				url,
+				lastPublished: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			spin.stop("Document updated!");
+			log.success(`Updated: ${url}`);
+			return;
+		}
+		spin.stop("Update failed.");
+		if (result.status === 401) {
+			log.error("Session expired. Run `mdtolink login` to re-authenticate.");
+			process.exitCode = 1;
+			return;
+		}
+		if (result.status === 404) {
+			log.warning("Previous document no longer exists on server. Creating a new one...");
+			const newSpin = spinner();
+			newSpin.start("Publishing document...");
+			await publishNew(api, absolutePath, content, title, slug, newSpin);
+			return;
+		}
+		const body = result.body;
+		log.error(body.message ?? body.error);
+		process.exitCode = 1;
+	} catch {
+		spin.stop("Update failed.");
+		log.error("Could not connect to server. Check MDTOLINK_SERVER_URL.");
+		process.exitCode = 1;
+	}
+}
+async function publishNew(api, absolutePath, content, title, slug, spin) {
+	try {
+		const result = await api.documents.create({ body: {
+			content,
+			title,
+			slug,
+			isPublic: true
+		} });
+		if (result.status === 201) {
+			const doc = result.body;
+			const url = formatDocumentUrl(doc);
+			await setDocumentMapping(absolutePath, {
+				documentId: doc.id,
+				slug: doc.slug,
+				url,
+				lastPublished: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			spin.stop("Published!");
+			log.success(`Published: ${url}`);
+			return;
+		}
+		spin.stop("Publish failed.");
+		const body = result.body;
+		if (result.status === 401) log.error("Session expired. Run `mdtolink login` to re-authenticate.");
+		else if (result.status === 403) {
+			log.error(body.message ?? body.error);
+			log.info("Upgrade at https://mdtolink.com/pricing");
+		} else log.error(body.message ?? body.error);
+		process.exitCode = 1;
+	} catch {
+		spin.stop("Publish failed.");
+		log.error("Could not connect to server. Check MDTOLINK_SERVER_URL.");
+		process.exitCode = 1;
+	}
+}
+
+//#endregion
+export { publish };