@janux/vite 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@janux/vite",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Vite plugin for Janux: JSX config, SSR routes, api() client stubs (SWC) and the dev server bridge.",
   "repository": {
     "type": "git",

package/src/app-config.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'bun:test';
+import { mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { resolveAppConfig } from './app-config';
+
+function appWithPackageJson(json: unknown): string {
+  const root = mkdtempSync(join(tmpdir(), 'janux-app-'));
+
+  writeFileSync(join(root, 'package.json'), JSON.stringify(json));
+
+  return root;
+}
+
+describe('resolveAppConfig package.json "janux" field', () => {
+  it('reads llmsTxt and title from the app package.json', () => {
+    const root = appWithPackageJson({
+      name: 'x',
+      janux: { title: 'My App', llmsTxt: { description: 'An app.' } },
+    });
+    const app = resolveAppConfig(root);
+
+    expect(app.title).toBe('My App');
+    expect(app.llmsTxt).toEqual({ description: 'An app.' });
+  });
+
+  it('lets explicit plugin options win over package.json', () => {
+    const root = appWithPackageJson({ name: 'x', janux: { title: 'From pkg' } });
+
+    expect(resolveAppConfig(root, { title: 'From plugin' }).title).toBe('From plugin');
+  });
+
+  it('defaults output to "bun" and reads "static" from the config', () => {
+    expect(resolveAppConfig(appWithPackageJson({ name: 'x' })).output).toBe('bun');
+    expect(resolveAppConfig(appWithPackageJson({ name: 'x', janux: { output: 'static' } })).output).toBe('static');
+    expect(resolveAppConfig(appWithPackageJson({ name: 'x' }), { output: 'static' }).output).toBe('static');
+  });
+
+  it('tolerates apps without a package.json or without the field', () => {
+    const root = mkdtempSync(join(tmpdir(), 'janux-app-'));
+
+    expect(resolveAppConfig(root).llmsTxt).toBeUndefined();
+    expect(resolveAppConfig(appWithPackageJson({ name: 'x' })).llmsTxt).toBeUndefined();
+  });
+});

package/src/app-config.ts

@@ -1,6 +1,8 @@
-import { existsSync, readdirSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 
+export type JanuxOutput = 'bun' | 'static';
+
 export interface JanuxAppConfig {
   root: string;
   routesDir: string;
@@ -9,7 +11,10 @@ export interface JanuxAppConfig {
   agentModule?: string;
   storesModule?: string;
   stylesheet?: string;
+  favicon?: string;
   title?: string;
+  llmsTxt?: { title?: string; description?: string };
+  output: JanuxOutput;
 }
 
 export interface JanuxPluginOptions {
@@ -19,14 +24,27 @@ export interface JanuxPluginOptions {
   agentModule?: string;
   storesModule?: string;
   title?: string;
+  llmsTxt?: { title?: string; description?: string };
+  output?: JanuxOutput;
 }
 
 function optional(path: string): string | undefined {
   return existsSync(path) ? path : undefined;
 }
 
+/** Optional per-app config: a `"janux"` field in the app's package.json (plugin options win over it). */
+function packageJsonOptions(root: string): JanuxPluginOptions {
+  try {
+    return JSON.parse(readFileSync(join(root, 'package.json'), 'utf8')).janux ?? {};
+  } catch {
+    return {};
+  }
+}
+
 /** Resolves the conventional app layout: src/routes, src/server, src/client.ts, src/agent.ts, src/stores.ts. */
-export function resolveAppConfig(root: string, options: JanuxPluginOptions = {}): JanuxAppConfig {
+export function resolveAppConfig(root: string, pluginOptions: JanuxPluginOptions = {}): JanuxAppConfig {
+  const options = { ...packageJsonOptions(root), ...pluginOptions };
+
   return {
     root,
     routesDir: resolve(root, options.routesDir ?? 'src/routes'),
@@ -35,7 +53,10 @@ export function resolveAppConfig(root: string, options: JanuxPluginOptions = {})
     agentModule: options.agentModule ?? optional(resolve(root, 'src/agent.ts')),
     storesModule: options.storesModule ?? optional(resolve(root, 'src/stores.ts')),
     stylesheet: optional(resolve(root, 'src/styles.css')),
+    favicon: optional(resolve(root, 'public/favicon.svg')) ? '/favicon.svg' : undefined,
     title: options.title,
+    llmsTxt: options.llmsTxt,
+    output: options.output ?? 'bun',
   };
 }
 

package/src/index.ts

@@ -1,4 +1,4 @@
 export { janux } from './plugin';
-export { resolveAppConfig, apiFiles, type JanuxPluginOptions, type JanuxAppConfig } from './app-config';
+export { resolveAppConfig, apiFiles, type JanuxPluginOptions, type JanuxAppConfig, type JanuxOutput } from './app-config';
 export { apiStubModule, exportedApiNames, apiModuleName } from './api-stubs';
 export { toFetchRequest, sendFetchResponse } from './request-adapter';

package/src/plugin.ts

@@ -1,6 +1,8 @@
+import { readFileSync } from 'node:fs';
 import type { Plugin, ViteDevServer } from 'vite';
 import { createJanuxServer, type ServerOptions } from '@janux/server';
 import { defineAgent } from '@janux/agent';
+import { mimeFor, resolvePublicFile } from './static-files';
 import { apiFiles, resolveAppConfig, type JanuxPluginOptions } from './app-config';
 import { apiModuleName, apiStubModule } from './api-stubs';
 import { sendFetchResponse, toFetchRequest } from './request-adapter';
@@ -28,7 +30,9 @@ async function loadServerOptions(vite: ViteDevServer, options: JanuxPluginOption
     storeDefs: (storesModule ?? {}) as ServerOptions['storeDefs'],
     runtimeUrl: app.clientEntry ? `/${relativeToRoot(vite.config.root, app.clientEntry)}` : undefined,
     stylesheets: app.stylesheet ? [`/${relativeToRoot(vite.config.root, app.stylesheet)}`] : [],
+    favicon: app.favicon,
     title: app.title,
+    llmsTxt: app.llmsTxt,
   };
 }
 
@@ -74,6 +78,14 @@ export function janux(options: JanuxPluginOptions = {}): Plugin {
       return () => {
         vite.middlewares.use((req, res, next) => {
           const handle = async () => {
+            const publicFile = resolvePublicFile(vite.config.root, req.url?.split('?')[0] ?? '/');
+
+            if (publicFile) {
+              res.writeHead(200, { 'content-type': mimeFor(publicFile) });
+              res.end(readFileSync(publicFile));
+
+              return;
+            }
             const server = await januxServer();
             const response = await server.fetch(await toFetchRequest(req));
 

package/src/static-files.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'bun:test';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { mimeFor, resolvePublicFile } from './static-files';
+
+const root = '/tmp/janux-static-test';
+
+mkdirSync(join(root, 'public'), { recursive: true });
+writeFileSync(join(root, 'public/logo.svg'), '<svg/>');
+
+describe('public/ static files', () => {
+  it('resolves existing files inside public/', () => {
+    expect(resolvePublicFile(root, '/logo.svg')).toBe(join(root, 'public/logo.svg'));
+    expect(resolvePublicFile(root, '/missing.png')).toBeUndefined();
+  });
+
+  it('refuses path traversal outside public/', () => {
+    expect(resolvePublicFile(root, '/../package.json')).toBeUndefined();
+    expect(resolvePublicFile(root, '/%2e%2e/secret')).toBeUndefined();
+  });
+
+  it('maps mime types with a safe fallback', () => {
+    expect(mimeFor('a.svg')).toBe('image/svg+xml');
+    expect(mimeFor('a.woff2')).toBe('font/woff2');
+    expect(mimeFor('a.unknown')).toBe('application/octet-stream');
+  });
+});

package/src/static-files.ts

@@ -0,0 +1,41 @@
+import { existsSync, statSync } from 'node:fs';
+import { extname, join, relative } from 'node:path';
+
+const MIME_TYPES: Record<string, string> = {
+  '.svg': 'image/svg+xml',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.ico': 'image/x-icon',
+  '.css': 'text/css; charset=utf-8',
+  '.js': 'text/javascript; charset=utf-8',
+  '.json': 'application/json',
+  '.txt': 'text/plain; charset=utf-8',
+  '.woff2': 'font/woff2',
+  '.webmanifest': 'application/manifest+json',
+};
+
+export function mimeFor(filePath: string): string {
+  return MIME_TYPES[extname(filePath)] ?? 'application/octet-stream';
+}
+
+/** Resolves a request path inside `<root>/public`, refusing traversal outside it. */
+export function resolvePublicFile(root: string, pathname: string): string | undefined {
+  const publicDir = join(root, 'public');
+  let decoded: string;
+
+  try {
+    decoded = decodeURIComponent(pathname);
+  } catch {
+    return undefined;
+  }
+  const candidate = join(publicDir, decoded);
+  const rel = relative(publicDir, candidate);
+
+  if (rel.startsWith('..') || rel === '') return undefined;
+  if (!existsSync(candidate) || !statSync(candidate).isFile()) return undefined;
+
+  return candidate;
+}