@jxsuite/server 0.28.2 → 0.28.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jxsuite/server",
-  "version": "0.28.2",
+  "version": "0.28.4",
   "description": "Jx development server with live reload, server-side proxy, and studio integration",
   "license": "MIT",
   "repository": {
@@ -27,13 +27,13 @@
     "test:coverage": "bun test --isolate --coverage"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.170",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.173",
     "@anthropic-ai/sdk": "^0.104.1",
-    "@jxsuite/compiler": "^0.28.2",
-    "@jxsuite/create": "^0.28.2",
-    "@jxsuite/parser": "^0.28.2",
-    "@jxsuite/runtime": "^0.28.2",
-    "@jxsuite/schema": "^0.28.2",
+    "@jxsuite/compiler": "^0.28.4",
+    "@jxsuite/create": "^0.28.4",
+    "@jxsuite/parser": "^0.28.4",
+    "@jxsuite/runtime": "^0.28.4",
+    "@jxsuite/schema": "^0.28.4",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "chokidar": "^5.0.0",
     "zod": "^4.4.3"

package/src/build.ts

@@ -21,13 +21,18 @@ export async function buildAll(
   for (const entry of builds) {
     const { match: _match, label, ...opts } = entry;
     const result = await Bun.build({
-      target: "browser",
       format: "esm",
       sourcemap: "linked",
+      target: "browser",
       ...opts,
     });
-    if (!result.success) result.logs.forEach((l) => console.error(l));
-    else console.log(`Built → ${entry.outdir}/${label ?? "bundle"}.js`);
+    if (!result.success) {
+      for (const l of result.logs) {
+        console.error(l);
+      }
+    } else {
+      console.log(`Built → ${entry.outdir}/${label ?? "bundle"}.js`);
+    }
   }
 }
 
@@ -55,26 +60,32 @@ export async function rebuild(
   const rebuilt = [];
   let ok = true;
   for (const entry of builds) {
-    if (!entry.match) continue;
+    if (!entry.match) {
+      continue;
+    }
     const matches =
       typeof entry.match === "function"
         ? entry.match(changedFile)
         : entry.match instanceof RegExp
           ? entry.match.test(changedFile)
           : false;
-    if (!matches) continue;
+    if (!matches) {
+      continue;
+    }
     const { match: _match, label, ...opts } = entry;
     const result = await Bun.build({
-      target: "browser",
       format: "esm",
       sourcemap: "linked",
+      target: "browser",
       ...opts,
     });
     if (result.success) {
       rebuilt.push(label ?? entry.outdir);
       console.log(`Rebuilt  → ${entry.outdir}/${label ?? "bundle"}.js  (${changedFile} changed)`);
     } else {
-      result.logs.forEach((l) => console.error(l));
+      for (const l of result.logs) {
+        console.error(l);
+      }
       ok = false;
     }
   }

package/src/claude-session.ts

@@ -8,8 +8,7 @@
 
 import { query } from "@anthropic-ai/claude-agent-sdk";
 
-import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
-import type { Options as AgentOptions } from "@anthropic-ai/claude-agent-sdk";
+import type { Options as AgentOptions, SDKMessage } from "@anthropic-ai/claude-agent-sdk";
 
 interface Session {
   id: string;
@@ -39,12 +38,12 @@ function buildSdkEnv() {
   return env;
 }
 
-const sessions: Map<string, Session> = new Map();
+const sessions = new Map<string, Session>();
 
 let idCounter = 0;
 
 function genId() {
-  return `ai_${Date.now().toString(36)}_${(++idCounter).toString(36)}`;
+  return `ai_${Date.now().toString(36)}_${(idCounter += 1).toString(36)}`;
 }
 
 /**
@@ -71,15 +70,17 @@ async function processStream(session: Session, stream: AsyncGenerator<SDKMessage
   session.status = "active";
   try {
     for await (const message of stream) {
-      if ((session.status as string) === "stopped") break;
+      if ((session.status as string) === "stopped") {
+        break;
+      }
       if (message.session_id && !session.sessionId) {
         session.sessionId = message.session_id;
       }
       broadcast(session, message.type, message);
     }
-  } catch (err) {
-    if (err instanceof Error && err.name !== "AbortError") {
-      broadcast(session, "error", { type: "error", error: String(err) });
+  } catch (error) {
+    if (error instanceof Error && error.name !== "AbortError") {
+      broadcast(session, "error", { error: String(error), type: "error" });
     }
   } finally {
     session.status = "idle";
@@ -106,34 +107,34 @@ export function createSession(
   const abortController = new AbortController();
 
   const session: Session = {
+    abortController,
     id,
-    sessionId: null,
-    projectRoot,
     messages: [],
+    projectRoot,
+    query: null,
+    sessionId: null,
     sseClients: new Set(),
     status: "active",
-    abortController,
-    query: null,
   };
 
   sessions.set(id, session);
 
   const queryOpts: AgentOptions = {
-    cwd: projectRoot,
     abortController,
-    permissionMode: "acceptEdits",
     allowedTools: ["Read", "Edit", "Write", "Bash", "Glob", "Grep"],
-    maxTurns: 30,
+    cwd: projectRoot,
+    env: buildSdkEnv(),
     includePartialMessages: true,
+    maxTurns: 30,
+    permissionMode: "acceptEdits",
     persistSession: true,
-    env: buildSdkEnv(),
   };
 
   if (opts.systemPrompt) {
     queryOpts.systemPrompt = opts.systemPrompt;
   }
 
-  const stream = query({ prompt: message, options: queryOpts });
+  const stream = query({ options: queryOpts, prompt: message });
   session.query = stream;
   processStream(session, stream);
 
@@ -148,21 +149,25 @@ export function createSession(
  */
 export function sendMessage(id: string, message: string) {
   const session = sessions.get(id);
-  if (!session) throw new Error(`Session not found: ${id}`);
-  if (session.status === "active") throw new Error("Session is still processing");
+  if (!session) {
+    throw new Error(`Session not found: ${id}`);
+  }
+  if (session.status === "active") {
+    throw new Error("Session is still processing");
+  }
 
   const abortController = new AbortController();
   session.abortController = abortController;
 
   const queryOpts: AgentOptions = {
-    cwd: session.projectRoot,
     abortController,
-    permissionMode: "acceptEdits",
     allowedTools: ["Read", "Edit", "Write", "Bash", "Glob", "Grep"],
-    maxTurns: 30,
-    includePartialMessages: true,
     continue: true,
+    cwd: session.projectRoot,
     env: buildSdkEnv(),
+    includePartialMessages: true,
+    maxTurns: 30,
+    permissionMode: "acceptEdits",
   };
 
   if (session.sessionId) {
@@ -170,7 +175,7 @@ export function sendMessage(id: string, message: string) {
     delete queryOpts.continue;
   }
 
-  const stream = query({ prompt: message, options: queryOpts });
+  const stream = query({ options: queryOpts, prompt: message });
   session.query = stream;
   processStream(session, stream);
 }
@@ -182,7 +187,9 @@ export function sendMessage(id: string, message: string) {
  */
 export function stopSession(id: string) {
   const session = sessions.get(id);
-  if (!session) return;
+  if (!session) {
+    return;
+  }
   session.status = "stopped";
   if (session.abortController) {
     session.abortController.abort();
@@ -214,6 +221,9 @@ export function streamSession(id: string) {
   const encoder = new TextEncoder();
   let sendRef: (event: string, data: unknown) => void = () => {};
   const stream = new ReadableStream({
+    cancel() {
+      session.sseClients.delete(sendRef);
+    },
     start(controller) {
       /** @param {string} event @param {unknown} data */
       sendRef = (event: string, data: unknown) => {
@@ -237,18 +247,15 @@ export function streamSession(id: string) {
           clearInterval(heartbeat);
           session.sseClients.delete(sendRef);
         }
-      }, 15000);
-    },
-    cancel() {
-      session.sseClients.delete(sendRef);
+      }, 15_000);
     },
   });
 
   return new Response(stream, {
     headers: {
-      "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
       Connection: "keep-alive",
+      "Content-Type": "text/event-stream",
     },
   });
 }
@@ -261,16 +268,16 @@ export function streamSession(id: string) {
 export async function getAuthStatus() {
   try {
     const ctrl = new AbortController();
-    const timeout = setTimeout(() => ctrl.abort(), 15000);
+    const timeout = setTimeout(() => ctrl.abort(), 15_000);
     const testStream = query({
-      prompt: "Say OK",
       options: {
         abortController: ctrl,
+        env: buildSdkEnv(),
+        includePartialMessages: true,
         maxTurns: 1,
         persistSession: false,
-        includePartialMessages: true,
-        env: buildSdkEnv(),
       },
+      prompt: "Say OK",
     });
 
     for await (const msg of testStream) {
@@ -279,9 +286,9 @@ export async function getAuthStatus() {
           | { content?: unknown[] }
           | undefined;
         if (Array.isArray(content?.content)) {
-          const text = content.content.find((b: any) => b.type === "text") as
-            | { text?: string }
-            | undefined;
+          const text = content.content.find(
+            (b: unknown) => (b as { type?: string }).type === "text",
+          ) as { text?: string } | undefined;
           if (text?.text?.toLowerCase().includes("error")) {
             clearTimeout(timeout);
             ctrl.abort();
@@ -308,8 +315,8 @@ export async function getAuthStatus() {
 
     clearTimeout(timeout);
     return { authenticated: true };
-  } catch (err) {
-    return { authenticated: false, error: String(err) };
+  } catch (error) {
+    return { authenticated: false, error: String(error) };
   }
 }
 
@@ -320,10 +327,12 @@ export async function getAuthStatus() {
  */
 export function getSession(id: string) {
   const session = sessions.get(id);
-  if (!session) return null;
+  if (!session) {
+    return null;
+  }
   return {
     id: session.id,
-    status: session.status,
     messageCount: session.messages.length,
+    status: session.status,
   };
 }

package/src/code-api.ts

@@ -6,6 +6,7 @@
  */
 
 import { tmpdir } from "node:os";
+import { errorMessage } from "@jxsuite/schema/parse";
 import { join, resolve } from "node:path";
 import { unlink } from "node:fs/promises";
 import { format } from "oxfmt";
@@ -42,8 +43,12 @@ function unwrapFormatted(formatted: string) {
   const lines = formatted.split("\n");
   // Remove first line (function header) and last non-empty line (closing brace)
   let end = lines.length - 1;
-  while (end > 0 && lines[end].trim() === "") end--;
-  if (lines[end].trim() === "}") end--;
+  while (end > 0 && lines[end].trim() === "") {
+    end -= 1;
+  }
+  if (lines[end].trim() === "}") {
+    end -= 1;
+  }
   const bodyLines = lines.slice(1, end + 1);
   // Dedent by one tab (oxfmt uses the project's indentStyle)
   return bodyLines.map((l) => (l.startsWith("\t") ? l.slice(1) : l)).join("\n");
@@ -59,17 +64,14 @@ function adjustDiagnostics(diagnostics: OxcDiagnostic[], headerLen: number) {
       const line = d.labels?.[0]?.span?.line;
       return line == null || line > 1;
     })
-    .map((d) => ({
-      ...d,
-      labels: d.labels?.map((label) => ({
-        ...label,
-        span: {
-          ...label.span,
-          offset: label.span.offset - headerLen,
-          line: label.span.line - 1,
-        },
-      })),
-    }));
+    .map((d) => {
+      // Diagnostics are freshly parsed and serialized right after; mutate in place
+      for (const label of d.labels ?? []) {
+        label.span.line -= 1;
+        label.span.offset -= headerLen;
+      }
+      return d;
+    });
 }
 
 // ─── Reusable transpiler ─────────────────────────────────────────────────────
@@ -84,7 +86,9 @@ const minifier = new Bun.Transpiler({ minifyWhitespace: true });
  */
 export async function handleCodeApi(req: Request, url: URL) {
   const path = url.pathname;
-  if (!path.startsWith("/__studio/code/") || req.method !== "POST") return null;
+  if (!path.startsWith("/__studio/code/") || req.method !== "POST") {
+    return null;
+  }
 
   let body;
   try {
@@ -99,7 +103,9 @@ export async function handleCodeApi(req: Request, url: URL) {
 
   if (action === "format") {
     const { code, args } = body;
-    if (!code?.trim()) return Response.json({ code: "", errors: [] });
+    if (!code?.trim()) {
+      return Response.json({ code: "", errors: [] });
+    }
 
     try {
       const wrapped = wrapBody(code, args);
@@ -108,10 +114,10 @@ export async function handleCodeApi(req: Request, url: URL) {
         code: unwrapFormatted(result.code),
         errors: result.errors,
       });
-    } catch (e) {
+    } catch (error) {
       return Response.json({
         code,
-        errors: [{ message: (e as Error).message }],
+        errors: [{ message: errorMessage(error) }],
       });
     }
   }
@@ -120,13 +126,15 @@ export async function handleCodeApi(req: Request, url: URL) {
 
   if (action === "minify") {
     const { code } = body;
-    if (!code?.trim()) return Response.json({ code: "" });
+    if (!code?.trim()) {
+      return Response.json({ code: "" });
+    }
 
     try {
       const minified = minifier.transformSync(code).trim();
       return Response.json({ code: minified });
-    } catch (e) {
-      return Response.json({ code, error: (e as Error).message });
+    } catch (error) {
+      return Response.json({ code, error: errorMessage(error) });
     }
   }
 
@@ -134,7 +142,9 @@ export async function handleCodeApi(req: Request, url: URL) {
 
   if (action === "lint") {
     const { code, args } = body;
-    if (!code?.trim()) return Response.json({ diagnostics: [] });
+    if (!code?.trim()) {
+      return Response.json({ diagnostics: [] });
+    }
 
     const wrapped = wrapBody(code, args);
     const headerLen = wrapped.indexOf("\n") + 1;
@@ -146,8 +156,8 @@ export async function handleCodeApi(req: Request, url: URL) {
     try {
       await Bun.write(tmpFile, wrapped);
       const proc = Bun.spawn([OXLINT_BIN, "--format=json", "-A", "no-unused-vars", tmpFile], {
-        stdout: "pipe",
         stderr: "pipe",
+        stdout: "pipe",
       });
       const output = await new Response(proc.stdout).text();
       await proc.exited;
@@ -155,10 +165,10 @@ export async function handleCodeApi(req: Request, url: URL) {
       const parsed = JSON.parse(output);
       const adjusted = adjustDiagnostics(parsed.diagnostics || [], headerLen);
       return Response.json({ diagnostics: adjusted });
-    } catch (e) {
+    } catch (error) {
       return Response.json({
         diagnostics: [],
-        error: (e as Error).message,
+        error: errorMessage(error),
       });
     } finally {
       try {

package/src/resolve.ts

@@ -1,11 +1,12 @@
 /** Resolve.js — Generic $src module proxy + timing: "server" function proxy */
 
-import { resolve, relative, dirname } from "node:path";
-import { readFileSync, existsSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+import { errorMessage, parseClassDef } from "@jxsuite/schema/parse";
+import { existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { loadContentTypes } from "@jxsuite/compiler/content-loader";
 import type { DynamicClass } from "@jxsuite/runtime/types";
-import type { ClassJsonDef } from "./types.ts";
+import type { JxClassDef } from "@jxsuite/schema/types";
 
 /**
  * Lazy-load project context (project.json + content types) for class instantiation.
@@ -19,7 +20,9 @@ import type { ClassJsonDef } from "./types.ts";
  */
 async function loadProjectContext(projectRoot: string) {
   const projectJsonPath = resolve(projectRoot, "project.json");
-  if (!existsSync(projectJsonPath)) return null;
+  if (!existsSync(projectJsonPath)) {
+    return null;
+  }
   try {
     const config = JSON.parse(readFileSync(projectJsonPath, "utf8"));
     const contentTypes = config.contentTypes
@@ -51,7 +54,9 @@ export async function handleResolve(
   }
 
   const { $src, $prototype, $export: xport, $base, ...config } = body;
-  if (!$src) return new Response("Missing $src", { status: 400 });
+  if (!$src) {
+    return new Response("Missing $src", { status: 400 });
+  }
 
   let moduleAbsPath;
   try {
@@ -60,12 +65,12 @@ export async function handleResolve(
       if ($base) {
         const docUrlPath = new URL($base).pathname;
         const docDir = docUrlPath.slice(0, docUrlPath.lastIndexOf("/") + 1);
-        moduleAbsPath = resolve(resolve(root, "." + docDir), $src);
+        moduleAbsPath = resolve(resolve(root, `.${docDir}`), $src);
       } else {
         moduleAbsPath = resolve(activeProjectRoot || root, $src);
       }
     } else {
-      // npm/bare specifier — use createRequire from project root, fall back to server package
+      // Npm/bare specifier — use createRequire from project root, fall back to server package
       const projectRoot = activeProjectRoot || root;
       const projRequire = createRequire(resolve(projectRoot, "package.json"));
       try {
@@ -75,18 +80,18 @@ export async function handleResolve(
         moduleAbsPath = serverRequire.resolve($src);
       }
     }
-  } catch (e) {
-    return new Response(`Cannot resolve $src "${$src}": ${(e as Error).message}`, { status: 400 });
+  } catch (error) {
+    return new Response(`Cannot resolve $src "${$src}": ${errorMessage(error)}`, { status: 400 });
   }
 
   // Rebase relative config paths from doc-relative to CWD-relative
   if ($base) {
     const docUrlPath = new URL($base).pathname;
     const docDir = docUrlPath.slice(0, docUrlPath.lastIndexOf("/") + 1);
-    const docAbsDir = resolve(root, "." + docDir);
+    const docAbsDir = resolve(root, `.${docDir}`);
     for (const [k, v] of Object.entries(config)) {
       if (typeof v === "string" && (v.startsWith("./") || v.startsWith("../"))) {
-        config[k] = "./" + relative(process.cwd(), resolve(docAbsDir, v)).split("\\").join("/");
+        config[k] = `./${relative(process.cwd(), resolve(docAbsDir, v)).split("\\").join("/")}`;
       }
     }
   }
@@ -95,7 +100,7 @@ export async function handleResolve(
   if (moduleAbsPath.endsWith(".class.json")) {
     try {
       const content = readFileSync(moduleAbsPath, "utf8");
-      const classDef = JSON.parse(content);
+      const classDef = parseClassDef(content, moduleAbsPath);
 
       // Inject project context for classes that need it
       const projectRoot = activeProjectRoot || root;
@@ -139,8 +144,8 @@ export async function handleResolve(
             ? instance.value
             : instance;
       return Response.json(value);
-    } catch (e) {
-      return Response.json({ error: (e as Error).message }, { status: 500 });
+    } catch (error) {
+      return Response.json({ error: errorMessage(error) }, { status: 500 });
     }
   }
 
@@ -168,19 +173,21 @@ export async function handleServerFunction(req: Request, root: string) {
   }
 
   const { $src, $export: xport, $base, arguments: args = {} } = body;
-  if (!$src || !xport) return new Response("Missing $src or $export", { status: 400 });
+  if (!$src || !xport) {
+    return new Response("Missing $src or $export", { status: 400 });
+  }
 
   let moduleAbsPath;
   try {
     if ($base) {
       const docUrlPath = new URL($base).pathname;
       const docDir = docUrlPath.slice(0, docUrlPath.lastIndexOf("/") + 1);
-      moduleAbsPath = resolve(resolve(root, "." + docDir), $src);
+      moduleAbsPath = resolve(resolve(root, `.${docDir}`), $src);
     } else {
       moduleAbsPath = resolve(root, $src);
     }
-  } catch (e) {
-    return new Response(`Cannot resolve $src: ${(e as Error).message}`, {
+  } catch (error) {
+    return new Response(`Cannot resolve $src: ${errorMessage(error)}`, {
       status: 400,
     });
   }
@@ -188,8 +195,8 @@ export async function handleServerFunction(req: Request, root: string) {
   let mod;
   try {
     mod = await import(moduleAbsPath);
-  } catch (e) {
-    return new Response(`Failed to import "${$src}": ${(e as Error).message}`, {
+  } catch (error) {
+    return new Response(`Failed to import "${$src}": ${errorMessage(error)}`, {
       status: 500,
     });
   }
@@ -204,8 +211,8 @@ export async function handleServerFunction(req: Request, root: string) {
   try {
     const result = await fn(args);
     return Response.json(result ?? null);
-  } catch (e) {
-    return Response.json({ error: (e as Error).message }, { status: 500 });
+  } catch (error) {
+    return Response.json({ error: errorMessage(error) }, { status: 500 });
   }
 }
 
@@ -213,23 +220,31 @@ export async function handleServerFunction(req: Request, root: string) {
  * Dynamically construct a class from a .class.json schema definition. Server-side variant — no
  * private field limitations.
  *
- * @param {ClassJsonDef} classDef
+ * @param {JxClassDef} classDef
  */
-function classFromSchema(classDef: ClassJsonDef) {
+function classFromSchema(classDef: JxClassDef) {
   const fields = classDef.$defs?.fields ?? {};
-  const ctor = classDef.$defs?.constructor;
+  // JSON objects inherit Object.prototype.constructor — only an own object value counts.
+  const rawCtor = classDef.$defs?.constructor;
+  const ctor = typeof rawCtor === "object" ? rawCtor : undefined;
   const methods = classDef.$defs?.methods ?? {};
 
+  // oxlint-disable-next-line typescript/no-extraneous-class -- methods are attached to the prototype dynamically below
   class DynClass {
     constructor(config = {}) {
       const self = this as Record<string, unknown>;
       const cfg = config as Record<string, unknown>;
       for (const [key, field] of Object.entries(fields)) {
         const id = field.identifier ?? key;
-        if (cfg[id] !== undefined) self[id] = cfg[id];
-        else if (field.initializer !== undefined) self[id] = field.initializer;
-        else if (field.default !== undefined) self[id] = structuredClone(field.default);
-        else self[id] = null;
+        if (cfg[id] !== undefined) {
+          self[id] = cfg[id];
+        } else if (field.initializer !== undefined) {
+          self[id] = field.initializer;
+        } else if (field.default !== undefined) {
+          self[id] = structuredClone(field.default);
+        } else {
+          self[id] = null;
+        }
       }
       if (ctor?.body) {
         const bodyStr = Array.isArray(ctor.body) ? ctor.body.join("\n") : ctor.body;
@@ -241,17 +256,22 @@ function classFromSchema(classDef: ClassJsonDef) {
   for (const [key, method] of Object.entries(methods)) {
     const name = method.identifier ?? key;
     const params = (method.parameters ?? []).map((p) => {
-      if (p.$ref) return p.$ref.split("/").pop() ?? "arg";
-      return p.identifier ?? p.name ?? "arg";
+      if (p.$ref) {
+        return p.$ref.split("/").pop() ?? "arg";
+      }
+      const n = p.identifier ?? p.name;
+      return typeof n === "string" ? n : "arg";
     });
     const bodyStr = Array.isArray(method.body) ? method.body.join("\n") : (method.body ?? "");
 
     if (method.role === "accessor") {
       const descriptor: PropertyDescriptor = {};
-      if (method.getter) descriptor.get = new Function(method.getter.body) as () => unknown;
+      if (method.getter) {
+        descriptor.get = new Function(method.getter.body ?? "") as () => unknown;
+      }
       if (method.setter) {
         const sp = (method.setter.parameters ?? []).map((p) => p.$ref?.split("/").pop() ?? "v");
-        descriptor.set = new Function(...sp, method.setter.body) as (v: unknown) => void;
+        descriptor.set = new Function(...sp, method.setter.body ?? "") as (v: unknown) => void;
       }
       Object.defineProperty(DynClass.prototype, name, {
         ...descriptor,
@@ -265,8 +285,8 @@ function classFromSchema(classDef: ClassJsonDef) {
   }
 
   Object.defineProperty(DynClass, "name", {
-    value: classDef.title,
     configurable: true,
+    value: classDef.title,
   });
   return DynClass;
 }