getfilepress 0.1.2 → 0.1.4

package/packages/import/src/cli.ts

@@ -24,6 +24,7 @@ import {
 	ollamaSetupHint,
 	summarizeHtmlForBrief
 } from './ollama.ts';
+import { pickDiscoveredServer, scanOllamaNetwork } from './ollanet-scan.ts';
 import { harvestImagesFromPage, planImages, type ImagePlan } from './images.ts';
 import { formatAttributionMarkdown, planStockCovers } from './stock.ts';
 import { DEFAULT_BRIEF, themeCssFromBrief, tokensFromSourceCss } from './theme.ts';
@@ -57,22 +58,30 @@ function parseArgs(argv: string[]) {
 		author?: string;
 		url?: string;
 		ollama: string;
+		ollamaExplicit: boolean;
 		model: string;
+		modelExplicit: boolean;
 		noLlm: boolean;
 		dryRun: boolean;
 		force: boolean;
 		yes: boolean;
 		fetchImages: boolean;
+		scan: boolean;
+		lan: boolean;
 	} = {
 		_: [],
 		inspire: [],
 		ollama: process.env.OLLAMA_HOST?.trim() || 'http://127.0.0.1:11434',
+		ollamaExplicit: Boolean(process.env.OLLAMA_HOST?.trim()),
 		model: process.env.FILEPRESS_OLLAMA_MODEL?.trim() || 'gemma4:12b',
+		modelExplicit: Boolean(process.env.FILEPRESS_OLLAMA_MODEL?.trim()),
 		noLlm: false,
 		dryRun: false,
 		force: false,
 		yes: false,
-		fetchImages: false
+		fetchImages: false,
+		scan: false,
+		lan: false
 	};
 
 	for (let i = 0; i < argv.length; i++) {
@@ -89,13 +98,24 @@ function parseArgs(argv: string[]) {
 		else if (a === '--title') out.title = next();
 		else if (a === '--author') out.author = next();
 		else if (a === '--url') out.url = next();
-		else if (a === '--ollama') out.ollama = next();
-		else if (a === '--model') out.model = next();
+		else if (a === '--ollama') {
+			out.ollama = next();
+			out.ollamaExplicit = true;
+		}
+		else if (a === '--model') {
+			out.model = next();
+			out.modelExplicit = true;
+		}
 		else if (a === '--no-llm') out.noLlm = true;
 		else if (a === '--dry-run') out.dryRun = true;
 		else if (a === '--force') out.force = true;
 		else if (a === '--yes' || a === '-y') out.yes = true;
 		else if (a === '--fetch-images') out.fetchImages = true;
+		else if (a === '--scan') out.scan = true;
+		else if (a === '--lan') {
+			out.lan = true;
+			out.scan = true;
+		}
 		else if (a === '--help' || a === '-h') out._.push('help');
 		else out._.push(a);
 	}
@@ -108,6 +128,55 @@ async function prompt(rl: ReturnType<typeof createInterface>, q: string, def?: s
 	return ans || def || '';
 }
 
+async function maybeScanOllama(
+	args: ReturnType<typeof parseArgs>,
+	rl: ReturnType<typeof createInterface> | null
+): Promise<{ host: string; model: string }> {
+	let host = args.ollama;
+	let model = args.model;
+	if (args.noLlm || !args.scan) return { host, model };
+
+	console.log(
+		args.lan
+			? 'import: scanning for Ollama (localhost, config, Tailscale, LAN) …'
+			: 'import: scanning for Ollama (localhost, config, Tailscale) …'
+	);
+	const result = await scanOllamaNetwork({ lan: args.lan });
+	if (result.error) {
+		console.warn(`import: ollanet scan failed: ${result.error}`);
+		return { host, model };
+	}
+	if (!result.servers.length) {
+		console.warn(
+			'import: no Ollama servers found. Add ~/.ollanet/config.json hosts, set OLLANET_HOSTS, or pass --lan.'
+		);
+		return { host, model };
+	}
+
+	for (const [i, s] of result.servers.entries()) {
+		const models = s.models.length ? s.models.join(', ') : '(no models)';
+		console.log(`  ${i + 1}. ${s.label}  ${s.endpoint}  ${models}`);
+	}
+
+	let picked = pickDiscoveredServer(result.servers, args.ollamaExplicit ? host : undefined);
+	if (rl && result.servers.length > 1) {
+		const def = String((picked ? result.servers.indexOf(picked) : 0) + 1);
+		const ans = await prompt(rl, 'Ollama server number', def);
+		const idx = Number(ans) - 1;
+		if (Number.isInteger(idx) && result.servers[idx]) picked = result.servers[idx];
+	}
+	if (picked) {
+		host = picked.endpoint;
+		if (!args.modelExplicit) {
+			const preferred = process.env.FILEPRESS_OLLAMA_MODEL?.trim();
+			if (preferred && picked.models.includes(preferred)) model = preferred;
+			else if (picked.models[0]) model = picked.models[0];
+		}
+		console.log(`import: using ${host} · ${model}`);
+	}
+	return { host, model };
+}
+
 async function main() {
 	const args = parseArgs(process.argv.slice(2));
 	if (args._.includes('help')) {
@@ -121,6 +190,8 @@ Options:
   --title / --author / --url
   --ollama <host>      Default http://127.0.0.1:11434
   --model <name>       Default gemma4:12b
+  --scan               Discover Ollama hosts via ollanet (localhost, config, Tailscale)
+  --lan                Also TCP-scan local LAN (implies --scan)
   --no-llm             Skip Ollama; token theme from source CSS / defaults
   --dry-run            Crawl + report only (no write)
   --force              Overwrite generated content in --out
@@ -232,6 +303,9 @@ Options:
 					};
 
 		if (!opts.noLlm) {
+			const picked = await maybeScanOllama(args, rl);
+			opts.ollamaHost = picked.host;
+			opts.ollamaModel = picked.model;
 			const up = await ollamaAvailable(opts.ollamaHost);
 			if (!up) {
 				console.warn(`import: ${ollamaSetupHint(opts.ollamaHost)}`);

package/packages/import/src/ollama.ts

@@ -2,6 +2,30 @@ import type { DesignBrief, SiteIR } from './ir.ts';
 import type { InspirationSignals } from './inspire.ts';
 import { DEFAULT_BRIEF, parseBriefJson } from './theme.ts';
 
+/** Strip trailing slashes; used to compare Genie picker values with env. */
+export function normalizeOllamaHost(host: string): string {
+	return host.trim().replace(/\/+$/, '');
+}
+
+/** Allow only http(s) Ollama URLs (no credentials). */
+export function assertOllamaEndpoint(raw: string): string {
+	const trimmed = raw.trim();
+	if (!trimmed) throw new Error('Ollama host is empty');
+	let url: URL;
+	try {
+		url = new URL(trimmed);
+	} catch {
+		throw new Error(`Invalid Ollama host "${trimmed}"`);
+	}
+	if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+		throw new Error(`Ollama host must be http(s), got ${url.protocol}`);
+	}
+	if (url.username || url.password) {
+		throw new Error('Ollama host must not include credentials');
+	}
+	return `${url.protocol}//${url.host}`;
+}
+
 export async function ollamaAvailable(host: string): Promise<boolean> {
 	try {
 		const res = await fetch(`${host.replace(/\/+$/, '')}/api/tags`, {
@@ -13,6 +37,23 @@ export async function ollamaAvailable(host: string): Promise<boolean> {
 	}
 }
 
+/** Model names from `GET /api/tags` (empty if unreachable). */
+export async function listOllamaModels(host: string): Promise<string[]> {
+	try {
+		const res = await fetch(`${host.replace(/\/+$/, '')}/api/tags`, {
+			signal: AbortSignal.timeout(4000)
+		});
+		if (!res.ok) return [];
+		const data = (await res.json()) as { models?: Array<{ name?: string }> };
+		return (data.models || [])
+			.map((m) => (m.name || '').trim())
+			.filter(Boolean)
+			.sort((a, b) => a.localeCompare(b));
+	} catch {
+		return [];
+	}
+}
+
 /** Shared copy for import + Genie Mode when Ollama is missing or unused. */
 export function ollamaSetupHint(host: string): string {
 	const h = host.replace(/\/+$/, '') || 'http://127.0.0.1:11434';
@@ -20,7 +61,8 @@ export function ollamaSetupHint(host: string): string {
 		`Ollama not reachable at ${h}.`,
 		`Install from https://ollama.com then pull a model (e.g. ollama pull gemma4:12b).`,
 		`For a GPU-tuned named variant, use Finetuna: https://github.com/Catalyst-Forge-LLC/finetuna`,
-		`Then set FILEPRESS_OLLAMA_MODEL to that name (and OLLAMA_HOST if remote).`
+		`Then set FILEPRESS_OLLAMA_MODEL to that name (and OLLAMA_HOST if remote).`,
+		`To find other Ollama boxes (Tailscale, LAN, OLLANET_HOSTS), use Genie “Scan network” or filepress import --scan (ollanet).`
 	].join(' ');
 }
 

package/packages/import/src/ollanet-scan.ts

@@ -0,0 +1,132 @@
+/**
+ * Optional network discovery for Ollama via ollanet (≥ 0.4.0).
+ * LAN TCP scan is opt-in (slow); default scan is localhost + config + Tailscale.
+ * Node-only — Genie middleware and the import CLI, never the Svelte client.
+ */
+import { scanNetwork } from 'ollanet';
+
+export type DiscoveredOllamaServer = {
+	label: string;
+	endpoint: string;
+	source: string;
+	self: boolean;
+	models: string[];
+};
+
+export type OllamaScanResult = {
+	ok: boolean;
+	network: string;
+	sources: string[];
+	scanned: number;
+	servers: DiscoveredOllamaServer[];
+	error?: string;
+};
+
+/** Loose scan JSON (ollanet ScanPayload plus incomplete fixtures). */
+type ScanPayloadLike = {
+	network?: string;
+	sources?: string[];
+	scanned?: number;
+	servers?: Array<{
+		hostname?: string;
+		dnsName?: string;
+		ip?: string;
+		source?: string;
+		self?: boolean;
+		endpoint?: string;
+		models?: Array<{ name?: string }>;
+	}>;
+};
+
+export function normalizeEndpoint(host: string): string {
+	return host.trim().replace(/\/+$/, '').toLowerCase();
+}
+
+export function serverLabel(server: {
+	dnsName?: string;
+	hostname?: string;
+	ip?: string;
+	self?: boolean;
+	source?: string;
+}): string {
+	const name = (server.dnsName || server.hostname || server.ip || 'ollama').trim();
+	const bits = [name];
+	if (server.self) bits.push('this device');
+	if (server.source && server.source !== 'localhost') bits.push(server.source);
+	return bits.join(' · ');
+}
+
+export function mapScanPayload(payload: ScanPayloadLike): OllamaScanResult {
+	const servers = (payload.servers ?? [])
+		.map((s) => {
+			const endpoint = (s.endpoint || '').trim().replace(/\/+$/, '');
+			if (!endpoint) return null;
+			const models = (s.models ?? [])
+				.map((m) => (m.name || '').trim())
+				.filter(Boolean)
+				.sort((a, b) => a.localeCompare(b));
+			return {
+				label: serverLabel(s),
+				endpoint,
+				source: s.source || 'unknown',
+				self: Boolean(s.self),
+				models
+			} satisfies DiscoveredOllamaServer;
+		})
+		.filter((s): s is DiscoveredOllamaServer => s != null);
+
+	const seen = new Set<string>();
+	const deduped: DiscoveredOllamaServer[] = [];
+	for (const s of servers) {
+		const key = normalizeEndpoint(s.endpoint);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		deduped.push(s);
+	}
+
+	return {
+		ok: true,
+		network: payload.network || 'local',
+		sources: payload.sources ?? [],
+		scanned: payload.scanned ?? deduped.length,
+		servers: deduped
+	};
+}
+
+/** Prefer an explicit endpoint, then this-device with models, then any host with models. */
+export function pickDiscoveredServer(
+	servers: DiscoveredOllamaServer[],
+	preferredEndpoint?: string
+): DiscoveredOllamaServer | undefined {
+	if (preferredEndpoint) {
+		const want = normalizeEndpoint(preferredEndpoint);
+		const hit = servers.find((s) => normalizeEndpoint(s.endpoint) === want);
+		if (hit) return hit;
+	}
+	const withModels = servers.filter((s) => s.models.length > 0);
+	const pool = withModels.length ? withModels : servers;
+	return pool.find((s) => s.self) ?? pool[0];
+}
+
+/**
+ * Discover reachable Ollama servers. Never throws — callers get `error` text.
+ * Pass `lan: true` to TCP-scan local /24s (can take several seconds).
+ */
+export async function scanOllamaNetwork(
+	opts: { lan?: boolean } = {}
+): Promise<OllamaScanResult> {
+	try {
+		const payload = await scanNetwork({ lanScan: Boolean(opts.lan) });
+		return mapScanPayload(payload);
+	} catch (e) {
+		const message = e instanceof Error ? e.message : String(e);
+		return {
+			ok: false,
+			network: '',
+			sources: [],
+			scanned: 0,
+			servers: [],
+			error: message
+		};
+	}
+}

package/packages/import/tsconfig.json

@@ -9,5 +9,5 @@
 		"lib": ["ESNext", "DOM"],
 		"types": ["node"]
 	},
-	"include": ["src/**/*.ts"]
+	"include": ["src/**/*.ts", "src/**/*.d.ts"]
 }

package/scripts/copy-path-mounts.mjs

@@ -0,0 +1,40 @@
+/**
+ * Copy FilePress `paths` mounts into <site>/build after `vite build`.
+ * Reads `.filepress/path-mounts.json` written when vite.config loads the site config.
+ *
+ * Usage: node scripts/copy-path-mounts.mjs <siteRoot>
+ */
+import { cpSync, existsSync, mkdirSync, readFileSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+const siteRoot = resolve(process.argv[2] ?? '');
+const buildDir = join(siteRoot, 'build');
+const cachePath = join(siteRoot, '.filepress', 'path-mounts.json');
+
+if (!existsSync(cachePath)) {
+	process.exit(0);
+}
+if (!existsSync(buildDir)) {
+	console.warn(`filepress: path mounts skipped — build dir missing (${buildDir})`);
+	process.exit(0);
+}
+
+/** @type {{ url: string; dir: string }[]} */
+const mounts = JSON.parse(readFileSync(cachePath, 'utf8'));
+if (!Array.isArray(mounts) || mounts.length === 0) process.exit(0);
+
+for (const mount of mounts) {
+	const src = resolve(siteRoot, mount.dir);
+	const dest = join(buildDir, ...mount.url.replace(/^\//, '').split('/'));
+	if (!existsSync(src)) {
+		console.warn(`filepress: path mount ${mount.url} ← ${mount.dir} (missing; skipped)`);
+		continue;
+	}
+	if (!statSync(src).isDirectory()) {
+		console.error(`filepress: path mount dir "${mount.dir}" is not a directory`);
+		process.exit(1);
+	}
+	mkdirSync(dest, { recursive: true });
+	cpSync(src, dest, { recursive: true });
+	console.log(`filepress: mounted ${mount.url} ← ${mount.dir}`);
+}

package/scripts/create-site.mjs

@@ -198,24 +198,17 @@ pnpm build    # → build/
 Optional: add \`theme.css\` next to \`filepress.config.ts\` to
 override the default Essay theme.
 
-## Deploy (Cloudflare Pages)
+## Deploy
 
-\`link:\` only works on your machine. For CI/hosting, switch to npm or a git pin:
+\`link:\` only works on your machine. For CI/hosting, pin npm or a git tag:
 
 \`\`\`json
 "getfilepress": "^0.1.1"
 \`\`\`
 
-or:
+**Cloudflare Pages (recommended):** build \`pnpm install && pnpm build\`, output \`build\`, Node 20+.
 
-\`\`\`json
-"getfilepress": "github:Catalyst-Forge-LLC/filepress#v0.1.1"
-\`\`\`
-
-| Setting | Value |
-| --- | --- |
-| Build command | \`pnpm install && pnpm build\` |
-| Output directory | \`build\` |
+Any static host: publish the \`build/\` folder. Details: https://getfilepress.com/deploy
 `
 	);
 

package/scripts/filepress.mjs

@@ -100,7 +100,7 @@ function findPackageBin(pkgName, binName, starts = [appDir, importDir, packageRo
 	return null;
 }
 
-function runNodeBin(pkgName, binName, args, { cwd, env } = {}) {
+function runNodeBin(pkgName, binName, args, { cwd, env, onSuccess } = {}) {
 	const bin = findPackageBin(pkgName, binName);
 	if (!bin) {
 		fail(
@@ -116,7 +116,19 @@ function runNodeBin(pkgName, binName, args, { cwd, env } = {}) {
 	});
 	child.on('exit', (code, signal) => {
 		if (signal) process.kill(process.pid, signal);
-		process.exit(code ?? 1);
+		if (code) process.exit(code ?? 1);
+		if (typeof onSuccess === 'function') {
+			const result = onSuccess();
+			// If onSuccess returns a ChildProcess, wait for it instead of exiting now.
+			if (result && typeof result.on === 'function') {
+				result.on('exit', (c, s) => {
+					if (s) process.kill(process.pid, s);
+					process.exit(c ?? 1);
+				});
+				return;
+			}
+		}
+		process.exit(0);
 	});
 	return child;
 }
@@ -269,5 +281,21 @@ function runSiteCommand(argv) {
 	const viteArgs = [command];
 	if (args.host !== null) viteArgs.push('--host', args.host === 'true' ? 'true' : args.host);
 	viteArgs.push(...args.extra);
-	runNodeBin('vite', 'vite', viteArgs, { cwd: appDir, env });
+	runNodeBin('vite', 'vite', viteArgs, {
+		cwd: appDir,
+		env,
+		onSuccess:
+			command === 'build'
+				? () => {
+						const copyScript = join(scriptDir, 'copy-path-mounts.mjs');
+						if (!existsSync(copyScript)) return;
+						return spawn(process.execPath, [copyScript, siteRoot], {
+							cwd: packageRoot,
+							env,
+							stdio: 'inherit',
+							shell: false
+						});
+					}
+				: undefined
+	});
 }