@olenbetong/appframe-vite 6.7.0 → 6.8.0

package/README.md

@@ -42,7 +42,7 @@ On first run, the plugin logs in, configures Vite’s proxy for Appframe routes,
 
 ### MUI X license key
 
-The plugin injects the MUI X Pro license key into the bundle as the global `__MUI_X_LICENSE_KEY__`, for both `serve` and `build`. `@olenbetong/appframe-ds/grid` reads it and registers the license itself, so an app using the Designsystemet `AfGrid` does not need its own `LicenseInfo.setLicenseKey()` call.
+The plugin injects the MUI X Premium license key into the bundle as the global `__MUI_X_LICENSE_KEY__`, for both `serve` and `build`. `@olenbetong/appframe-ds/grid` reads it and registers the license itself, so an app using the Designsystemet `AfGrid` does not need its own `LicenseInfo.setLicenseKey()` call.
 
 The key is resolved from, in order:
 
@@ -90,6 +90,38 @@ This package reads `package.json.appframe` to know what to proxy and how to buil
   - Adds a Rollup visualizer report at `dist/stats.html`.
 - Resolve
   - Adds the alias `~/` to `/src/` so imports like `~/components/Button` resolve to `src/components/Button`.
+- DevTools API (see below)
+
+## DevTools
+
+In dev mode the plugin exposes a small JSON API at `/__appframe_devtools__/api` for the **Appframe DevTools
+browser extension** (`packages/appframe-devtools` in the SynergiWeb repo). The extension adds an "Appframe"
+panel to Chrome/Edge DevTools with a live view of the app's data objects, an editor for `resources.yaml`
+and a browser for the data API catalog. Nothing is injected into the page — the toolbar that older
+versions added to every dev-served page is gone.
+
+| Endpoint                    | Purpose                                                                                                               |
+| --------------------------- | --------------------------------------------------------------------------------------------------------------------- |
+| `GET /api/config`           | Discovery: `{ appframe: true, apiVersion, hostname, articleId, articleHostname, appName, appVersion, pluginVersion }` |
+| `GET /api/resources`        | Parsed `resources.yaml`                                                                                               |
+| `POST /api/resources`       | Add an entry (`type: "dataObject" \| "procedure"` plus the entry fields)                                              |
+| `PUT /api/resources/:id`    | Replace an entry                                                                                                      |
+| `DELETE /api/resources/:id` | Remove an entry and its generated output file                                                                         |
+| `POST /api/catalog`         | Register a `dbObjectId` as a data API resource on dev, stage and prod                                                 |
+| `GET /api/release`          | Current session (`session: null` when none) and the capabilities derived from the app's scripts                       |
+| `POST /api/release`         | Start a job: `{ kind: "release", dry?, force? }` or `{ kind: "deploy", target, copyDatasources? }`; 409 while running |
+| `DELETE /api/release`       | Cancel the running job                                                                                                |
+| `POST /api/release/input`   | Answer one of the script's questions (`{ name, value }`: the release type and notes, or the apply confirmation)       |
+| `GET /api/release/events`   | Server-sent events: the session snapshot, then every step, log line and question as it happens                        |
+
+The release job runs whatever `scripts.release` is in the app's package.json, from the app directory, with
+`--ui` appended. The deploy job runs `pnpm run build`, optionally `pnpm run cd` (or `copy-datasources`) and
+`pnpm run deploy` with `APPFRAME_DEPLOY_HOSTNAME` set to the target, which `app-deploy.ts` and
+`app-copy-datasources.ts` honour over the hostnames in package.json. The script is expected to follow the protocol in `scripts/lib/releaseUi.ts` (JSON event lines
+prefixed with `@@appframe-devtools ` on stdout, answers as JSON lines on stdin).
+
+Disable it with `appframe({ devtools: false })` when there is no article context (Storybook does this).
+The extension page has host permissions for `localhost`, so the API needs no CORS headers.
 
 ## CLI — `appframe-vite`
 
@@ -243,7 +275,7 @@ import {
 	fetchAndGenerate,
 	buildYamlConfig,
 	parseYamlConfig,
-	formatWithBiome,
+	writeGeneratedFile,
 	getCustomImportPath,
 	type CLIOptions,
 } from "@olenbetong/appframe-vite/resources";

package/lib/devtoolsServer.d.ts

@@ -1,7 +1,56 @@
+import { type ReleaseServerOptions } from "./releaseServer.js";
 import type { Connect } from "vite";
 /**
- * Creates a Connect middleware that:
- * 1. Serves the appframe-devtools static SPA at `/__appframe_devtools__/`
- * 2. Exposes a REST API at `/__appframe_devtools__/api/resources` for resources.yaml CRUD
+ * Bumped whenever the shape of the DevTools API changes in a way the browser
+ * extension has to know about. The extension compares it against the value it
+ * was built for.
  */
-export declare function createDevtoolsMiddleware(hostname: string): Connect.NextHandleFunction;
+export declare const DEVTOOLS_API_VERSION = 1;
+/**
+ * Information about the app the dev server is serving. Passed to the middleware
+ * and returned verbatim by the discovery endpoint.
+ */
+export interface DevtoolsServerInfo {
+    /** Appframe host the dev server proxies to, e.g. `dev.obet.no`. */
+    hostname: string;
+    /** Article ID from `package.json → appframe.article.id`. */
+    articleId: string;
+    /**
+     * CMS site the article belongs to (`appframe.article.hostname` in package.json), or
+     * `null` when the app does not declare one. Dev servers are usually reached through an
+     * alias such as `dev.obet.no`, while the CMS stores the article under the site's own
+     * hostname; the extension resolves it through `stbv_WebSiteCMS_SitesAliases` when null.
+     */
+    articleHostname: string | null;
+    /** `name` from the app's package.json. */
+    appName: string;
+    /** `version` from the app's package.json. */
+    appVersion: string;
+    /** Version of `@olenbetong/appframe-vite` running the dev server. */
+    pluginVersion: string;
+}
+/**
+ * Payload of `GET /__appframe_devtools__/api/config`. The `appframe: true` marker
+ * lets the extension tell an Appframe dev server from any other localhost page
+ * (a plain Vite server answers unknown paths with `index.html`).
+ */
+export interface DevtoolsDiscovery extends DevtoolsServerInfo {
+    appframe: true;
+    apiVersion: number;
+}
+/**
+ * Creates a Connect middleware exposing the DevTools JSON API used by the
+ * Appframe DevTools browser extension (`packages/appframe-devtools`). Mounted at
+ * `/__appframe_devtools__`, it answers:
+ *
+ * - `GET    /api/config`        — discovery payload (`DevtoolsDiscovery`)
+ * - `GET    /api/resources`     — parsed `resources.yaml`
+ * - `POST   /api/resources`     — add an entry (`type: "dataObject" | "procedure"`)
+ * - `PUT    /api/resources/:id` — replace an entry
+ * - `DELETE /api/resources/:id` — remove an entry and its generated output file
+ * - `POST   /api/catalog`       — register a DBObjectID as a data API resource on dev, stage and prod
+ *
+ * Nothing is served outside `/api/`; the UI lives in the extension. The extension
+ * page has host permissions for localhost, so no CORS headers are needed here.
+ */
+export declare function createDevtoolsMiddleware(info: DevtoolsServerInfo, options?: ReleaseServerOptions): Connect.NextHandleFunction;

