coderaft 0.0.4

package/LICENSE.md

@@ -0,0 +1,110 @@
+# Third-Party Licenses
+
+This package bundles the following third-party dependencies.
+
+See [ThirdPartyNotices.txt](./ThirdPartyNotices.txt) for the full notices from bundled VS Code grammars, extensions, and assets.
+
+---
+
+## MIT License
+
+The following packages are licensed under the **MIT License**:
+
+| Package                          | Author/Copyright                    |
+| -------------------------------- | ----------------------------------- |
+| code-server                      | Coder Technologies Inc.             |
+| @microsoft/1ds-core-js           | Microsoft Application Insights Team |
+| @microsoft/1ds-post-js           | Microsoft Application Insights Team |
+| @parcel/watcher                  | Parcel                              |
+| @vscode/deviceid                 | Microsoft Corporation               |
+| @vscode/iconv-lite-umd           | Microsoft                           |
+| @vscode/native-watchdog          | Microsoft Corporation               |
+| @vscode/proxy-agent              | Microsoft                           |
+| @vscode/ripgrep                  | Rob Lourens                         |
+| @vscode/spdlog                   | Microsoft                           |
+| @vscode/tree-sitter-wasm         | Visual Studio Code Team             |
+| @vscode/vscode-languagedetection | Tyler Leonhardt                     |
+| @vscode/windows-process-tree     | Microsoft Corporation               |
+| @vscode/windows-registry         | Microsoft Corporation               |
+| @xterm/addon-clipboard           | The xterm.js authors                |
+| @xterm/addon-image               | The xterm.js authors                |
+| @xterm/addon-ligatures           | The xterm.js authors                |
+| @xterm/addon-progress            | The xterm.js authors                |
+| @xterm/addon-search              | The xterm.js authors                |
+| @xterm/addon-serialize           | The xterm.js authors                |
+| @xterm/addon-unicode11           | The xterm.js authors                |
+| @xterm/addon-webgl               | The xterm.js authors                |
+| @xterm/headless                  | The xterm.js authors                |
+| @xterm/xterm                     | The xterm.js authors                |
+| cookie                           | Roman Shtylman                      |
+| http-proxy-agent                 | Nathan Rajlich                      |
+| https-proxy-agent                | Nathan Rajlich                      |
+| katex                            | KaTeX Contributors                  |
+| minimist                         | James Halliday                      |
+| node-pty                         | Microsoft Corporation               |
+| tas-client                       | Microsoft                           |
+| vscode-oniguruma                 | Microsoft Corporation               |
+| vscode-regexpp                   | Toru Nagashima                      |
+| vscode-textmate                  | Microsoft Corporation               |
+| ws                               | Einar Otto Stangvik                 |
+| yauzl                            | Josh Wolfe                          |
+| yazl                             | Josh Wolfe                          |
+
+```
+MIT License
+
+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.
+```
+
+---
+
+## Apache License 2.0
+
+The following packages are licensed under the **Apache License 2.0**:
+
+| Package                       | Author/Copyright        |
+| ----------------------------- | ----------------------- |
+| @anthropic-ai/sandbox-runtime | Anthropic PBC           |
+| kerberos                      | The MongoDB NodeJS Team |
+| typescript                    | Microsoft Corp.         |
+
+```
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
+## LGPL-2.1+
+
+| Package   | Author/Copyright |
+| --------- | ---------------- |
+| jschardet | António Afonso   |
+
+Licensed under the GNU Lesser General Public License v2.1 or later.
+See https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html

package/code.mjs

@@ -0,0 +1,48 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+// Auto-updated by scripts/pack.ts
+const codeArchiveHash = "2cc1d5a1fed987e5";
+
+const archivePath = fileURLToPath(new URL("./code.tar.zst", import.meta.url));
+
+const verbose = !!process.env.DEBUG;
+
+const gray = (str) => `\x1b[90m${str}\x1b[0m`;
+const log = (...args) => console.log(gray(`[code-server] ${args.join(" ")}`));
+const vlog = verbose ? log : () => {};
+
+export async function loadCode() {
+  if (process.env.CODE_MODULES_DIR) {
+    vlog(`Using CODE_MODULES_DIR: ${process.env.CODE_MODULES_DIR}`);
+    return { modulesDir: resolve(process.env.CODE_MODULES_DIR) };
+  }
+
+  const cacheDir = join(tmpdir(), "code-server", codeArchiveHash);
+  const modulesDir = join(cacheDir, "node_modules");
+  const markerPath = join(cacheDir, ".complete");
+
+  if (existsSync(markerPath) && readFileSync(markerPath, "utf8") === codeArchiveHash) {
+    vlog(`Cache hit: ${cacheDir}`);
+    return { modulesDir };
+  }
+
+  if (!existsSync(archivePath)) {
+    throw new Error(`Archive not found: ${archivePath}`);
+  }
+
+  mkdirSync(cacheDir, { recursive: true });
+
+  vlog(`Extracting... (${cacheDir})`);
+  const start = performance.now();
+
+  const { extractTarZst } = await import("./tar.mjs");
+  await extractTarZst(archivePath, cacheDir);
+
+  writeFileSync(markerPath, codeArchiveHash);
+  vlog(`Extracted in ${(performance.now() - start).toFixed(0)}ms`);
+
+  return { modulesDir };
+}

package/dist/_chunks/server.mjs

@@ -0,0 +1,218 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import { createReadStream, readFileSync, readdirSync, unlinkSync } from "node:fs";
+import { createServer } from "node:http";
+import { homedir } from "node:os";
+import { extname, join, normalize, sep } from "node:path";
+import { stat } from "node:fs/promises";
+import { loadCode } from "#code";
+const STATIC_MIME = {
+	".js": "text/javascript",
+	".mjs": "text/javascript",
+	".css": "text/css",
+	".html": "text/html",
+	".json": "application/json",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".ico": "image/x-icon",
+	".webp": "image/webp",
+	".wasm": "application/wasm",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".map": "application/json",
+	".txt": "text/plain"
+};
+async function serveStatic(res, root, relPath) {
+	const abs = normalize(join(root, decodeURIComponent(relPath)));
+	if (abs !== root && !abs.startsWith(root + sep)) {
+		res.writeHead(400).end("Bad request.");
+		return true;
+	}
+	try {
+		const st = await stat(abs);
+		if (!st.isFile()) return false;
+		const headers = {
+			"Content-Type": STATIC_MIME[extname(abs).toLowerCase()] ?? "application/octet-stream",
+			"Content-Length": st.size,
+			"Cache-Control": "public, max-age=31536000, immutable"
+		};
+		if (abs.endsWith("/serviceWorker.js")) headers["Service-Worker-Allowed"] = "/";
+		res.writeHead(200, headers);
+		createReadStream(abs).pipe(res);
+		return true;
+	} catch {
+		return false;
+	}
+}
+const MANIFEST_BODY = JSON.stringify({
+	name: "code-server",
+	short_name: "code-server",
+	start_url: ".",
+	display: "fullscreen",
+	display_override: ["window-controls-overlay"],
+	description: "Run Code on a remote server.",
+	icons: [192, 512].flatMap((size) => [{
+		src: `./_static/src/browser/media/pwa-icon-${size}.png`,
+		type: "image/png",
+		sizes: `${size}x${size}`,
+		purpose: "any"
+	}, {
+		src: `./_static/src/browser/media/pwa-icon-maskable-${size}.png`,
+		type: "image/png",
+		sizes: `${size}x${size}`,
+		purpose: "maskable"
+	}])
+});
+const ROBOTS_TXT = "User-agent: *\nDisallow: /\n";
+async function createCodeServer(opts = {}) {
+	const withoutToken = opts.vscode?.["without-connection-token"] === true;
+	const connectionToken = withoutToken ? "" : opts.connectionToken ?? randomUUID();
+	const defaultFolder = opts.defaultFolder ?? process.cwd();
+	const mintKey = randomBytes(32);
+	process.env.CODE_SERVER_PARENT_PID ??= String(process.pid);
+	cleanupStaleLocks(opts.vscode?.["user-data-dir"] ?? join(homedir(), ".vscode-server-oss", "data"));
+	const { modulesDir } = await loadCode();
+	const vsRootPath = join(modulesDir, "code-server", "lib", "vscode");
+	const _log = console.log;
+	console.log = (...args) => {
+		if (typeof args[0] === "string" && args[0].includes("[reconnection-grace-time]")) return;
+		if (args.length === 2 && typeof args[1] === "string" && !args[1].trim()) return;
+		_log(...args);
+	};
+	const vscodeServer = await (await (await import(join(vsRootPath, "out/server-main.js"))).loadCodeWithNls()).createServer(null, {
+		"default-folder": defaultFolder,
+		...withoutToken ? {} : { "connection-token": connectionToken },
+		"reconnection-grace-time": "10800",
+		"disable-getting-started-override": true,
+		...opts.vscode
+	});
+	console.log = _log;
+	return {
+		connectionToken,
+		handleRequest(req, res) {
+			const method = req.method ?? "GET";
+			const url = (req.url ?? "/").split("?")[0];
+			if (url === "/manifest.json") {
+				res.writeHead(200, {
+					"Content-Type": "application/manifest+json",
+					"Cache-Control": "no-cache"
+				});
+				res.end(MANIFEST_BODY);
+				return;
+			}
+			if (url === "/healthz") {
+				sendJson(res, 200, {
+					status: "alive",
+					lastHeartbeat: Date.now()
+				});
+				return;
+			}
+			if (url === "/update/check") {
+				const codeServerVersion = JSON.parse(readFileSync(join(modulesDir, "code-server", "package.json"), "utf8")).version;
+				sendJson(res, 200, {
+					checked: Date.now(),
+					latest: codeServerVersion,
+					current: codeServerVersion,
+					isLatest: true
+				});
+				return;
+			}
+			if (url === "/robots.txt") {
+				res.writeHead(200, {
+					"Content-Type": "text/plain; charset=utf-8",
+					"Content-Length": Buffer.byteLength(ROBOTS_TXT)
+				});
+				res.end(ROBOTS_TXT);
+				return;
+			}
+			if (url === "/mint-key" && method === "POST") {
+				res.writeHead(200, {
+					"Content-Type": "application/octet-stream",
+					"Content-Length": mintKey.length
+				});
+				res.end(mintKey);
+				return;
+			}
+			if (url === "/login" || url === "/logout") {
+				res.writeHead(302, { Location: "/" });
+				res.end();
+				return;
+			}
+			if (url.startsWith("/_static/")) {
+				serveStatic(res, join(modulesDir, "code-server"), url.slice(9)).then((served) => {
+					if (!served) vscodeServer.handleRequest(req, res);
+				});
+				return;
+			}
+			vscodeServer.handleRequest(req, res);
+		},
+		handleUpgrade(req, socket) {
+			vscodeServer.handleUpgrade(req, socket);
+			socket.resume();
+		},
+		async dispose() {
+			vscodeServer.dispose();
+		}
+	};
+}
+async function startCodeServer(opts = {}) {
+	const port = opts.port ?? (Number(process.env.PORT) || 8080);
+	const handler = await createCodeServer(opts);
+	const server = createServer((req, res) => {
+		handler.handleRequest(req, res);
+	});
+	server.on("upgrade", (req, socket) => {
+		handler.handleUpgrade(req, socket);
+	});
+	const listen = (p) => new Promise((resolve, reject) => {
+		server.once("error", reject);
+		const cb = () => {
+			server.removeListener("error", reject);
+			resolve();
+		};
+		if (opts.host) server.listen(p, opts.host, cb);
+		else server.listen(p, cb);
+	});
+	try {
+		await listen(port);
+	} catch (err) {
+		if (err?.code === "EADDRINUSE") await listen(0);
+		else throw err;
+	}
+	const actualPort = server.address().port;
+	return {
+		server,
+		port: actualPort,
+		url: handler.connectionToken ? `http://localhost:${actualPort}/?tkn=${handler.connectionToken}` : `http://localhost:${actualPort}/`,
+		connectionToken: handler.connectionToken,
+		async close() {
+			await handler.dispose();
+			server.closeAllConnections();
+			await new Promise((resolve, reject) => {
+				server.close((err) => err ? reject(err) : resolve());
+			});
+		}
+	};
+}
+function cleanupStaleLocks(userDataDir) {
+	const storageDir = join(userDataDir, "User", "workspaceStorage");
+	try {
+		for (const entry of readdirSync(storageDir)) {
+			const lockPath = join(storageDir, entry, "vscode.lock");
+			try {
+				unlinkSync(lockPath);
+			} catch {}
+		}
+	} catch {}
+}
+function sendJson(res, status, body) {
+	const payload = JSON.stringify(body);
+	res.writeHead(status, {
+		"Content-Type": "application/json; charset=utf-8",
+		"Content-Length": Buffer.byteLength(payload)
+	});
+	res.end(payload);
+}
+export { startCodeServer as n, createCodeServer as t };

