@galaxy-tool-util/gxwf-web 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 John Chilton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/app.d.ts

@@ -0,0 +1,27 @@
+/**
+ * HTTP server factory for gxwf-web.
+ *
+ * Creates a Node.js http.Server wired to the contents/workflow request handler.
+ * Returns a `ready` promise that resolves once the ToolCache is loaded and
+ * initial workflow discovery completes — callers may await it before serving
+ * traffic but the server is safe to bind before that.
+ */
+import { type Server } from "node:http";
+import { type ToolSource } from "@galaxy-tool-util/core";
+import { type AppState } from "./router.js";
+export type { AppState };
+export interface CreateAppOptions {
+    cacheDir?: string;
+    /** Tool sources to fetch from when a tool is not in cache. */
+    sources?: ToolSource[];
+    /** Absolute path to a built gxwf-ui dist directory. When set, the server
+     *  serves the frontend at the root and falls back to index.html for SPA routing. */
+    uiDir?: string;
+}
+/** Create a configured gxwf-web HTTP server for the given workflow directory. */
+export declare function createApp(directory: string, opts?: CreateAppOptions): {
+    server: Server;
+    state: AppState;
+    ready: Promise<void>;
+};
+//# sourceMappingURL=app.d.ts.map

package/dist/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AACtD,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAC1E,OAAO,EAAwB,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGlE,YAAY,EAAE,QAAQ,EAAE,CAAC;AAEzB,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8DAA8D;IAC9D,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;IACvB;wFACoF;IACpF,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,iFAAiF;AACjF,wBAAgB,SAAS,CACvB,SAAS,EAAE,MAAM,EACjB,IAAI,GAAE,gBAAqB,GAC1B;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CA0B3D"}

package/dist/app.js

@@ -0,0 +1,37 @@
+/**
+ * HTTP server factory for gxwf-web.
+ *
+ * Creates a Node.js http.Server wired to the contents/workflow request handler.
+ * Returns a `ready` promise that resolves once the ToolCache is loaded and
+ * initial workflow discovery completes — callers may await it before serving
+ * traffic but the server is safe to bind before that.
+ */
+import { createServer } from "node:http";
+import { ToolInfoService } from "@galaxy-tool-util/core";
+import { createRequestHandler } from "./router.js";
+import { discoverWorkflows } from "./workflows.js";
+/** Create a configured gxwf-web HTTP server for the given workflow directory. */
+export function createApp(directory, opts = {}) {
+    const service = new ToolInfoService({
+        cacheDir: opts.cacheDir,
+        sources: opts.sources,
+    });
+    const cache = service.cache;
+    const state = {
+        directory,
+        cache,
+        workflows: { directory, workflows: [] },
+        cacheDir: opts.cacheDir,
+        uiDir: opts.uiDir,
+    };
+    const handler = createRequestHandler(state);
+    const server = createServer((req, res) => {
+        void handler(req, res);
+    });
+    const ready = (async () => {
+        await cache.index.load();
+        state.workflows = discoverWorkflows(directory);
+    })();
+    return { server, state, ready };
+}
+//# sourceMappingURL=app.js.map

package/dist/app.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.js","sourceRoot":"","sources":["../src/app.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,YAAY,EAAe,MAAM,WAAW,CAAC;AACtD,OAAO,EAAE,eAAe,EAAmB,MAAM,wBAAwB,CAAC;AAC1E,OAAO,EAAE,oBAAoB,EAAiB,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAanD,iFAAiF;AACjF,MAAM,UAAU,SAAS,CACvB,SAAiB,EACjB,OAAyB,EAAE;IAE3B,MAAM,OAAO,GAAG,IAAI,eAAe,CAAC;QAClC,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,OAAO,EAAE,IAAI,CAAC,OAAO;KACtB,CAAC,CAAC;IACH,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;IAE5B,MAAM,KAAK,GAAa;QACtB,SAAS;QACT,KAAK;QACL,SAAS,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,EAAE;QACvC,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,KAAK,EAAE,IAAI,CAAC,KAAK;KAClB,CAAC;IAEF,MAAM,OAAO,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC;IAC5C,MAAM,MAAM,GAAG,YAAY,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;QACvC,KAAK,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IACzB,CAAC,CAAC,CAAC;IAEH,MAAM,KAAK,GAAG,CAAC,KAAK,IAAI,EAAE;QACxB,MAAM,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;QACzB,KAAK,CAAC,SAAS,GAAG,iBAAiB,CAAC,SAAS,CAAC,CAAC;IACjD,CAAC,CAAC,EAAE,CAAC;IAEL,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;AAClC,CAAC"}