package/lib/devtoolsServer.js

@@ -1,32 +1,16 @@
-import { createReadStream, existsSync, rmSync } from "node:fs";
+import { createReleaseManager, handleReleaseApi, } from "./releaseServer.js";
+import { rmSync } from "node:fs";
 import https from "node:https";
-import { createRequire } from "node:module";
-import { dirname, extname, join } from "node:path";
 import bodyParser from "body-parser";
 import { login } from "./proxy.js";
 import { readResourcesConfig, writeResourcesConfig } from "./resourcesConfig.js";
-const require = createRequire(import.meta.url);
 const ALL_SERVERS = ["dev.obet.no", "stage.obet.no", "test.obet.no"];
-const MIME_TYPES = {
-    ".html": "text/html; charset=utf-8",
-    ".js": "application/javascript; charset=utf-8",
-    ".css": "text/css; charset=utf-8",
-    ".json": "application/json; charset=utf-8",
-    ".svg": "image/svg+xml",
-    ".png": "image/png",
-    ".ico": "image/x-icon",
-    ".woff2": "font/woff2",
-    ".woff": "font/woff",
-};
-function getDevtoolsDist() {
-    try {
-        const pkgPath = require.resolve("@olenbetong/appframe-devtools/package.json");
-        return join(dirname(pkgPath), "dist");
-    }
-    catch {
-        return null;
-    }
-}
+/**
+ * Bumped whenever the shape of the DevTools API changes in a way the browser
+ * extension has to know about. The extension compares it against the value it
+ * was built for.
+ */
+export const DEVTOOLS_API_VERSION = 1;
 function sendJson(res, status, data) {
     const body = status === 204 ? "" : JSON.stringify(data);
     res.statusCode = status;
@@ -86,7 +70,7 @@ async function addResourceOnServer(hostname, cookies, dbObjectId, name) {
         req.end();
     });
 }