package/dist/cli.d.mts

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

package/dist/cli.mjs

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+import { n as startCodeServer } from "./_chunks/server.mjs";
+import { parseArgs } from "node:util";
+const { values, positionals } = parseArgs({
+	allowPositionals: true,
+	options: {
+		port: {
+			type: "string",
+			short: "p"
+		},
+		host: {
+			type: "string",
+			short: "H"
+		},
+		"server-base-path": { type: "string" },
+		"socket-path": { type: "string" },
+		"print-startup-performance": { type: "boolean" },
+		"connection-token": { type: "string" },
+		"connection-token-file": { type: "string" },
+		"without-connection-token": { type: "boolean" },
+		auth: { type: "string" },
+		"github-auth": { type: "string" },
+		"default-folder": { type: "string" },
+		"default-workspace": { type: "string" },
+		locale: { type: "string" },
+		"server-data-dir": { type: "string" },
+		"user-data-dir": { type: "string" },
+		"extensions-dir": { type: "string" },
+		"extensions-download-dir": { type: "string" },
+		"builtin-extensions-dir": { type: "string" },
+		"agent-plugins-dir": { type: "string" },
+		log: { type: "string" },
+		"logs-path": { type: "string" },
+		"disable-websocket-compression": { type: "boolean" },
+		"use-host-proxy": { type: "boolean" },
+		"disable-file-downloads": { type: "boolean" },
+		"disable-file-uploads": { type: "boolean" },
+		"file-watcher-polling": { type: "string" },
+		"telemetry-level": { type: "string" },
+		"disable-telemetry": { type: "boolean" },
+		"disable-update-check": { type: "boolean" },
+		"disable-experiments": { type: "boolean" },
+		"enable-sync": { type: "boolean" },
+		"enable-proposed-api": {
+			type: "string",
+			multiple: true
+		},
+		"disable-workspace-trust": { type: "boolean" },
+		"disable-getting-started-override": { type: "boolean" },
+		"enable-remote-auto-shutdown": { type: "boolean" },
+		"remote-auto-shutdown-without-delay": { type: "boolean" },
+		"without-browser-env-var": { type: "boolean" },
+		"reconnection-grace-time": { type: "string" },
+		"agent-host-path": { type: "string" },
+		"agent-host-port": { type: "string" },
+		"inspect-ptyhost": { type: "string" },
+		"inspect-brk-ptyhost": { type: "string" },
+		"inspect-agenthost": { type: "string" },
+		"inspect-brk-agenthost": { type: "string" },
+		"enable-smoke-test-driver": { type: "boolean" },
+		"crash-reporter-directory": { type: "string" },
+		"crash-reporter-id": { type: "string" },
+		"force-disable-user-env": { type: "boolean" },
+		"force-user-env": { type: "boolean" },
+		open: {
+			type: "boolean",
+			short: "o"
+		},
+		help: {
+			type: "boolean",
+			short: "h"
+		}
+	},
+	strict: true
+});
+if (values.help) {
+	console.log(`
+  Usage: code-server [options]
+
+  Server:
+    -p, --port <port>                    Port to listen on (default: $PORT or 8080)
+    -H, --host <host>                    Host/interface to bind
+        --server-base-path <path>        Base path for the web UI (default: /)
+        --socket-path <path>             Path to a socket file to listen on
+        --print-startup-performance      Print startup timing to stdout
+
+  Auth:
+        --connection-token <token>       Connection token for auth (auto-generated)
+        --connection-token-file <path>   Path to file containing connection token
+        --without-connection-token       Disable connection token auth
+        --auth <type>                    Auth type
+        --github-auth <token>            GitHub auth token
+
+  Defaults:
+        --default-folder <path>          Default workspace folder
+        --default-workspace <path>       Default workspace file
+        --locale <locale>                The locale to use (e.g. en-US)
+
+  Data:
+        --server-data-dir <path>         Server data directory
+        --user-data-dir <path>           User data directory
+        --extensions-dir <path>          Extensions directory
+        --extensions-download-dir <path> Extensions download directory
+        --builtin-extensions-dir <path>  Built-in extensions directory
+        --agent-plugins-dir <path>       Agent plugins directory
+
+  Logging:
+        --log <level>                    Log level (off, critical, error, warn, info, debug, trace)
+        --logs-path <path>               Logs output directory
+
+  Network:
+        --disable-websocket-compression  Disable WebSocket compression
+        --use-host-proxy                 Enable host proxy
+
+  Files:
+        --disable-file-downloads         Disable file downloads
+        --disable-file-uploads           Disable file uploads
+        --file-watcher-polling <ms>      File watcher polling interval
+
+  Telemetry:
+        --telemetry-level <level>        Telemetry level (off, crash, error, all)
+        --disable-telemetry              Disable telemetry
+        --disable-update-check           Disable update check
+        --disable-experiments            Disable experiments
+
+  Features:
+        --enable-sync                    Enable settings sync
+        --enable-proposed-api <ext-id>   Enable proposed API for extension (repeatable)
+        --disable-workspace-trust        Disable workspace trust
+        --disable-getting-started-override  Disable getting started override
+
+  Remote:
+        --enable-remote-auto-shutdown    Enable remote auto shutdown
+        --remote-auto-shutdown-without-delay  Auto shutdown without delay
+        --without-browser-env-var        Disable browser env var
+        --reconnection-grace-time <sec>  Reconnection grace time (default: 10800)
+
+  Agent Host:
+        --agent-host-path <path>         Agent host WebSocket socket path
+        --agent-host-port <port>         Agent host WebSocket port
+
+  Shell:
+        --force-disable-user-env         Force disable user shell env resolution
+        --force-user-env                 Force user shell env resolution
+
+  Debugging:
+        --inspect-ptyhost <port>         Inspect pty host
+        --inspect-brk-ptyhost <port>     Inspect pty host (break on start)
+        --inspect-agenthost <port>       Inspect agent host
+        --inspect-brk-agenthost <port>   Inspect agent host (break on start)
+        --enable-smoke-test-driver       Enable smoke test driver
+        --crash-reporter-directory <dir> Crash reporter directory
+        --crash-reporter-id <id>         Crash reporter ID
+
+    -o, --open                           Open in browser on startup
+    -h, --help                           Show this help message
+`);
+	process.exit(0);
+}
+const vscode = {};
+for (const key of [
+	"server-base-path",
+	"socket-path",
+	"print-startup-performance",
+	"connection-token-file",
+	"without-connection-token",
+	"auth",
+	"github-auth",
+	"default-workspace",
+	"locale",
+	"server-data-dir",
+	"user-data-dir",
+	"extensions-dir",
+	"extensions-download-dir",
+	"builtin-extensions-dir",
+	"agent-plugins-dir",
+	"log",
+	"file-watcher-polling",
+	"disable-websocket-compression",
+	"use-host-proxy",
+	"disable-file-downloads",
+	"disable-file-uploads",
+	"telemetry-level",
+	"disable-telemetry",
+	"disable-update-check",
+	"disable-experiments",
+	"enable-sync",
+	"enable-proposed-api",
+	"disable-workspace-trust",
+	"disable-getting-started-override",
+	"enable-remote-auto-shutdown",
+	"remote-auto-shutdown-without-delay",
+	"without-browser-env-var",
+	"reconnection-grace-time",
+	"agent-host-path",
+	"agent-host-port",
+	"inspect-ptyhost",
+	"inspect-brk-ptyhost",
+	"inspect-agenthost",
+	"inspect-brk-agenthost",
+	"enable-smoke-test-driver",
+	"crash-reporter-directory",
+	"crash-reporter-id",
+	"force-disable-user-env",
+	"force-user-env"
+]) if (values[key] !== void 0) vscode[key] = values[key];
+if (values["logs-path"]) vscode.logsPath = values["logs-path"];
+const dir = positionals[0];
+const autoPort0 = !values.port && values.open && !process.env.PORT;
+if (autoPort0 || dir) vscode["disable-workspace-trust"] = true;
+const handle = await startCodeServer({
+	port: values.port ? Number(values.port) : autoPort0 ? 0 : void 0,
+	host: values.host,
+	defaultFolder: dir || values["default-folder"],
+	connectionToken: values["connection-token"],
+	vscode
+});
+const c = {
+	cyan: "\x1B[36m",
+	bold: "\x1B[1m",
+	dim: "\x1B[2m",
+	reset: "\x1B[0m"
+};
+const mem = `${(process.memoryUsage.rss() / 1024 / 1024).toFixed(0)} MB`;
+console.log(`\n  ${c.bold}${c.cyan}➜${c.reset}  ${c.bold}Ready${c.reset} ${c.dim}at${c.reset} ${c.cyan}${handle.url}${c.reset}\n  ${c.bold}${c.cyan}➜${c.reset}  ${c.bold}Memory${c.reset} ${c.dim}${mem}${c.reset}\n`);
+if (values.open) {
+	const { exec } = await import("node:child_process");
+	const url = handle.url;
+	const platform = process.platform;
+	if (platform === "darwin") exec(`open -na "Google Chrome" --args --app="${url}" || open -na "Chromium" --args --app="${url}" || open "${url}"`);
+	else if (platform === "win32") exec(`start chrome --app="${url}" || start msedge --app="${url}" || start "" "${url}"`);
+	else exec(`google-chrome-stable --app="${url}" 2>/dev/null || google-chrome --app="${url}" 2>/dev/null || chromium --app="${url}" 2>/dev/null || xdg-open "${url}"`);
+}
+let shuttingDown = false;
+const shutdown = () => {
+	if (shuttingDown) return;
+	shuttingDown = true;
+	handle.close().finally(() => process.exit(0));
+};
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+export {};

