@waishnav/devspace 1.0.2 → 1.0.3

package/README.md

@@ -50,14 +50,14 @@ DevSpace is a self-hosted MCP server that lets ChatGPT read, edit, search, and r
   </tbody>
 </table>
 
-<p align="center">
+<p>
   DevSpace is open to new sponsors.
   <a href="https://x.com/wshxnv">Get in touch to become one.</a>
 </p>
 
 ## Installation
 
-DevSpace requires Node `>=20.12 <27`. Node 22 LTS is recommended.
+DevSpace requires Node `>=22.19 <27`.
 
 Install the DevSpace CLI:
 
@@ -117,6 +117,14 @@ Most users should connect through a public HTTPS tunnel:
 https://your-tunnel-host.example.com/mcp
 ```
 
+> [!NOTE]
+> Using DevSpace as an MCP connector isn't against OpenAI's Usage Policies — it's
+> a standard custom App/connector setup, and writing or running code isn't a
+> restricted use case. But your account is governed by your usage, not by
+> DevSpace. Don't point it at anything that would violate your provider's terms.
+> Used normally, you're fine. (Based on OpenAI's Usage Policies and Service Terms
+> as of June 2026.)
+
 ## What ChatGPT Can Do
 
 Once connected, ChatGPT can open one of your approved project folders as a
@@ -192,14 +200,42 @@ explicit, inspectable tools.
 
 ## Built by Waishnav
 
-I'm Waishnav, the creator of [GitCMS](https://gitcms.dev/), a Git-backed CMS
-for markdown sites.
-
-I like building opinionated products, and DevSpace is another example of that.
-I'm on a journey to build a single-person company doing multiple millions in
+I'm Waishnav, I like building opinionated products and tools, and DevSpace is one example of that.
+This year, I started my journey to build a single-person and multiple-agents company doing multiple millions in
 revenue. If you want to watch the failures, wins, lessons, and everything in
 between, come hang out with me on [X](https://x.com/wshxnv).
 
+## More from me
+
+<table>
+  <thead>
+    <tr>
+      <th>Project</th>
+      <th>About</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td align="center" width="220">
+        <a href="https://gitcms.dev/">
+          <img
+            src="https://gitcms.dev/brand/gitcms-logo.svg"
+            alt="GitCMS"
+            width="48"
+          /><br />
+          <strong>GitCMS</strong>
+        </a>
+      </td>
+      <td>
+        <strong>Modern CMS and tooling for markdown based content sites — built for agents and humans.</strong><br><br>
+        Visual editing, editorial workflow, and ChatGPT/Claude content agents, with
+        every post and page stored as files in your repo.
+        <a href="https://gitcms.dev/">Learn more</a>.
+      </td>
+    </tr>
+  </tbody>
+</table>
+
 ## Local Development
 
 For working on DevSpace itself:

package/dist/apply-patch.js

@@ -0,0 +1,399 @@
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { access, mkdir, readFile, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { TextDecoder } from "node:util";
+function patchError(message) {
+    return new Error(`Invalid patch: ${message}`);
+}
+export function parsePatch(patch) {
+    const lines = patchLines(patch);
+    if (lines.shift()?.trim() !== "*** Begin Patch") {
+        throw patchError("missing *** Begin Patch marker");
+    }
+    if (lines.pop()?.trim() !== "*** End Patch") {
+        throw patchError("missing *** End Patch marker");
+    }
+    const actions = [];
+    let index = 0;
+    while (index < lines.length) {
+        const header = lines[index++].trim();
+        if (header === "")
+            continue;
+        if (header.startsWith("*** Environment ID: ")) {
+            if (!header.slice("*** Environment ID: ".length).trim()) {
+                throw patchError("environment id cannot be empty");
+            }
+            continue;
+        }
+        if (header.startsWith("*** Add File: ")) {
+            const path = header.slice("*** Add File: ".length);
+            const content = [];
+            while (index < lines.length && !isTopLevelHeader(lines[index])) {
+                const line = lines[index++];
+                if (!line.startsWith("+")) {
+                    throw patchError(`added file line must start with +: ${line}`);
+                }
+                content.push(line.slice(1));
+            }
+            if (content.length === 0)
+                throw patchError(`add file for ${path} has no content`);
+            actions.push({
+                kind: "add",
+                path,
+                content: `${content.join("\n")}\n`,
+            });
+            continue;
+        }
+        if (header.startsWith("*** Delete File: ")) {
+            actions.push({ kind: "delete", path: header.slice("*** Delete File: ".length) });
+            continue;
+        }
+        if (header.startsWith("*** Update File: ")) {
+            const path = header.slice("*** Update File: ".length);
+            let moveTo;
+            const hunks = [];
+            if (lines[index]?.trim().startsWith("*** Move to: ")) {
+                moveTo = lines[index++].trim().slice("*** Move to: ".length);
+            }
+            let current;
+            const finishCurrent = () => {
+                if (!current)
+                    return;
+                if (current.lines.length === 0)
+                    throw patchError(`empty update hunk for ${path}`);
+                hunks.push(current);
+                current = undefined;
+            };
+            while (index < lines.length) {
+                const line = lines[index];
+                const trimmed = line.trim();
+                if (!current && trimmed === "") {
+                    index++;
+                    continue;
+                }
+                if (trimmed === "*** End of File") {
+                    if (!current)
+                        throw patchError(`end-of-file marker without update hunk for ${path}`);
+                    current.endOfFile = true;
+                    index++;
+                    continue;
+                }
+                if ((!current || !line.startsWith(" ")) && isTopLevelHeader(line))
+                    break;
+                if (trimmed.startsWith("@@") && !line.startsWith(" ")) {
+                    finishCurrent();
+                    const changeContext = trimmed.slice(2).trim();
+                    current = { lines: [], changeContext: changeContext || undefined };
+                    index++;
+                    continue;
+                }
+                current ??= { lines: [] };
+                index++;
+                if (line.startsWith(" "))
+                    current.lines.push({ kind: "context", text: line.slice(1) });
+                else if (line.startsWith("+"))
+                    current.lines.push({ kind: "add", text: line.slice(1) });
+                else if (line.startsWith("-"))
+                    current.lines.push({ kind: "remove", text: line.slice(1) });
+                else if (line === "\")
+                    continue;
+                else
+                    throw patchError(`hunk line must start with space, +, or -: ${line}`);
+            }
+            finishCurrent();
+            if (hunks.length === 0 && !moveTo) {
+                throw patchError(`update for ${path} has no hunks or move destination`);
+            }
+            actions.push({ kind: "update", path, moveTo, hunks });
+            continue;
+        }
+        throw patchError(`unknown action header: ${header}`);
+    }
+    if (actions.length === 0)
+        throw patchError("contains no file actions");
+    return actions;
+}
+function patchLines(patch) {
+    let lines = patch.replace(/\r\n/g, "\n").trim().split("\n");
+    const first = lines[0]?.trim();
+    const last = lines.at(-1)?.trim();
+    if ((first === "<<EOF" || first === "<<'EOF'" || first === '<<"EOF"') &&
+        last?.endsWith("EOF") &&
+        lines.length >= 4) {
+        lines = lines.slice(1, -1);
+    }
+    return lines;
+}
+function isTopLevelHeader(line) {
+    const trimmed = line.trim();
+    return (trimmed.startsWith("*** Add File: ") ||
+        trimmed.startsWith("*** Delete File: ") ||
+        trimmed.startsWith("*** Update File: ") ||
+        trimmed.startsWith("*** Environment ID: "));
+}
+function isInside(root, path) {
+    const rel = relative(root, path);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+async function resolveConfinedPath(root, input) {
+    if (!input || input.includes("\0") || isAbsolute(input)) {
+        throw patchError(`path must be relative to the workspace: ${input}`);
+    }
+    const rootPath = await realpath(root);
+    const target = resolve(rootPath, input);
+    if (!isInside(rootPath, target)) {
+        throw patchError(`path escapes the workspace: ${input}`);
+    }
+    let existing = target;
+    while (true) {
+        try {
+            const resolved = await realpath(existing);
+            if (!isInside(rootPath, resolved)) {
+                throw patchError(`path resolves outside the workspace: ${input}`);
+            }
+            break;
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== "ENOENT")
+                throw error;
+            const parent = dirname(existing);
+            if (parent === existing)
+                throw error;
+            existing = parent;
+        }
+    }
+    return target;
+}
+function splitFile(content) {
+    const eol = content.includes("\r\n") ? "\r\n" : "\n";
+    const normalized = content.replace(/\r\n/g, "\n");
+    const finalNewline = normalized.endsWith("\n");
+    const lines = normalized.split("\n");
+    if (finalNewline)
+        lines.pop();
+    return { lines, eol, finalNewline };
+}
+function findSequence(haystack, needle, from, endOfFile = false) {
+    if (needle.length === 0)
+        return from;
+    const matchAt = (index, normalize) => needle.every((line, offset) => normalize(haystack[index + offset] ?? "") === normalize(line));
+    for (const normalize of [
+        (value) => value,
+        (value) => value.trimEnd(),
+        (value) => value.trim(),
+    ]) {
+        const start = endOfFile ? haystack.length - needle.length : from;
+        const end = haystack.length - needle.length;
+        for (let index = start; index <= end; index += 1) {
+            if (index >= from && matchAt(index, normalize))
+                return index;
+        }
+    }
+    return -1;
+}
+function applyHunks(path, content, hunks) {
+    const file = splitFile(content);
+    const lines = [...file.lines];
+    let cursor = 0;
+    for (const hunk of hunks) {
+        if (hunk.changeContext) {
+            const contextIndex = findSequence(lines, [hunk.changeContext], cursor);
+            if (contextIndex < 0) {
+                throw patchError(`could not find hunk context in ${path}: ${hunk.changeContext}`);
+            }
+            cursor = contextIndex + 1;
+        }
+        const oldLines = hunk.lines
+            .filter((line) => line.kind !== "add")
+            .map((line) => line.text);
+        const newLines = hunk.lines
+            .filter((line) => line.kind !== "remove")
+            .map((line) => line.text);
+        const index = hunk.endOfFile && oldLines.length === 0
+            ? lines.length
+            : findSequence(lines, oldLines, cursor, hunk.endOfFile);
+        if (index < 0) {
+            const preview = oldLines.slice(0, 3).join("\n");
+            throw patchError(`could not find hunk context in ${path}: ${preview}`);
+        }
+        lines.splice(index, oldLines.length, ...newLines);
+        cursor = index + newLines.length;
+    }
+    const normalized = `${lines.join("\n")}\n`;
+    return file.eol === "\r\n" ? normalized.replace(/\n/g, "\r\n") : normalized;
+}
+async function fileExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function replaceFile(temporary, destination, destinationExists, platform = process.platform) {
+    if (platform !== "win32" || !destinationExists) {
+        await rename(temporary, destination);
+        return;
+    }
+    const backup = `${temporary}.original`;
+    await rename(destination, backup);
+    try {
+        await rename(temporary, destination);
+    }
+    catch (error) {
+        await rename(backup, destination);
+        throw error;
+    }
+    await rm(backup, { force: true });
+}
+export async function applyPatch(root, patch) {
+    const actions = parsePatch(patch);
+    const results = [];
+    const patches = [];
+    for (const action of actions) {
+        if (action.kind === "add") {
+            const absolute = await resolveConfinedPath(root, action.path);
+            const original = await readOptionalTextFile(absolute, action.path);
+            await writeTextFile(absolute, action.content, original?.mode);
+            patches.push(unifiedFilePatch(action.path, action.path, original?.content ?? null, action.content));
+            results.push({ path: action.path, operation: "add" });
+            continue;
+        }
+        const absolute = await resolveConfinedPath(root, action.path);
+        const file = await readRequiredTextFile(absolute, action.path);
+        if (action.kind === "delete") {
+            await rm(absolute);
+            patches.push(unifiedFilePatch(action.path, action.path, file.content, null));
+            results.push({ path: action.path, operation: "delete" });
+            continue;
+        }
+        const updated = applyHunks(action.path, file.content, action.hunks);
+        if (action.moveTo) {
+            const destination = await resolveConfinedPath(root, action.moveTo);
+            if (destination !== absolute)
+                await readOptionalTextFile(destination, action.moveTo);
+            await writeTextFile(destination, updated, file.mode);
+            if (destination !== absolute)
+                await rm(absolute);
+            patches.push(unifiedFilePatch(action.path, action.moveTo, file.content, updated));
+            results.push({ path: action.moveTo, previousPath: action.path, operation: "move" });
+        }
+        else {
+            await writeTextFile(absolute, updated, file.mode);
+            patches.push(unifiedFilePatch(action.path, action.path, file.content, updated));
+            results.push({ path: action.path, operation: "update" });
+        }
+    }
+    const unifiedPatch = patches.filter(Boolean).join("\n");
+    const stats = countPatchStats(unifiedPatch);
+    return { files: results, patch: unifiedPatch, ...stats };
+}
+async function readRequiredTextFile(absolute, displayPath) {
+    if (!(await fileExists(absolute)))
+        throw patchError(`file does not exist: ${displayPath}`);
+    const metadata = await stat(absolute);
+    if (!metadata.isFile())
+        throw patchError(`path is not a regular file: ${displayPath}`);
+    return { content: await readUtf8Text(absolute, displayPath), mode: metadata.mode };
+}
+async function readOptionalTextFile(absolute, displayPath) {
+    if (!(await fileExists(absolute)))
+        return null;
+    const metadata = await stat(absolute);
+    if (!metadata.isFile())
+        throw patchError(`path is not a regular file: ${displayPath}`);
+    return { content: await readUtf8Text(absolute, displayPath), mode: metadata.mode };
+}
+async function readUtf8Text(absolute, displayPath) {
+    const bytes = await readFile(absolute);
+    let content;
+    try {
+        content = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+    catch {
+        throw patchError(`file is not valid UTF-8 text: ${displayPath}`);
+    }
+    if (content.includes("\0"))
+        throw patchError(`file appears to be binary: ${displayPath}`);
+    return content;
+}
+async function writeTextFile(destination, content, mode) {
+    await mkdir(dirname(destination), { recursive: true });
+    const temporary = `${destination}.devspace-patch-${process.pid}-${randomUUID()}`;
+    try {
+        await writeFile(temporary, content, mode === undefined ? undefined : { mode });
+        await replaceFile(temporary, destination, await fileExists(destination));
+    }
+    catch (error) {
+        await rm(temporary, { force: true });
+        throw error;
+    }
+}
+function fileLines(content) {
+    if (content.length === 0)
+        return [];
+    const normalized = content.replace(/\r\n/g, "\n");
+    const lines = normalized.split("\n");
+    if (normalized.endsWith("\n"))
+        lines.pop();
+    return lines;
+}
+function hunkRange(start, count) {
+    return count === 0 ? "0,0" : `${start},${count}`;
+}
+function unifiedFilePatch(oldPath, newPath, oldContent, newContent) {
+    const oldLines = fileLines(oldContent ?? "");
+    const newLines = fileLines(newContent ?? "");
+    let prefix = 0;
+    while (prefix < oldLines.length &&
+        prefix < newLines.length &&
+        oldLines[prefix] === newLines[prefix]) {
+        prefix += 1;
+    }
+    let suffix = 0;
+    while (suffix < oldLines.length - prefix &&
+        suffix < newLines.length - prefix &&
+        oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix]) {
+        suffix += 1;
+    }
+    const contextBefore = Math.min(3, prefix);
+    const contextAfter = Math.min(3, suffix);
+    const oldChanged = oldLines.slice(prefix, oldLines.length - suffix);
+    const newChanged = newLines.slice(prefix, newLines.length - suffix);
+    const before = oldLines.slice(prefix - contextBefore, prefix);
+    const after = oldLines.slice(oldLines.length - suffix, oldLines.length - suffix + contextAfter);
+    const oldCount = contextBefore + oldChanged.length + contextAfter;
+    const newCount = contextBefore + newChanged.length + contextAfter;
+    const oldStart = oldContent === null ? 0 : prefix - contextBefore + 1;
+    const newStart = newContent === null ? 0 : prefix - contextBefore + 1;
+    const displayOld = oldContent === null ? "/dev/null" : `a/${oldPath}`;
+    const displayNew = newContent === null ? "/dev/null" : `b/${newPath}`;
+    return [
+        `diff --git a/${oldPath} b/${newPath}`,
+        oldContent === null ? "new file mode 100644" : undefined,
+        newContent === null ? "deleted file mode 100644" : undefined,
+        `--- ${displayOld}`,
+        `+++ ${displayNew}`,
+        `@@ -${hunkRange(oldStart, oldCount)} +${hunkRange(newStart, newCount)} @@`,
+        ...before.map((line) => ` ${line}`),
+        ...oldChanged.map((line) => `-${line}`),
+        ...newChanged.map((line) => `+${line}`),
+        ...after.map((line) => ` ${line}`),
+    ]
+        .filter((line) => line !== undefined)
+        .join("\n");
+}
+function countPatchStats(patch) {
+    let additions = 0;
+    let removals = 0;
+    for (const line of patch.split("\n")) {
+        if (line.startsWith("+") && !line.startsWith("+++"))
+            additions += 1;
+        if (line.startsWith("-") && !line.startsWith("---"))
+            removals += 1;
+    }
+    return { additions, removals };
+}

package/dist/cli.js

@@ -31,6 +31,9 @@ async function main(argv) {
         case "help":
             printHelp();
             return;
+        case "version":
+            printVersion();
+            return;
     }
 }
 function normalizeCommand(command) {
@@ -40,6 +43,8 @@ function normalizeCommand(command) {
         return command;
     if (command === "help" || command === "--help" || command === "-h")
         return "help";
+    if (command === "version" || command === "--version" || command === "-v")
+        return "version";
     throw new Error(`Unknown command: ${command}`);
 }
 async function ensureConfigured() {
@@ -226,11 +231,19 @@ function printHelp() {
         "  devspace doctor          Show config, runtime, and native dependency status",
         "  devspace config get      Print persisted config",
         "  devspace config set publicBaseUrl <url|null>",
+        "  devspace -v, --version   Print the installed version",
         "",
         "For temporary tunnels:",
         "  DEVSPACE_PUBLIC_BASE_URL=https://example.trycloudflare.com devspace serve",
     ].join("\n"));
 }
+function printVersion() {
+    const packageJson = require("../package.json");
+    if (typeof packageJson.version !== "string") {
+        throw new Error("Unable to read DevSpace package version.");
+    }
+    console.log(packageJson.version);
+}
 function normalizeOptionalPublicBaseUrl(value) {
     const trimmed = value.trim();
     if (!trimmed || trimmed === "null" || trimmed === "none")

package/dist/config.js

@@ -44,17 +44,16 @@ function normalizeAllowedHosts(rawHosts, derivedHosts) {
 function parseBoolean(value) {
     return ["1", "true", "yes", "on"].includes(value?.toLowerCase() ?? "");
 }
-function parseMinimalTools(env) {
-    if (env.DEVSPACE_TOOL_MODE === "minimal")
-        return true;
-    if (env.DEVSPACE_TOOL_MODE === "full")
-        return false;
-    if (env.DEVSPACE_TOOL_MODE) {
-        throw new Error(`Invalid DEVSPACE_TOOL_MODE: ${env.DEVSPACE_TOOL_MODE}`);
+function parseToolMode(env) {
+    const mode = env.DEVSPACE_TOOL_MODE;
+    if (mode === "minimal" || mode === "full" || mode === "codex")
+        return mode;
+    if (mode)
+        throw new Error(`Invalid DEVSPACE_TOOL_MODE: ${mode}`);
+    if (env.DEVSPACE_MINIMAL_TOOLS !== undefined) {
+        return parseBoolean(env.DEVSPACE_MINIMAL_TOOLS) ? "minimal" : "full";
     }
-    if (env.DEVSPACE_MINIMAL_TOOLS !== undefined)
-        return parseBoolean(env.DEVSPACE_MINIMAL_TOOLS);
-    return true;
+    return "minimal";
 }
 function parseLogLevel(value) {
     if (!value || value === "info")
@@ -74,8 +73,7 @@ function parsePathList(value) {
     return (value
         ?.split(",")
         .map((entry) => entry.trim())
-        .filter(Boolean)
-        .map((entry) => resolve(expandHomePath(entry))) ?? []);
+        .filter(Boolean) ?? []);
 }
 function parseStringList(value, fallback) {
     const entries = value
@@ -170,7 +168,7 @@ export function loadConfig(env = process.env) {
         allowedRoots: parseAllowedRoots(env.DEVSPACE_ALLOWED_ROOTS ?? files.config.allowedRoots),
         allowedHosts: parseAllowedHosts(env.DEVSPACE_ALLOWED_HOSTS, derivedAllowedHosts),
         publicBaseUrl,
-        minimalTools: parseMinimalTools(env),
+        toolMode: parseToolMode(env),
         toolNaming: parseToolNaming(env.DEVSPACE_TOOL_NAMING),
         widgets: parseWidgetMode(env.DEVSPACE_WIDGETS),
         stateDir: resolve(expandHomePath(env.DEVSPACE_STATE_DIR ?? files.config.stateDir ?? defaultStateDir())),

package/dist/process-platform.js

@@ -0,0 +1,49 @@
+import { basename } from "node:path";
+import { spawnSync } from "node:child_process";
+const defaultProcessTreeRuntime = {
+    platform: process.platform,
+    killGroup: (pid, signal) => process.kill(-pid, signal),
+    killWindowsTree: (pid) => {
+        const result = spawnSync("taskkill.exe", ["/pid", String(pid), "/T", "/F"], {
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        return !result.error && result.status === 0;
+    },
+};
+const LOGIN_SHELLS = new Set(["bash", "ksh", "zsh"]);
+const POSIX_SHELLS = new Set(["ash", "dash", "sh"]);
+export function resolveShellCommand(command, platform = process.platform, environment = process.env) {
+    if (platform === "win32") {
+        return {
+            executable: environment.ComSpec ?? environment.COMSPEC ?? "cmd.exe",
+            args: ["/d", "/s", "/c", command],
+        };
+    }
+    const configuredShell = environment.SHELL;
+    const shellName = configuredShell ? basename(configuredShell) : "";
+    if (configuredShell && LOGIN_SHELLS.has(shellName)) {
+        return { executable: configuredShell, args: ["-lc", command] };
+    }
+    if (configuredShell && POSIX_SHELLS.has(shellName)) {
+        return { executable: configuredShell, args: ["-c", command] };
+    }
+    return { executable: "/bin/sh", args: ["-c", command] };
+}
+export function terminateProcessTree(child, signal, detached, runtime = defaultProcessTreeRuntime) {
+    if (runtime.platform === "win32" && child.pid) {
+        if (runtime.killWindowsTree(child.pid))
+            return;
+    }
+    else if (detached && child.pid) {
+        try {
+            runtime.killGroup(child.pid, signal);
+            return;
+        }
+        catch (error) {
+            if (error.code === "ESRCH")
+                return;
+        }
+    }
+    child.kill(signal);
+}