-async function handleApi(req, res, apiPath, hostname, next) {
+async function handleApi(req, res, apiPath, info, release, next) {
     // apiPath is the path after /__appframe_devtools__/api
     // e.g. /config, /resources or /resources/dsMyObject
     const segments = apiPath
@@ -95,7 +79,14 @@ async function handleApi(req, res, apiPath, hostname, next) {
         .filter(Boolean);
     const method = req.method?.toUpperCase() ?? "GET";
     if (apiPath === "/config" && method === "GET") {
-        return sendJson(res, 200, { hostname });
+        const discovery = { appframe: true, apiVersion: DEVTOOLS_API_VERSION, ...info };
+        return sendJson(res, 200, discovery);
+    }
+    if (apiPath === "/release" || apiPath.startsWith("/release/")) {
+        if (await handleReleaseApi(req, res, apiPath.slice("/release".length), release)) {
+            return;
+        }
+        return next();
     }
     // Only handle /resources and /resources/:id
     if (!apiPath.startsWith("/resources") && apiPath !== "/catalog") {
@@ -197,50 +188,32 @@ async function handleApi(req, res, apiPath, hostname, next) {
     }
 }
 /**
- * Creates a Connect middleware that:
- * 1. Serves the appframe-devtools static SPA at `/__appframe_devtools__/`
- * 2. Exposes a REST API at `/__appframe_devtools__/api/resources` for resources.yaml CRUD
+ * Creates a Connect middleware exposing the DevTools JSON API used by the
+ * Appframe DevTools browser extension (`packages/appframe-devtools`). Mounted at
+ * `/__appframe_devtools__`, it answers:
+ *
+ * - `GET    /api/config`        — discovery payload (`DevtoolsDiscovery`)
+ * - `GET    /api/resources`     — parsed `resources.yaml`
+ * - `POST   /api/resources`     — add an entry (`type: "dataObject" | "procedure"`)
+ * - `PUT    /api/resources/:id` — replace an entry
+ * - `DELETE /api/resources/:id` — remove an entry and its generated output file
+ * - `POST   /api/catalog`       — register a DBObjectID as a data API resource on dev, stage and prod
+ *
+ * Nothing is served outside `/api/`; the UI lives in the extension. The extension
+ * page has host permissions for localhost, so no CORS headers are needed here.
  */
-export function createDevtoolsMiddleware(hostname) {
+export function createDevtoolsMiddleware(info, options = { appDir: process.cwd(), scripts: {} }) {
     const jsonParser = bodyParser.json();
-    const devtoolsDist = getDevtoolsDist();
+    const release = createReleaseManager(options);
     return (req, res, next) => {
         // req.url here is the path after /__appframe_devtools__ (Connect strips the prefix)
         const url = req.url ?? "/";
-        // REST API
         if (url.startsWith("/api/")) {
             jsonParser(req, res, () => {
-                handleApi(req, res, url.slice(4), hostname, next).catch(next);
+                handleApi(req, res, url.slice(4).split("?")[0], info, release, next).catch(next);
             });
             return;
         }
-        // Static files
-        if (!devtoolsDist) {
-            res.statusCode = 503;
-            res.setHeader("Content-Type", "text/plain");
-            res.end("@olenbetong/appframe-devtools not found or not built.\n" +
-                "Run: pnpm --filter @olenbetong/appframe-devtools build");
-            return;
-        }
-        const safePath = url.split("?")[0] || "/";
-        const filePath = join(devtoolsDist, safePath === "/" ? "index.html" : safePath);
-        if (existsSync(filePath)) {
-            const mime = MIME_TYPES[extname(filePath)] ?? "application/octet-stream";
-            res.setHeader("Content-Type", mime);
-            createReadStream(filePath).pipe(res);
-        }
-        else {
-            // SPA fallback - all unknown paths serve index.html
-            const indexPath = join(devtoolsDist, "index.html");
-            if (existsSync(indexPath)) {
-                res.setHeader("Content-Type", "text/html; charset=utf-8");
-                createReadStream(indexPath).pipe(res);
-            }
-            else {
-                res.statusCode = 404;
-                res.setHeader("Content-Type", "text/plain");
-                res.end("DevTools app not built yet.\n" + "Run: pnpm --filter @olenbetong/appframe-devtools build");
-            }
-        }
+        next();
     };
 }

package/lib/format.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Format content in memory with oxfmt's stdin mode. `filePath` only tells oxfmt
+ * which parser to use, and does not have to exist yet.
+ * Returns the original content if oxfmt is unavailable or rejects the input.
+ */
+export declare function formatContent(content: string, filePath: string): Promise<string>;
+/** Format a file in place with oxfmt. Silently skips if oxfmt is unavailable. */
+export declare function formatFile(filePath: string): Promise<void>;
+/**
+ * Lint a file with oxlint, applying the fixes it can apply automatically.
+ * Returns the diagnostics oxlint could not fix, or an empty string when the
+ * file is clean (or oxlint is unavailable).
+ */
+export declare function lintFile(filePath: string): Promise<string>;

package/lib/format.js

@@ -0,0 +1,70 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+/**
+ * Locate a binary in the nearest `node_modules/.bin`, walking up from cwd.
+ * Falls back to the bare name so a globally installed binary on PATH still works.
+ */
+function findBin(name) {
+    let current = resolve(process.cwd());
+    while (true) {
+        let candidate = join(current, "node_modules", ".bin", name);
+        let candidateCmd = `${candidate}.cmd`;
+        if (existsSync(candidateCmd))
+            return candidateCmd;
+        if (existsSync(candidate))
+            return candidate;
+        let parent = dirname(current);
+        if (parent === current)
+            return name;
+        current = parent;
+    }
+}
+// On Windows the resolved binary is a `.cmd` shim, which Node refuses to spawn
+// without a shell. Passing an args array together with `shell: true` is
+// deprecated (DEP0190), so build the quoted command line ourselves instead.
+const useShell = process.platform === "win32";
+function run(bin, args, input) {
+    return new Promise((done) => {
+        let child = useShell
+            ? spawn([bin, ...args].map((part) => `"${part}"`).join(" "), { shell: true, stdio: "pipe" })
+            : spawn(bin, args, { stdio: "pipe" });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        // Binary missing, or not executable — treat as "tool unavailable"
+        child.on("error", () => done({ ok: false, stdout, stderr }));
+        child.on("close", (code) => done({ ok: code === 0, stdout, stderr }));
+        if (input !== undefined) {
+            child.stdin.on("error", () => { });
+            child.stdin.end(input);
+        }
+    });
+}
+/**
+ * Format content in memory with oxfmt's stdin mode. `filePath` only tells oxfmt
+ * which parser to use, and does not have to exist yet.
+ * Returns the original content if oxfmt is unavailable or rejects the input.
+ */
+export async function formatContent(content, filePath) {
+    let { ok, stdout } = await run(findBin("oxfmt"), [`--stdin-filepath=${resolve(filePath)}`], content);
+    return ok ? stdout : content;
+}
+/** Format a file in place with oxfmt. Silently skips if oxfmt is unavailable. */
+export async function formatFile(filePath) {
+    await run(findBin("oxfmt"), ["--write", resolve(filePath)]);
+}
+/**
+ * Lint a file with oxlint, applying the fixes it can apply automatically.
+ * Returns the diagnostics oxlint could not fix, or an empty string when the
+ * file is clean (or oxlint is unavailable).
+ */
+export async function lintFile(filePath) {
+    let { ok, stdout, stderr } = await run(findBin("oxlint"), ["--fix", resolve(filePath)]);
+    return ok ? "" : `${stdout}${stderr}`.trim();
+}

package/lib/generateTypes.js

@@ -1,9 +1,9 @@
-import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import fs from "node:fs/promises";
 import { resolve } from "node:path";
 import vm from "node:vm";
 import { Client, DataObject, generateApiDataHandler, getDefaultClient, Procedure, setDefaultClient, } from "@olenbetong/appframe-data";
+import { formatFile, lintFile } from "./format.js";
 import { importJson } from "./importJson.js";
 import { createLogMessage, diagnoseServerResponse, wrapJsonError } from "./utils.js";
 // ─── Type generation logic ────────────────────────────────────────────────────
@@ -30,7 +30,7 @@ function getDataObjectTypes(af, parameterOverrides = {}) {
             let fieldName = propName.indexOf("-") > 0 ? `"${propName}"` : propName;
             result.push(`\t${fieldName}: ${type};`);
         }
-        result.push("};");
+        result.push("}");
         result.push("");
         globals.push(`${id}: DataObject<${typeName}>;`);
     }
@@ -118,22 +118,11 @@ function withTimeout(promise, ms, label) {
         new Promise((_, reject) => setTimeout(() => reject(new Error(`Timed out: ${label}`)), ms)),
     ]);
 }
-/** Run biome format on a file. Silently skips if biome is unavailable. */
-async function formatFile(filePath) {
-    await new Promise((resolve) => {
-        const child = spawn("pnpm", ["biome", "format", filePath, "--write"], {
-            shell: process.platform === "win32",
-            stdio: "pipe",
-        });
-        child.on("close", () => resolve());
-        child.on("error", () => resolve());
-    });
-}
 // ─── Core type generation ─────────────────────────────────────────────────────
 const TIMEOUT_MS = 30_000;
 const MAX_RETRIES = 3;
 const RETRY_DELAY_BASE_MS = 2_000;
-async function doGenerateTypes(hostname, username, password, appframe) {
+async function doGenerateTypes(hostname, username, password, appframe, logger) {
     const client = new Client(hostname);
     setDefaultClient(client);
     try {
@@ -225,12 +214,19 @@ async function doGenerateTypes(hostname, username, password, appframe) {
     }
     const outPath = resolve(process.cwd(), "./src/appframe.d.ts");
     await fs.writeFile(outPath, new Uint8Array(Buffer.from(types)));
-    await formatFile("./src/appframe.d.ts");
+    // Run the project's own oxc toolchain over the result so the generated file
+    // matches the formatting and lint rules the editor enforces on everything else.
+    await formatFile(outPath);
+    const diagnostics = await lintFile(outPath);
+    if (diagnostics) {
+        let message = "oxlint reported problems in src/appframe.d.ts:\n" + diagnostics;
+        logger.info(createLogMessage(message, { source: hostname, type: "warn" }));
+    }
 }
 export async function runGenerateTypes(hostname, username, password, appframe, logger) {
     for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
         try {
-            await doGenerateTypes(hostname, username, password, appframe);
+            await doGenerateTypes(hostname, username, password, appframe, logger);
             logger.info(createLogMessage("typescript types generated successfully", { source: hostname }));
             return;
         }

package/lib/index.d.ts

@@ -13,9 +13,11 @@ export interface AppframePluginOptions {
      */
     generateTypes?: boolean;
     /**
-     * Whether to enable the Appframe devtools panel and toolbar in dev mode.
-     * Set to `false` to skip serving the devtools app and injecting the toolbar
-     * script (e.g. when running Storybook).
+     * Whether to expose the DevTools JSON API at `/__appframe_devtools__/api` in dev
+     * mode. The Appframe DevTools browser extension (`packages/appframe-devtools`)
+     * uses it to edit `resources.yaml` and browse the data API catalog. Nothing is
+     * injected into the page. Set to `false` when there is no article context
+     * (e.g. when running Storybook).
      *
      * @default true
      */
@@ -31,3 +33,5 @@ export interface AppframePluginOptions {
 }
 export default function appframe(options?: AppframePluginOptions): Plugin[];
 export { addAppframeBuildConfig, appframeDataGlobal, createDevMiddleware, publishSafeOutput };
+export { DEVTOOLS_API_VERSION, type DevtoolsDiscovery, type DevtoolsServerInfo } from "./devtoolsServer.js";
+export type { JobOptions, ReleaseEvent, ReleaseScriptEvent, ReleaseSnapshot, ReleaseStep } from "./releaseServer.js";

package/lib/index.js

@@ -6,6 +6,7 @@ import { addAppframeBuildConfig } from "./build.js";
 import { generateFromConfig } from "./cli-resources-generate.js";
 import { createDevMiddleware, getLoginInfo, getProxyRoutes } from "./devServer.js";
 import { createDevtoolsMiddleware } from "./devtoolsServer.js";
+import { importJson } from "./importJson.js";
 import { runGenerateTypes } from "./generateTypes.js";
 import { getMuiXLicenseKey } from "./licenses.js";
 import { localizeMiddleware } from "./localization.js";
@@ -204,9 +205,23 @@ export default function appframe(options = {}) {
                     }
                 }, 300);
             });
-            // DevTools panel: serve the devtools app + REST API at /__appframe_devtools__/
+            // DevTools API for the browser extension at /__appframe_devtools__/api
             if (devtools) {
-                _server.middlewares.use("/__appframe_devtools__", createDevtoolsMiddleware(hostname));
+                let [pluginPkg, appPkg] = await Promise.all([
+                    importJson("../package.json"),
+                    importJson("./package.json", true),
+                ]);
+                _server.middlewares.use("/__appframe_devtools__", createDevtoolsMiddleware({
+                    hostname,
+                    articleId: String(appframe.article?.id ?? ""),
+                    articleHostname: appframe.article?.hostname ? String(appframe.article.hostname) : null,
+                    appName: String(appPkg.name ?? ""),
+                    appVersion: String(appPkg.version ?? ""),
+                    pluginVersion: String(pluginPkg.version ?? ""),
+                }, {
+                    appDir: process.cwd(),
+                    scripts: Object.fromEntries(Object.entries((appPkg.scripts ?? {})).filter((entry) => typeof entry[1] === "string")),
+                }));
             }
             _server.middlewares.use(`/api/user/localize/new/${appframe.article.id}`, jsonParser);
             _server.middlewares.use(`/api/user/localize/new/${appframe.article.id}`, localizeMiddleware);
@@ -224,22 +239,8 @@ export default function appframe(options = {}) {
                 _server.middlewares.use(createDevMiddleware(_server));
             };
         },
