teamcopilot 0.0.1

package/dist/utils/workspace-sync.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkspaceDirFromEnv = getWorkspaceDirFromEnv;
+exports.getWorkspaceDatabaseUrl = getWorkspaceDatabaseUrl;
+exports.workspaceDatabaseExists = workspaceDatabaseExists;
+exports.ensureWorkspaceDatabaseDirectory = ensureWorkspaceDatabaseDirectory;
+exports.initializeWorkspaceDirectory = initializeWorkspaceDirectory;
+exports.ensureWorkspaceDatabase = ensureWorkspaceDatabase;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ignore_1 = __importDefault(require("ignore"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const assert_1 = require("./assert");
+const runtime_paths_1 = require("./runtime-paths");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const WORKSPACE_DB_DIRECTORY = ".sqlite";
+const WORKSPACE_DB_FILENAME = "data.db";
+const HONEYTOKEN_UUID = "1f9f0b72-5f9f-4c9b-aef1-2fb2e0f6d8c4";
+const HONEYTOKEN_FILE_NAME = `honeytoken-${HONEYTOKEN_UUID}.txt`;
+function getWorkspaceDirFromEnv() {
+    let workspaceDir = (0, assert_1.assertEnv)("WORKSPACE_DIR");
+    if (!path_1.default.isAbsolute(workspaceDir)) {
+        workspaceDir = path_1.default.resolve(process.cwd(), workspaceDir);
+    }
+    return workspaceDir;
+}
+function getPrismaCliEntrypoint() {
+    return require.resolve("prisma/build/index.js", {
+        paths: [(0, runtime_paths_1.getPackageRoot)()],
+    });
+}
+function getWorkspaceDatabasePath() {
+    return path_1.default.join(getWorkspaceDirFromEnv(), WORKSPACE_DB_DIRECTORY, WORKSPACE_DB_FILENAME);
+}
+function getWorkspaceDatabaseUrl() {
+    return `file:${getWorkspaceDatabasePath()}`;
+}
+function workspaceDatabaseExists() {
+    return fs_1.default.existsSync(getWorkspaceDatabasePath());
+}
+function ensureWorkspaceDatabaseDirectory() {
+    fs_1.default.mkdirSync(path_1.default.dirname(getWorkspaceDatabasePath()), { recursive: true });
+}
+function normalizeRelativePath(relativePath) {
+    return relativePath.split(path_1.default.sep).join("/");
+}
+const MANAGED_WORKSPACE_DIRECTORIES = new Set([
+    "workflows",
+    "custom-skills",
+]);
+function shouldSkipManagedDirectoryContent(relativePath) {
+    const [topLevelSegment] = relativePath.split("/");
+    if (MANAGED_WORKSPACE_DIRECTORIES.has(topLevelSegment)) {
+        return true;
+    }
+    if (relativePath === ".opencode/xdg-data" || relativePath.startsWith(".opencode/xdg-data/")) {
+        return true;
+    }
+    return false;
+}
+function evaluateIgnoreRuleSets(relativePath, isDirectory, ruleSets) {
+    let isIgnored = false;
+    for (const ruleSet of ruleSets) {
+        if (ruleSet.basePath.length > 0) {
+            if (relativePath !== ruleSet.basePath && !relativePath.startsWith(`${ruleSet.basePath}/`)) {
+                continue;
+            }
+        }
+        const relativeToRuleBase = ruleSet.basePath.length > 0
+            ? relativePath.slice(ruleSet.basePath.length + 1)
+            : relativePath;
+        if (!relativeToRuleBase) {
+            continue;
+        }
+        const candidates = isDirectory
+            ? [relativeToRuleBase, `${relativeToRuleBase}/`]
+            : [relativeToRuleBase];
+        for (const candidate of candidates) {
+            const result = ruleSet.matcher.test(candidate);
+            if (result.ignored) {
+                isIgnored = true;
+            }
+            if (result.unignored) {
+                isIgnored = false;
+            }
+        }
+    }
+    return isIgnored;
+}
+function readLocalGitignoreRuleSet(sourceDirectory, relativePath) {
+    const gitignorePath = path_1.default.join(sourceDirectory, ".gitignore");
+    if (!fs_1.default.existsSync(gitignorePath)) {
+        return null;
+    }
+    const matcher = (0, ignore_1.default)();
+    matcher.add(fs_1.default.readFileSync(gitignorePath, "utf-8"));
+    return {
+        basePath: relativePath,
+        matcher,
+    };
+}
+function mergeGitignoreFile(sourceGitignorePath, targetGitignorePath) {
+    const sourceLines = fs_1.default.readFileSync(sourceGitignorePath, "utf-8").split(/\r?\n/);
+    if (!fs_1.default.existsSync(targetGitignorePath)) {
+        fs_1.default.writeFileSync(targetGitignorePath, `${sourceLines.join("\n").replace(/\n*$/, "\n")}`, "utf-8");
+        return;
+    }
+    const existingContent = fs_1.default.readFileSync(targetGitignorePath, "utf-8");
+    const existingLines = existingContent.split(/\r?\n/);
+    const existingEntries = new Set(existingLines);
+    const linesToAppend = [];
+    for (const sourceLine of sourceLines) {
+        if (sourceLine.length === 0 || existingEntries.has(sourceLine)) {
+            continue;
+        }
+        existingEntries.add(sourceLine);
+        linesToAppend.push(sourceLine);
+    }
+    if (linesToAppend.length === 0) {
+        return;
+    }
+    const needsSeparator = existingContent.length > 0 && !existingContent.endsWith("\n");
+    const prefix = needsSeparator ? "\n" : "";
+    const suffix = existingContent.endsWith("\n") || existingContent.length === 0 ? "" : "\n";
+    fs_1.default.writeFileSync(targetGitignorePath, `${existingContent}${suffix}${prefix}${linesToAppend.join("\n")}\n`, "utf-8");
+}
+function syncTemplateDirectory(sourceDirectory, targetDirectory, relativePath, inheritedRuleSets) {
+    const localRuleSet = readLocalGitignoreRuleSet(sourceDirectory, relativePath);
+    const activeRuleSets = localRuleSet ? [...inheritedRuleSets, localRuleSet] : inheritedRuleSets;
+    fs_1.default.mkdirSync(targetDirectory, { recursive: true });
+    const entries = fs_1.default.readdirSync(sourceDirectory, { withFileTypes: true });
+    for (const entry of entries) {
+        const sourceEntryPath = path_1.default.join(sourceDirectory, entry.name);
+        const targetEntryPath = path_1.default.join(targetDirectory, entry.name);
+        const relativeEntryPath = normalizeRelativePath(relativePath.length > 0 ? path_1.default.join(relativePath, entry.name) : entry.name);
+        if (shouldSkipManagedDirectoryContent(relativeEntryPath)) {
+            continue;
+        }
+        const isDirectory = entry.isDirectory();
+        if (evaluateIgnoreRuleSets(relativeEntryPath, isDirectory, activeRuleSets)) {
+            continue;
+        }
+        if (isDirectory) {
+            syncTemplateDirectory(sourceEntryPath, targetEntryPath, relativeEntryPath, activeRuleSets);
+            continue;
+        }
+        if (entry.isFile()) {
+            if (entry.name === ".gitignore") {
+                mergeGitignoreFile(sourceEntryPath, targetEntryPath);
+                continue;
+            }
+            fs_1.default.copyFileSync(sourceEntryPath, targetEntryPath);
+        }
+    }
+}
+async function initializeWorkspaceNodeDependencies(workspaceDir) {
+    const workspacePackageJsonPath = path_1.default.join(workspaceDir, "package.json");
+    const existingPackageJson = fs_1.default.existsSync(workspacePackageJsonPath)
+        ? JSON.parse(fs_1.default.readFileSync(workspacePackageJsonPath, "utf-8"))
+        : {};
+    const dependencies = {
+        ...(existingPackageJson.dependencies ?? {}),
+        "opencode-ai": "1.1.65",
+    };
+    const workspacePackageJson = {
+        ...existingPackageJson,
+        dependencies,
+    };
+    fs_1.default.writeFileSync(workspacePackageJsonPath, JSON.stringify(workspacePackageJson, null, 2), "utf-8");
+    await execFileAsync("npm", ["install"], {
+        cwd: workspaceDir,
+        env: process.env,
+    });
+}
+async function initializeWorkspaceDirectory() {
+    const workspaceDir = getWorkspaceDirFromEnv();
+    fs_1.default.mkdirSync(workspaceDir, { recursive: true });
+    const workflowsDir = path_1.default.join(workspaceDir, "workflows");
+    fs_1.default.mkdirSync(workflowsDir, { recursive: true });
+    const skillsDir = path_1.default.join(workspaceDir, "custom-skills");
+    fs_1.default.mkdirSync(skillsDir, { recursive: true });
+    const honeytokenValue = `DO_NOT_EXPOSE:${HONEYTOKEN_UUID}\n`;
+    fs_1.default.writeFileSync(path_1.default.join(workflowsDir, HONEYTOKEN_FILE_NAME), honeytokenValue, "utf-8");
+    fs_1.default.writeFileSync(path_1.default.join(skillsDir, HONEYTOKEN_FILE_NAME), honeytokenValue, "utf-8");
+    const workspaceTemplateDir = (0, runtime_paths_1.getWorkspaceTemplateDirectory)();
+    syncTemplateDirectory(workspaceTemplateDir, workspaceDir, "", []);
+    await initializeWorkspaceNodeDependencies(workspaceDir);
+}
+async function ensureWorkspaceDatabase() {
+    const workspaceDatabaseUrl = getWorkspaceDatabaseUrl();
+    ensureWorkspaceDatabaseDirectory();
+    process.env.DATABASE_URL = workspaceDatabaseUrl;
+    await execFileAsync(process.execPath, [getPrismaCliEntrypoint(), "migrate", "deploy", "--schema", (0, runtime_paths_1.getPrismaSchemaPath)()], {
+        cwd: (0, runtime_paths_1.getPackageRoot)(),
+        env: {
+            ...process.env,
+            DATABASE_URL: workspaceDatabaseUrl,
+        },
+    });
+}