@ilya-lesikov/pi-pi 0.1.0

package/3p/pi-plannotator/apps/pi-extension/server/integrations.ts

@@ -0,0 +1,195 @@
+/**
+ * Note-taking app integrations (Obsidian, Bear, Octarine).
+ * Node.js equivalents of packages/server/integrations.ts.
+ * Config types, save functions, tag extraction, filename generation
+ */
+
+import { execSync, spawn } from "node:child_process";
+import { existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+
+import {
+	type ObsidianConfig,
+	type BearConfig,
+	type OctarineConfig,
+	type IntegrationResult,
+	extractTitle,
+	generateFrontmatter,
+	generateFilename,
+	generateOctarineFrontmatter,
+	stripH1,
+	buildHashtags,
+	buildBearContent,
+	detectObsidianVaults,
+} from "../generated/integrations-common.js";
+import { sanitizeTag } from "../generated/project.js";
+import { resolveUserPath } from "../generated/resolve-file.js";
+
+export type { ObsidianConfig, BearConfig, OctarineConfig, IntegrationResult };
+export {
+	extractTitle,
+	generateFrontmatter,
+	generateFilename,
+	generateOctarineFrontmatter,
+	stripH1,
+	buildHashtags,
+	buildBearContent,
+	detectObsidianVaults,
+};
+
+/** Detect project name from git or cwd (sync). Used by extractTags for note integrations. */
+function detectProjectNameSync(): string | null {
+	try {
+		const toplevel = execSync("git rev-parse --show-toplevel", {
+			encoding: "utf-8",
+			stdio: ["pipe", "pipe", "pipe"],
+		}).trim();
+		if (toplevel) {
+			const name = sanitizeTag(basename(toplevel));
+			if (name) return name;
+		}
+	} catch {
+		/* not in a git repo */
+	}
+	try {
+		return sanitizeTag(basename(process.cwd())) ?? null;
+	} catch {
+		return null;
+	}
+}
+
+export async function extractTags(markdown: string): Promise<string[]> {
+	const tags = new Set<string>(["plannotator"]);
+	const projectName = detectProjectNameSync();
+	if (projectName) tags.add(projectName);
+	const stopWords = new Set([
+		"the",
+		"and",
+		"for",
+		"with",
+		"this",
+		"that",
+		"from",
+		"into",
+		"plan",
+		"implementation",
+		"overview",
+		"phase",
+		"step",
+		"steps",
+	]);
+	const h1Match = markdown.match(
+		/^#\s+(?:Implementation\s+Plan:|Plan:)?\s*(.+)$/im,
+	);
+	if (h1Match) {
+		h1Match[1]
+			.toLowerCase()
+			.replace(/[^\w\s-]/g, " ")
+			.split(/\s+/)
+			.filter((w) => w.length > 2 && !stopWords.has(w))
+			.slice(0, 3)
+			.forEach((w) => tags.add(w));
+	}
+	const seenLangs = new Set<string>();
+	let langMatch: RegExpExecArray | null;
+	const langRegex = /```(\w+)/g;
+	while ((langMatch = langRegex.exec(markdown)) !== null) {
+		const lang = langMatch[1];
+		const n = lang.toLowerCase();
+		if (
+			!seenLangs.has(n) &&
+			!["json", "yaml", "yml", "text", "txt", "markdown", "md"].includes(n)
+		) {
+			seenLangs.add(n);
+			tags.add(n);
+		}
+	}
+	return Array.from(tags).slice(0, 7);
+}
+
+export async function saveToObsidian(
+	config: ObsidianConfig,
+): Promise<IntegrationResult> {
+	try {
+		const { vaultPath, folder, plan } = config;
+		if (!vaultPath?.trim()) {
+			return { success: false, error: "Vault path is required" };
+		}
+		const normalizedVault = resolveUserPath(vaultPath);
+		if (!existsSync(normalizedVault))
+			return {
+				success: false,
+				error: `Vault path does not exist: ${normalizedVault}`,
+			};
+		if (!statSync(normalizedVault).isDirectory())
+			return {
+				success: false,
+				error: `Vault path is not a directory: ${normalizedVault}`,
+			};
+		const folderName = folder.trim() || "plannotator";
+		const targetFolder = join(normalizedVault, folderName);
+		if (!existsSync(targetFolder)) mkdirSync(targetFolder, { recursive: true });
+		const filename = generateFilename(
+			plan,
+			config.filenameFormat,
+			config.filenameSeparator,
+		);
+		const filePath = join(targetFolder, filename);
+		const tags = await extractTags(plan);
+		const frontmatter = generateFrontmatter(tags);
+		const content = `${frontmatter}\n\n[[Plannotator Plans]]\n\n${plan}`;
+		writeFileSync(filePath, content);
+		return { success: true, path: filePath };
+	} catch (err) {
+		return {
+			success: false,
+			error: err instanceof Error ? err.message : "Unknown error",
+		};
+	}
+}
+
+export async function saveToBear(
+	config: BearConfig,
+): Promise<IntegrationResult> {
+	try {
+		const { plan, customTags, tagPosition = "append" } = config;
+		const title = extractTitle(plan);
+		const body = stripH1(plan);
+		const tags = customTags?.trim() ? undefined : await extractTags(plan);
+		const hashtags = buildHashtags(customTags, tags ?? []);
+		const content = buildBearContent(body, hashtags, tagPosition);
+		const url = `bear://x-callback-url/create?title=${encodeURIComponent(title)}&text=${encodeURIComponent(content)}&open_note=no`;
+		spawn("open", [url], { stdio: "ignore" });
+		return { success: true };
+	} catch (err) {
+		return {
+			success: false,
+			error: err instanceof Error ? err.message : "Unknown error",
+		};
+	}
+}
+
+export async function saveToOctarine(
+	config: OctarineConfig,
+): Promise<IntegrationResult> {
+	try {
+		const { plan } = config;
+		const workspace = config.workspace.trim();
+		if (!workspace) return { success: false, error: "Workspace is required" };
+		const folder = config.folder.trim() || "plannotator";
+		const filename = generateFilename(plan);
+		const base = filename.replace(/\.md$/, "");
+		const path = folder ? `${folder}/${base}` : base;
+		const tags = await extractTags(plan);
+		const frontmatter = generateOctarineFrontmatter(tags);
+		const content = `${frontmatter}\n\n${plan}`;
+		const url = `octarine://create?path=${encodeURIComponent(path)}&content=${encodeURIComponent(content)}&workspace=${encodeURIComponent(workspace)}&fresh=true&openAfter=false`;
+		spawn("open", [url], { stdio: "ignore" });
+		return { success: true, path };
+	} catch (err) {
+		return {
+			success: false,
+			error: err instanceof Error ? err.message : "Unknown error",
+		};
+	}
+}