package/dist/bin/gxwf-web.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=gxwf-web.d.ts.map

package/dist/bin/gxwf-web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gxwf-web.d.ts","sourceRoot":"","sources":["../../src/bin/gxwf-web.ts"],"names":[],"mappings":""}

package/dist/bin/gxwf-web.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from "node:fs";
+import { loadWorkflowToolConfig, toolInfoOptionsFromConfig, } from "@galaxy-tool-util/core";
+import { createApp } from "../app.js";
+const args = process.argv.slice(2);
+let directory = null;
+let host = "127.0.0.1";
+let port = 8000;
+let cacheDir;
+let configPath;
+let outputSchema = false;
+for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--host" && args[i + 1]) {
+        host = args[++i];
+    }
+    else if (args[i] === "--port" && args[i + 1]) {
+        port = parseInt(args[++i], 10);
+    }
+    else if (args[i] === "--cache-dir" && args[i + 1]) {
+        cacheDir = args[++i];
+    }
+    else if (args[i] === "--config" && args[i + 1]) {
+        configPath = args[++i];
+    }
+    else if (args[i] === "--output-schema") {
+        outputSchema = true;
+    }
+    else if (!args[i].startsWith("--")) {
+        directory = args[i];
+    }
+}
+if (outputSchema) {
+    // openapi.json lives at <package-root>/openapi.json — two levels above dist/bin/
+    const specPath = new URL("../../openapi.json", import.meta.url);
+    // Write through the stream and exit in the drain callback so large specs
+    // (which exceed typical OS pipe buffers) aren't truncated by process.exit.
+    process.stdout.write(readFileSync(specPath), () => process.exit(0));
+}
+else if (!directory) {
+    console.error("Usage: gxwf-web <directory> [--host 127.0.0.1] [--port 8000] [--cache-dir <path>] [--config <path>] [--output-schema]");
+    process.exit(1);
+}
+else if (!existsSync(directory)) {
+    console.error(`Directory does not exist: ${directory}`);
+    process.exit(1);
+}
+else {
+    main().catch((err) => {
+        console.error("Failed to start server:", err);
+        process.exit(1);
+    });
+}
+async function main() {
+    let sources;
+    if (configPath) {
+        if (!existsSync(configPath)) {
+            console.error(`Config file not found: ${configPath}`);
+            process.exit(1);
+        }
+        const config = await loadWorkflowToolConfig(configPath);
+        const toolOpts = toolInfoOptionsFromConfig(config);
+        sources = toolOpts.sources;
+        // --cache-dir CLI flag takes precedence over config file
+        cacheDir ??= toolOpts.cacheDir;
+    }
+    // Resolve UI dist: GXWF_UI_DIST env var overrides the bundled copy.
+    // Bundled copy is copied from gxwf-ui during build → public/;
+    // two levels up from dist/bin/ lands at the package root.
+    const uiDirFromEnv = process.env.GXWF_UI_DIST;
+    if (uiDirFromEnv && !existsSync(uiDirFromEnv)) {
+        console.error(`GXWF_UI_DIST points to non-existent path: ${uiDirFromEnv}`);
+        process.exit(1);
+    }
+    const uiDirCandidate = new URL("../../public", import.meta.url).pathname;
+    const uiDir = uiDirFromEnv ?? (existsSync(uiDirCandidate) ? uiDirCandidate : undefined);
+    const { server, ready } = createApp(directory, { cacheDir, sources, uiDir });
+    server.listen(port, host, () => {
+        console.log(`gxwf-web listening on ${host}:${port}`);
+        console.log(`Serving workflows from: ${directory}`);
+        if (uiDir) {
+            console.log(`UI: http://${host}:${port}/`);
+        }
+        else {
+            console.log("UI: not available (run pnpm build to bundle the frontend)");
+        }
+        if (configPath)
+            console.log(`Config: ${configPath}`);
+    });
+    void ready.then(() => {
+        console.log("Tool cache loaded, workflows discovered.");
+    });
+}
+//# sourceMappingURL=gxwf-web.js.map

