@cjhyy/code-shell-server 0.8.0

package/dist/attachment-service.js

@@ -0,0 +1,587 @@
+import { createHash } from "node:crypto";
+import { appendFile, lstat, mkdir, readdir, readFile, realpath, rename, rm, stat, writeFile, } from "node:fs/promises";
+import { basename, extname, join, relative, resolve, sep } from "node:path";
+import { sanitizeImageBytes } from "./image-byte-probe.js";
+const CODE_SHELL_DIR = ".code-shell";
+const ATTACHMENTS_DIR = "attachments";
+const MANIFEST_FILE = "manifest.jsonl";
+const GITIGNORE_CONTENT = "*\n!.gitignore\n";
+export const DRAFT_ATTACHMENT_TTL_MS = 24 * 60 * 60 * 1000;
+export const SENT_ATTACHMENT_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+export const MAX_STAGED_IMAGE_BYTES = 10 * 1024 * 1024;
+export const MAX_STAGED_FILE_BYTES = 20 * 1024 * 1024;
+const IMAGE_MIME_EXT = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/jpg": ".jpg",
+    "image/webp": ".webp",
+    "image/gif": ".gif",
+};
+const ALLOWED_IMAGE_MIMES = new Set(Object.keys(IMAGE_MIME_EXT));
+let idCounter = 0;
+export async function stageImageDataUrl(input) {
+    const parsed = parseDataUrl(input.dataUrl);
+    if (!parsed || !ALLOWED_IMAGE_MIMES.has(parsed.mime)) {
+        throw new Error(`unsupported image data URL MIME`);
+    }
+    if (input.mime && normalizeMime(input.mime) !== parsed.mime) {
+        throw new Error(`data URL MIME ${parsed.mime} does not match declared MIME ${input.mime}`);
+    }
+    return stageImageBuffer(input, parsed.mime, parsed.buffer);
+}
+/** Stage already-transferred bytes without expanding them back through base64. */
+export async function stageImageBytes(input) {
+    const mime = normalizeMime(input.mime);
+    if (!ALLOWED_IMAGE_MIMES.has(mime))
+        throw new Error(`unsupported image MIME ${input.mime}`);
+    if ((input.bytes === undefined) === (input.sourceFile === undefined)) {
+        throw new Error("exactly one of bytes or sourceFile is required");
+    }
+    let buffer;
+    if (input.sourceFile !== undefined) {
+        const source = await lstat(input.sourceFile);
+        if (!source.isFile() || source.isSymbolicLink()) {
+            throw new Error("image source must be a regular file");
+        }
+        if (source.size > MAX_STAGED_IMAGE_BYTES) {
+            throw new Error(`image attachment exceeds size limit (${formatBytes(MAX_STAGED_IMAGE_BYTES)})`);
+        }
+        buffer = await readFile(input.sourceFile);
+    }
+    else {
+        buffer = Buffer.from(input.bytes);
+    }
+    return stageImageBuffer(input, mime, buffer);
+}
+async function stageImageBuffer(input, mime, buffer) {
+    const cwd = await resolveExistingDirectory(input.cwd, "cwd");
+    assertSafeSessionId(input.sessionId);
+    if (buffer.byteLength > MAX_STAGED_IMAGE_BYTES) {
+        throw new Error(`image attachment exceeds size limit (${formatBytes(MAX_STAGED_IMAGE_BYTES)})`);
+    }
+    const sanitized = sanitizeImageBytes(mime, buffer);
+    buffer = sanitized.bytes;
+    const image = sanitized.image;
+    const attachmentsRoot = await ensureAttachmentsRoot(cwd);
+    const sessionDir = await ensureSessionDir(attachmentsRoot, input.sessionId);
+    const sha256 = createHash("sha256").update(buffer).digest("hex");
+    const sha16 = sha256.slice(0, 16);
+    const ext = IMAGE_MIME_EXT[mime] ?? ".bin";
+    const safeBase = safeSlug(input.name, "image");
+    const existing = await findExistingSessionFile(sessionDir, sha16);
+    const filename = existing ?? `${sha16}-${safeBase}${ext}`;
+    const absPath = await safeJoin(sessionDir, filename, sessionDir);
+    if (!existing) {
+        const tmpPath = await safeJoin(sessionDir, `.${filename}.${process.pid}.${Date.now()}.tmp`, sessionDir);
+        await writeFile(tmpPath, buffer, { flag: "wx" });
+        try {
+            await rename(tmpPath, absPath);
+        }
+        catch (error) {
+            await rm(tmpPath, { force: true }).catch(() => undefined);
+            throw error;
+        }
+    }
+    const relPath = normalizePath(relative(cwd, absPath));
+    const createdAt = Date.now();
+    idCounter += 1;
+    const meta = {
+        id: `att_${sha16}_${idCounter.toString(36)}`,
+        sessionId: input.sessionId,
+        kind: "image",
+        origin: input.origin,
+        path: relPath,
+        absPath,
+        relPath,
+        mime,
+        size: buffer.byteLength,
+        sha256,
+        ...(input.name ? { originalName: input.name } : {}),
+        createdAt,
+        width: image.width,
+        height: image.height,
+        vision: { include: true },
+    };
+    await appendManifest(sessionDir, { event: "staged", status: "draft", ...meta });
+    return meta;
+}
+/** Stage an untrusted non-image file inside the canonical attachment root. */
+export async function stageFileBytes(input) {
+    const cwd = await resolveExistingDirectory(input.cwd, "cwd");
+    assertSafeSessionId(input.sessionId);
+    const buffer = Buffer.from(input.bytes);
+    if (buffer.byteLength > MAX_STAGED_FILE_BYTES) {
+        throw new Error(`file attachment exceeds size limit (${formatBytes(MAX_STAGED_FILE_BYTES)})`);
+    }
+    const attachmentsRoot = await ensureAttachmentsRoot(cwd);
+    const sessionDir = await ensureSessionDir(attachmentsRoot, input.sessionId);
+    const sha256 = createHash("sha256").update(buffer).digest("hex");
+    const sha16 = sha256.slice(0, 16);
+    const safeBase = safeSlug(input.name, "file");
+    const rawExt = extname(basename(input.name ?? ""));
+    const originalExt = /^\.[A-Za-z0-9]{1,15}$/.test(rawExt) ? rawExt : "";
+    const existing = await findExistingSessionFile(sessionDir, sha16);
+    const filename = existing ?? `${sha16}-${safeBase}${originalExt}`;
+    const absPath = await safeJoin(sessionDir, filename, sessionDir);
+    if (!existing) {
+        const tmpPath = await safeJoin(sessionDir, `.${filename}.${process.pid}.${Date.now()}.tmp`, sessionDir);
+        await writeFile(tmpPath, buffer, { flag: "wx" });
+        try {
+            await rename(tmpPath, absPath);
+        }
+        catch (error) {
+            await rm(tmpPath, { force: true }).catch(() => undefined);
+            throw error;
+        }
+    }
+    const relPath = normalizePath(relative(cwd, absPath));
+    const createdAt = Date.now();
+    idCounter += 1;
+    const meta = {
+        id: `att_${sha16}_${idCounter.toString(36)}`,
+        sessionId: input.sessionId,
+        kind: "file",
+        origin: input.origin,
+        path: relPath,
+        absPath,
+        relPath,
+        mime: normalizeMime(input.mime) || "application/octet-stream",
+        size: buffer.byteLength,
+        sha256,
+        ...(input.name ? { originalName: basename(input.name) } : {}),
+        createdAt,
+    };
+    await appendManifest(sessionDir, { event: "staged", status: "draft", ...meta });
+    return meta;
+}
+export async function markAttachmentsSent(cwd, sessionId, attachments) {
+    if (attachments.length === 0)
+        return;
+    const resolvedCwd = await resolveExistingDirectory(cwd, "cwd");
+    assertSafeSessionId(sessionId);
+    const sessionDir = await ensureSessionDir(await ensureAttachmentsRoot(resolvedCwd), sessionId);
+    const sentAt = Date.now();
+    for (const attachment of attachments) {
+        if (attachment.sessionId !== sessionId)
+            continue;
+        await appendManifest(sessionDir, {
+            event: "sent",
+            id: attachment.id,
+            sessionId,
+            kind: attachment.kind,
+            origin: attachment.origin,
+            path: attachment.path,
+            absPath: attachment.absPath,
+            relPath: attachment.relPath,
+            mime: attachment.mime,
+            size: attachment.size,
+            sha256: attachment.sha256,
+            originalName: attachment.originalName,
+            sentAt,
+            status: "sent",
+        });
+    }
+}
+export async function listRecentAttachments(input) {
+    const cwd = await resolveExistingDirectory(input.cwd, "cwd");
+    const root = await resolveAttachmentsRoot(cwd);
+    if (!root)
+        return [];
+    const sessionIds = input.sessionId ? [input.sessionId] : await listSafeSessionDirs(root);
+    const staged = new Map();
+    const sent = new Set();
+    for (const sessionId of sessionIds) {
+        assertSafeSessionId(sessionId);
+        const sessionDir = await safeJoin(root, sessionId, root).catch(() => null);
+        if (!sessionDir)
+            continue;
+        const records = await readManifest(sessionDir);
+        for (const record of records) {
+            if (record.event === "staged") {
+                const meta = recordToMeta(record);
+                if (meta && (await pathExistsInside(meta.absPath, root))) {
+                    staged.set(meta.id, meta);
+                }
+            }
+            else if (record.event === "sent" && record.id) {
+                sent.add(record.id);
+            }
+            else if ((record.event === "removedFromDraft" || record.event === "cleanup") && record.id) {
+                staged.delete(record.id);
+            }
+        }
+    }
+    return [...staged.values()]
+        .filter((meta) => sent.has(meta.id) || meta.kind !== "image")
+        .sort((a, b) => b.createdAt - a.createdAt)
+        .slice(0, 50);
+}
+export async function cleanupAttachments(input) {
+    const cwd = await resolveExistingDirectory(input.cwd, "cwd");
+    const root = await resolveAttachmentsRoot(cwd);
+    if (!root)
+        return { removed: [], sessionsRemoved: [] };
+    const now = input.now ?? Date.now();
+    const sessionIds = input.sessionId ? [input.sessionId] : await listSafeSessionDirs(root);
+    const removed = [];
+    const sessionsRemoved = [];
+    for (const sessionId of sessionIds) {
+        assertSafeSessionId(sessionId);
+        const sessionDir = await safeJoin(root, sessionId, root).catch(() => null);
+        if (!sessionDir)
+            continue;
+        const records = await readManifest(sessionDir);
+        if (input.sessionId) {
+            const files = await manifestFilesInside(records, root);
+            for (const file of files) {
+                await rm(file, { force: true }).catch(() => undefined);
+                removed.push(file);
+            }
+            await rm(sessionDir, { recursive: true, force: true }).catch(() => undefined);
+            sessionsRemoved.push(sessionId);
+            continue;
+        }
+        const latest = latestAttachmentState(records);
+        for (const state of latest.values()) {
+            const createdAt = state.createdAt ?? 0;
+            const sentAt = state.sentAt;
+            const isSent = typeof sentAt === "number";
+            const ttl = isSent ? SENT_ATTACHMENT_TTL_MS : DRAFT_ATTACHMENT_TTL_MS;
+            const basis = isSent ? sentAt : createdAt;
+            if (!basis || now - basis < ttl)
+                continue;
+            if (!state.absPath || !(await pathExistsInside(state.absPath, root)))
+                continue;
+            await rm(state.absPath, { force: true }).catch(() => undefined);
+            removed.push(state.absPath);
+            await appendManifest(sessionDir, {
+                event: "cleanup",
+                id: state.id,
+                sessionId,
+                absPath: state.absPath,
+                relPath: state.relPath,
+                path: state.path,
+                sha256: state.sha256,
+                cleanedAt: now,
+            });
+        }
+    }
+    return { removed, sessionsRemoved };
+}
+export async function cleanupSessionAttachments(cwd, sessionId) {
+    await cleanupAttachments({ cwd, sessionId }).catch(() => undefined);
+}
+function normalizeMime(mime) {
+    return String(mime ?? "")
+        .trim()
+        .toLowerCase();
+}
+function parseDataUrl(dataUrl) {
+    if (typeof dataUrl !== "string")
+        return null;
+    const match = /^data:([^;,]+);base64,([\s\S]*)$/.exec(dataUrl);
+    if (!match)
+        return null;
+    const mime = normalizeMime(match[1]);
+    const base64 = (match[2] ?? "").replace(/\s+/g, "");
+    const decodedSize = byteLengthFromBase64(base64);
+    if (decodedSize > MAX_STAGED_IMAGE_BYTES) {
+        throw new Error(`image attachment exceeds decoded size limit (${formatBytes(MAX_STAGED_IMAGE_BYTES)})`);
+    }
+    try {
+        const buffer = Buffer.from(base64, "base64");
+        if (buffer.byteLength > MAX_STAGED_IMAGE_BYTES) {
+            throw new Error(`image attachment exceeds decoded size limit (${formatBytes(MAX_STAGED_IMAGE_BYTES)})`);
+        }
+        return { mime, buffer };
+    }
+    catch (error) {
+        if (String(error.message).includes("decoded size limit"))
+            throw error;
+        return null;
+    }
+}
+function byteLengthFromBase64(base64) {
+    if (!base64)
+        return 0;
+    const padding = base64.endsWith("==") ? 2 : base64.endsWith("=") ? 1 : 0;
+    return Math.max(0, Math.floor((base64.length * 3) / 4) - padding);
+}
+function formatBytes(bytes) {
+    return `${(bytes / 1024 / 1024).toFixed(0)} MB`;
+}
+async function resolveExistingDirectory(path, label) {
+    if (typeof path !== "string" || path.length === 0) {
+        throw new Error(`${label} must be a non-empty string`);
+    }
+    const resolved = resolve(path);
+    const info = await stat(resolved);
+    if (!info.isDirectory())
+        throw new Error(`${label} must be a directory`);
+    return realpath(resolved);
+}
+export function assertSafeSessionId(sessionId) {
+    if (typeof sessionId !== "string" || sessionId.length === 0) {
+        throw new Error(`invalid session id: must be a non-empty string`);
+    }
+    if (sessionId.includes("/") || sessionId.includes("\\")) {
+        throw new Error(`invalid session id: contains path separator`);
+    }
+    if (sessionId === "." || sessionId === ".." || sessionId.includes("..")) {
+        throw new Error(`invalid session id: contains parent-dir token`);
+    }
+    if (!/^[A-Za-z0-9_.-]+$/.test(sessionId)) {
+        throw new Error(`invalid session id: unexpected characters`);
+    }
+    if (sessionId.length > 128) {
+        throw new Error(`invalid session id: too long`);
+    }
+}
+async function ensureAttachmentsRoot(cwd) {
+    const codeShellDir = await safeJoin(cwd, CODE_SHELL_DIR, cwd);
+    await rejectSymlinkIfExists(codeShellDir, "CodeShell state directory");
+    await mkdir(codeShellDir, { recursive: true });
+    const codeShellReal = await realDirectoryInside(codeShellDir, cwd, {
+        label: "CodeShell state directory",
+        allowSame: false,
+    });
+    const gitignore = await safeJoin(codeShellReal, ".gitignore", codeShellReal);
+    await writeFile(gitignore, GITIGNORE_CONTENT, "utf-8");
+    const attachmentsRoot = await safeJoin(codeShellReal, ATTACHMENTS_DIR, codeShellReal);
+    await rejectSymlinkIfExists(attachmentsRoot, "attachments root");
+    await mkdir(attachmentsRoot, { recursive: true });
+    return realDirectoryInside(attachmentsRoot, codeShellReal, {
+        label: "attachments root",
+        allowSame: false,
+    });
+}
+async function resolveAttachmentsRoot(cwd) {
+    const root = join(cwd, CODE_SHELL_DIR, ATTACHMENTS_DIR);
+    try {
+        const info = await lstat(root);
+        if (info.isSymbolicLink())
+            throw new Error(`attachments root must not be a symlink`);
+        if (!info.isDirectory())
+            return null;
+        return realDirectoryInside(root, join(cwd, CODE_SHELL_DIR), {
+            label: "attachments root",
+            allowSame: false,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+async function ensureSessionDir(attachmentsRoot, sessionId) {
+    const sessionDir = await safeJoin(attachmentsRoot, sessionId, attachmentsRoot);
+    await rejectSymlinkIfExists(sessionDir, "attachment session directory");
+    await mkdir(sessionDir, { recursive: true });
+    return realDirectoryInside(sessionDir, attachmentsRoot, {
+        label: "attachment session directory",
+        allowSame: false,
+    });
+}
+async function safeJoin(root, child, containmentRoot) {
+    const parent = await realpath(root);
+    const normalizedContainment = await realpath(containmentRoot);
+    const target = resolve(parent, child);
+    assertInside(target, normalizedContainment, {
+        label: "attachment path",
+        allowSame: false,
+    });
+    assertInside(target, parent, {
+        label: "attachment path",
+        allowSame: false,
+    });
+    try {
+        const info = await lstat(target);
+        if (info.isSymbolicLink())
+            throw new Error(`attachment path must not be a symlink`);
+        const targetReal = await realpath(target);
+        assertInside(targetReal, normalizedContainment, {
+            label: "attachment path",
+            allowSame: false,
+        });
+        assertInside(targetReal, parent, {
+            label: "attachment path",
+            allowSame: false,
+        });
+        return targetReal;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return target;
+        throw error;
+    }
+}
+async function rejectSymlinkIfExists(path, label) {
+    try {
+        const info = await lstat(path);
+        if (info.isSymbolicLink())
+            throw new Error(`${label} must not be a symlink`);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+}
+async function realDirectoryInside(path, containmentRoot, opts) {
+    const info = await lstat(path);
+    if (info.isSymbolicLink())
+        throw new Error(`${opts.label} must not be a symlink`);
+    if (!info.isDirectory())
+        throw new Error(`${opts.label} must be a directory`);
+    const real = await realpath(path);
+    const rootReal = await realpath(containmentRoot);
+    assertInside(real, rootReal, opts);
+    return real;
+}
+function assertInside(target, containmentRoot, opts) {
+    const rel = relative(containmentRoot, target);
+    if (rel === ".." ||
+        rel.startsWith(`..${sep}`) ||
+        (!opts.allowSame && resolve(target) === resolve(containmentRoot))) {
+        throw new Error(`path escapes attachment root`);
+    }
+}
+async function pathExistsInside(absPath, root) {
+    try {
+        const info = await lstat(absPath);
+        if (info.isSymbolicLink())
+            return false;
+        const fileReal = await realpath(absPath);
+        const rootReal = await realpath(root);
+        const rel = relative(rootReal, fileReal);
+        return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep}`);
+    }
+    catch {
+        return false;
+    }
+}
+function safeSlug(name, fallback) {
+    const base = basename(String(name ?? fallback));
+    const noExt = base.slice(0, base.length - extname(base).length) || fallback;
+    const slug = noExt
+        .normalize("NFKC")
+        .replace(/[\u0000-\u001f\u007f<>:"/\\|?*]+/g, "-")
+        .replace(/\s+/g, "-")
+        .replace(/^\.+|\.+$/g, "")
+        .replace(/-+/g, "-")
+        .slice(0, 80)
+        .replace(/[-. ]+$/g, "");
+    return slug || fallback;
+}
+async function findExistingSessionFile(sessionDir, sha16) {
+    let entries;
+    try {
+        entries = await readdir(sessionDir);
+    }
+    catch {
+        return null;
+    }
+    return entries.find((entry) => entry.startsWith(`${sha16}-`) && entry !== MANIFEST_FILE) ?? null;
+}
+async function appendManifest(sessionDir, record) {
+    const manifest = await safeJoin(sessionDir, MANIFEST_FILE, sessionDir);
+    await appendFile(manifest, `${JSON.stringify(record)}\n`, "utf-8");
+}
+async function readManifest(sessionDir) {
+    try {
+        const manifest = await safeJoin(sessionDir, MANIFEST_FILE, sessionDir);
+        const raw = await readFile(manifest, "utf-8");
+        return raw
+            .split("\n")
+            .filter(Boolean)
+            .map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((record) => !!record);
+    }
+    catch {
+        return [];
+    }
+}
+async function listSafeSessionDirs(root) {
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .filter((name) => {
+        try {
+            assertSafeSessionId(name);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function normalizePath(p) {
+    return sep === "\\" ? p.replace(/\\/g, "/") : p;
+}
+function recordToMeta(record) {
+    if (!record.id ||
+        !record.sessionId ||
+        !record.kind ||
+        !record.origin ||
+        !record.path ||
+        !record.absPath ||
+        typeof record.size !== "number" ||
+        !record.sha256 ||
+        typeof record.createdAt !== "number") {
+        return null;
+    }
+    return {
+        id: record.id,
+        sessionId: record.sessionId,
+        kind: record.kind,
+        origin: record.origin,
+        path: record.path,
+        absPath: record.absPath,
+        relPath: record.relPath,
+        mime: record.mime,
+        size: record.size,
+        sha256: record.sha256,
+        originalName: record.originalName,
+        createdAt: record.createdAt,
+        vision: record.kind === "image" ? { include: true } : undefined,
+    };
+}
+async function manifestFilesInside(records, root) {
+    const files = new Set();
+    for (const record of records) {
+        if (!record.absPath)
+            continue;
+        if (await pathExistsInside(record.absPath, root))
+            files.add(record.absPath);
+    }
+    return [...files];
+}
+function latestAttachmentState(records) {
+    const latest = new Map();
+    for (const record of records) {
+        if (!record.id)
+            continue;
+        if (record.event === "staged")
+            latest.set(record.id, record);
+        if (record.event === "sent") {
+            const prev = latest.get(record.id) ?? record;
+            latest.set(record.id, { ...prev, ...record, status: "sent" });
+        }
+        if (record.event === "removedFromDraft" || record.event === "cleanup")
+            latest.delete(record.id);
+    }
+    return latest;
+}

package/dist/bin/code-shell-serve.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/code-shell-serve.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Headless no-account web host CLI. See serve/cli.ts.
+import { runServeCli } from "../serve/cli.js";
+runServeCli().catch((error) => {
+    console.error(`[serve] fatal: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+});

package/dist/client-message-id.d.ts

@@ -0,0 +1 @@
+export declare function stablePromptHash(text: string): string;

package/dist/client-message-id.js

@@ -0,0 +1,8 @@
+export function stablePromptHash(text) {
+    let h = 2166136261;
+    for (let i = 0; i < text.length; i += 1) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return `${(h >>> 0).toString(36)}-${text.length.toString(36)}`;
+}

package/dist/image-byte-probe.d.ts

@@ -0,0 +1,17 @@
+export interface ProbedImage {
+    mime: "image/png" | "image/jpeg" | "image/gif" | "image/webp";
+    width: number;
+    height: number;
+}
+export interface SanitizedImageBytes {
+    image: ProbedImage;
+    bytes: Buffer;
+    trailingBytes: number;
+}
+/** Strictly verify byte signature, bounded container structure, and declared MIME. */
+export declare function probeImageBytes(declaredMime: string, bytes: Uint8Array): ProbedImage;
+/**
+ * Verify untrusted image bytes and remove data after a complete JPEG EOI marker.
+ * Other image formats remain strict, and the returned JPEG is probed again after truncation.
+ */
+export declare function sanitizeImageBytes(declaredMime: string, bytes: Uint8Array): SanitizedImageBytes;