package/dist/index.d.mts

@@ -0,0 +1,112 @@
+import { IncomingMessage, Server, ServerResponse } from "node:http";
+import { Duplex } from "node:stream";
+/**
+ * Options for `createServer()` from VS Code server
+ * (`code-server/lib/vscode/out/server-main.js`).
+ *
+ * Scope: only options that are actually consumed when the server is embedded
+ * via `createServer(null, opts)` — i.e. reached through `zF`/`jF`/`uM`/`AF`
+ * directly, or read from `environmentService.args` during request handling,
+ * workbench construction, or extension host setup.
+ *
+ * Options that only fire through the `spawnCli`/`YH` argv-parsing entry
+ * (license prompt, extension install/list/uninstall, host/port listen,
+ * `--folder-uri`, `--locate-shell-integration-path`, etc.) are intentionally
+ * omitted — passing them to `createServer()` has no effect.
+ */
+interface VSCodeServerOptions {
+  /** The path under which the web UI and the code server is provided. Defaults to `'/'`. */
+  "server-base-path"?: string;
+  /** The path to a socket file for the server to listen to. Also toggles Windows management-connection socket transfer. */
+  "socket-path"?: string;
+  /** Print startup timing breakdown to stdout once the server is ready. */
+  "print-startup-performance"?: boolean;
+  /** A secret that must be included with all requests. */
+  "connection-token"?: string;
+  /** Path to a file that contains the connection token. */
+  "connection-token-file"?: string;
+  /** Run without a connection token. Only use this if the connection is secured by other means. */
+  "without-connection-token"?: boolean;
+  auth?: string;
+  "github-auth"?: string;
+  /** Specifies the directory that server data is kept in. */
+  "server-data-dir"?: string;
+  "user-data-dir"?: string;
+  "extensions-dir"?: string;
+  "extensions-download-dir"?: string;
+  "builtin-extensions-dir"?: string;
+  /** The path to the directory where agent plugins are located. */
+  "agent-plugins-dir"?: string;
+  /** The workspace folder to open when no input is specified in the browser URL. A relative or absolute path resolved against the current working directory. */
+  "default-folder"?: string;
+  /** The workspace to open when no input is specified in the browser URL. A relative or absolute path resolved against the current working directory. */
+  "default-workspace"?: string;
+  locale?: string;
+  log?: string;
+  logsPath?: string;
+  "disable-websocket-compression"?: boolean;
+  "use-host-proxy"?: boolean;
+  "disable-file-downloads"?: boolean;
+  "disable-file-uploads"?: boolean;
+  "file-watcher-polling"?: string;
+  /** Sets the initial telemetry level. Valid levels are: `'off'`, `'crash'`, `'error'` and `'all'`. */
+  "telemetry-level"?: string;
+  "disable-telemetry"?: boolean;
+  "disable-update-check"?: boolean;
+  "disable-experiments"?: boolean;
+  "enable-sync"?: boolean;
+  "enable-proposed-api"?: string[];
+  "disable-workspace-trust"?: boolean;
+  "disable-getting-started-override"?: boolean;
+  "link-protection-trusted-domains"?: string[];
+  "enable-remote-auto-shutdown"?: boolean;
+  "remote-auto-shutdown-without-delay"?: boolean;
+  "without-browser-env-var"?: boolean;
+  /** Override the reconnection grace time window in seconds. Defaults to `10800` (3 hours). */
+  "reconnection-grace-time"?: string;
+  /** The path to a socket file for the agent host WebSocket server to listen on. */
+  "agent-host-path"?: string;
+  /** The port the agent host WebSocket server should listen on. */
+  "agent-host-port"?: string;
+  "inspect-ptyhost"?: string;
+  "inspect-brk-ptyhost"?: string;
+  "inspect-agenthost"?: string;
+  "inspect-brk-agenthost"?: string;
+  "enable-smoke-test-driver"?: boolean;
+  "crash-reporter-directory"?: string;
+  "crash-reporter-id"?: string;
+  "force-disable-user-env"?: boolean;
+  "force-user-env"?: boolean;
+}
+interface CreateCodeServerOptions {
+  /** Workspace folder opened when no input is given in the URL. */
+  defaultFolder?: string;
+  /** Connection token (shared auth secret). Auto-generated if omitted. */
+  connectionToken?: string;
+  /** Extra options forwarded to VS Code's `createServer()`. */
+  vscode?: VSCodeServerOptions;
+}
+interface StartCodeServerOptions extends CreateCodeServerOptions {
+  /** TCP port to listen on. Defaults to `$PORT` or `8080`. */
+  port?: number;
+  /** Host/interface to bind. Defaults to Node's default (all interfaces). */
+  host?: string;
+}
+interface CodeServerHandler {
+  /** Node-style HTTP request handler (middleware). */
+  handleRequest(req: IncomingMessage, res: ServerResponse): void;
+  /** Handle WebSocket upgrade. */
+  handleUpgrade(req: IncomingMessage, socket: Duplex): void;
+  connectionToken: string;
+  dispose(): Promise<void>;
+}
+interface CodeServerHandle {
+  server: Server;
+  port: number;
+  url: string;
+  connectionToken: string;
+  close(): Promise<void>;
+}
+declare function createCodeServer(opts?: CreateCodeServerOptions): Promise<CodeServerHandler>;
+declare function startCodeServer(opts?: StartCodeServerOptions): Promise<CodeServerHandle>;
+export { type CodeServerHandle, type CodeServerHandler, type CreateCodeServerOptions, type StartCodeServerOptions, createCodeServer, startCodeServer };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { n as startCodeServer, t as createCodeServer } from "./_chunks/server.mjs";
+export { createCodeServer, startCodeServer };

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "coderaft",
+  "version": "0.0.4",
+  "repository": "pithings/coderaft",
+  "bin": {
+    "coderaft": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist",
+    "LICENSE.md",
+    "ThirdPartyNotices.txt",
+    "tar.mjs",
+    "code.mjs",
+    "code.tar.zst"
+  ],
+  "type": "module",
+  "imports": {
+    "#code": "./code.mjs"
+  },
+  "scripts": {
+    "build": "obuild"
+  },
+  "devDependencies": {
+    "@anthropic-ai/sandbox-runtime": "0.0.42",
+    "@github/copilot": "^1.0.11",
+    "@github/copilot-sdk": "^0.2.0",
+    "@microsoft/1ds-core-js": "^3.2.13",
+    "@microsoft/1ds-post-js": "^3.2.13",
+    "@parcel/watcher": "^2.5.6",
+    "@vscode/deviceid": "^0.1.1",
+    "@vscode/fs-copyfile": "^2.0.0",
+    "@vscode/iconv-lite-umd": "0.7.1",
+    "@vscode/native-watchdog": "^1.4.6",
+    "@vscode/proxy-agent": "^0.40.0",
+    "@vscode/ripgrep": "^1.17.1",
+    "@vscode/spdlog": "^0.15.8",
+    "@vscode/tree-sitter-wasm": "^0.3.0",
+    "@vscode/vscode-languagedetection": "1.0.23",
+    "@vscode/windows-process-tree": "^0.6.0",
+    "@vscode/windows-registry": "^1.2.0",
+    "@xterm/addon-clipboard": "^0.3.0-beta.191",
+    "@xterm/addon-image": "^0.10.0-beta.191",
+    "@xterm/addon-ligatures": "^0.11.0-beta.191",
+    "@xterm/addon-progress": "^0.3.0-beta.191",
+    "@xterm/addon-search": "^0.17.0-beta.191",
+    "@xterm/addon-serialize": "^0.15.0-beta.191",
+    "@xterm/addon-unicode11": "^0.10.0-beta.191",
+    "@xterm/addon-webgl": "^0.20.0-beta.190",
+    "@xterm/headless": "^6.1.0-beta.191",
+    "@xterm/xterm": "^6.1.0-beta.191",
+    "code-server": "^4.114.0",
+    "cookie": "^0.7.0",
+    "http-proxy-agent": "^7.0.0",
+    "https-proxy-agent": "^7.0.2",
+    "jschardet": "3.1.4",
+    "katex": "^0.16.22",
+    "kerberos": "2.1.1",
+    "minimist": "^1.2.8",
+    "node-pty": "^1.2.0-beta.12",
+    "tas-client": "0.3.1",
+    "typescript": "^6.0.2",
+    "vscode-oniguruma": "1.7.0",
+    "vscode-regexpp": "^3.1.0",
+    "vscode-textmate": "^9.3.2",
+    "ws": "^8.19.0",
+    "yauzl": "^3.0.0",
+    "yazl": "^2.4.3"
+  }
+}