package/dist/bin/gxwf-web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gxwf-web.js","sourceRoot":"","sources":["../../src/bin/gxwf-web.ts"],"names":[],"mappings":"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"}

package/dist/contents.d.ts

@@ -0,0 +1,29 @@
+/**
+ * File CRUD operations mirroring the Jupyter Contents API shape.
+ *
+ * Pure functions — takes the target directory as an argument.
+ * Port of Python's gxwf_web/contents.py.
+ */
+import type { CheckpointModel, ContentsModel } from "./models.js";
+export declare const CHECKPOINTS_DIR = ".checkpoints";
+export declare class HttpError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+export declare function isIgnored(name: string): boolean;
+export declare function isWorkflowFile(relPath: string): boolean;
+/**
+ * Resolve relPath under directory, rejecting traversal and symlink escapes.
+ * Returns the absolute path.
+ */
+export declare function resolveSafePath(directory: string, relPath: string): string;
+export declare function readContents(directory: string, relPath: string, includeContent?: boolean, formatOverride?: string | null): ContentsModel;
+export declare function writeContents(directory: string, relPath: string, model: ContentsModel, expectedMtime?: Date): ContentsModel;
+export declare function deleteContents(directory: string, relPath: string): void;
+export declare function createUntitled(directory: string, parentRel: string, type: "file" | "directory", ext?: string | null): ContentsModel;
+export declare function renameContents(directory: string, relPath: string, newRelPath: string): ContentsModel;
+export declare function createCheckpoint(directory: string, relPath: string): CheckpointModel;
+export declare function listCheckpoints(directory: string, relPath: string): CheckpointModel[];
+export declare function restoreCheckpoint(directory: string, relPath: string, checkpointId: string): void;
+export declare function deleteCheckpoint(directory: string, relPath: string, checkpointId: string): void;
+//# sourceMappingURL=contents.d.ts.map

package/dist/contents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contents.d.ts","sourceRoot":"","sources":["../src/contents.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAIlE,eAAO,MAAM,eAAe,iBAAiB,CAAC;AAuB9C,qBAAa,SAAU,SAAQ,KAAK;aAEhB,MAAM,EAAE,MAAM;gBAAd,MAAM,EAAE,MAAM,EAC9B,OAAO,EAAE,MAAM;CAKlB;AAQD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAG/C;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAiC1E;AAmGD,wBAAgB,YAAY,CAC1B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,cAAc,UAAO,EACrB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,GAC7B,aAAa,CAyDf;AAED,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,aAAa,EACpB,aAAa,CAAC,EAAE,IAAI,GACnB,aAAa,CAkCf;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAkBvE;AAED,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,GAAG,WAAW,EAC1B,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,GAClB,aAAa,CAiCf;AAED,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GACjB,aAAa,CAsBf;AAaD,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,eAAe,CAapF;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,eAAe,EAAE,CAiBrF;AAED,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAchG;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAmB/F"}

package/dist/contents.js