-        transformIndexHtml(_html, ctx) {
-            // Only inject the toolbar in dev mode
-            if (command !== "serve" || !devtools)
-                return;
-            // Only inject for article pages (not the devtools app itself)
-            if (ctx.originalUrl?.startsWith("/__appframe_devtools__"))
-                return;
-            return [
-                {
-                    tag: "script",
-                    attrs: { src: "/__appframe_devtools__/toolbar.js", defer: true },
-                    injectTo: "body",
-                },
-            ];
-        },
     };
     return [...(dataGlobal ? [appframeDataGlobal()] : []), plugin, publishSafeOutput()];
 }
 export { addAppframeBuildConfig, appframeDataGlobal, createDevMiddleware, publishSafeOutput };
+export { DEVTOOLS_API_VERSION } from "./devtoolsServer.js";

package/lib/releaseServer.d.ts

@@ -0,0 +1,146 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export type ReleaseStepStatus = "pending" | "running" | "done" | "failed" | "skipped";
+export interface ReleaseStep {
+    id: string;
+    label: string;
+    status: ReleaseStepStatus;
+    message?: string;
+}
+export interface ReleaseTransaction {
+    Name: string;
+    Namespace: string;
+    CreatedBy: string;
+    Status: number;
+    LastError: string | null;
+}
+/** Events the release script emits (see `scripts/lib/releaseUi.ts`). */
+export type ReleaseScriptEvent = {
+    type: "steps";
+    steps: Array<{
+        id: string;
+        label: string;
+    }>;
+} | {
+    type: "step";
+    id: string;
+    status: ReleaseStepStatus;
+    message?: string;
+} | {
+    type: "notes";
+    draft: string;
+    existing: string | null;
+    hasCommitReleaseNotes: boolean;
+} | {
+    type: "version";
+    current: string;
+    next: Record<string, string>;
+} | {
+    type: "input";
+    name: string;
+} | {
+    type: "apply-review";
+    namespace: string;
+    server: string;
+    transactions: ReleaseTransaction[];
+} | {
+    type: "result";
+    tag: string;
+    version: string;
+    releaseUrl: string | null;
+} | {
+    type: "error";
+    message: string;
+};
+/** What the panel receives: script events plus the process' own output and exit. */
+export type ReleaseEvent = ReleaseScriptEvent | {
+    type: "log";
+    line: string;
+} | {
+    type: "exit";
+    code: number | null;
+};
+export type JobOptions = {
+    kind: "release";
+    dry: boolean;
+    force: boolean;
+} | {
+    kind: "deploy";
+    target: string;
+    copyDatasources: boolean;
+};
+export interface ReleaseSnapshot {
+    id: number;
+    kind: JobOptions["kind"];
+    status: "running" | "done" | "failed" | "cancelled";
+    options: JobOptions;
+    steps: ReleaseStep[];
+    notes: {
+        draft: string;
+        existing: string | null;
+        hasCommitReleaseNotes: boolean;
+    } | null;
+    version: {
+        current: string;
+        next: Record<string, string>;
+    } | null;
+    /** Inputs the script has asked for and not received yet. */
+    awaiting: string[];
+    review: {
+        namespace: string;
+        server: string;
+        transactions: ReleaseTransaction[];
+    } | null;
+    result: {
+        tag: string;
+        version: string;
+        releaseUrl: string | null;
+    } | null;
+    error: string | null;
+    log: string[];
+    startedAt: string;
+    finishedAt: string | null;
+}
+export interface ReleaseServerOptions {
+    /** Directory of the app, where the scripts run. */
+    appDir: string;
+    /** The app's package.json `scripts`. */
+    scripts: Record<string, string>;
+}
+/** Servers a deploy can target; `APPFRAME_DEPLOY_HOSTNAME` is validated against this list. */
+export declare const DEPLOY_TARGETS: readonly ["dev.obet.no", "stage.obet.no", "test.obet.no"];
+/** Marks an event line on the script's stdout (see `scripts/lib/releaseUi.ts`). */
+export declare const EVENT_PREFIX = "@@appframe-devtools ";
+/** Returns the event on an stdout line, or `null` for ordinary output. */
+export declare function parseReleaseEventLine(line: string): ReleaseScriptEvent | null;
+/** Applies one event to the snapshot (mutating), the same way the panel does. */
+export declare function applyReleaseEvent(snapshot: ReleaseSnapshot, event: ReleaseEvent): void;
+type Listener = (event: ReleaseEvent) => void;
+export declare function createReleaseManager(options: ReleaseServerOptions): {
+    readonly snapshot: ReleaseSnapshot | null;
+    /** What the panel can offer, derived from the app's scripts. */
+    capabilities: {
+        release: boolean;
+        deploy: boolean;
+        copyDatasources: boolean;
+        targets: ("dev.obet.no" | "stage.obet.no" | "test.obet.no")[];
+    };
+    script: string;
+    start: (jobOptions: JobOptions) => ReleaseSnapshot;
+    sendInput: (name: string, value: unknown) => void;
+    cancel: () => void;
+    subscribe(listener: Listener): () => void;
+};
+export type ReleaseManager = ReturnType<typeof createReleaseManager>;
+/**
+ * Routes under `/__appframe_devtools__/api/release`:
+ * - `GET    /release`         — current session snapshot (`session: null` when none) and the capabilities
+ * - `POST   /release`         — start a job: `{ kind: "release", dry?, force? }` or
+ *                               `{ kind: "deploy", target, copyDatasources? }`; 409 while one is running
+ * - `DELETE /release`         — cancel the running job
+ * - `POST   /release/input`   — answer a release script question (`{ name, value }`)
+ * - `GET    /release/events`  — server-sent events: a `snapshot` message, then one `event` message per event
+ */
+export declare function handleReleaseApi(req: IncomingMessage & {
+    body?: unknown;
+}, res: ServerResponse, subPath: string, manager: ReleaseManager): Promise<boolean>;
+export {};

