@waishnav/devspace 1.0.1 → 1.0.3

package/README.md

@@ -1,6 +1,6 @@
 <p align="center">
   <picture>
-    <img src="docs/assets/devspace-logo-light.png" alt="DevSpace logo" width="140">
+    <img src="https://raw.githubusercontent.com/Waishnav/devspace/main/docs/assets/devspace-logo-light.png" alt="DevSpace logo" width="140">
   </picture>
 </p>
 
@@ -14,15 +14,65 @@
   <a href="https://github.com/Waishnav/devspace/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/npm/l/%40waishnav%2Fdevspace?style=flat-square" /></a>
 </p>
 
-[![DevSpace connected to ChatGPT](docs/assets/devspace-screenshot.png)](docs/assets/devspace-screenshot.png)
+[![DevSpace connected to ChatGPT](https://raw.githubusercontent.com/Waishnav/devspace/main/docs/assets/devspace-screenshot.png)](https://raw.githubusercontent.com/Waishnav/devspace/main/docs/assets/devspace-screenshot.png)
 
 **Give ChatGPT a secure connection to your own machine and Turn ChatGPT into Codex**
 
 DevSpace is a self-hosted MCP server that lets ChatGPT read, edit, search, and run code in your real local projects — your files, your tools, your terminal — without uploading anything to a third party. You run it on your machine, expose it through a tunnel you control, and approve the connection with a password only you have.
 
-## Quick Start
+## Sponsors and Special Thanks
+
+<table>
+  <thead>
+    <tr>
+      <th>Sponsor</th>
+      <th>About</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td align="center" width="220">
+        <a href="https://rebates.ai/">
+          <img
+            src="https://app.rebates.ai/brand/rebates-lockup.svg"
+            alt="Rebates"
+            width="170"
+          >
+        </a>
+      </td>
+      <td>
+        <strong>The ads in your terminal pay you.</strong><br><br>
+        <a href="https://rebates.ai/">Rebates</a> adds one optional
+        sponsored footer to your coding agent and pays you cash back for every
+        session in which it is shown. Turn it off at any time.
+      </td>
+    </tr>
+  </tbody>
+</table>
+
+<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 `>=22.19 <27`.
+
+Install the DevSpace CLI:
+
+```bash
+npm install -g @waishnav/devspace
+```
+
+Then initialize and start the server:
+
+```bash
+devspace init
+devspace serve
+```
 
-DevSpace requires Node `>=20.12 <27`. Node 22 LTS is recommended.
+Or run it without a global install:
 
 ```bash
 npx @waishnav/devspace init
@@ -42,11 +92,7 @@ Use the public origin without `/mcp` during setup:
 https://your-tunnel-host.example.com
 ```
 
-Then configure your MCP client with:
-
-```text
-https://your-tunnel-host.example.com/mcp
-```
+You will configure your MCP client with the public `/mcp` URL after setup.
 
 When the client connects, DevSpace opens an Owner password approval page. Enter
 the Owner password printed by `devspace init`. It is also stored in:
@@ -57,20 +103,7 @@ the Owner password printed by `devspace init`. It is also stored in:
 
 Keep that password private.
 
-## What ChatGPT Gets
-
-After the MCP client connects, ChatGPT can open a project with
-`open_workspace` and then reuse the returned `workspaceId` for later calls.
-
-DevSpace provides tools for:
-
-- reading, writing, and editing files inside the opened workspace
-- running shell-backed search and directory inspection in the default minimal tool mode
-- running shell commands for tests, builds, git, and package scripts
-- opening isolated Git worktrees when you want parallel work
-- loading `AGENTS.md` and `CLAUDE.md` instructions
-- exposing local agent skills from your skill folders
-- showing ChatGPT Apps tool cards, with an opt-in aggregate `show_changes` card
+## Connect Your MCP Client
 
 The default local endpoint is:
 
@@ -84,6 +117,30 @@ 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
+workspace. From there, it can inspect the repo, make scoped edits, run commands,
+and show you what changed.
+
+DevSpace gives ChatGPT tools to:
+
+- read, write, and edit files inside the opened workspace
+- search code and inspect directories
+- run shell commands for tests, builds, git, and package scripts
+- use isolated Git worktrees for parallel coding sessions
+- follow project instructions from `AGENTS.md` and `CLAUDE.md`
+- discover local agent skills from your skill folders
+- show tool cards and optional change summaries in ChatGPT Apps-compatible hosts
+
 ## Mental Model
 
 DevSpace is remote access to selected local folders.
@@ -95,7 +152,7 @@ connected client like a trusted coding partner with access to your machine.
 For a normal ChatGPT coding session:
 
 1. Start your tunnel.
-2. Run `npx @waishnav/devspace serve`.
+2. Run `devspace serve`.
 3. Connect the MCP client to your public `/mcp` URL.
 4. Approve the connection with the Owner password.
 5. Ask ChatGPT to open a project inside one of your allowed roots.
@@ -115,16 +172,69 @@ shell.
 Run this to inspect your local setup:
 
 ```bash
-npx @waishnav/devspace doctor
+devspace doctor
 ```
 
 ## Documentation
 
-- [Setup Guide](docs/setup.md)
-- [ChatGPT Coding Workflow](docs/chatgpt-coding-workflow.md)
-- [Configuration Reference](docs/configuration.md)
-- [Security Model](docs/security.md)
-- [Troubleshooting Gotchas](docs/gotchas.md)
+- [Setup Guide](https://github.com/Waishnav/devspace/blob/main/docs/setup.md)
+- [ChatGPT Coding Workflow](https://github.com/Waishnav/devspace/blob/main/docs/chatgpt-coding-workflow.md)
+- [Configuration Reference](https://github.com/Waishnav/devspace/blob/main/docs/configuration.md)
+- [Security Model](https://github.com/Waishnav/devspace/blob/main/docs/security.md)
+- [Troubleshooting Gotchas](https://github.com/Waishnav/devspace/blob/main/docs/gotchas.md)
+
+## Philosophy
+
+Every piece of software is becoming conversational. Natural language is
+redefining how we interact with tools, workflows, and systems.
+
+My bet is that ChatGPT becomes the operating system for everything. Once we
+reach AGI, we will simply talk to ChatGPT, and it will prompt, coordinate, and
+orchestrate sub-agents that set up the right loops for us.
+
+We are not there yet.
+
+DevSpace is one attempt to fast-forward that future: a way for MCP-capable
+hosts like ChatGPT and Claude to work directly with local project files through
+explicit, inspectable tools.
+
+## Built by Waishnav
+
+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
 

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() {
@@ -149,7 +154,7 @@ async function serve() {
     }
     const { createServer } = await import("./server.js");
     const config = loadConfig();
-    const { app } = createServer(config);
+    const { app, close } = createServer(config);
     const httpServer = app.listen(config.port, config.host, () => {
         console.log(`devspace listening on http://${config.host}:${config.port}/mcp`);
         console.log(`public base url: ${config.publicBaseUrl}`);
@@ -162,7 +167,10 @@ async function serve() {
         console.log(`logging: ${config.logging.level} ${config.logging.format}`);
     });
     const shutdown = () => {
-        httpServer.close(() => process.exit(0));
+        httpServer.close(() => {
+            close();
+            process.exit(0);
+        });
     };
     process.once("SIGINT", shutdown);
     process.once("SIGTERM", shutdown);
@@ -223,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")