@mcoda/core 0.1.9 → 0.1.12

package/dist/workspace/WorkspaceManager.js

@@ -1,3 +1,4 @@
+import os from "node:os";
 import path from "node:path";
 import { promises as fs } from "node:fs";
 import { randomUUID } from "node:crypto";
@@ -11,6 +12,138 @@ const fileExists = async (candidate) => {
         return false;
     }
 };
+const dirHasEntries = async (candidate) => {
+    try {
+        const entries = await fs.readdir(candidate);
+        return entries.length > 0;
+    }
+    catch {
+        return false;
+    }
+};
+const STATE_DIR_NAMES = [".mcoda", ".mcoda-state", ".mcoda_state"];
+const resolveUniqueTarget = async (base) => {
+    if (!(await fileExists(base)))
+        return base;
+    const parent = path.dirname(base);
+    const stem = path.basename(base);
+    for (let attempt = 0; attempt < 5; attempt += 1) {
+        const candidate = path.join(parent, `${stem}-${randomUUID().slice(0, 8)}`);
+        if (!(await fileExists(candidate)))
+            return candidate;
+    }
+    return path.join(parent, `${stem}-${Date.now()}`);
+};
+const copyLegacyConfigIfMissing = async (sourceDir, targetDir, warnings) => {
+    const sourceConfig = path.join(sourceDir, "config.json");
+    const targetConfig = path.join(targetDir, "config.json");
+    if (!(await fileExists(sourceConfig)))
+        return;
+    if (await fileExists(targetConfig))
+        return;
+    try {
+        await PathHelper.ensureDir(targetDir);
+        await fs.copyFile(sourceConfig, targetConfig);
+        warnings.push(`Copied legacy workspace config from ${sourceConfig} to ${targetConfig}.`);
+    }
+    catch (error) {
+        warnings.push(`Unable to copy legacy workspace config from ${sourceConfig}: ${error.message ?? String(error)}`);
+    }
+};
+export const cleanupWorkspaceStateDirs = async (input) => {
+    const warnings = [];
+    const workspaceRoot = path.resolve(input.workspaceRoot);
+    const mcodaDir = path.resolve(input.mcodaDir);
+    for (const name of STATE_DIR_NAMES) {
+        const source = path.join(workspaceRoot, name);
+        if (!(await fileExists(source)))
+            continue;
+        if (PathHelper.normalizePathCase(source) === PathHelper.normalizePathCase(mcodaDir)) {
+            continue;
+        }
+        let stat;
+        try {
+            stat = await fs.lstat(source);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isSymbolicLink()) {
+            warnings.push(`Skipped legacy state directory symlink at ${source}.`);
+            continue;
+        }
+        if (!stat.isDirectory()) {
+            warnings.push(`Skipped legacy state path ${source} because it is not a directory.`);
+            continue;
+        }
+        if (!(await dirHasEntries(source))) {
+            try {
+                await fs.rm(source, { recursive: true, force: true });
+                warnings.push(`Removed empty legacy state directory at ${source}.`);
+            }
+            catch (error) {
+                warnings.push(`Unable to remove empty legacy state directory at ${source}: ${error.message ?? String(error)}`);
+            }
+            continue;
+        }
+        if (name === ".mcoda") {
+            await copyLegacyConfigIfMissing(source, mcodaDir, warnings);
+        }
+        const targetName = name.startsWith(".") ? name.slice(1) : name;
+        const targetBase = path.join(mcodaDir, "legacy", targetName);
+        const target = await resolveUniqueTarget(targetBase);
+        await PathHelper.ensureDir(path.dirname(target));
+        try {
+            await fs.rename(source, target);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "EXDEV") {
+                try {
+                    await fs.cp(source, target, { recursive: true });
+                    await fs.rm(source, { recursive: true, force: true });
+                }
+                catch (copyError) {
+                    warnings.push(`Unable to relocate legacy state directory from ${source}: ${copyError.message ?? String(copyError)}`);
+                    continue;
+                }
+            }
+            else {
+                warnings.push(`Unable to relocate legacy state directory from ${source}: ${error.message ?? String(error)}`);
+                continue;
+            }
+        }
+        warnings.push(`Relocated legacy state directory from ${source} to ${target}.`);
+    }
+    return warnings;
+};
+export const resolveDocgenStatePath = (input) => {
+    const warnings = [];
+    const outputPath = path.resolve(input.outputPath);
+    const mcodaDir = path.resolve(input.mcodaDir);
+    const tempDir = path.resolve(os.tmpdir());
+    const allowedRoots = [mcodaDir, tempDir];
+    const isAllowed = allowedRoots.some((root) => PathHelper.isPathInside(root, outputPath));
+    if (isAllowed) {
+        return { statePath: outputPath, warnings };
+    }
+    const basename = path.basename(outputPath) || "docgen.md";
+    const statePath = path.join(mcodaDir, "state", "docgen", input.commandName, input.jobId, basename);
+    warnings.push(`Intermediate state redirected from ${outputPath} to ${statePath} to keep docgen state under .mcoda or OS temp directories.`);
+    return { statePath, warnings };
+};
+const maybeCopyLegacyWorkspace = async (sourceDir, targetDir) => {
+    if (!(await fileExists(sourceDir)))
+        return;
+    if (await dirHasEntries(targetDir))
+        return;
+    try {
+        await fs.cp(sourceDir, targetDir, { recursive: true });
+    }
+    catch {
+        /* best effort */
+    }
+};
 const findGitRoot = async (start) => {
     // Only consider the provided directory; do not walk upward.
     const current = path.resolve(start);
@@ -30,27 +163,34 @@ const findWorkspaceMarker = async (start) => {
         return current;
     return undefined;
 };
-const ensureGitignore = async (workspaceRoot) => {
-    const gitignorePath = path.join(workspaceRoot, ".gitignore");
-    const entry = ".mcoda/\n";
-    try {
-        const content = await fs.readFile(gitignorePath, "utf8");
-        if (content.includes(".mcoda/"))
-            return;
-        await fs.writeFile(gitignorePath, `${content.trimEnd()}\n${entry}`, "utf8");
-    }
-    catch {
-        await fs.writeFile(gitignorePath, entry, "utf8");
+const readWorkspaceConfig = async (mcodaDir, fallbackDir) => {
+    const readConfig = async (dir) => {
+        const configPath = path.join(dir, "config.json");
+        try {
+            const raw = await fs.readFile(configPath, "utf8");
+            return JSON.parse(raw);
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const primary = await readConfig(mcodaDir);
+    if (primary)
+        return primary;
+    if (fallbackDir && fallbackDir !== mcodaDir) {
+        return readConfig(fallbackDir);
     }
+    return undefined;
 };
-const readWorkspaceConfig = async (mcodaDir) => {
-    const configPath = path.join(mcodaDir, "config.json");
-    try {
-        const raw = await fs.readFile(configPath, "utf8");
-        return JSON.parse(raw);
+const applyWorkspaceEnvOverrides = (config) => {
+    if (!config)
+        return;
+    if (config.codexNoSandbox === true) {
+        process.env.MCODA_CODEX_NO_SANDBOX = "1";
+        return;
     }
-    catch {
-        return undefined;
+    if (config.codexNoSandbox === false && process.env.MCODA_CODEX_NO_SANDBOX === undefined) {
+        process.env.MCODA_CODEX_NO_SANDBOX = "0";
     }
 };
 const readWorkspaceIdentity = async (mcodaDir) => {
@@ -77,9 +217,10 @@ const migrateWorkspaceDbIds = async (workspace, legacyIds) => {
     if (!(await fileExists(workspace.workspaceDbPath))) {
         return;
     }
+    let conn;
     try {
         const { Connection } = await import("@mcoda/db");
-        const conn = await Connection.open(workspace.workspaceDbPath);
+        conn = await Connection.open(workspace.workspaceDbPath);
         const db = conn.db;
         const placeholders = legacyIds.map(() => "?").join(",");
         const params = [workspace.workspaceId, ...legacyIds];
@@ -87,11 +228,20 @@ const migrateWorkspaceDbIds = async (workspace, legacyIds) => {
         for (const table of tables) {
             await db.run(`UPDATE ${table} SET workspace_id = ? WHERE workspace_id IN (${placeholders})`, params);
         }
-        await conn.close();
     }
     catch {
         /* best effort */
     }
+    finally {
+        if (conn) {
+            try {
+                await conn.close();
+            }
+            catch {
+                /* best effort */
+            }
+        }
+    }
     const updateJsonArray = async (filePath) => {
         try {
             const raw = await fs.readFile(filePath, "utf8");
@@ -114,12 +264,13 @@ const migrateWorkspaceDbIds = async (workspace, legacyIds) => {
             /* ignore */
         }
     };
-    await updateJsonArray(path.join(workspace.workspaceRoot, ".mcoda", "command_runs.json"));
-    await updateJsonArray(path.join(workspace.workspaceRoot, ".mcoda", "token_usage.json"));
+    await updateJsonArray(path.join(workspace.mcodaDir, "command_runs.json"));
+    await updateJsonArray(path.join(workspace.mcodaDir, "token_usage.json"));
 };
 export class WorkspaceResolver {
     static async resolveWorkspace(input) {
         const cwd = path.resolve(input.cwd ?? process.cwd());
+        const noRepoWrites = Boolean(input.noRepoWrites);
         let explicit = input.explicitWorkspace;
         let explicitPath;
         if (explicit) {
@@ -140,10 +291,13 @@ export class WorkspaceResolver {
         const fromMarker = await findWorkspaceMarker(explicitPath ?? cwd);
         const gitRoot = await findGitRoot(explicitPath ?? cwd);
         const workspaceRoot = explicitPath ?? fromMarker ?? gitRoot ?? cwd;
-        const mcodaDir = path.join(workspaceRoot, ".mcoda");
+        const repoMcodaDir = path.join(workspaceRoot, ".mcoda");
+        const mcodaDir = PathHelper.getGlobalWorkspaceDir(workspaceRoot);
         await PathHelper.ensureDir(mcodaDir);
-        await ensureGitignore(workspaceRoot);
-        const existingIdentity = await readWorkspaceIdentity(mcodaDir);
+        await maybeCopyLegacyWorkspace(repoMcodaDir, mcodaDir);
+        const repoIdentity = await readWorkspaceIdentity(repoMcodaDir);
+        const globalIdentity = await readWorkspaceIdentity(mcodaDir);
+        const existingIdentity = globalIdentity ?? repoIdentity;
         let identity;
         let legacyIds = [];
         if (existingIdentity) {
@@ -154,6 +308,19 @@ export class WorkspaceResolver {
                 legacyIds.push(workspaceRoot);
                 updatedIdentity = true;
             }
+            if (repoIdentity) {
+                if (repoIdentity.id && repoIdentity.id !== existingIdentity.id) {
+                    legacyIds.push(repoIdentity.id);
+                    updatedIdentity = true;
+                }
+                if (repoIdentity.legacyIds?.length) {
+                    legacyIds.push(...repoIdentity.legacyIds);
+                    updatedIdentity = true;
+                }
+                if (!globalIdentity) {
+                    updatedIdentity = true;
+                }
+            }
             if (!looksLikeWorkspaceId(existingIdentity.id)) {
                 legacyIds.push(existingIdentity.id);
                 identity = {
@@ -161,7 +328,7 @@ export class WorkspaceResolver {
                     id: randomUUID(),
                     legacyIds: Array.from(new Set(legacyIds)),
                 };
-                await writeWorkspaceIdentity(mcodaDir, identity);
+                updatedIdentity = true;
             }
             else {
                 identity = {
@@ -171,9 +338,9 @@ export class WorkspaceResolver {
                 if ((identity.legacyIds?.length ?? 0) !== existingLegacy.size) {
                     updatedIdentity = true;
                 }
-                if (updatedIdentity) {
-                    await writeWorkspaceIdentity(mcodaDir, identity);
-                }
+            }
+            if (updatedIdentity) {
+                await writeWorkspaceIdentity(mcodaDir, identity);
             }
         }
         else {
@@ -186,19 +353,23 @@ export class WorkspaceResolver {
             await writeWorkspaceIdentity(mcodaDir, identity);
         }
         const legacyWorkspaceIds = Array.from(new Set([...(identity.legacyIds ?? []), workspaceRoot].filter(Boolean)));
-        const config = await readWorkspaceConfig(mcodaDir);
+        const config = await readWorkspaceConfig(mcodaDir, repoMcodaDir);
+        applyWorkspaceEnvOverrides(config);
         const resolution = {
             workspaceRoot,
             workspaceId: identity.id,
             id: identity.id,
             legacyWorkspaceIds,
             mcodaDir,
-            workspaceDbPath: PathHelper.getWorkspaceDbPath(workspaceRoot),
+            workspaceDbPath: path.join(mcodaDir, "mcoda.db"),
             globalDbPath: PathHelper.getGlobalDbPath(),
+            noRepoWrites,
             config,
         };
         // Best-effort migration of workspace_id columns and JSON logs from legacy IDs.
-        await migrateWorkspaceDbIds(resolution, legacyWorkspaceIds.filter((id) => id !== identity.id));
+        if (!noRepoWrites) {
+            await migrateWorkspaceDbIds(resolution, legacyWorkspaceIds.filter((id) => id !== identity.id));
+        }
         return resolution;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcoda/core",
-  "version": "0.1.9",
+  "version": "0.1.12",
   "description": "Core services and APIs for the mcoda CLI.",
   "type": "module",
   "main": "dist/index.js",
@@ -32,10 +32,11 @@
   "dependencies": {
     "@apidevtools/swagger-parser": "^10.1.0",
     "yaml": "^2.4.2",
-    "@mcoda/db": "0.1.9",
-    "@mcoda/shared": "0.1.9",
-    "@mcoda/agents": "0.1.9",
-    "@mcoda/integrations": "0.1.9"
+    "@mcoda/shared": "0.1.12",
+    "@mcoda/agents": "0.1.12",
+    "@mcoda/generators": "0.1.12",
+    "@mcoda/integrations": "0.1.12",
+    "@mcoda/db": "0.1.12"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",