package/lib/releaseServer.js

@@ -0,0 +1,384 @@
+/**
+ * Runs the app's release and deploy scripts for the Appframe DevTools extension.
+ *
+ * Two kinds of job share one session slot, one snapshot shape and one event stream:
+ *
+ * - `release` spawns `scripts.release` with `--ui`, which makes it report its steps as JSON
+ *   events (stdout lines starting with `EVENT_PREFIX`) and read its answers (release type,
+ *   notes, apply confirmation) as JSON lines from stdin instead of prompting. Every other
+ *   stdout/stderr line is log output.
+ * - `deploy` runs `scripts.build`, optionally `scripts.cd` (copy data sources), then
+ *   `scripts.deploy` as consecutive steps, with `APPFRAME_DEPLOY_HOSTNAME` set to the chosen
+ *   target so the deploy and copy scripts use it instead of the hostname in package.json.
+ *
+ * The snapshot lets a panel opened mid-job catch up; events are streamed over server-sent
+ * events.
+ */
+import { spawn } from "node:child_process";
+import readline from "node:readline";
+/** Servers a deploy can target; `APPFRAME_DEPLOY_HOSTNAME` is validated against this list. */
+export const DEPLOY_TARGETS = ["dev.obet.no", "stage.obet.no", "test.obet.no"];
+const LOG_LIMIT = 2000;
+/** Marks an event line on the script's stdout (see `scripts/lib/releaseUi.ts`). */
+export const EVENT_PREFIX = "@@appframe-devtools ";
+/** Returns the event on an stdout line, or `null` for ordinary output. */
+export function parseReleaseEventLine(line) {
+    let trimmed = line.trimStart();
+    if (!trimmed.startsWith(EVENT_PREFIX))
+        return null;
+    try {
+        let parsed = JSON.parse(trimmed.slice(EVENT_PREFIX.length));
+        return parsed && typeof parsed.type === "string" ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Applies one event to the snapshot (mutating), the same way the panel does. */
+export function applyReleaseEvent(snapshot, event) {
+    switch (event.type) {
+        case "steps":
+            snapshot.steps = event.steps.map((s) => ({ ...s, status: "pending" }));
+            break;
+        case "step": {
+            let step = snapshot.steps.find((s) => s.id === event.id);
+            if (step) {
+                step.status = event.status;
+                step.message = event.message;
+            }
+            else {
+                snapshot.steps.push({ id: event.id, label: event.id, status: event.status, message: event.message });
+            }
+            break;
+        }
+        case "notes":
+            snapshot.notes = {
+                draft: event.draft,
+                existing: event.existing,
+                hasCommitReleaseNotes: event.hasCommitReleaseNotes,
+            };
+            break;
+        case "version":
+            snapshot.version = { current: event.current, next: event.next };
+            break;
+        case "input":
+            if (!snapshot.awaiting.includes(event.name))
+                snapshot.awaiting.push(event.name);
+            break;
+        case "apply-review":
+            snapshot.review = { namespace: event.namespace, server: event.server, transactions: event.transactions };
+            break;
+        case "result":
+            snapshot.result = { tag: event.tag, version: event.version, releaseUrl: event.releaseUrl };
+            break;
+        case "error":
+            snapshot.error = event.message;
+            break;
+        case "log":
+            snapshot.log.push(event.line);
+            if (snapshot.log.length > LOG_LIMIT)
+                snapshot.log.splice(0, snapshot.log.length - LOG_LIMIT);
+            break;
+        case "exit":
+            snapshot.finishedAt = new Date().toISOString();
+            if (snapshot.status === "running") {
+                snapshot.status = event.code === 0 ? "done" : "failed";
+                if (event.code !== 0 && !snapshot.error) {
+                    snapshot.error = `The script exited with code ${event.code}`;
+                }
+                // Whatever was still running did not finish.
+                for (let step of snapshot.steps) {
+                    if (step.status === "running")
+                        step.status = event.code === 0 ? "done" : "failed";
+                }
+            }
+            break;
+    }
+}
+function httpError(message, status) {
+    return Object.assign(new Error(message), { status });
+}
+/**
+ * Kills the script and everything it started. The scripts run through a shell, so
+ * `child.kill()` alone would only end the shell and leave `vite build` or the release
+ * script running (and the session's pipes open) until they finish on their own.
+ */
+function killTree(child) {
+    if (!child.pid)
+        return;
+    if (process.platform === "win32") {
+        spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" }).on("error", () => child.kill());
+    }
+    else {
+        try {
+            // The child is spawned detached, so its pid is also its process group id.
+            process.kill(-child.pid, "SIGTERM");
+        }
+        catch {
+            child.kill("SIGTERM");
+        }
+    }
+}
+export function createReleaseManager(options) {
+    let nextId = 1;
+    let current = null;
+    let listeners = new Set();
+    let scripts = options.scripts;
+    let copyScript = scripts.cd ?? scripts["copy-datasources"] ?? null;
+    function broadcast(event) {
+        if (current)
+            applyReleaseEvent(current.snapshot, event);
+        for (let listener of listeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // A dead SSE connection; it is removed on close.
+            }
+        }
+    }
+    function readLines(stream, onLine) {
+        if (!stream)
+            return;
+        readline.createInterface({ input: stream, terminal: false }).on("line", onLine);
+    }
+    function spawnScript(command, env) {
+        return spawn(command, {
+            cwd: options.appDir,
+            shell: true,
+            stdio: ["pipe", "pipe", "pipe"],
+            // Own process group on POSIX so `killTree` can end the whole tree.
+            detached: process.platform !== "win32",
+            env: { ...process.env, FORCE_COLOR: "0", CI: "true", ...env },
+        });
+    }
+    function newSnapshot(jobOptions) {
+        return {
+            id: nextId++,
+            kind: jobOptions.kind,
+            status: "running",
+            options: jobOptions,
+            steps: [],
+            notes: null,
+            version: null,
+            awaiting: [],
+            review: null,
+            result: null,
+            error: null,
+            log: [],
+            startedAt: new Date().toISOString(),
+            finishedAt: null,
+        };
+    }
+    function startRelease(jobOptions) {
+        if (!scripts.release)
+            throw httpError("This app has no `release` script in package.json", 400);
+        let args = ["--ui"];
+        if (jobOptions.dry)
+            args.push("--dry");
+        if (jobOptions.force)
+            args.push("--force");
+        let snapshot = newSnapshot(jobOptions);
+        let child = spawnScript(`${scripts.release} ${args.join(" ")}`, {});
+        current = { snapshot, child };
+        readLines(child.stdout, (line) => {
+            let event = parseReleaseEventLine(line);
+            broadcast(event ?? { type: "log", line });
+        });
+        readLines(child.stderr, (line) => broadcast({ type: "log", line }));
+        child.on("error", (err) => {
+            broadcast({ type: "error", message: `Could not start the release script: ${err.message}` });
+        });
+        child.on("close", (code) => {
+            if (current?.child === child)
+                current.child = null;
+            broadcast({ type: "exit", code });
+        });
+        return snapshot;
+    }
+    function startDeploy(jobOptions) {
+        if (!scripts.build || !scripts.deploy) {
+            throw httpError("This app needs `build` and `deploy` scripts in package.json", 400);
+        }
+        if (!DEPLOY_TARGETS.includes(jobOptions.target)) {
+            throw httpError(`Unknown deploy target ${jobOptions.target}`, 400);
+        }
+        if (jobOptions.copyDatasources && !copyScript) {
+            throw httpError("This app has no `cd` or `copy-datasources` script in package.json", 400);
+        }
+        let plan = [
+            { id: "build", label: "Build (pnpm run build)", command: "pnpm run build" },
+        ];
+        if (jobOptions.copyDatasources) {
+            plan.push({
+                id: "copy-datasources",
+                label: `Copy data sources from dev to ${jobOptions.target}`,
+                command: scripts.cd ? "pnpm run cd" : "pnpm run copy-datasources",
+            });
+        }
+        plan.push({ id: "deploy", label: `Deploy to ${jobOptions.target}`, command: "pnpm run deploy" });
+        let snapshot = newSnapshot(jobOptions);
+        let session = { snapshot, child: null };
+        current = session;
+        broadcast({ type: "steps", steps: plan.map(({ id, label }) => ({ id, label })) });
+        let env = { APPFRAME_DEPLOY_HOSTNAME: jobOptions.target };
+        let runStep = (step) => new Promise((resolve) => {
+            broadcast({ type: "step", id: step.id, status: "running" });
+            broadcast({ type: "log", line: `$ ${step.command}` });
+            let child = spawnScript(step.command, env);
+            session.child = child;
+            readLines(child.stdout, (line) => broadcast({ type: "log", line }));
+            readLines(child.stderr, (line) => broadcast({ type: "log", line }));
+            child.on("error", (err) => {
+                broadcast({ type: "step", id: step.id, status: "failed", message: err.message });
+                resolve(1);
+            });
+            child.on("close", (code) => {
+                session.child = null;
+                if (snapshot.status !== "running") {
+                    broadcast({ type: "step", id: step.id, status: "failed", message: "cancelled" });
+                }
+                else if (code === 0) {
+                    broadcast({ type: "step", id: step.id, status: "done" });
+                }
+                else {
+                    broadcast({ type: "step", id: step.id, status: "failed", message: `exit code ${code}` });
+                }
+                resolve(code);
+            });
+        });
+        (async () => {
+            let code = 0;
+            for (let step of plan) {
+                code = await runStep(step);
+                if (code !== 0 || snapshot.status !== "running")
+                    break;
+            }
+            broadcast({ type: "exit", code });
+        })();
+        return snapshot;
+    }
+    function start(jobOptions) {
+        if (current?.snapshot.status === "running") {
+            throw httpError("A release or deploy is already running", 409);
+        }
+        return jobOptions.kind === "deploy" ? startDeploy(jobOptions) : startRelease(jobOptions);
+    }
+    function sendInput(name, value) {
+        if (!current?.child?.stdin || current.snapshot.status !== "running" || current.snapshot.kind !== "release") {
+            throw httpError("No release is waiting for input", 409);
+        }
+        current.child.stdin.write(`${JSON.stringify({ name, value })}\n`);
+        current.snapshot.awaiting = current.snapshot.awaiting.filter((n) => n !== name);
+    }
+    function cancel() {
+        if (!current || current.snapshot.status !== "running")
+            return;
+        current.snapshot.status = "cancelled";
+        current.snapshot.error = "Cancelled from the DevTools panel";
+        if (current.child)
+            killTree(current.child);
+    }
+    return {
+        get snapshot() {
+            return current?.snapshot ?? null;
+        },
+        /** What the panel can offer, derived from the app's scripts. */
+        capabilities: {
+            release: Boolean(scripts.release),
+            deploy: Boolean(scripts.build && scripts.deploy),
+            copyDatasources: Boolean(copyScript),
+            targets: [...DEPLOY_TARGETS],
+        },
+        script: scripts.release ?? null,
+        start,
+        sendInput,
+        cancel,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}
+function sendJson(res, status, data) {
+    res.statusCode = status;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.end(JSON.stringify(data));
+}
+function parseJobOptions(body) {
+    let b = (body ?? {});
+    if (b.kind === "deploy") {
+        return { kind: "deploy", target: String(b.target ?? ""), copyDatasources: b.copyDatasources === true };
+    }
+    return { kind: "release", dry: b.dry === true, force: b.force === true };
+}
+/**
+ * Routes under `/__appframe_devtools__/api/release`:
+ * - `GET    /release`         — current session snapshot (`session: null` when none) and the capabilities
+ * - `POST   /release`         — start a job: `{ kind: "release", dry?, force? }` or
+ *                               `{ kind: "deploy", target, copyDatasources? }`; 409 while one is running
+ * - `DELETE /release`         — cancel the running job
+ * - `POST   /release/input`   — answer a release script question (`{ name, value }`)
+ * - `GET    /release/events`  — server-sent events: a `snapshot` message, then one `event` message per event
+ */
+export async function handleReleaseApi(req, res, subPath, manager) {
+    let method = req.method?.toUpperCase() ?? "GET";
+    if (subPath === "" && method === "GET") {
+        sendJson(res, 200, {
+            available: manager.capabilities.release,
+            capabilities: manager.capabilities,
+            script: manager.script,
+            session: manager.snapshot,
+        });
+        return true;
+    }
+    if (subPath === "" && method === "POST") {
+        try {
+            let snapshot = manager.start(parseJobOptions(req.body));
+            sendJson(res, 200, { session: snapshot });
+        }
+        catch (error) {
+            let status = error.status ?? 500;
+            sendJson(res, status, { error: error.message });
+        }
+        return true;
+    }
+    if (subPath === "" && method === "DELETE") {
+        manager.cancel();
+        sendJson(res, 200, { session: manager.snapshot });
+        return true;
+    }
+    if (subPath === "/input" && method === "POST") {
+        let body = (req.body ?? {});
+        if (typeof body.name !== "string") {
+            sendJson(res, 400, { error: "`name` is required" });
+            return true;
+        }
+        try {
+            manager.sendInput(body.name, body.value);
+            sendJson(res, 200, { session: manager.snapshot });
+        }
+        catch (error) {
+            let status = error.status ?? 500;
+            sendJson(res, status, { error: error.message });
+        }
+        return true;
+    }
+    if (subPath === "/events" && method === "GET") {
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "text/event-stream");
+        res.setHeader("Cache-Control", "no-cache");
+        res.setHeader("Connection", "keep-alive");
+        res.flushHeaders?.();
+        let write = (data) => res.write(`data: ${JSON.stringify(data)}\n\n`);
+        write({ kind: "snapshot", snapshot: manager.snapshot });
+        let unsubscribe = manager.subscribe((event) => write({ kind: "event", event }));
+        let keepAlive = setInterval(() => res.write(": keep-alive\n\n"), 20_000);
+        req.on("close", () => {
+            clearInterval(keepAlive);
+            unsubscribe();
+        });
+        return true;
+    }
+    return false;
+}

package/lib/releaseServer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/releaseServer.test.js

@@ -0,0 +1,83 @@
+import { describe, expect, it } from "vitest";
+import { applyReleaseEvent, EVENT_PREFIX, parseReleaseEventLine } from "./releaseServer.js";
+function snapshot() {
+    return {
+        id: 1,
+        kind: "release",
+        status: "running",
+        options: { kind: "release", dry: false, force: false },
+        steps: [],
+        notes: null,
+        version: null,
+        awaiting: [],
+        review: null,
+        result: null,
+        error: null,
+        log: [],
+        startedAt: "2026-09-03T00:00:00.000Z",
+        finishedAt: null,
+    };
+}
+describe("parseReleaseEventLine", () => {
+    it("parses prefixed JSON objects with a type", () => {
+        expect(parseReleaseEventLine(`${EVENT_PREFIX}{"type":"input","name":"release"}`)).toEqual({
+            type: "input",
+            name: "release",
+        });
+    });
+    it("ignores other lines", () => {
+        expect(parseReleaseEventLine("Running type checks...")).toBeNull();
+        expect(parseReleaseEventLine('{"type":"input","name":"release"}')).toBeNull();
+        expect(parseReleaseEventLine(`${EVENT_PREFIX}{"foo":1}`)).toBeNull();
+        expect(parseReleaseEventLine(`${EVENT_PREFIX}{not json`)).toBeNull();
+    });
+});
+describe("applyReleaseEvent", () => {
+    it("tracks step statuses from the announced list", () => {
+        let s = snapshot();
+        applyReleaseEvent(s, {
+            type: "steps",
+            steps: [
+                { id: "a", label: "A" },
+                { id: "b", label: "B" },
+            ],
+        });
+        applyReleaseEvent(s, { type: "step", id: "a", status: "running" });
+        applyReleaseEvent(s, { type: "step", id: "a", status: "done" });
+        applyReleaseEvent(s, { type: "step", id: "b", status: "failed", message: "boom" });
+        expect(s.steps).toEqual([
+            { id: "a", label: "A", status: "done", message: undefined },
+            { id: "b", label: "B", status: "failed", message: "boom" },
+        ]);
+    });
+    it("records inputs asked for, notes, version and review", () => {
+        let s = snapshot();
+        applyReleaseEvent(s, { type: "notes", draft: "## x", existing: null, hasCommitReleaseNotes: true });
+        applyReleaseEvent(s, { type: "version", current: "1.0.0", next: { patch: "1.0.1" } });
+        applyReleaseEvent(s, { type: "input", name: "release" });
+        applyReleaseEvent(s, { type: "input", name: "release" });
+        expect(s.notes?.draft).toBe("## x");
+        expect(s.version?.next.patch).toBe("1.0.1");
+        expect(s.awaiting).toEqual(["release"]);
+    });
+    it("marks a failed exit and finishes running steps", () => {
+        let s = snapshot();
+        applyReleaseEvent(s, { type: "steps", steps: [{ id: "build", label: "Build" }] });
+        applyReleaseEvent(s, { type: "step", id: "build", status: "running" });
+        applyReleaseEvent(s, { type: "exit", code: 1 });
+        expect(s.status).toBe("failed");
+        expect(s.steps[0].status).toBe("failed");
+        expect(s.error).toMatch(/exited with code 1/);
+        expect(s.finishedAt).not.toBeNull();
+    });
+    it("keeps a cancelled status on exit and caps the log", () => {
+        let s = snapshot();
+        s.status = "cancelled";
+        for (let i = 0; i < 2105; i++)
+            applyReleaseEvent(s, { type: "log", line: `l${i}` });
+        applyReleaseEvent(s, { type: "exit", code: null });
+        expect(s.status).toBe("cancelled");
+        expect(s.log.length).toBe(2000);
+        expect(s.log[0]).toBe("l105");
+    });
+});

package/lib/resourceGenerate.d.ts

@@ -1,10 +1,4 @@
 import type { Client } from "@olenbetong/appframe-data";
-/**
- * Format a file with Biome if available. Searches for `biome` in the nearest
- * node_modules/.bin up from cwd, then falls back to the global PATH.
- * Silently skips if Biome is not found or formatting fails.
- */
-export declare function formatWithBiome(filePath: string): Promise<void>;
 /**
  * Write a generated file only when the content changed.
  * Formats the content before comparing so that an already-formatted file
@@ -13,6 +7,8 @@ export declare function formatWithBiome(filePath: string): Promise<void>;
  */
 export declare function writeGeneratedFile(filePath: string, content: string): Promise<boolean>;
 export type CLIOptions = {
+    /** Procedures only. `false` stops the framework wrapping the call in a transaction. */
+    transaction?: boolean;
     server: string;
     types?: boolean;
     global: boolean;

package/lib/resourceGenerate.js

@@ -1,68 +1,8 @@
-import { exec, spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join, relative, resolve, sep } from "node:path";
-import { promisify } from "node:util";
+import { dirname, relative, resolve, sep } from "node:path";
+import { formatContent } from "./format.js";
 import { importJson } from "./importJson.js";
-const execAsync = promisify(exec);
-// ---------------------------------------------------------------------------
-// Biome formatting
-// ---------------------------------------------------------------------------
-function findBiomeBin() {
-    let current = resolve(process.cwd());
-    while (true) {
-        let candidate = join(current, "node_modules", ".bin", "biome");
-        let candidateCmd = `${candidate}.cmd`;
-        if (existsSync(candidateCmd))
-            return candidateCmd;
-        if (existsSync(candidate))
-            return candidate;
-        let parent = dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    return null;
-}
-/**
- * Format a file with Biome if available. Searches for `biome` in the nearest
- * node_modules/.bin up from cwd, then falls back to the global PATH.
- * Silently skips if Biome is not found or formatting fails.
- */
-export async function formatWithBiome(filePath) {
-    let bin = findBiomeBin() ?? "biome";
-    try {
-        await execAsync(`"${bin}" format --write "${resolve(filePath)}"`);
-    }
-    catch {
-        // Biome not available or not applicable — silently skip
-    }
-}
-/**
- * Format content in memory using Biome's stdin mode.
- * Returns the formatted content, or the original if Biome is unavailable.
- */
-async function formatContentWithBiome(content, filePath) {
-    let bin = findBiomeBin() ?? "biome";
-    return new Promise((resolve) => {
-        let child = spawn(bin, ["format", `--stdin-file-path=${filePath}`], { stdio: "pipe" });
-        let stdout = "";
-        let failed = false;
-        child.stdout.on("data", (chunk) => {
-            stdout += chunk.toString();
-        });
-        child.on("error", () => {
-            failed = true;
-            resolve(content);
-        });
-        child.on("close", (code) => {
-            if (!failed)
-                resolve(code === 0 ? stdout : content);
-        });
-        child.stdin.write(content);
-        child.stdin.end();
-    });
-}
 /**
  * Write a generated file only when the content changed.
  * Formats the content before comparing so that an already-formatted file
@@ -71,7 +11,7 @@ async function formatContentWithBiome(content, filePath) {
  */
 export async function writeGeneratedFile(filePath, content) {
     await mkdir(dirname(filePath), { recursive: true });
-    let formatted = await formatContentWithBiome(content, filePath);
+    let formatted = await formatContent(content, filePath);
     if (existsSync(filePath)) {
         let existing = await readFile(filePath, "utf-8");
         if (existing === formatted) {
@@ -365,7 +305,7 @@ export function getProcedureDefinition(name, procDefinition, options) {
     output.push(`export const ${procName} = new ${options.global ? "af." : ""}ProcedureAPI${options.types ? `<${paramTypeName}, ${options.typesJsonReturnType ?? "{ Table?: unknown[] }"}>` : ""}({
   procedureId: "${name}",
   parameters: ${JSON.stringify(parameters, null, 2)},
-  timeout: 30000
+  timeout: 30000${options.transaction === false ? ",\n  transaction: false" : ""}
 });`);
     if (options.expose) {
         output.push("");

package/lib/resourcesConfig.d.ts

@@ -30,6 +30,13 @@ export type ResourceEntry = {
     global?: boolean;
     /** Emit TypeScript type definitions */
     types?: boolean;
+    /**
+     * Procedures only. `false` stops the framework wrapping the call in a transaction.
+     *
+     * Needed by a procedure that writes across a linked server: the wrapping transaction makes the
+     * remote write a distributed one, which fails without MSDTC configured between the servers.
+     */
+    transaction?: boolean;
     /** Permissions to set: I = insert, U = update, D = delete (e.g. `IUD`) */
     permissions?: string;
     /** Maximum records to fetch (default `50`; use `-1` for all) */

package/lib/resourcesConfig.js

@@ -97,6 +97,7 @@ export function entryToCLIOptions(entry, hostname) {
         global: entry.global ?? false,
         dynamic: entry.dynamic ?? false,
         types: entry.types,
+        transaction: entry.transaction,
         maxRecords: entry.maxRecords !== undefined ? String(entry.maxRecords) : "50",
         sortOrder: sortOrderToString(entry.sortOrder),
         permissions: entry.permissions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olenbetong/appframe-vite",
-  "version": "6.7.0",
+  "version": "6.8.0",
   "description": "Tools to use and deploy Vite applications to Appframe",
   "main": "./lib/index.js",
   "type": "module",
@@ -35,19 +35,18 @@
     "commander": "15.0.0",
     "dotenv": "^17.4.2",
     "fuzzy": "^0.1.3",
-    "inquirer": "^14.0.2",
+    "inquirer": "^14.2.0",
     "inquirer-autocomplete-standalone": "^0.8.1",
     "jsdom": "30.0.1",
-    "rollup-plugin-visualizer": "^7.0.1",
+    "rollup-plugin-visualizer": "^7.1.1",
     "yaml": "^2.9.0",
-    "@olenbetong/appframe-data": "1.6.1",
-    "@olenbetong/appframe-devtools": "0.3.0"
+    "@olenbetong/appframe-data": "1.7.0"
   },
   "devDependencies": {
     "@types/jsdom": "^27.0.0",
-    "@types/node": "26.2.0",
+    "@types/node": "26.4.0",
     "typescript": "7.0.2",
-    "vite": "8.2.1"
+    "vite": "8.2.2"
   },
   "peerDependencies": {
     "vite": ">=8.1.5"