teamcopilot 0.0.1

package/dist/utils/resource-files.js

@@ -0,0 +1,572 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResourceFileManager = createResourceFileManager;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const redact_1 = require("./redact");
+function createResourceFileManager(options) {
+    const { getResourcePath, resourceLabel, editorLabel } = options;
+    const rootLabel = `${resourceLabel} root`;
+    const symlinkRootError = `${editorLabel} editor does not support symlinked ${resourceLabel} directories`;
+    const symlinkError = `${editorLabel} editor does not support symlinks`;
+    function toEtag(buffer) {
+        return crypto_1.default.createHash("sha256").update(buffer).digest("hex");
+    }
+    function normalizeRelativePath(rawPath, allowEmpty) {
+        const input = rawPath.trim();
+        if (!input) {
+            if (allowEmpty) {
+                return "";
+            }
+            throw {
+                status: 400,
+                message: "path is required"
+            };
+        }
+        if (input.includes("\0")) {
+            throw {
+                status: 400,
+                message: "path contains invalid characters"
+            };
+        }
+        const withForwardSlashes = input.replace(/\\/g, "/");
+        if (withForwardSlashes.startsWith("/")) {
+            throw {
+                status: 400,
+                message: `path must be relative to the ${rootLabel}`
+            };
+        }
+        const normalized = path_1.default.posix.normalize(withForwardSlashes);
+        if (normalized === "." && allowEmpty) {
+            return "";
+        }
+        if (normalized === "." || normalized.startsWith("../") || normalized === "..") {
+            throw {
+                status: 400,
+                message: `path escapes the ${rootLabel}`
+            };
+        }
+        return normalized;
+    }
+    function resolveTarget(slug, relativePath) {
+        const root = getResourcePath(slug);
+        const absolute = path_1.default.resolve(root, relativePath);
+        const normalizedRoot = path_1.default.resolve(root);
+        if (absolute !== normalizedRoot && !absolute.startsWith(`${normalizedRoot}${path_1.default.sep}`)) {
+            throw {
+                status: 400,
+                message: `path escapes the ${rootLabel}`
+            };
+        }
+        return absolute;
+    }
+    function assertRootNotSymlink(slug) {
+        const resourceRoot = getResourcePath(slug);
+        if (!fs_1.default.existsSync(resourceRoot)) {
+            return;
+        }
+        const rootLstat = fs_1.default.lstatSync(resourceRoot);
+        if (rootLstat.isSymbolicLink()) {
+            throw {
+                status: 400,
+                message: symlinkRootError
+            };
+        }
+    }
+    function assertRealPathWithinRoot(slug, absolutePath) {
+        const realRoot = fs_1.default.realpathSync(getResourcePath(slug));
+        const realTarget = fs_1.default.realpathSync(absolutePath);
+        if (realTarget !== realRoot && !realTarget.startsWith(`${realRoot}${path_1.default.sep}`)) {
+            throw {
+                status: 400,
+                message: `path escapes the ${rootLabel}`
+            };
+        }
+    }
+    function assertNoSymlinkInAncestors(slug, absolutePath) {
+        const root = path_1.default.resolve(getResourcePath(slug));
+        let current = path_1.default.resolve(absolutePath);
+        while (true) {
+            const lstat = fs_1.default.lstatSync(current);
+            if (lstat.isSymbolicLink()) {
+                throw {
+                    status: 400,
+                    message: symlinkError
+                };
+            }
+            if (current === root) {
+                return;
+            }
+            const parent = path_1.default.dirname(current);
+            if (parent === current) {
+                throw {
+                    status: 400,
+                    message: `path escapes the ${rootLabel}`
+                };
+            }
+            current = parent;
+        }
+    }
+    function assertExistingPathIsSafe(slug, absolutePath) {
+        assertRootNotSymlink(slug);
+        assertRealPathWithinRoot(slug, absolutePath);
+        assertNoSymlinkInAncestors(slug, absolutePath);
+    }
+    function assertParentDirectoryIsSafeForCreate(slug, parentAbsolutePath) {
+        assertRootNotSymlink(slug);
+        assertRealPathWithinRoot(slug, parentAbsolutePath);
+        assertNoSymlinkInAncestors(slug, parentAbsolutePath);
+    }
+    function assertValidName(name) {
+        const trimmed = name.trim();
+        if (!trimmed || trimmed === "." || trimmed === "..") {
+            throw {
+                status: 400,
+                message: "Invalid file or folder name"
+            };
+        }
+        if (trimmed.includes("/") || trimmed.includes("\\") || trimmed.includes("\0")) {
+            throw {
+                status: 400,
+                message: "Invalid file or folder name"
+            };
+        }
+    }
+    function findClosingQuoteIndex(input, quote) {
+        for (let i = 1; i < input.length; i += 1) {
+            const ch = input[i];
+            if (ch === "\\") {
+                i += 1;
+                continue;
+            }
+            if (ch === quote) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    function toFileNode(parentRelativePath, name, absolutePath) {
+        const lstat = fs_1.default.lstatSync(absolutePath);
+        const isDir = lstat.isDirectory();
+        let readable = true;
+        try {
+            fs_1.default.accessSync(absolutePath, fs_1.default.constants.R_OK);
+        }
+        catch {
+            readable = false;
+        }
+        let hasChildren = null;
+        if (isDir && readable) {
+            try {
+                hasChildren = fs_1.default.readdirSync(absolutePath).length > 0;
+            }
+            catch {
+                hasChildren = false;
+                readable = false;
+            }
+        }
+        const relativePath = parentRelativePath ? `${parentRelativePath}/${name}` : name;
+        return {
+            path: relativePath,
+            name,
+            kind: isDir ? "directory" : "file",
+            size_bytes: isDir ? null : lstat.size,
+            modified_at_ms: lstat.mtimeMs,
+            has_children: isDir ? (hasChildren ?? false) : null,
+            readable,
+        };
+    }
+    function compareNodes(a, b) {
+        if (a.kind !== b.kind) {
+            return a.kind === "directory" ? -1 : 1;
+        }
+        return a.name.localeCompare(b.name);
+    }
+    function looksBinary(buffer) {
+        if (buffer.length === 0) {
+            return false;
+        }
+        const sample = buffer.subarray(0, Math.min(buffer.length, 8000));
+        for (let i = 0; i < sample.length; i += 1) {
+            if (sample[i] === 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+    function parseEnvAssignmentLine(line) {
+        const match = line.match(/^(\s*(?:export\s+)?)([A-Za-z_][A-Za-z0-9_-]*)(\s*=\s*)(.*)$/);
+        if (!match) {
+            return { kind: "other" };
+        }
+        const [, prefix, key, separator, remainder] = match;
+        if (remainder.startsWith('"')) {
+            const closeIdx = findClosingQuoteIndex(remainder, '"');
+            if (closeIdx === -1) {
+                return { kind: "other" };
+            }
+            return {
+                kind: "assignment",
+                prefix,
+                key,
+                separator,
+                quote: '"',
+                value: remainder.slice(1, closeIdx),
+                suffix: remainder.slice(closeIdx + 1),
+            };
+        }
+        if (remainder.startsWith("'")) {
+            const closeIdx = findClosingQuoteIndex(remainder, "'");
+            if (closeIdx === -1) {
+                return { kind: "other" };
+            }
+            return {
+                kind: "assignment",
+                prefix,
+                key,
+                separator,
+                quote: "'",
+                value: remainder.slice(1, closeIdx),
+                suffix: remainder.slice(closeIdx + 1),
+            };
+        }
+        const commentStart = remainder.search(/\s#/);
+        if (commentStart === -1) {
+            return {
+                kind: "assignment",
+                prefix,
+                key,
+                separator,
+                quote: null,
+                value: remainder.trim(),
+                suffix: "",
+            };
+        }
+        const valuePart = remainder.slice(0, commentStart).trim();
+        const suffix = remainder.slice(commentStart);
+        return {
+            kind: "assignment",
+            prefix,
+            key,
+            separator,
+            quote: null,
+            value: valuePart,
+            suffix,
+        };
+    }
+    function serializeEnvAssignment(parsed) {
+        if (parsed.quote === '"') {
+            return `${parsed.prefix}${parsed.key}${parsed.separator}"${parsed.value}"${parsed.suffix}`;
+        }
+        if (parsed.quote === "'") {
+            return `${parsed.prefix}${parsed.key}${parsed.separator}'${parsed.value}'${parsed.suffix}`;
+        }
+        return `${parsed.prefix}${parsed.key}${parsed.separator}${parsed.value}${parsed.suffix}`;
+    }
+    function splitLinesPreserveNewline(input) {
+        const parts = [];
+        const regex = /([^\r\n]*)(\r\n|\n|\r|$)/g;
+        let match;
+        while ((match = regex.exec(input)) !== null) {
+            const line = match[1];
+            const newline = match[2];
+            if (line === "" && newline === "" && match.index === input.length) {
+                break;
+            }
+            parts.push({ line, newline });
+            if (newline === "") {
+                break;
+            }
+        }
+        return parts;
+    }
+    function mergeDotenvMaskedValues(currentRaw, editedContent) {
+        const currentLines = splitLinesPreserveNewline(currentRaw);
+        const editedLines = splitLinesPreserveNewline(editedContent);
+        const currentQueuesByKey = new Map();
+        for (const item of currentLines) {
+            const parsed = parseEnvAssignmentLine(item.line);
+            if (parsed.kind !== "assignment")
+                continue;
+            const arr = currentQueuesByKey.get(parsed.key) ?? [];
+            arr.push(parsed);
+            currentQueuesByKey.set(parsed.key, arr);
+        }
+        const output = [];
+        for (const item of editedLines) {
+            const parsedEdited = parseEnvAssignmentLine(item.line);
+            if (parsedEdited.kind !== "assignment" || !(0, redact_1.isLikelySensitiveKey)(parsedEdited.key)) {
+                output.push(item.line + item.newline);
+                continue;
+            }
+            const queue = currentQueuesByKey.get(parsedEdited.key);
+            const currentParsed = queue?.shift();
+            if (!currentParsed) {
+                output.push(item.line + item.newline);
+                continue;
+            }
+            if (parsedEdited.quote !== currentParsed.quote) {
+                output.push(item.line + item.newline);
+                continue;
+            }
+            const maskedCurrent = (0, redact_1.maskValue)(currentParsed.value);
+            if (parsedEdited.value !== maskedCurrent) {
+                output.push(item.line + item.newline);
+                continue;
+            }
+            const mergedLine = serializeEnvAssignment({
+                ...parsedEdited,
+                value: currentParsed.value,
+            });
+            output.push(mergedLine + item.newline);
+        }
+        return output.join("");
+    }
+    function listDirectory(slug, rawPath) {
+        const relativePath = normalizeRelativePath(rawPath ?? "", true);
+        const absolutePath = resolveTarget(slug, relativePath);
+        if (!fs_1.default.existsSync(absolutePath)) {
+            throw {
+                status: 404,
+                message: "Directory not found"
+            };
+        }
+        assertExistingPathIsSafe(slug, absolutePath);
+        const stat = fs_1.default.statSync(absolutePath);
+        if (!stat.isDirectory()) {
+            throw {
+                status: 400,
+                message: "path must be a directory"
+            };
+        }
+        const names = fs_1.default.readdirSync(absolutePath);
+        for (const name of names) {
+            const childPath = path_1.default.join(absolutePath, name);
+            if (fs_1.default.lstatSync(childPath).isSymbolicLink()) {
+                throw {
+                    status: 400,
+                    message: symlinkError
+                };
+            }
+        }
+        const entries = names
+            .map((name) => toFileNode(relativePath, name, path_1.default.join(absolutePath, name)))
+            .sort(compareNodes);
+        return {
+            path: relativePath,
+            entries,
+        };
+    }
+    function readFileContent(slug, rawPath) {
+        const relativePath = normalizeRelativePath(rawPath ?? "", false);
+        const absolutePath = resolveTarget(slug, relativePath);
+        if (!fs_1.default.existsSync(absolutePath)) {
+            throw {
+                status: 404,
+                message: "File not found"
+            };
+        }
+        assertExistingPathIsSafe(slug, absolutePath);
+        const stat = fs_1.default.statSync(absolutePath);
+        if (!stat.isFile()) {
+            throw {
+                status: 400,
+                message: "path must be a file"
+            };
+        }
+        const bytes = fs_1.default.readFileSync(absolutePath);
+        const etag = toEtag(bytes);
+        const name = path_1.default.basename(relativePath);
+        if (looksBinary(bytes)) {
+            const response = {
+                path: relativePath,
+                name,
+                kind: "binary",
+                etag,
+                size_bytes: bytes.length,
+                modified_at_ms: stat.mtimeMs,
+                message: "This file appears to be binary and is not editable in the browser.",
+            };
+            return response;
+        }
+        const rawContent = bytes.toString("utf-8");
+        const isDotenv = name === ".env";
+        const content = isDotenv ? (0, redact_1.sanitizeStringContent)(rawContent) : rawContent;
+        const response = {
+            path: relativePath,
+            name,
+            kind: "text",
+            encoding: "utf-8",
+            content,
+            etag,
+            size_bytes: bytes.length,
+            modified_at_ms: stat.mtimeMs,
+        };
+        return response;
+    }
+    function saveFileContent(slug, request) {
+        const relativePath = normalizeRelativePath(request.path, false);
+        const absolutePath = resolveTarget(slug, relativePath);
+        if (!fs_1.default.existsSync(absolutePath)) {
+            throw {
+                status: 404,
+                message: "File not found"
+            };
+        }
+        assertExistingPathIsSafe(slug, absolutePath);
+        const stat = fs_1.default.statSync(absolutePath);
+        if (!stat.isFile()) {
+            throw {
+                status: 400,
+                message: "path must be a file"
+            };
+        }
+        const currentBytes = fs_1.default.readFileSync(absolutePath);
+        const currentEtag = toEtag(currentBytes);
+        if (currentEtag !== request.base_etag) {
+            throw {
+                status: 409,
+                message: "File changed on disk. Please reload and try again."
+            };
+        }
+        const name = path_1.default.basename(relativePath);
+        const isDotenv = name === ".env";
+        const nextContent = isDotenv
+            ? mergeDotenvMaskedValues(currentBytes.toString("utf-8"), request.content)
+            : request.content;
+        fs_1.default.writeFileSync(absolutePath, nextContent, "utf-8");
+        const nextBytes = fs_1.default.readFileSync(absolutePath);
+        const nextStat = fs_1.default.statSync(absolutePath);
+        return {
+            path: relativePath,
+            etag: toEtag(nextBytes),
+            modified_at_ms: nextStat.mtimeMs,
+            size_bytes: nextBytes.length,
+        };
+    }
+    function createFileOrFolder(slug, rawParentPath, name, kind) {
+        assertValidName(name);
+        const parentRelativePath = normalizeRelativePath(rawParentPath ?? "", true);
+        const parentAbsolutePath = resolveTarget(slug, parentRelativePath);
+        if (!fs_1.default.existsSync(parentAbsolutePath)) {
+            throw {
+                status: 404,
+                message: "Parent directory not found"
+            };
+        }
+        assertParentDirectoryIsSafeForCreate(slug, parentAbsolutePath);
+        if (!fs_1.default.statSync(parentAbsolutePath).isDirectory()) {
+            throw {
+                status: 400,
+                message: "parent_path must be a directory"
+            };
+        }
+        const targetAbsolutePath = path_1.default.join(parentAbsolutePath, name);
+        if (fs_1.default.existsSync(targetAbsolutePath)) {
+            throw {
+                status: 409,
+                message: "A file or folder with that name already exists"
+            };
+        }
+        if (kind === "directory") {
+            fs_1.default.mkdirSync(targetAbsolutePath);
+        }
+        else {
+            fs_1.default.writeFileSync(targetAbsolutePath, "", "utf-8");
+        }
+        return toFileNode(parentRelativePath, name, targetAbsolutePath);
+    }
+    function uploadFileFromTempPath(slug, rawParentPath, name, tempFilePath) {
+        assertValidName(name);
+        const parentRelativePath = normalizeRelativePath(rawParentPath ?? "", true);
+        const parentAbsolutePath = resolveTarget(slug, parentRelativePath);
+        if (!fs_1.default.existsSync(parentAbsolutePath)) {
+            throw {
+                status: 404,
+                message: "Parent directory not found"
+            };
+        }
+        assertParentDirectoryIsSafeForCreate(slug, parentAbsolutePath);
+        if (!fs_1.default.statSync(parentAbsolutePath).isDirectory()) {
+            throw {
+                status: 400,
+                message: "parent_path must be a directory"
+            };
+        }
+        if (!fs_1.default.existsSync(tempFilePath) || !fs_1.default.statSync(tempFilePath).isFile()) {
+            throw {
+                status: 400,
+                message: "Uploaded file was not received correctly"
+            };
+        }
+        const targetAbsolutePath = path_1.default.join(parentAbsolutePath, name);
+        if (fs_1.default.existsSync(targetAbsolutePath)) {
+            throw {
+                status: 409,
+                message: "A file or folder with that name already exists"
+            };
+        }
+        fs_1.default.copyFileSync(tempFilePath, targetAbsolutePath);
+        return toFileNode(parentRelativePath, name, targetAbsolutePath);
+    }
+    function renamePath(slug, rawPath, newName) {
+        assertValidName(newName);
+        const relativePath = normalizeRelativePath(rawPath ?? "", false);
+        const absolutePath = resolveTarget(slug, relativePath);
+        if (!fs_1.default.existsSync(absolutePath)) {
+            throw {
+                status: 404,
+                message: "File or folder not found"
+            };
+        }
+        assertExistingPathIsSafe(slug, absolutePath);
+        const parentRelativePath = path_1.default.posix.dirname(relativePath) === "." ? "" : path_1.default.posix.dirname(relativePath);
+        const parentAbsolutePath = resolveTarget(slug, parentRelativePath);
+        assertParentDirectoryIsSafeForCreate(slug, parentAbsolutePath);
+        const newAbsolutePath = path_1.default.join(parentAbsolutePath, newName);
+        const newRelativePath = parentRelativePath ? `${parentRelativePath}/${newName}` : newName;
+        if (fs_1.default.existsSync(newAbsolutePath)) {
+            throw {
+                status: 409,
+                message: "A file or folder with that name already exists"
+            };
+        }
+        fs_1.default.renameSync(absolutePath, newAbsolutePath);
+        const node = toFileNode(parentRelativePath, newName, newAbsolutePath);
+        return {
+            old_path: relativePath,
+            new_path: newRelativePath,
+            node,
+        };
+    }
+    function deletePath(slug, rawPath) {
+        const relativePath = normalizeRelativePath(rawPath ?? "", false);
+        const absolutePath = resolveTarget(slug, relativePath);
+        if (!fs_1.default.existsSync(absolutePath)) {
+            throw {
+                status: 404,
+                message: "File or folder not found"
+            };
+        }
+        assertExistingPathIsSafe(slug, absolutePath);
+        const stat = fs_1.default.statSync(absolutePath);
+        if (stat.isDirectory()) {
+            fs_1.default.rmSync(absolutePath, { recursive: true, force: false });
+            return;
+        }
+        fs_1.default.unlinkSync(absolutePath);
+    }
+    return {
+        listDirectory,
+        readFileContent,
+        saveFileContent,
+        createFileOrFolder,
+        uploadFileFromTempPath,
+        renamePath,
+        deletePath,
+    };
+}

package/dist/utils/runtime-paths.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageRoot = getPackageRoot;
+exports.getWorkspaceTemplateDirectory = getWorkspaceTemplateDirectory;
+exports.getFrontendDistDirectory = getFrontendDistDirectory;
+exports.getPrismaSchemaPath = getPrismaSchemaPath;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function findPackageRoot(startDirectory) {
+    let currentDirectory = startDirectory;
+    while (true) {
+        const packageJsonPath = path_1.default.join(currentDirectory, "package.json");
+        if (fs_1.default.existsSync(packageJsonPath)) {
+            return currentDirectory;
+        }
+        const parentDirectory = path_1.default.dirname(currentDirectory);
+        if (parentDirectory === currentDirectory) {
+            throw new Error(`Could not find package.json above ${startDirectory}`);
+        }
+        currentDirectory = parentDirectory;
+    }
+}
+function getPackageRoot() {
+    return findPackageRoot(__dirname);
+}
+function getWorkspaceTemplateDirectory() {
+    const packageRoot = getPackageRoot();
+    const candidateDirectories = [
+        path_1.default.join(packageRoot, "dist", "workspace_files"),
+        path_1.default.join(packageRoot, "src", "workspace_files"),
+    ];
+    for (const candidateDirectory of candidateDirectories) {
+        if (fs_1.default.existsSync(candidateDirectory)) {
+            return candidateDirectory;
+        }
+    }
+    throw new Error(`Workspace template directory not found in ${packageRoot}`);
+}
+function getFrontendDistDirectory() {
+    const packageRoot = getPackageRoot();
+    const candidateDirectories = [
+        path_1.default.join(packageRoot, "dist", "frontend"),
+        path_1.default.join(packageRoot, "frontend", "dist"),
+    ];
+    for (const candidateDirectory of candidateDirectories) {
+        if (fs_1.default.existsSync(candidateDirectory)) {
+            return candidateDirectory;
+        }
+    }
+    throw new Error(`Frontend build directory not found in ${packageRoot}`);
+}
+function getPrismaSchemaPath() {
+    const schemaPath = path_1.default.join(getPackageRoot(), "prisma", "schema.prisma");
+    if (!fs_1.default.existsSync(schemaPath)) {
+        throw new Error(`Prisma schema not found: ${schemaPath}`);
+    }
+    return schemaPath;
+}

package/dist/utils/session-abort.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abortOpencodeSession = abortOpencodeSession;
+const client_1 = __importDefault(require("../prisma/client"));
+const assert_1 = require("./assert");
+const opencode_client_1 = require("./opencode-client");
+function getErrorMessage(error) {
+    if (error && typeof error === "object" && "detail" in error) {
+        return String(error.detail);
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return "Unknown error";
+}
+async function abortOpencodeSession(opencodeSessionId) {
+    const pendingQuestion = await (0, opencode_client_1.getPendingQuestionForSession)(opencodeSessionId);
+    if (pendingQuestion) {
+        const abortAnswer = "User aborted";
+        const answers = pendingQuestion.questions.map(() => [abortAnswer]);
+        await (0, opencode_client_1.replyToPendingQuestion)(pendingQuestion.id, answers);
+    }
+    const pendingPermissions = await (0, opencode_client_1.listPendingPermissionsForSession)(opencodeSessionId);
+    for (const pendingPermission of pendingPermissions) {
+        await (0, opencode_client_1.replyToPendingPermission)(opencodeSessionId, pendingPermission.id, "reject");
+    }
+    await client_1.default.tool_execution_permissions.updateMany({
+        where: {
+            opencode_session_id: opencodeSessionId,
+            status: "pending"
+        },
+        data: {
+            status: "rejected",
+            responded_at: BigInt(Date.now())
+        }
+    });
+    const client = await (0, opencode_client_1.getOpencodeClient)();
+    await client.session.command({
+        path: { id: opencodeSessionId },
+        body: {
+            command: "session.interrupt",
+            arguments: ""
+        }
+    });
+    const abortResult = await client.session.abort({
+        path: { id: opencodeSessionId }
+    });
+    (0, assert_1.assertCondition)(!abortResult.error, getErrorMessage(abortResult.error));
+}