package/tar.mjs

@@ -0,0 +1,169 @@
+// Streaming tar.zst extractor with pool-buffer strategy.
+// Decompresses with Node's built-in zstd (libzstd) and parses tar entries
+// incrementally as chunks arrive — no need to buffer the full archive.
+// A single pre-allocated buffer (pool) grows to fit the largest tar entry,
+// then compacts after each batch of entries, keeping memory ~3x lower than
+// a full-buffer approach while matching or beating system tar in speed.
+// Supports USTAR, GNU long names (type "L"), pax headers, and symlinks.
+
+import { createReadStream, mkdirSync, openSync, writeSync, closeSync, symlinkSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { createZstdDecompress } from "node:zlib";
+
+const BLOCK = 512;
+const HIGH_WATER = 4 * 1024 * 1024; // 4MB initial buffer
+
+/**
+ * Extract a .tar.zst archive to a directory (streaming, low memory).
+ * @param {string} archivePath - path to .tar.zst file
+ * @param {string} destDir - destination directory
+ * @returns {Promise<void>}
+ */
+export async function extractTarZst(archivePath, destDir) {
+  const stream = createReadStream(archivePath).pipe(createZstdDecompress());
+
+  // Pre-allocated buffer with read/write cursors to avoid repeated concat
+  let pool = Buffer.allocUnsafe(HIGH_WATER);
+  let start = 0; // read cursor
+  let end = 0; // write cursor
+
+  let gnuLongName = "";
+  let paxPath = "";
+  const createdDirs = new Set();
+
+  function ensureDir(dir) {
+    if (!createdDirs.has(dir)) {
+      mkdirSync(dir, { recursive: true });
+      createdDirs.add(dir);
+    }
+  }
+
+  function available() {
+    return end - start;
+  }
+
+  function compact() {
+    if (start === 0) return;
+    if (start === end) {
+      start = end = 0;
+    } else {
+      pool.copy(pool, 0, start, end);
+      end -= start;
+      start = 0;
+    }
+  }
+
+  function appendChunk(chunk) {
+    const needed = end + chunk.length;
+    if (needed > pool.length) {
+      // Grow: max of double or exactly what's needed
+      const newSize = Math.max(pool.length * 2, needed - start);
+      const newPool = Buffer.allocUnsafe(newSize);
+      pool.copy(newPool, 0, start, end);
+      end -= start;
+      start = 0;
+      pool = newPool;
+    } else if (end + chunk.length > pool.length) {
+      compact();
+    }
+    chunk.copy(pool, end);
+    end += chunk.length;
+  }
+
+  function processEntries() {
+    while (available() >= BLOCK) {
+      // Null block
+      if (pool[start] === 0 && pool[start + 1] === 0) {
+        start += BLOCK;
+        continue;
+      }
+
+      const size = parseOctal(pool, start + 124, 12);
+      const typeflag = String.fromCharCode(pool[start + 156]);
+      const dataBlocks = Math.ceil(size / BLOCK) * BLOCK;
+      const totalNeeded = BLOCK + dataBlocks;
+
+      if (available() < totalNeeded) break;
+
+      const headerStart = start;
+      const dataStart = start + BLOCK;
+
+      if (typeflag === "L") {
+        // eslint-disable-next-line no-control-regex
+        gnuLongName = pool.toString("utf8", dataStart, dataStart + size).replace(/\0+$/, "");
+        start += totalNeeded;
+        continue;
+      }
+
+      if (typeflag === "x") {
+        paxPath = parsePaxPath(pool.toString("utf8", dataStart, dataStart + size));
+        start += totalNeeded;
+        continue;
+      }
+
+      if (typeflag === "g") {
+        start += totalNeeded;
+        continue;
+      }
+
+      const name = gnuLongName || paxPath || readTarPath(pool, headerStart);
+      gnuLongName = "";
+      paxPath = "";
+
+      if (name) {
+        const fullPath = join(destDir, name);
+
+        if (typeflag === "5" || name.endsWith("/")) {
+          ensureDir(fullPath);
+        } else if (typeflag === "2") {
+          const linkname = readString(pool, headerStart + 157, 100);
+          ensureDir(dirname(fullPath));
+          symlinkSync(linkname, fullPath);
+        } else if (typeflag === "0" || typeflag === "\0") {
+          ensureDir(dirname(fullPath));
+          const fd = openSync(fullPath, "w", parseOctal(pool, headerStart + 100, 8) || 0o644);
+          writeSync(fd, pool, dataStart, size);
+          closeSync(fd);
+        }
+      }
+
+      start += totalNeeded;
+    }
+  }
+
+  for await (const chunk of stream) {
+    appendChunk(chunk);
+    processEntries();
+    compact();
+  }
+
+  // Process any remaining data
+  processEntries();
+}
+
+// --- tar header parsing ---
+
+function readTarPath(buf, offset) {
+  const prefix = readString(buf, offset + 345, 155);
+  const name = readString(buf, offset, 100);
+  return prefix ? prefix + "/" + name : name;
+}
+
+function readString(buf, offset, length) {
+  const end = buf.indexOf(0, offset);
+  const slice = buf.subarray(offset, end >= 0 && end < offset + length ? end : offset + length);
+  return slice.toString("utf8");
+}
+
+function parseOctal(buf, offset, length) {
+  const str = readString(buf, offset, length).trim();
+  return str ? parseInt(str, 8) || 0 : 0;
+}
+
+function parsePaxPath(paxData) {
+  for (const line of paxData.split("\n")) {
+    const match = line.match(/^\d+ path=(.+)/);
+    if (match) return match[1];
+  }
+  return "";
+}