package/3p/pi-plannotator/apps/pi-extension/server/network.test.ts

@@ -0,0 +1,158 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import {
+	getServerHostname,
+	getServerPort,
+	isNoOpBrowserSentinel,
+	isRemoteSession,
+	openBrowser,
+} from "./network";
+
+const savedEnv: Record<string, string | undefined> = {};
+const envKeys = [
+	"PLANNOTATOR_REMOTE",
+	"PLANNOTATOR_PORT",
+	"SSH_TTY",
+	"SSH_CONNECTION",
+	"PLANNOTATOR_BROWSER",
+	"BROWSER",
+];
+
+function clearEnv() {
+	for (const key of envKeys) {
+		savedEnv[key] = process.env[key];
+		delete process.env[key];
+	}
+}
+
+afterEach(() => {
+	for (const key of envKeys) {
+		if (savedEnv[key] !== undefined) {
+			process.env[key] = savedEnv[key];
+		} else {
+			delete process.env[key];
+		}
+	}
+});
+
+describe("pi remote detection", () => {
+	test("false by default", () => {
+		clearEnv();
+		expect(isRemoteSession()).toBe(false);
+	});
+
+	test("true when PLANNOTATOR_REMOTE=1", () => {
+		clearEnv();
+		process.env.PLANNOTATOR_REMOTE = "1";
+		expect(isRemoteSession()).toBe(true);
+	});
+
+	test("true when PLANNOTATOR_REMOTE=true", () => {
+		clearEnv();
+		process.env.PLANNOTATOR_REMOTE = "true";
+		expect(isRemoteSession()).toBe(true);
+	});
+
+	test("false when PLANNOTATOR_REMOTE=0", () => {
+		clearEnv();
+		process.env.PLANNOTATOR_REMOTE = "0";
+		expect(isRemoteSession()).toBe(false);
+	});
+
+	test("false when PLANNOTATOR_REMOTE=false", () => {
+		clearEnv();
+		process.env.PLANNOTATOR_REMOTE = "false";
+		expect(isRemoteSession()).toBe(false);
+	});
+
+	test("PLANNOTATOR_REMOTE=false overrides SSH_TTY", () => {
+		clearEnv();
+		process.env.PLANNOTATOR_REMOTE = "false";
+		process.env.SSH_TTY = "/dev/pts/0";
+		expect(isRemoteSession()).toBe(false);
+	});
+
+	test("PLANNOTATOR_REMOTE=0 overrides SSH_CONNECTION", () => {
+		clearEnv();
+		process.env.PLANNOTATOR_REMOTE = "0";
+		process.env.SSH_CONNECTION = "192.168.1.1 12345 192.168.1.2 22";
+		expect(isRemoteSession()).toBe(false);
+	});
+
+	test("true when SSH_TTY is set and env var is unset", () => {
+		clearEnv();
+		process.env.SSH_TTY = "/dev/pts/0";
+		expect(isRemoteSession()).toBe(true);
+	});
+});
+
+describe("pi port selection", () => {
+	test("uses random local port when false overrides SSH", () => {
+		clearEnv();
+		process.env.PLANNOTATOR_REMOTE = "false";
+		process.env.SSH_TTY = "/dev/pts/0";
+		expect(getServerPort()).toEqual({ port: 0, portSource: "random" });
+	});
+
+	test("uses default remote port when SSH is detected", () => {
+		clearEnv();
+		process.env.SSH_CONNECTION = "192.168.1.1 12345 192.168.1.2 22";
+		expect(getServerPort()).toEqual({ port: 19432, portSource: "remote-default" });
+	});
+
+	test("PLANNOTATOR_PORT still takes precedence", () => {
+		clearEnv();
+		process.env.PLANNOTATOR_REMOTE = "false";
+		process.env.SSH_TTY = "/dev/pts/0";
+		process.env.PLANNOTATOR_PORT = "9999";
+		expect(getServerPort()).toEqual({ port: 9999, portSource: "env" });
+	});
+});
+
+describe("pi server hostname", () => {
+	test("binds local sessions to loopback", () => {
+		clearEnv();
+		expect(getServerHostname()).toBe("127.0.0.1");
+	});
+
+	test("binds remote sessions to all interfaces", () => {
+		clearEnv();
+		process.env.PLANNOTATOR_REMOTE = "1";
+		expect(getServerHostname()).toBe("0.0.0.0");
+	});
+});
+
+describe("pi browser no-op sentinels", () => {
+	test("recognizes no-op values case- and whitespace-insensitively", () => {
+		for (const value of [
+			"true",
+			"false",
+			"none",
+			":",
+			"0",
+			"1",
+			"TRUE",
+			"  none  ",
+		]) {
+			expect(isNoOpBrowserSentinel(value)).toBe(true);
+		}
+	});
+
+	test("does not flag real browser handlers or explicit command paths", () => {
+		expect(isNoOpBrowserSentinel("/usr/bin/firefox")).toBe(false);
+		expect(isNoOpBrowserSentinel("Google Chrome")).toBe(false);
+		expect(isNoOpBrowserSentinel("open")).toBe(false);
+		expect(isNoOpBrowserSentinel("/usr/bin/true")).toBe(false);
+	});
+
+	test("remote BROWSER=true is treated as no browser handler", async () => {
+		clearEnv();
+		process.env.PLANNOTATOR_REMOTE = "1";
+		process.env.BROWSER = "true";
+
+		expect(await openBrowser("http://127.0.0.1:19432")).toEqual({
+			opened: false,
+			isRemote: true,
+			url: "http://127.0.0.1:19432",
+		});
+	});
+});

