@huseynsnmz/pi-suite 0.0.0-stage → 0.2.0

package/packages/board/src/core/launch-options.mjs

@@ -0,0 +1,418 @@
+/**
+ * Launch dialog helpers: resolve cwd suggestions, scoped model choices, and thinking options.
+ */
+import { existsSync, readdirSync, statSync } from "node:fs";
+import path from "node:path";
+import { SettingsManager } from "@earendil-works/pi-coding-agent";
+
+/** @typedef {"off"|"minimal"|"low"|"medium"|"high"|"xhigh"|"max"} ThinkingLevel */
+
+/**
+ * @typedef {Object} LaunchModelLike
+ * @property {string} provider
+ * @property {string} id
+ * @property {string=} name
+ * @property {boolean=} reasoning
+ * @property {Partial<Record<ThinkingLevel, string|null>>=} thinkingLevelMap
+ */
+
+/**
+ * @typedef {Object} LaunchModelChoice
+ * @property {LaunchModelLike} model
+ * @property {ThinkingLevel=} thinkingLevel
+ */
+
+/**
+ * @typedef {Object} LaunchContext
+ * @property {LaunchModelChoice[]} choices
+ * @property {LaunchModelLike|null} selectedModel
+ * @property {ThinkingLevel} thinking
+ * @property {ThinkingLevel[]} thinkingOptions
+ * @property {"scoped"|"all"} scopeSource
+ */
+
+export const THINKING_LEVELS = /** @type {const} */ (["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+
+/** @param {unknown} value @returns {value is ThinkingLevel} */
+export function isThinkingLevel(value) {
+	return typeof value === "string" && THINKING_LEVELS.includes(/** @type {ThinkingLevel} */ (value));
+}
+
+/** @param {LaunchModelLike|null|undefined} model */
+export function canonicalModelRef(model) {
+	return model ? `${model.provider}/${model.id}` : "";
+}
+
+/**
+ * Whether a stored model reference resolves to a currently-available model.
+ * Same rule as the dashboard launch picker: case-insensitive exact "provider/id".
+ * A null/empty reference is trivially available (no constraint), and an
+ * empty/unavailable model list must not block launches (the caller cannot judge
+ * availability, so the conservative answer is allow — issue #90).
+ * @param {string|null|undefined} modelRef
+ * @param {LaunchModelLike[]|undefined|null} availableModels
+ * @returns {boolean}
+ */
+export function modelRefAvailable(modelRef, availableModels) {
+	const ref = String(modelRef ?? "").trim().toLowerCase();
+	if (!ref) return true;
+	if (!availableModels || availableModels.length === 0) return true;
+	return availableModels.some((model) => `${model.provider}/${model.id}`.toLowerCase() === ref);
+}
+
+/** @param {LaunchModelLike|null|undefined} a @param {LaunchModelLike|null|undefined} b */
+export function sameModel(a, b) {
+	return Boolean(a && b && a.provider === b.provider && a.id === b.id);
+}
+
+/** @param {LaunchModelLike|null|undefined} model @returns {ThinkingLevel[]} */
+export function supportedThinkingLevels(model) {
+	if (!model?.reasoning) return ["off"];
+	const map = model.thinkingLevelMap ?? {};
+	const levels = THINKING_LEVELS.filter((level) => map[level] !== null);
+	return levels.length ? levels : [...THINKING_LEVELS];
+}
+
+/**
+ * @param {LaunchModelLike|null|undefined} model
+ * @param {ThinkingLevel|undefined|null} requested
+ * @param {ThinkingLevel=} fallback
+ * @returns {ThinkingLevel}
+ */
+export function clampThinkingLevel(model, requested, fallback = "off") {
+	const supported = supportedThinkingLevels(model);
+	if (requested && supported.includes(requested)) return requested;
+	if (supported.includes(fallback)) return fallback;
+	return supported[0] ?? "off";
+}
+
+/**
+ * Resolve the model choices for a cwd using pi's scoped-model settings semantics.
+ * Falls back to all available models when no scoped models are configured or none resolve.
+ *
+ * @param {string} cwd
+ * @param {LaunchModelLike[]} availableModels
+ * @param {LaunchModelLike|null|undefined} preferredModel
+ * @param {ThinkingLevel|undefined|null} preferredThinking
+ * @returns {LaunchContext}
+ */
+export function resolveLaunchContext(cwd, availableModels, preferredModel, preferredThinking) {
+	const settings = SettingsManager.create(cwd);
+	const patterns = settings.getEnabledModels();
+	const scoped = resolveScopedModels(patterns, availableModels);
+	const fallbackChoices = sortModels(availableModels, preferredModel).map((model) => ({ model }));
+	const choices = scoped.length ? scoped : fallbackChoices;
+	const scopeSource = scoped.length ? "scoped" : "all";
+	const defaultThinking = normalizeThinking(settings.getDefaultThinkingLevel()) ?? preferredThinking ?? "off";
+	const selectedChoice = preferredModel ? choices.find((choice) => sameModel(choice.model, preferredModel)) : undefined;
+	const selectedModel = selectedChoice?.model ?? choices[0]?.model ?? preferredModel ?? null;
+	const thinkingBase = selectedChoice?.thinkingLevel ?? preferredThinking ?? defaultThinking;
+	const thinking = clampThinkingLevel(selectedModel, thinkingBase, defaultThinking);
+	return {
+		choices,
+		selectedModel,
+		thinking,
+		thinkingOptions: supportedThinkingLevels(selectedModel),
+		scopeSource,
+	};
+}
+
+/**
+ * @param {string|undefined} value
+ * @returns {ThinkingLevel|undefined}
+ */
+function normalizeThinking(value) {
+	return isThinkingLevel(value) ? value : undefined;
+}
+
+/** @param {LaunchModelLike[]} models @param {LaunchModelLike|null|undefined} current */
+function sortModels(models, current) {
+	return [...models].sort((a, b) => {
+		const aCurrent = sameModel(a, current);
+		const bCurrent = sameModel(b, current);
+		if (aCurrent && !bCurrent) return -1;
+		if (!aCurrent && bCurrent) return 1;
+		const providerCmp = a.provider.localeCompare(b.provider);
+		return providerCmp !== 0 ? providerCmp : a.id.localeCompare(b.id);
+	});
+}
+
+/** @param {string|undefined} patterns @param {LaunchModelLike[]} _available */
+function resolveScopedModels(patterns, _available) {
+	const available = Array.isArray(_available) ? _available : [];
+	if (!patterns?.length) return [];
+	/** @type {LaunchModelChoice[]} */
+	const scoped = [];
+	for (const rawPattern of patterns) {
+		const pattern = String(rawPattern || "").trim();
+		if (!pattern) continue;
+		if (hasGlob(pattern)) {
+			const colonIdx = pattern.lastIndexOf(":");
+			let globPattern = pattern;
+			/** @type {ThinkingLevel|undefined} */
+			let thinkingLevel;
+			if (colonIdx !== -1) {
+				const suffix = pattern.slice(colonIdx + 1);
+				if (isThinkingLevel(suffix)) {
+					thinkingLevel = suffix;
+					globPattern = pattern.slice(0, colonIdx);
+				}
+			}
+			const matches = available.filter((model) => matchGlob(`${model.provider}/${model.id}`, globPattern) || matchGlob(model.id, globPattern));
+			for (const model of matches) pushUnique(scoped, { model, thinkingLevel });
+			continue;
+		}
+		const parsed = parseModelPattern(pattern, available);
+		if (parsed.model) pushUnique(scoped, { model: parsed.model, thinkingLevel: parsed.thinkingLevel });
+	}
+	return scoped;
+}
+
+/** @param {LaunchModelChoice[]} choices @param {LaunchModelChoice} choice */
+function pushUnique(choices, choice) {
+	if (!choices.find((entry) => sameModel(entry.model, choice.model))) choices.push(choice);
+}
+
+/** @param {string} pattern */
+function hasGlob(pattern) {
+	return /[*?[]/.test(pattern);
+}
+
+/** @param {string} text @param {string} glob */
+function matchGlob(text, glob) {
+	try {
+		return new RegExp(`^${globToRegExp(glob)}$`, "i").test(text);
+	} catch {
+		return false;
+	}
+}
+
+/** @param {string} glob */
+function globToRegExp(glob) {
+	let out = "";
+	for (let i = 0; i < glob.length; i++) {
+		const ch = glob[i];
+		if (ch === "*") {
+			out += ".*";
+			continue;
+		}
+		if (ch === "?") {
+			out += ".";
+			continue;
+		}
+		if (ch === "[") {
+			const end = glob.indexOf("]", i + 1);
+			if (end > i) {
+				out += glob.slice(i, end + 1);
+				i = end;
+				continue;
+			}
+		}
+		out += escapeRegExp(ch);
+	}
+	return out;
+}
+
+/** @param {string} text */
+function escapeRegExp(text) {
+	return text.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
+}
+
+/** @param {string} id */
+function isAlias(id) {
+	if (id.endsWith("-latest")) return true;
+	return !/-\d{8}$/.test(id);
+}
+
+/** @param {string} modelReference @param {LaunchModelLike[]} availableModels */
+function findExactModelReferenceMatch(modelReference, availableModels) {
+	const trimmed = modelReference.trim();
+	if (!trimmed) return undefined;
+	const lower = trimmed.toLowerCase();
+	const canonicalMatches = availableModels.filter((model) => `${model.provider}/${model.id}`.toLowerCase() === lower);
+	if (canonicalMatches.length === 1) return canonicalMatches[0];
+	if (canonicalMatches.length > 1) return undefined;
+	const slashIndex = trimmed.indexOf("/");
+	if (slashIndex !== -1) {
+		const provider = trimmed.slice(0, slashIndex).trim();
+		const modelId = trimmed.slice(slashIndex + 1).trim();
+		if (provider && modelId) {
+			const providerMatches = availableModels.filter((model) => model.provider.toLowerCase() === provider.toLowerCase() && model.id.toLowerCase() === modelId.toLowerCase());
+			if (providerMatches.length === 1) return providerMatches[0];
+			if (providerMatches.length > 1) return undefined;
+		}
+	}
+	const idMatches = availableModels.filter((model) => model.id.toLowerCase() === lower);
+	return idMatches.length === 1 ? idMatches[0] : undefined;
+}
+
+/** @param {string} modelPattern @param {LaunchModelLike[]} availableModels */
+function tryMatchModel(modelPattern, availableModels) {
+	const exact = findExactModelReferenceMatch(modelPattern, availableModels);
+	if (exact) return exact;
+	const lower = modelPattern.toLowerCase();
+	const matches = availableModels.filter((model) => model.id.toLowerCase().includes(lower) || model.name?.toLowerCase().includes(lower));
+	if (!matches.length) return undefined;
+	const aliases = matches.filter((model) => isAlias(model.id));
+	const dated = matches.filter((model) => !isAlias(model.id));
+	if (aliases.length) return aliases.sort((a, b) => b.id.localeCompare(a.id))[0];
+	return dated.sort((a, b) => b.id.localeCompare(a.id))[0];
+}
+
+/** @param {string} pattern @param {LaunchModelLike[]} availableModels */
+function parseModelPattern(pattern, availableModels) {
+	const exact = tryMatchModel(pattern, availableModels);
+	if (exact) return { model: exact, thinkingLevel: undefined };
+	const lastColon = pattern.lastIndexOf(":");
+	if (lastColon === -1) return { model: undefined, thinkingLevel: undefined };
+	const prefix = pattern.slice(0, lastColon);
+	const suffix = pattern.slice(lastColon + 1);
+	if (isThinkingLevel(suffix)) {
+		const result = parseModelPattern(prefix, availableModels);
+		if (result.model) return { model: result.model, thinkingLevel: suffix };
+		return result;
+	}
+	return parseModelPattern(prefix, availableModels);
+}
+
+/** @param {string} input */
+function expandHome(input) {
+	const home = process.env.HOME || process.env.USERPROFILE || "";
+	if (!home) return input;
+	if (input === "~") return home;
+	if (input.startsWith(`~${path.sep}`)) return path.join(home, input.slice(2));
+	return input;
+}
+
+/** @param {string} value @param {string} baseCwd */
+export function resolveDirectoryValue(value, baseCwd) {
+	const raw = String(value || "").trim();
+	if (!raw) return existsDir(baseCwd) ? path.resolve(baseCwd) : null;
+	const expanded = expandHome(raw);
+	const resolved = path.isAbsolute(expanded) ? path.resolve(expanded) : path.resolve(baseCwd, expanded);
+	return existsDir(resolved) ? resolved : null;
+}
+
+/**
+ * @param {string} query
+ * @param {string} baseCwd
+ * @param {number=} limit
+ * @returns {string[]}
+ */
+export function listDirectorySuggestions(query, baseCwd, limit = 8) {
+	const raw = String(query || "").trim();
+	const expanded = expandHome(raw);
+	const resolved = raw ? (path.isAbsolute(expanded) ? path.resolve(expanded) : path.resolve(baseCwd, expanded)) : path.resolve(baseCwd);
+	let searchDir = resolved;
+	let fragment = "";
+	if (!existsDir(resolved) || !raw.endsWith(path.sep)) {
+		searchDir = existsDir(resolved) ? resolved : path.dirname(resolved);
+		fragment = existsDir(resolved) ? "" : path.basename(resolved);
+	}
+	/** @type {string[]} */
+	const out = [];
+	if (existsDir(resolved)) out.push(path.resolve(resolved));
+	if (existsDir(searchDir)) {
+		const lowerFragment = fragment.toLowerCase();
+		const children = readdirSync(searchDir, { withFileTypes: true })
+			.filter((entry) => entry.isDirectory())
+			.map((entry) => entry.name)
+			.filter((name) => !lowerFragment || name.toLowerCase().includes(lowerFragment))
+			.sort((a, b) => a.localeCompare(b));
+		for (const name of children) out.push(path.join(searchDir, name));
+	}
+	return Array.from(new Set(out)).slice(0, Math.max(1, limit));
+}
+
+/** @param {string} dir */
+function existsDir(dir) {
+	try {
+		return existsSync(dir) && statSync(dir).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Keep only candidates whose path is an existing directory.
+ * @param {CwdCandidate[]} candidates
+ * @returns {CwdCandidate[]}
+ */
+export function existingCwdCandidates(candidates) {
+	return candidates.filter((entry) => existsDir(entry.path));
+}
+
+/**
+ * @typedef {Object} CwdCandidate
+ * @property {string} path
+ * @property {number} count
+ */
+
+/**
+ * Filter ranked cwd candidates by case-insensitive substring match anywhere
+ * in the path (empty query keeps the full ranked list).
+ * @param {CwdCandidate[]} candidates
+ * @param {string} query
+ * @returns {CwdCandidate[]}
+ */
+export function filterCwdCandidates(candidates, query) {
+	const q = String(query ?? "").trim().toLowerCase();
+	if (!q) return candidates;
+	return candidates.filter((entry) => entry.path.toLowerCase().includes(q));
+}
+
+/**
+ * Whether two path strings resolve to the same directory. Blank inputs never
+ * match (path.resolve("") would silently equal process.cwd()).
+ * @param {string} a
+ * @param {string} b
+ * @returns {boolean}
+ */
+export function sameResolvedDir(a, b) {
+	const na = String(a ?? "").trim();
+	const nb = String(b ?? "").trim();
+	if (!na || !nb) return false;
+	return path.resolve(expandHome(na)) === path.resolve(expandHome(nb));
+}
+
+/**
+ * Browse-mode Tab completion for the cwd picker. Completes to the highlighted
+ * suggestion with a trailing separator (so the next recompute lists that
+ * directory's children); when the highlight already equals the current query
+ * (no progress), advances cyclically so repeated Tab drills downward. A lone
+ * self suggestion stays put, so drilling stops naturally at leaf directories.
+ * @param {string} query
+ * @param {string[]} suggestions
+ * @param {number} index
+ * @returns {{query: string, completed: string, usedIndex: number} | null}
+ */
+export function browseTabCompletion(query, suggestions, index) {
+	if (!suggestions || suggestions.length === 0) return null;
+	const len = suggestions.length;
+	let usedIndex = ((index % len) + len) % len;
+	let completed = suggestions[usedIndex];
+	if (len > 1 && sameResolvedDir(completed, query)) {
+		usedIndex = (usedIndex + 1) % len;
+		completed = suggestions[usedIndex];
+	}
+	return { query: completed + path.sep, completed, usedIndex };
+}
+
+/**
+ * Decide cwd picker mode + suggestions for a query: favorites when the query
+ * is empty or matches ranked candidates, filesystem browse otherwise.
+ * @param {string} query
+ * @param {CwdCandidate[]} ranked
+ * @param {string} baseCwd
+ * @returns {{mode: "favorites"|"browse", suggestions: string[]}}
+ */
+export function nextCwdPickerState(query, ranked, baseCwd) {
+	if (!ranked || ranked.length === 0) {
+		return { mode: "browse", suggestions: listDirectorySuggestions(query, baseCwd) };
+	}
+	const matches = filterCwdCandidates(ranked, query);
+	if (String(query ?? "").trim() === "" || matches.length > 0) {
+		return { mode: "favorites", suggestions: matches.map((entry) => entry.path) };
+	}
+	return { mode: "browse", suggestions: listDirectorySuggestions(query, baseCwd) };
+}

package/packages/board/src/core/launch.mjs

@@ -0,0 +1,157 @@
+/**
+ * Launch a detached job-runner process for one run.
+ *
+ * The runner is a plain `.mjs` spawned with `node`, fully detached (its own process
+ * group, stdio ignored) so it survives the parent Pi reloading or exiting. The parent
+ * records the runner pid in `pid.json` and watches the store files the runner writes.
+ */
+import { spawn } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { atomicWriteJson } from "./atomic.mjs";
+import { resolveNode } from "./invocation.mjs";
+import * as P from "./paths.mjs";
+import { writePid } from "./store.mjs";
+
+/** @typedef {import("./types.mjs").RunConfig} RunConfig */
+/** @typedef {import("./types.mjs").HostConfig} HostConfig */
+/** @typedef {import("./types.mjs").TitleConfig} TitleConfig */
+/** @typedef {import("./types.mjs").AutoStateConfig} AutoStateConfig */
+
+/**
+ * Spawn a fully detached runner child with async spawn failures made harmless.
+ *
+ * A spawn that fails to start (e.g. a transient ENOENT on the node binary,
+ * issue #86) reports asynchronously via the 'error' event; without a listener
+ * the EventEmitter rethrows it as an uncaughtException and takes down the
+ * whole host Pi process. Callers already handle the failure gracefully via
+ * the pid == null branch (state "failed").
+ * @param {string} command
+ * @param {string[]} args
+ * @param {string} cwd
+ * @returns {import("node:child_process").ChildProcess}
+ */
+function spawnDetached(command, args, cwd) {
+	const child = spawn(command, args, {
+		cwd,
+		detached: true,
+		stdio: "ignore",
+		env: process.env,
+		// Windows: detached children get their own console window unless
+		// suppressed (CREATE_NO_WINDOW; no-op on POSIX) — issue #49.
+		windowsHide: true,
+	});
+	child.on("error", () => {});
+	child.unref();
+	return child;
+}
+
+/**
+ * @param {string} root
+ * @param {RunConfig} config
+ * @param {{ runnerScript: string, node?: string }} opts
+ * @returns {{ pid: number|null, configPath: string }}
+ */
+export function launchRun(root, config, opts) {
+	const runDir = P.runDir(root, config.viewId, config.runId);
+	const configPath = `${runDir}/config.json`;
+	atomicWriteJson(configPath, config);
+
+	const node = opts.node ?? resolveNode();
+	const child = spawnDetached(node, [opts.runnerScript, configPath], config.cwd);
+
+	const pid = child.pid ?? null;
+	// Record the *runner/monitor* pid for liveness polling (the worker pid is tracked
+	// inside status.json by the runner itself).
+	writePid(root, config.viewId, config.runId, pid);
+	return { pid, configPath };
+}
+
+/**
+ * Launch a detached PTY host for a view. The host owns a long-lived child Pi and
+ * exposes a JSONL control socket for attach/input/resize/terminate.
+ * @param {string} root
+ * @param {HostConfig} config
+ * @param {{ runnerScript: string, node?: string }} opts
+ * @returns {{ pid: number|null, configPath: string }}
+ */
+export function launchHost(root, config, opts) {
+	// Instance-specific config path wins when present (issue #70: concurrent
+	// launches must not share the fixed host-config.json); legacy callers keep it.
+	const configPath = config.configPath ?? P.hostConfigPath(root, config.viewId);
+	atomicWriteJson(configPath, config);
+
+	const node = opts.node ?? resolveNode();
+	const child = spawnDetached(node, [opts.runnerScript, configPath], config.cwd);
+
+	return { pid: child.pid ?? null, configPath };
+}
+
+/**
+ * Launch a detached title runner for a view. Best-effort only: it may update `meta.json`
+ * later with a short GPT-generated name derived from the initial task prompt.
+ * @param {string} root
+ * @param {TitleConfig} config
+ * @param {{ runnerScript: string, node?: string }} opts
+ * @returns {{ pid: number|null, configPath: string }}
+ */
+export function launchTitle(root, config, opts) {
+	const configPath = P.titleConfigPath(root, config.viewId);
+	atomicWriteJson(configPath, config);
+
+	const node = opts.node ?? resolveNode();
+	const child = spawnDetached(node, [opts.runnerScript, configPath], config.cwd);
+
+	return { pid: child.pid ?? null, configPath };
+}
+
+/**
+ * Launch a detached auto-state classifier for a view. Best-effort: it may update
+ * state.json later with a model-refined terminal bucket.
+ * @param {string} root
+ * @param {AutoStateConfig} config
+ * @param {{ runnerScript: string, node?: string }} opts
+ * @returns {{ pid: number|null, configPath: string }}
+ */
+export function launchAutoState(root, config, opts) {
+	const configPath = P.autoStateConfigPath(root, config.viewId);
+	atomicWriteJson(configPath, config);
+
+	const node = opts.node ?? resolveNode();
+	const child = spawnDetached(node, [opts.runnerScript, configPath], config.cwd);
+
+	return { pid: child.pid ?? null, configPath };
+}
+
+/**
+ * Compute the detached coordinator spawn plan (issue #241): an absolute root
+ * argv and a cwd OUTSIDE the root (the root's parent; at a drive/filesystem
+ * root the parent is the root itself). The coordinator derives all paths from
+ * the root argument and never uses cwd, so keeping cwd off the root releases
+ * the win32 directory handle that made throwaway roots undeletable.
+ * @param {string} root
+ * @returns {{ root: string, cwd: string }}
+ */
+export function coordinatorSpawnPlan(root) {
+	const absoluteRoot = resolve(root);
+	return { root: absoluteRoot, cwd: dirname(absoluteRoot) };
+}
+
+/**
+ * Launch the detached view-state coordinator for a board root (issue #91, spec
+ * D3). No config file: the coordinator takes the root as its only argument.
+ * Idempotent by lease — a second instance loses the coordinator lease and
+ * exits silently, so callers may spawn freely on probe failure.
+ * The child's cwd is the root's PARENT (issue #241): the coordinator derives
+ * paths from argv and cwd must not pin the root on win32. At a drive/filesystem
+ * root (win32 `C:\`, POSIX `/`) the parent is the root itself — see
+ * `coordinatorSpawnPlan`.
+ * @param {string} root
+ * @param {{ runnerScript: string, node?: string }} opts
+ * @returns {{ pid: number|null }}
+ */
+export function launchCoordinator(root, opts) {
+	const node = opts.node ?? resolveNode();
+	const plan = coordinatorSpawnPlan(root);
+	const child = spawnDetached(node, [opts.runnerScript, plan.root], plan.cwd);
+	return { pid: child.pid ?? null };
+}

package/packages/board/src/core/load-config.mjs

@@ -0,0 +1,4 @@
+/** Imported first, because some modules read their settings as they load. */
+import { applyConfig } from "./config.mjs";
+
+applyConfig();