@@ -0,0 +1,408 @@
+/**
+ * File CRUD operations mirroring the Jupyter Contents API shape.
+ *
+ * Pure functions — takes the target directory as an argument.
+ * Port of Python's gxwf_web/contents.py.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+// ── Constants ────────────────────────────────────────────────────────
+export const CHECKPOINTS_DIR = ".checkpoints";
+const DEFAULT_CHECKPOINT_ID = "checkpoint";
+const UNTITLED_FILE_STEM = "untitled";
+const UNTITLED_DIRECTORY_STEM = "Untitled Folder";
+/** Conflict detection tolerance in milliseconds (matches Python's 1s). */
+const MTIME_TOLERANCE_MS = 1000;
+const IGNORE_NAMES = new Set([
+    ".git",
+    "__pycache__",
+    ".venv",
+    "node_modules",
+    ".ruff_cache",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".tox",
+    CHECKPOINTS_DIR,
+]);
+const IGNORE_SUFFIXES = [".pyc", ".pyo"];
+const WORKFLOW_SUFFIXES = [".ga", ".gxwf.yml", ".gxwf.yaml"];
+// ── Error type ───────────────────────────────────────────────────────
+export class HttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = "HttpError";
+    }
+}
+function fail(status, message) {
+    throw new HttpError(status, message);
+}
+// ── Path helpers ─────────────────────────────────────────────────────
+export function isIgnored(name) {
+    if (IGNORE_NAMES.has(name))
+        return true;
+    return IGNORE_SUFFIXES.some((s) => name.endsWith(s));
+}
+export function isWorkflowFile(relPath) {
+    return WORKFLOW_SUFFIXES.some((s) => relPath.endsWith(s));
+}
+/**
+ * Resolve relPath under directory, rejecting traversal and symlink escapes.
+ * Returns the absolute path.
+ */
+export function resolveSafePath(directory, relPath) {
+    directory = path.resolve(directory);
+    if (relPath === "" || relPath === "/") {
+        return directory;
+    }
+    if (path.isAbsolute(relPath)) {
+        fail(400, "Path must be relative");
+    }
+    const joined = path.resolve(path.join(directory, relPath));
+    if (joined !== directory && !joined.startsWith(directory + path.sep)) {
+        fail(403, "Path escapes configured directory");
+    }
+    // Symlink escape check — only when the target exists (else realpath == joined).
+    if (fs.existsSync(joined)) {
+        const realJoined = fs.realpathSync(joined);
+        const realDir = fs.realpathSync(directory);
+        if (realJoined !== realDir && !realJoined.startsWith(realDir + path.sep)) {
+            fail(403, "Path escapes configured directory via symlink");
+        }
+    }
+    // Ignored component check.
+    for (const part of relPath.replace(/\\/g, "/").split("/")) {
+        if (part && isIgnored(part)) {
+            fail(403, `Path contains ignored component: ${part}`);
+        }
+    }
+    return joined;
+}
+// ── Mime type lookup ─────────────────────────────────────────────────
+function guessMimetype(absPath) {
+    const ext = path.extname(absPath).toLowerCase();
+    const map = {
+        ".txt": "text/plain",
+        ".html": "text/html",
+        ".htm": "text/html",
+        ".css": "text/css",
+        ".js": "application/javascript",
+        ".mjs": "application/javascript",
+        ".ts": "text/plain",
+        ".json": "application/json",
+        ".xml": "application/xml",
+        ".md": "text/markdown",
+        ".ga": "application/json",
+        ".yml": "text/yaml",
+        ".yaml": "text/yaml",
+        ".csv": "text/csv",
+        ".tsv": "text/tab-separated-values",
+        ".png": "image/png",
+        ".jpg": "image/jpeg",
+        ".jpeg": "image/jpeg",
+        ".gif": "image/gif",
+        ".svg": "image/svg+xml",
+        ".pdf": "application/pdf",
+        ".zip": "application/zip",
+    };
+    return map[ext] ?? null;
+}
+// ── Stat helpers ─────────────────────────────────────────────────────
+function statTimes(absPath) {
+    const st = fs.statSync(absPath);
+    return {
+        created: new Date(st.ctimeMs).toISOString(),
+        lastModified: new Date(st.mtimeMs).toISOString(),
+        size: st.size,
+    };
+}
+function isWritable(absPath) {
+    try {
+        fs.accessSync(absPath, fs.constants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ── File body read ───────────────────────────────────────────────────
+function readFileBody(absPath, formatOverride) {
+    const raw = fs.readFileSync(absPath);
+    const mimetype = guessMimetype(absPath);
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    if (formatOverride === "text") {
+        try {
+            const text = decoder.decode(raw);
+            return { format: "text", content: text, mimetype: mimetype ?? "text/plain" };
+        }
+        catch {
+            fail(400, "File is not valid utf-8");
+        }
+    }
+    if (formatOverride === "base64") {
+        return {
+            format: "base64",
+            content: raw.toString("base64"),
+            mimetype: mimetype ?? "application/octet-stream",
+        };
+    }
+    if (formatOverride != null) {
+        fail(400, `Unsupported format: ${formatOverride}`);
+    }
+    // Auto-detect: try UTF-8 first, fall back to base64.
+    try {
+        const text = decoder.decode(raw);
+        return { format: "text", content: text, mimetype: mimetype ?? "text/plain" };
+    }
+    catch {
+        return {
+            format: "base64",
+            content: raw.toString("base64"),
+            mimetype: mimetype ?? "application/octet-stream",
+        };
+    }
+}
+// ── Public operations ────────────────────────────────────────────────
+export function readContents(directory, relPath, includeContent = true, formatOverride) {
+    const absPath = resolveSafePath(directory, relPath);
+    if (!fs.existsSync(absPath)) {
+        fail(404, `Not found: ${relPath}`);
+    }
+    const name = path.basename(absPath) || path.basename(path.resolve(directory));
+    const writable = isWritable(absPath);
+    const { created, lastModified, size } = statTimes(absPath);
+    if (fs.statSync(absPath).isDirectory()) {
+        let children = null;
+        if (includeContent) {
+            children = [];
+            for (const entry of fs.readdirSync(absPath).sort()) {
+                if (isIgnored(entry))
+                    continue;
+                const childRel = relPath ? `${relPath}/${entry}` : entry;
+                children.push(readContents(directory, childRel, false));
+            }
+        }
+        return {
+            name,
+            path: relPath,
+            type: "directory",
+            writable,
+            created,
+            last_modified: lastModified,
+            size: null,
+            mimetype: null,
+            format: null,
+            content: children,
+        };
+    }
+    let format = null;
+    let content = null;
+    let mimetype = guessMimetype(absPath);
+    if (includeContent) {
+        const body = readFileBody(absPath, formatOverride);
+        format = body.format;
+        content = body.content;
+        mimetype = body.mimetype;
+    }
+    return {
+        name,
+        path: relPath,
+        type: "file",
+        writable,
+        created,
+        last_modified: lastModified,
+        size,
+        mimetype,
+        format,
+        content,
+    };
+}
+export function writeContents(directory, relPath, model, expectedMtime) {
+    const absPath = resolveSafePath(directory, relPath);
+    const parent = path.dirname(absPath);
+    if (parent && !fs.existsSync(parent)) {
+        fs.mkdirSync(parent, { recursive: true });
+    }
+    // Conflict detection.
+    if (expectedMtime !== undefined && fs.existsSync(absPath) && fs.statSync(absPath).isFile()) {
+        const diskMtime = fs.statSync(absPath).mtimeMs;
+        if (diskMtime - expectedMtime.getTime() > MTIME_TOLERANCE_MS) {
+            fail(409, `File modified on disk since ${expectedMtime.toISOString()} (disk mtime ${new Date(diskMtime).toISOString()})`);
+        }
+    }
+    if (model.type === "directory") {
+        fs.mkdirSync(absPath, { recursive: true });
+    }
+    else {
+        const fmt = model.format ?? "text";
+        if (fmt === "text") {
+            const raw = typeof model.content === "string" ? model.content : "";
+            fs.writeFileSync(absPath, raw, "utf-8");
+        }
+        else if (fmt === "base64") {
+            const raw = typeof model.content === "string" ? model.content : "";
+            fs.writeFileSync(absPath, Buffer.from(raw, "base64"));
+        }
+        else {
+            fail(400, `Unsupported format: ${fmt}`);
+        }
+    }
+    return readContents(directory, relPath, false);
+}
+export function deleteContents(directory, relPath) {
+    const absPath = resolveSafePath(directory, relPath);
+    if (!fs.existsSync(absPath)) {
+        fail(404, `Not found: ${relPath}`);
+    }
+    if (absPath === path.resolve(directory)) {
+        fail(403, "Cannot delete configured root directory");
+    }
+    if (fs.statSync(absPath).isDirectory()) {
+        fs.rmSync(absPath, { recursive: true });
+    }
+    else {
+        fs.unlinkSync(absPath);
+    }
+    // Cascade: remove any checkpoints for this path.
+    const cpDir = checkpointDirFor(directory, relPath);
+    if (fs.existsSync(cpDir) && fs.statSync(cpDir).isDirectory()) {
+        fs.rmSync(cpDir, { recursive: true });
+    }
+}
+export function createUntitled(directory, parentRel, type, ext) {
+    const parentAbs = resolveSafePath(directory, parentRel);
+    if (!fs.existsSync(parentAbs) || !fs.statSync(parentAbs).isDirectory()) {
+        fail(404, `Parent directory not found: ${parentRel}`);
+    }
+    if (type === "file") {
+        const stem = UNTITLED_FILE_STEM;
+        let suffix = ext ?? "";
+        if (suffix && !suffix.startsWith("."))
+            suffix = "." + suffix;
+        for (let i = 0;; i++) {
+            const name = i === 0 ? `${stem}${suffix}` : `${stem}${i}${suffix}`;
+            const candidateRel = parentRel ? `${parentRel}/${name}` : name;
+            const candidateAbs = resolveSafePath(directory, candidateRel);
+            if (!fs.existsSync(candidateAbs)) {
+                fs.writeFileSync(candidateAbs, "", "utf-8");
+                return readContents(directory, candidateRel, false);
+            }
+        }
+    }
+    else if (type === "directory") {
+        const stem = UNTITLED_DIRECTORY_STEM;
+        for (let i = 0;; i++) {
+            const name = i === 0 ? stem : `${stem} ${i}`;
+            const candidateRel = parentRel ? `${parentRel}/${name}` : name;
+            const candidateAbs = resolveSafePath(directory, candidateRel);
+            if (!fs.existsSync(candidateAbs)) {
+                fs.mkdirSync(candidateAbs);
+                return readContents(directory, candidateRel, false);
+            }
+        }
+    }
+    else {
+        fail(400, `Unsupported type: ${type}`);
+    }
+}
+export function renameContents(directory, relPath, newRelPath) {
+    const src = resolveSafePath(directory, relPath);
+    const dst = resolveSafePath(directory, newRelPath);
+    if (!fs.existsSync(src)) {
+        fail(404, `Not found: ${relPath}`);
+    }
+    if (fs.existsSync(dst)) {
+        fail(409, `Destination exists: ${newRelPath}`);
+    }
+    const parent = path.dirname(dst);
+    if (parent && !fs.existsSync(parent)) {
+        fs.mkdirSync(parent, { recursive: true });
+    }
+    fs.renameSync(src, dst);
+    // Cascade: move any checkpoints.
+    const srcCp = checkpointDirFor(directory, relPath);
+    if (fs.existsSync(srcCp) && fs.statSync(srcCp).isDirectory()) {
+        const dstCp = checkpointDirFor(directory, newRelPath);
+        fs.mkdirSync(path.dirname(dstCp), { recursive: true });
+        fs.renameSync(srcCp, dstCp);
+    }
+    return readContents(directory, newRelPath, false);
+}
+// ── Checkpoint operations ─────────────────────────────────────────────
+function checkpointDirFor(directory, relPath) {
+    return path.join(path.resolve(directory), CHECKPOINTS_DIR, relPath);
+}
+function checkpointModel(cpFile, cpId) {
+    const mtime = fs.statSync(cpFile).mtimeMs;
+    return { id: cpId, last_modified: new Date(mtime).toISOString() };
+}
+export function createCheckpoint(directory, relPath) {
+    const absPath = resolveSafePath(directory, relPath);
+    if (!fs.existsSync(absPath) || !fs.statSync(absPath).isFile()) {
+        fail(404, `File not found: ${relPath}`);
+    }
+    const cpDir = checkpointDirFor(directory, relPath);
+    fs.mkdirSync(cpDir, { recursive: true });
+    const cpFile = path.join(cpDir, DEFAULT_CHECKPOINT_ID);
+    fs.copyFileSync(absPath, cpFile);
+    // Preserve mtime via utimes (mirrors Python's shutil.copy2).
+    const st = fs.statSync(absPath);
+    fs.utimesSync(cpFile, st.atime, st.mtime);
+    return checkpointModel(cpFile, DEFAULT_CHECKPOINT_ID);
+}
+export function listCheckpoints(directory, relPath) {
+    const absPath = resolveSafePath(directory, relPath);
+    if (!fs.existsSync(absPath) || !fs.statSync(absPath).isFile()) {
+        fail(404, `File not found: ${relPath}`);
+    }
+    const cpDir = checkpointDirFor(directory, relPath);
+    if (!fs.existsSync(cpDir) || !fs.statSync(cpDir).isDirectory()) {
+        return [];
+    }
+    return fs
+        .readdirSync(cpDir)
+        .sort()
+        .filter((entry) => {
+        const f = path.join(cpDir, entry);
+        return fs.statSync(f).isFile();
+    })
+        .map((entry) => checkpointModel(path.join(cpDir, entry), entry));
+}
+export function restoreCheckpoint(directory, relPath, checkpointId) {
+    const absPath = resolveSafePath(directory, relPath);
+    if (!fs.existsSync(absPath) || !fs.statSync(absPath).isFile()) {
+        fail(404, `File not found: ${relPath}`);
+    }
+    const cpDir = checkpointDirFor(directory, relPath);
+    const cpFile = path.join(cpDir, checkpointId);
+    if (!fs.existsSync(cpFile) || !fs.statSync(cpFile).isFile()) {
+        fail(404, `Checkpoint not found: ${checkpointId}`);
+    }
+    fs.copyFileSync(cpFile, absPath);
+    // Preserve mtime (mirrors Python's shutil.copy2).
+    const cpSt = fs.statSync(cpFile);
+    fs.utimesSync(absPath, cpSt.atime, cpSt.mtime);
+}
+export function deleteCheckpoint(directory, relPath, checkpointId) {
+    resolveSafePath(directory, relPath); // validation only
+    const cpDir = checkpointDirFor(directory, relPath);
+    const cpFile = path.join(cpDir, checkpointId);
+    if (!fs.existsSync(cpFile) || !fs.statSync(cpFile).isFile()) {
+        fail(404, `Checkpoint not found: ${checkpointId}`);
+    }
+    fs.unlinkSync(cpFile);
+    // Clean up empty checkpoint dir tree (mirrors Python's os.removedirs — walk up).
+    let dir = cpDir;
+    const root = path.resolve(directory);
+    while (dir !== root) {
+        try {
+            fs.rmdirSync(dir); // throws if non-empty
+        }
+        catch {
+            break;
+        }
+        dir = path.dirname(dir);
+    }
+}
+//# sourceMappingURL=contents.js.map