package/3p/pi-plannotator/apps/pi-extension/server/network.ts

@@ -0,0 +1,268 @@
+/**
+ * Network utilities — remote detection, port binding, browser opening.
+ * isRemoteSession, getServerPort, listenOnPort, openBrowser
+ */
+
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import type { Server } from "node:http";
+import { release } from "node:os";
+import { delimiter, join } from "node:path";
+import { loadConfig, resolveUseGlimpse } from "../generated/config.js";
+
+const DEFAULT_REMOTE_PORT = 19432;
+const LOOPBACK_HOST = "127.0.0.1";
+const NOOP_BROWSER_VALUES = new Set(["true", "false", "none", ":", "0", "1"]);
+
+export function isNoOpBrowserSentinel(value: string | undefined): boolean {
+	if (!value) return false;
+	return NOOP_BROWSER_VALUES.has(value.trim().toLowerCase());
+}
+
+/**
+ * Check if running in a remote session (SSH, devcontainer, etc.)
+ * Honors PLANNOTATOR_REMOTE as a tri-state override, or detects SSH_TTY/SSH_CONNECTION.
+ */
+function getRemoteOverride(): boolean | null {
+	const remote = process.env.PLANNOTATOR_REMOTE;
+	if (remote === undefined) {
+		return null;
+	}
+
+	if (remote === "1" || remote?.toLowerCase() === "true") {
+		return true;
+	}
+
+	if (remote === "0" || remote?.toLowerCase() === "false") {
+		return false;
+	}
+
+	return null;
+}
+
+export function isRemoteSession(): boolean {
+	const remoteOverride = getRemoteOverride();
+	if (remoteOverride !== null) {
+		return remoteOverride;
+	}
+	// Legacy SSH detection
+	if (process.env.SSH_TTY || process.env.SSH_CONNECTION) {
+		return true;
+	}
+	return false;
+}
+
+/**
+ * Get the server port to use.
+ * - PLANNOTATOR_PORT env var takes precedence
+ * - Remote sessions default to 19432 (for port forwarding)
+ * - Local sessions use random port
+ * Returns { port, portSource } so caller can notify user if needed.
+ */
+export function getServerPort(): {
+	port: number;
+	portSource: "env" | "remote-default" | "random";
+} {
+	const envPort = process.env.PLANNOTATOR_PORT;
+	if (envPort) {
+		const parsed = parseInt(envPort, 10);
+		if (!Number.isNaN(parsed) && parsed >= 0 && parsed < 65536) {
+			return { port: parsed, portSource: "env" };
+		}
+		// Invalid port - fall back silently, caller can check env var themselves
+	}
+	if (isRemoteSession()) {
+		return { port: DEFAULT_REMOTE_PORT, portSource: "remote-default" };
+	}
+	return { port: 0, portSource: "random" };
+}
+
+export function getServerHostname(): string {
+	return isRemoteSession() ? "0.0.0.0" : LOOPBACK_HOST;
+}
+
+const MAX_RETRIES = 5;
+const RETRY_DELAY_MS = 500;
+
+export async function listenOnPort(
+	server: Server,
+): Promise<{ port: number; portSource: "env" | "remote-default" | "random" }> {
+	const result = getServerPort();
+
+	for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+		try {
+			await new Promise<void>((resolve, reject) => {
+				server.once("error", reject);
+				server.listen(
+					result.port,
+					getServerHostname(),
+					() => {
+						server.removeListener("error", reject);
+						resolve();
+					},
+				);
+			});
+			const addr = server.address() as { port: number };
+			return { port: addr.port, portSource: result.portSource };
+		} catch (err: unknown) {
+			const isAddressInUse =
+				err instanceof Error && err.message.includes("EADDRINUSE");
+			if (isAddressInUse && attempt < MAX_RETRIES) {
+				await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+				continue;
+			}
+			if (isAddressInUse) {
+				const hint = isRemoteSession()
+					? " (set PLANNOTATOR_PORT to use a different port)"
+					: "";
+				throw new Error(
+					`Port ${result.port} in use after ${MAX_RETRIES} retries${hint}`,
+				);
+			}
+			throw err;
+		}
+	}
+
+	// Unreachable, but satisfies TypeScript
+	throw new Error("Failed to bind port");
+}
+
+/**
+ * Open URL in system browser (Node-compatible, no Bun $ dependency).
+ * Honors PLANNOTATOR_BROWSER and BROWSER env vars.
+ * Returns { opened: true } if browser was opened, { opened: false, isRemote: true, url } if remote session.
+ */
+function findCommandOnPath(command: string): string | null {
+	const extensions = process.platform === "win32" ? [".cmd", ".exe", ".bat", ""] : [""];
+	for (const dir of (process.env.PATH || "").split(delimiter)) {
+		if (!dir) continue;
+		for (const ext of extensions) {
+			const candidate = join(dir, `${command}${ext}`);
+			if (existsSync(candidate)) return candidate;
+		}
+	}
+	return null;
+}
+
+function buildGlimpseHtml(url: string): string {
+	const encodedUrl = JSON.stringify(url);
+	return `<!doctype html>
+<html>
+	<head>
+		<meta charset="utf-8" />
+		<title>Plannotator</title>
+		<style>
+			html, body { width: 100%; height: 100%; margin: 0; }
+			body { overflow: hidden; background: #0f1115; }
+		</style>
+	</head>
+	<body>
+		<script>
+			location.replace(${encodedUrl});
+		</script>
+	</body>
+</html>`;
+}
+
+async function openGlimpse(url: string): Promise<boolean> {
+	const glimpseCli = findCommandOnPath("glimpseui");
+	if (!glimpseCli) return false;
+
+	const args = [
+		"--width",
+		String(Number(process.env.PLANNOTATOR_GLIMPSE_WIDTH || 1280)),
+		"--height",
+		String(Number(process.env.PLANNOTATOR_GLIMPSE_HEIGHT || 900)),
+		"--title",
+		"Plannotator",
+		"--open-links",
+	];
+	const html = buildGlimpseHtml(url);
+
+	return await new Promise<boolean>((resolve) => {
+		let settled = false;
+		let successTimer: ReturnType<typeof setTimeout> | undefined;
+		const finish = (opened: boolean) => {
+			if (settled) return;
+			settled = true;
+			if (successTimer) clearTimeout(successTimer);
+			resolve(opened);
+		};
+
+		const child = spawn(glimpseCli, args, {
+			detached: true,
+			stdio: ["pipe", "ignore", "ignore"],
+		});
+		successTimer = setTimeout(() => {
+			child.unref();
+			finish(true);
+		}, 750);
+
+		child.once("error", () => finish(false));
+		child.once("exit", () => finish(false));
+		child.stdin.once("error", () => finish(false));
+		child.stdin.end(html);
+	});
+}
+
+export async function openBrowser(url: string): Promise<{
+	opened: boolean;
+	isRemote?: boolean;
+	url?: string;
+}> {
+	const rawPlannotatorBrowser = process.env.PLANNOTATOR_BROWSER;
+	const rawBrowser = process.env.BROWSER;
+	const plannotatorBrowser = isNoOpBrowserSentinel(rawPlannotatorBrowser)
+		? undefined
+		: rawPlannotatorBrowser;
+	const envBrowser = isNoOpBrowserSentinel(rawBrowser) ? undefined : rawBrowser;
+	const browser = plannotatorBrowser || envBrowser;
+	if (isRemoteSession() && !browser) {
+		return { opened: false, isRemote: true, url };
+	}
+
+	if (!browser && resolveUseGlimpse(loadConfig())) {
+		const openedViaGlimpse = await openGlimpse(url);
+		if (openedViaGlimpse) {
+			return { opened: true };
+		}
+	}
+
+	try {
+		const platform = process.platform;
+		const wsl =
+			platform === "linux" && release().toLowerCase().includes("microsoft");
+
+		let cmd: string;
+		let args: string[];
+
+		if (browser) {
+			if (plannotatorBrowser && platform === "darwin") {
+				cmd = "open";
+				args = ["-a", plannotatorBrowser, url];
+			} else if ((platform === "win32" || wsl) && plannotatorBrowser) {
+				cmd = "cmd.exe";
+				args = ["/c", "start", "", plannotatorBrowser, url];
+			} else {
+				cmd = browser;
+				args = [url];
+			}
+		} else if (platform === "win32" || wsl) {
+			cmd = "cmd.exe";
+			args = ["/c", "start", "", url];
+		} else if (platform === "darwin") {
+			cmd = "open";
+			args = [url];
+		} else {
+			cmd = "xdg-open";
+			args = [url];
+		}
+
+		const child = spawn(cmd, args, { detached: true, stdio: "ignore" });
+		child.once("error", () => {});
+		child.unref();
+		return { opened: true };
+	} catch {
+		return { opened: false };
+	}
+}