@decohere/scaffold 0.0.1-dev.18 → 0.0.1-dev.80

package/es6/src/webapi/cli-options.js

@@ -0,0 +1,36 @@
+import { resolveTargetDir } from "../resolve-target-dir.js";
+import { parseApiNames } from "./api-name.js";
+import { scaffoldApi } from "./create-api.js";
+export function collectName(value, previous) {
+    previous.push(value);
+    return previous;
+}
+export function addWebapiFeatureOptions(cmd) {
+    return cmd.option("--database <provider>", "Database provider: none | postgres/typeorm").option("--auth <provider>", "Auth provider: none | auth0").option("--postman <provider>", "Postman provider: none | local | api").option("-y, --yes", "Install dependencies without prompting").option("--install <mode>", "Dependency install mode: ask | yes | no", "ask");
+}
+export function toApiOptions(directory, opts, extra = {}) {
+    const installMode = String(opts.install ?? "ask").toLowerCase();
+    const names = Array.isArray(opts.name) ? opts.name : typeof opts.name === "string" ? [
+        opts.name
+    ] : extra.names;
+    return {
+        d: resolveTargetDir(directory, typeof opts.d === "string" ? opts.d : undefined),
+        databaseProvider: opts.database,
+        authProvider: opts.auth,
+        postmanProvider: opts.postman,
+        installDependencies: opts.yes === true ? "yes" : installMode === "yes" || installMode === "no" ? installMode : undefined,
+        names,
+        ...extra
+    };
+}
+export async function runScaffoldApi(normalized) {
+    parseApiNames(normalized.names);
+    const { closePrompt } = await import("../domain/prompt.js");
+    try {
+        await scaffoldApi(normalized);
+    } finally{
+        closePrompt();
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjYWZmb2xkL3NyYy93ZWJhcGkvY2xpLW9wdGlvbnMudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBDb21tYW5kIH0gZnJvbSBcImNvbW1hbmRlclwiO1xuaW1wb3J0IHsgcmVzb2x2ZVRhcmdldERpciB9IGZyb20gXCIuLi9yZXNvbHZlLXRhcmdldC1kaXIuanNcIjtcbmltcG9ydCB7IHBhcnNlQXBpTmFtZXMgfSBmcm9tIFwiLi9hcGktbmFtZS5qc1wiO1xuaW1wb3J0IHR5cGUgeyBBcGlPcHRpb25zIH0gZnJvbSBcIi4vY3JlYXRlLWFwaS5qc1wiO1xuaW1wb3J0IHsgc2NhZmZvbGRBcGkgfSBmcm9tIFwiLi9jcmVhdGUtYXBpLmpzXCI7XG5cbmV4cG9ydCBmdW5jdGlvbiBjb2xsZWN0TmFtZSh2YWx1ZTogc3RyaW5nLCBwcmV2aW91czogc3RyaW5nW10pOiBzdHJpbmdbXSB7XG5cdHByZXZpb3VzLnB1c2godmFsdWUpO1xuXHRyZXR1cm4gcHJldmlvdXM7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBhZGRXZWJhcGlGZWF0dXJlT3B0aW9ucyhjbWQ6IENvbW1hbmQpOiBDb21tYW5kIHtcblx0cmV0dXJuIGNtZFxuXHRcdC5vcHRpb24oXCItLWRhdGFiYXNlIDxwcm92aWRlcj5cIiwgXCJEYXRhYmFzZSBwcm92aWRlcjogbm9uZSB8IHBvc3RncmVzL3R5cGVvcm1cIilcblx0XHQub3B0aW9uKFwiLS1hdXRoIDxwcm92aWRlcj5cIiwgXCJBdXRoIHByb3ZpZGVyOiBub25lIHwgYXV0aDBcIilcblx0XHQub3B0aW9uKFwiLS1wb3N0bWFuIDxwcm92aWRlcj5cIiwgXCJQb3N0bWFuIHByb3ZpZGVyOiBub25lIHwgbG9jYWwgfCBhcGlcIilcblx0XHQub3B0aW9uKFwiLXksIC0teWVzXCIsIFwiSW5zdGFsbCBkZXBlbmRlbmNpZXMgd2l0aG91dCBwcm9tcHRpbmdcIilcblx0XHQub3B0aW9uKFwiLS1pbnN0YWxsIDxtb2RlPlwiLCBcIkRlcGVuZGVuY3kgaW5zdGFsbCBtb2RlOiBhc2sgfCB5ZXMgfCBub1wiLCBcImFza1wiKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHRvQXBpT3B0aW9ucyhcblx0ZGlyZWN0b3J5OiBzdHJpbmcgfCB1bmRlZmluZWQsXG5cdG9wdHM6IFJlY29yZDxzdHJpbmcsIHVua25vd24+LFxuXHRleHRyYTogUGFydGlhbDxBcGlPcHRpb25zPiA9IHt9LFxuKTogQXBpT3B0aW9ucyB7XG5cdGNvbnN0IGluc3RhbGxNb2RlID0gU3RyaW5nKG9wdHMuaW5zdGFsbCA/PyBcImFza1wiKS50b0xvd2VyQ2FzZSgpO1xuXHRjb25zdCBuYW1lcyA9IEFycmF5LmlzQXJyYXkob3B0cy5uYW1lKVxuXHRcdD8gKG9wdHMubmFtZSBhcyBzdHJpbmdbXSlcblx0XHQ6IHR5cGVvZiBvcHRzLm5hbWUgPT09IFwic3RyaW5nXCJcblx0XHRcdD8gW29wdHMubmFtZV1cblx0XHRcdDogZXh0cmEubmFtZXM7XG5cdHJldHVybiB7XG5cdFx0ZDogcmVzb2x2ZVRhcmdldERpcihkaXJlY3RvcnksIHR5cGVvZiBvcHRzLmQgPT09IFwic3RyaW5nXCIgPyBvcHRzLmQgOiB1bmRlZmluZWQpLFxuXHRcdGRhdGFiYXNlUHJvdmlkZXI6IG9wdHMuZGF0YWJhc2UgYXMgQXBpT3B0aW9uc1tcImRhdGFiYXNlUHJvdmlkZXJcIl0sXG5cdFx0YXV0aFByb3ZpZGVyOiBvcHRzLmF1dGggYXMgQXBpT3B0aW9uc1tcImF1dGhQcm92aWRlclwiXSxcblx0XHRwb3N0bWFuUHJvdmlkZXI6IG9wdHMucG9zdG1hbiBhcyBBcGlPcHRpb25zW1wicG9zdG1hblByb3ZpZGVyXCJdLFxuXHRcdGluc3RhbGxEZXBlbmRlbmNpZXM6XG5cdFx0XHRvcHRzLnllcyA9PT0gdHJ1ZVxuXHRcdFx0XHQ/IFwieWVzXCJcblx0XHRcdFx0OiBpbnN0YWxsTW9kZSA9PT0gXCJ5ZXNcIiB8fCBpbnN0YWxsTW9kZSA9PT0gXCJub1wiXG5cdFx0XHRcdFx0PyBpbnN0YWxsTW9kZVxuXHRcdFx0XHRcdDogdW5kZWZpbmVkLFxuXHRcdG5hbWVzLFxuXHRcdC4uLmV4dHJhLFxuXHR9O1xufVxuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gcnVuU2NhZmZvbGRBcGkobm9ybWFsaXplZDogQXBpT3B0aW9ucyk6IFByb21pc2U8dm9pZD4ge1xuXHRwYXJzZUFwaU5hbWVzKG5vcm1hbGl6ZWQubmFtZXMpO1xuXHRjb25zdCB7IGNsb3NlUHJvbXB0IH0gPSBhd2FpdCBpbXBvcnQoXCIuLi9kb21haW4vcHJvbXB0LmpzXCIpO1xuXHR0cnkge1xuXHRcdGF3YWl0IHNjYWZmb2xkQXBpKG5vcm1hbGl6ZWQpO1xuXHR9IGZpbmFsbHkge1xuXHRcdGNsb3NlUHJvbXB0KCk7XG5cdH1cbn1cbiJdLCJuYW1lcyI6WyJyZXNvbHZlVGFyZ2V0RGlyIiwicGFyc2VBcGlOYW1lcyIsInNjYWZmb2xkQXBpIiwiY29sbGVjdE5hbWUiLCJ2YWx1ZSIsInByZXZpb3VzIiwicHVzaCIsImFkZFdlYmFwaUZlYXR1cmVPcHRpb25zIiwiY21kIiwib3B0aW9uIiwidG9BcGlPcHRpb25zIiwiZGlyZWN0b3J5Iiwib3B0cyIsImV4dHJhIiwiaW5zdGFsbE1vZGUiLCJTdHJpbmciLCJpbnN0YWxsIiwidG9Mb3dlckNhc2UiLCJuYW1lcyIsIkFycmF5IiwiaXNBcnJheSIsIm5hbWUiLCJkIiwidW5kZWZpbmVkIiwiZGF0YWJhc2VQcm92aWRlciIsImRhdGFiYXNlIiwiYXV0aFByb3ZpZGVyIiwiYXV0aCIsInBvc3RtYW5Qcm92aWRlciIsInBvc3RtYW4iLCJpbnN0YWxsRGVwZW5kZW5jaWVzIiwieWVzIiwicnVuU2NhZmZvbGRBcGkiLCJub3JtYWxpemVkIiwiY2xvc2VQcm9tcHQiXSwibWFwcGluZ3MiOiJBQUNBLFNBQVNBLGdCQUFnQixRQUFRLDJCQUEyQjtBQUM1RCxTQUFTQyxhQUFhLFFBQVEsZ0JBQWdCO0FBRTlDLFNBQVNDLFdBQVcsUUFBUSxrQkFBa0I7QUFFOUMsT0FBTyxTQUFTQyxZQUFZQyxLQUFhLEVBQUVDLFFBQWtCO0lBQzVEQSxTQUFTQyxJQUFJLENBQUNGO0lBQ2QsT0FBT0M7QUFDUjtBQUVBLE9BQU8sU0FBU0Usd0JBQXdCQyxHQUFZO0lBQ25ELE9BQU9BLElBQ0xDLE1BQU0sQ0FBQyx5QkFBeUIsOENBQ2hDQSxNQUFNLENBQUMscUJBQXFCLCtCQUM1QkEsTUFBTSxDQUFDLHdCQUF3Qix3Q0FDL0JBLE1BQU0sQ0FBQyxhQUFhLDBDQUNwQkEsTUFBTSxDQUFDLG9CQUFvQiwyQ0FBMkM7QUFDekU7QUFFQSxPQUFPLFNBQVNDLGFBQ2ZDLFNBQTZCLEVBQzdCQyxJQUE2QixFQUM3QkMsUUFBNkIsQ0FBQyxDQUFDO0lBRS9CLE1BQU1DLGNBQWNDLE9BQU9ILEtBQUtJLE9BQU8sSUFBSSxPQUFPQyxXQUFXO0lBQzdELE1BQU1DLFFBQVFDLE1BQU1DLE9BQU8sQ0FBQ1IsS0FBS1MsSUFBSSxJQUNqQ1QsS0FBS1MsSUFBSSxHQUNWLE9BQU9ULEtBQUtTLElBQUksS0FBSyxXQUNwQjtRQUFDVCxLQUFLUyxJQUFJO0tBQUMsR0FDWFIsTUFBTUssS0FBSztJQUNmLE9BQU87UUFDTkksR0FBR3RCLGlCQUFpQlcsV0FBVyxPQUFPQyxLQUFLVSxDQUFDLEtBQUssV0FBV1YsS0FBS1UsQ0FBQyxHQUFHQztRQUNyRUMsa0JBQWtCWixLQUFLYSxRQUFRO1FBQy9CQyxjQUFjZCxLQUFLZSxJQUFJO1FBQ3ZCQyxpQkFBaUJoQixLQUFLaUIsT0FBTztRQUM3QkMscUJBQ0NsQixLQUFLbUIsR0FBRyxLQUFLLE9BQ1YsUUFDQWpCLGdCQUFnQixTQUFTQSxnQkFBZ0IsT0FDeENBLGNBQ0FTO1FBQ0xMO1FBQ0EsR0FBR0wsS0FBSztJQUNUO0FBQ0Q7QUFFQSxPQUFPLGVBQWVtQixlQUFlQyxVQUFzQjtJQUMxRGhDLGNBQWNnQyxXQUFXZixLQUFLO0lBQzlCLE1BQU0sRUFBRWdCLFdBQVcsRUFBRSxHQUFHLE1BQU0sTUFBTSxDQUFDO0lBQ3JDLElBQUk7UUFDSCxNQUFNaEMsWUFBWStCO0lBQ25CLFNBQVU7UUFDVEM7SUFDRDtBQUNEIn0=

package/es6/src/webapi/const.js

@@ -0,0 +1,20 @@
+/** Default API project slug when `--name` is omitted. */ export const DEFAULT_WEBAPI_NAME = "api";
+/** Relative path of an API project inside the monorepo. */ export function webapiProjectDir(name) {
+    return `projects/${name}`;
+}
+/**
+ * Forge release entry for a scaffolded API (`pack: true` → per-target outDir).
+ * Keep in sync with root `package.json` `"start"` / `"start:<name>"` and Dockerfiles.
+ */ export function webapiReleaseEntry(name) {
+    return `dist/release/${webapiProjectDir(name)}/es6/src/main.js`;
+}
+/** npm package name for a scaffolded API (`flux serve --project`). */ export function webapiPackageName(workspaceName, apiName) {
+    return `@${workspaceName}/${apiName}`;
+}
+/** Local listen port for the nth API (0-based). Production uses `PORT`. */ export function webapiPort(index) {
+    return 3000 + index;
+}
+/** @deprecated Use `webapiProjectDir(name)`. Default path for the first API. */ export const WEBAPI_PROJECT_DIR = webapiProjectDir(DEFAULT_WEBAPI_NAME);
+/** @deprecated Use `webapiReleaseEntry(name)`. Default start entry for the first API. */ export const WEBAPI_RELEASE_ENTRY = webapiReleaseEntry(DEFAULT_WEBAPI_NAME);
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/webapi/create-api.js

@@ -0,0 +1,217 @@
+import { existsSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { DockerCompose } from "../models/compose.model.js";
+import { ConfigYaml } from "../models/config-yaml.model.js";
+import { WELL_KNOWN_FILES } from "../models/const.js";
+import { DevContainer } from "../models/dev-container.model.js";
+import { commandHistory } from "../models/docker-image.model.js";
+import { EnvFile } from "../models/env-file.model.js";
+import { Gitignore } from "../models/gitignore.model.js";
+import { LaunchJson } from "../models/launch-json.model.js";
+import { PackageJson } from "../models/package-json.model.js";
+import { MonoRepoScaffold, ProjectScaffold } from "../models/project.model.js";
+import { TsConfig } from "../models/tsconfig.model.js";
+import { VitestConfig } from "../models/vitest-config.model.js";
+import { VSCodeSettings } from "../models/vscode-settings.model.js";
+import { ScaffoldService } from "../services/scaffold.service.js";
+import { CreateCliError, isDecohereWorkspace, listExistingApiNames, parseApiNames } from "./api-name.js";
+import { DEFAULT_WEBAPI_NAME, webapiPackageName, webapiPort, webapiProjectDir, webapiReleaseEntry } from "./const.js";
+import { DevContainerHostScripts } from "./devcontainer/host-scripts.js";
+import { AuthFeature } from "./features/auth.feature.js";
+import { DatabaseFeature } from "./features/database.feature.js";
+import { FinalizeFeature } from "./features/finalize.feature.js";
+import { PostmanFeature } from "./features/postman.feature.js";
+import { ApiPackageJson } from "./models/api-package-json.model.js";
+import { ControllerSourceFile } from "./models/controller-source-file.model.js";
+import { GithubCiWorkflows } from "./models/github-ci.model.js";
+import { MainSourceFile } from "./models/main-source-file.model.js";
+import { WebapiProductionDockerfile } from "./models/production-dockerfile.model.js";
+import { SampleConfigModel, SampleServiceModel } from "./models/sample-files.model.js";
+import { WebapiDevContainer } from "./models/webapi-image.model.js";
+export { WEBAPI_PROJECT_DIR, WEBAPI_RELEASE_ENTRY } from "./const.js";
+const features = [
+    DatabaseFeature,
+    AuthFeature,
+    PostmanFeature,
+    FinalizeFeature
+];
+export async function scaffoldApi(cliOptions) {
+    const targetDir = resolve(cliOptions.d ?? ".");
+    const projectName = cliOptions.projectName?.trim() || process.env.DECOHERE_PROJECT_NAME?.trim() || basename(targetDir);
+    const names = parseApiNames(cliOptions.names);
+    const workspace = cliOptions.add ? createAddWorkspace(targetDir, projectName, names) : createWorkspace(targetDir, projectName, names);
+    await ScaffoldService.scaffold(workspace, {
+        ...cliOptions,
+        names
+    }, features);
+}
+function createWorkspace(targetDir, projectName, apiNames) {
+    const monoRepo = new MonoRepoScaffold();
+    monoRepo.targetDir = targetDir;
+    monoRepo.setName(projectName);
+    const name = monoRepo.name;
+    const compose = new DockerCompose().setProjectName(name).addHeaderComment("Merge .cursor/mcp.json in the service command. postStartCommand runs after Cursor's first MCP snapshot.").addNetwork(name, {
+        name: `samples-${name}`
+    }).addService("devcontainer", {
+        build: ".",
+        volumes: [
+            // Workspace-local (created by initialize.sh as the host user).
+            // Do NOT bind ${HOME}/.npm/... — Docker creates missing host paths as root.
+            "./npm-auth:/home/node/.npm-config",
+            "./gh-auth:/home/node/.config/gh",
+            "webapi-node-modules:/workspace/node_modules",
+            // Named volume (not a Cursor-only mount) so CLI recreates keep Up-arrow history.
+            `${commandHistory.volumeName}:${commandHistory.dir}`
+        ],
+        env_file: [
+            "./gh.env"
+        ],
+        environment: {
+            NPM_CONFIG_USERCONFIG: "/home/node/.npm-config/.npmrc"
+        },
+        command: "'bash -c \"CODEBASE_RAG_WORKSPACE=/workspace node --experimental-strip-types /workspace/.devcontainer/codebase-rag-mcp.ts merge || true && exec sleep infinity\"'",
+        networks: [
+            name
+        ]
+    }).addVolume("webapi-node-modules").addVolume(commandHistory.volumeName);
+    const installCmd = "bash .devcontainer/post-create.sh";
+    const devContainer = new DevContainer().addExtension("biomejs.biome", "vitest.explorer").setInitializeCommand("bash .devcontainer/initialize.sh").setPostCreateCommand(installCmd).setUpdateContentCommand(installCmd).setPostStartCommand("bash .devcontainer/post-start.sh").useCompose();
+    for (const [index, apiName] of apiNames.entries()){
+        const port = webapiPort(index);
+        devContainer.forwardPort(port);
+        devContainer.setPortAttributes(port, {
+            label: apiName === DEFAULT_WEBAPI_NAME ? "API" : apiName,
+            requireLocalPort: true
+        });
+    }
+    // Workspace-level models (repo root)
+    monoRepo.addModel(compose);
+    monoRepo.addModel(devContainer);
+    monoRepo.addModel(new WebapiDevContainer());
+    monoRepo.addModel(new WebapiProductionDockerfile(apiNames));
+    monoRepo.addModel(new GithubCiWorkflows());
+    monoRepo.addModel(new VSCodeSettings(name));
+    monoRepo.addModel(new LaunchJson(apiNames));
+    monoRepo.addModel(new TsConfig());
+    monoRepo.addModel(new VitestConfig());
+    monoRepo.addModel(new PackageJson(`${name}.api`, {
+        apiNames,
+        workspaceName: name
+    }));
+    monoRepo.addModel(new ConfigYaml(WELL_KNOWN_FILES.CONFIG_YAML, "config/config.yaml", ""));
+    monoRepo.addModel(new ConfigYaml(WELL_KNOWN_FILES.CONFIG_DEV_YAML, "config/config.dev.yaml", ""));
+    monoRepo.addModel(new Gitignore());
+    monoRepo.addModel(new EnvFile());
+    monoRepo.addFile(new DevContainerHostScripts());
+    // Biome formatter/linter config
+    monoRepo.addFile({
+        files: ()=>[
+                {
+                    filePath: "biome.json",
+                    content: JSON.stringify({
+                        $schema: "https://biomejs.dev/schemas/2.0.0/schema.json",
+                        files: {
+                            includes: [
+                                "**/*.ts",
+                                "**/*.js",
+                                "**/*.json",
+                                "**/*.yml",
+                                "**/*.yaml"
+                            ]
+                        },
+                        assist: {
+                            actions: {
+                                source: {
+                                    organizeImports: "on"
+                                }
+                            }
+                        },
+                        vcs: {
+                            enabled: true,
+                            clientKind: "git",
+                            useIgnoreFile: true
+                        },
+                        formatter: {
+                            enabled: true,
+                            formatWithErrors: true,
+                            indentStyle: "tab",
+                            lineWidth: 95
+                        },
+                        javascript: {
+                            parser: {
+                                unsafeParameterDecoratorsEnabled: true
+                            }
+                        },
+                        linter: {
+                            rules: {
+                                style: {
+                                    useConsistentMemberAccessibility: {
+                                        level: "error",
+                                        options: {
+                                            accessibility: "explicit"
+                                        }
+                                    }
+                                }
+                            }
+                        },
+                        overrides: [
+                            {
+                                includes: [
+                                    "**/*.json"
+                                ],
+                                formatter: {
+                                    indentStyle: "space",
+                                    indentWidth: 2
+                                }
+                            }
+                        ]
+                    }, null, 2)
+                }
+            ]
+    });
+    for (const apiName of apiNames){
+        addApiProject(monoRepo, name, apiName);
+    }
+    return monoRepo;
+}
+function createAddWorkspace(targetDir, projectName, apiNames) {
+    if (!isDecohereWorkspace(targetDir)) {
+        throw new CreateCliError(`Not a Decohere workspace: ${targetDir}. Scaffold one first with \`npx @decohere/create webapi\`.`);
+    }
+    const existing = listExistingApiNames(targetDir);
+    for (const apiName of apiNames){
+        if (existing.includes(apiName)) {
+            throw new CreateCliError(`API "${apiName}" already exists at ${webapiProjectDir(apiName)}.`);
+        }
+    }
+    const monoRepo = new MonoRepoScaffold();
+    monoRepo.targetDir = targetDir;
+    monoRepo.setName(projectName);
+    const name = monoRepo.name;
+    const pkg = PackageJson.fromFile(join(targetDir, "package.json"));
+    monoRepo.addModel(pkg);
+    monoRepo.addModel(existsSync(join(targetDir, ".env")) ? EnvFile.fromFile(join(targetDir, ".env")) : new EnvFile());
+    monoRepo.addModel(existsSync(join(targetDir, "config/config.yaml")) ? ConfigYaml.fromFile(WELL_KNOWN_FILES.CONFIG_YAML, "config/config.yaml", join(targetDir, "config/config.yaml")) : new ConfigYaml(WELL_KNOWN_FILES.CONFIG_YAML, "config/config.yaml", ""));
+    monoRepo.addModel(existsSync(join(targetDir, "config/config.dev.yaml")) ? ConfigYaml.fromFile(WELL_KNOWN_FILES.CONFIG_DEV_YAML, "config/config.dev.yaml", join(targetDir, "config/config.dev.yaml")) : new ConfigYaml(WELL_KNOWN_FILES.CONFIG_DEV_YAML, "config/config.dev.yaml", ""));
+    for (const [offset, apiName] of apiNames.entries()){
+        const port = webapiPort(existing.length + offset);
+        pkg.addScript(`start:${apiName}`, `node ${webapiReleaseEntry(apiName)}`);
+        pkg.addScript(`dev:${apiName}`, `PORT=${port} flux serve --project ${webapiPackageName(name, apiName)}`);
+        addApiProject(monoRepo, name, apiName);
+    }
+    monoRepo.addModel(new WebapiProductionDockerfile(apiNames, {
+        namedOnly: true
+    }));
+    return monoRepo;
+}
+function addApiProject(monoRepo, workspaceName, apiName) {
+    const apiProject = new ProjectScaffold(webapiProjectDir(apiName));
+    apiProject.addModel(new ApiPackageJson(workspaceName, apiName));
+    apiProject.addModel(new MainSourceFile(`${workspaceName}.${apiName}`));
+    apiProject.addModel(new ControllerSourceFile());
+    apiProject.addFile(new SampleConfigModel());
+    apiProject.addFile(new SampleServiceModel());
+    monoRepo.addProject(apiProject);
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/src/webapi/create-api.ts"],"sourcesContent":["import { existsSync } from \"node:fs\";\nimport { basename, join, resolve } from \"node:path\";\nimport { DockerCompose } from \"../models/compose.model.js\";\nimport { ConfigYaml } from \"../models/config-yaml.model.js\";\nimport { WELL_KNOWN_FILES } from \"../models/const.js\";\nimport { DevContainer } from \"../models/dev-container.model.js\";\nimport { commandHistory } from \"../models/docker-image.model.js\";\nimport { EnvFile } from \"../models/env-file.model.js\";\nimport { Gitignore } from \"../models/gitignore.model.js\";\nimport { LaunchJson } from \"../models/launch-json.model.js\";\nimport { PackageJson } from \"../models/package-json.model.js\";\nimport { MonoRepoScaffold, ProjectScaffold } from \"../models/project.model.js\";\nimport { TsConfig } from \"../models/tsconfig.model.js\";\nimport { VitestConfig } from \"../models/vitest-config.model.js\";\nimport { VSCodeSettings } from \"../models/vscode-settings.model.js\";\nimport { ScaffoldService } from \"../services/scaffold.service.js\";\nimport {\n\tCreateCliError,\n\tisDecohereWorkspace,\n\tlistExistingApiNames,\n\tparseApiNames,\n} from \"./api-name.js\";\nimport {\n\tDEFAULT_WEBAPI_NAME,\n\twebapiPackageName,\n\twebapiPort,\n\twebapiProjectDir,\n\twebapiReleaseEntry,\n} from \"./const.js\";\nimport { DevContainerHostScripts } from \"./devcontainer/host-scripts.js\";\nimport { AuthFeature } from \"./features/auth.feature.js\";\nimport { DatabaseFeature } from \"./features/database.feature.js\";\nimport { FinalizeFeature } from \"./features/finalize.feature.js\";\nimport { PostmanFeature } from \"./features/postman.feature.js\";\nimport { ApiPackageJson } from \"./models/api-package-json.model.js\";\nimport { ControllerSourceFile } from \"./models/controller-source-file.model.js\";\nimport { GithubCiWorkflows } from \"./models/github-ci.model.js\";\nimport { MainSourceFile } from \"./models/main-source-file.model.js\";\nimport { WebapiProductionDockerfile } from \"./models/production-dockerfile.model.js\";\nimport { SampleConfigModel, SampleServiceModel } from \"./models/sample-files.model.js\";\nimport { WebapiDevContainer } from \"./models/webapi-image.model.js\";\n\nexport { WEBAPI_PROJECT_DIR, WEBAPI_RELEASE_ENTRY } from \"./const.js\";\n\nexport type ApiOptions = {\n\td?: string;\n\t/** Host project name (directory basename). Required when scaffolding into `/workspace`. */\n\tprojectName?: string;\n\t/** API slugs under `projects/`. Default `[\"api\"]`. Repeatable `--name`. */\n\tnames?: string[];\n\t/** Add APIs to an existing Decohere workspace instead of creating a new one. */\n\tadd?: boolean;\n\tauthProvider?: \"auth0\" | \"none\";\n\tdatabaseProvider?: \"none\" | \"postgres/typeorm\";\n\tpostmanProvider?: \"api\" | \"local\" | \"none\";\n\tinstallDependencies?: \"yes\" | \"no\";\n};\n\nconst features = [DatabaseFeature, AuthFeature, PostmanFeature, FinalizeFeature];\n\nexport async function scaffoldApi(cliOptions: ApiOptions) {\n\tconst targetDir = resolve(cliOptions.d ?? \".\");\n\tconst projectName =\n\t\tcliOptions.projectName?.trim() ||\n\t\tprocess.env.DECOHERE_PROJECT_NAME?.trim() ||\n\t\tbasename(targetDir);\n\tconst names = parseApiNames(cliOptions.names);\n\tconst workspace = cliOptions.add\n\t\t? createAddWorkspace(targetDir, projectName, names)\n\t\t: createWorkspace(targetDir, projectName, names);\n\tawait ScaffoldService.scaffold(workspace, { ...cliOptions, names }, features);\n}\n\nfunction createWorkspace(\n\ttargetDir: string,\n\tprojectName: string,\n\tapiNames: readonly string[],\n): MonoRepoScaffold {\n\tconst monoRepo = new MonoRepoScaffold();\n\tmonoRepo.targetDir = targetDir;\n\tmonoRepo.setName(projectName);\n\tconst name = monoRepo.name;\n\n\tconst compose = new DockerCompose()\n\t\t.setProjectName(name)\n\t\t.addHeaderComment(\n\t\t\t\"Merge .cursor/mcp.json in the service command. postStartCommand runs after Cursor's first MCP snapshot.\",\n\t\t)\n\t\t.addNetwork(name, { name: `samples-${name}` })\n\t\t.addService(\"devcontainer\", {\n\t\t\tbuild: \".\",\n\t\t\tvolumes: [\n\t\t\t\t// Workspace-local (created by initialize.sh as the host user).\n\t\t\t\t// Do NOT bind ${HOME}/.npm/... — Docker creates missing host paths as root.\n\t\t\t\t\"./npm-auth:/home/node/.npm-config\",\n\t\t\t\t\"./gh-auth:/home/node/.config/gh\",\n\t\t\t\t\"webapi-node-modules:/workspace/node_modules\",\n\t\t\t\t// Named volume (not a Cursor-only mount) so CLI recreates keep Up-arrow history.\n\t\t\t\t`${commandHistory.volumeName}:${commandHistory.dir}`,\n\t\t\t],\n\t\t\tenv_file: [\"./gh.env\"],\n\t\t\tenvironment: { NPM_CONFIG_USERCONFIG: \"/home/node/.npm-config/.npmrc\" },\n\t\t\tcommand:\n\t\t\t\t\"'bash -c \\\"CODEBASE_RAG_WORKSPACE=/workspace node --experimental-strip-types /workspace/.devcontainer/codebase-rag-mcp.ts merge || true && exec sleep infinity\\\"'\",\n\t\t\tnetworks: [name],\n\t\t})\n\t\t.addVolume(\"webapi-node-modules\")\n\t\t.addVolume(commandHistory.volumeName);\n\n\tconst installCmd = \"bash .devcontainer/post-create.sh\";\n\tconst devContainer = new DevContainer()\n\t\t.addExtension(\"biomejs.biome\", \"vitest.explorer\")\n\t\t.setInitializeCommand(\"bash .devcontainer/initialize.sh\")\n\t\t.setPostCreateCommand(installCmd)\n\t\t.setUpdateContentCommand(installCmd)\n\t\t.setPostStartCommand(\"bash .devcontainer/post-start.sh\")\n\t\t.useCompose();\n\n\tfor (const [index, apiName] of apiNames.entries()) {\n\t\tconst port = webapiPort(index);\n\t\tdevContainer.forwardPort(port);\n\t\tdevContainer.setPortAttributes(port, {\n\t\t\tlabel: apiName === DEFAULT_WEBAPI_NAME ? \"API\" : apiName,\n\t\t\trequireLocalPort: true,\n\t\t});\n\t}\n\n\t// Workspace-level models (repo root)\n\tmonoRepo.addModel(compose);\n\tmonoRepo.addModel(devContainer);\n\tmonoRepo.addModel(new WebapiDevContainer());\n\tmonoRepo.addModel(new WebapiProductionDockerfile(apiNames));\n\tmonoRepo.addModel(new GithubCiWorkflows());\n\tmonoRepo.addModel(new VSCodeSettings(name));\n\tmonoRepo.addModel(new LaunchJson(apiNames));\n\tmonoRepo.addModel(new TsConfig());\n\tmonoRepo.addModel(new VitestConfig());\n\tmonoRepo.addModel(new PackageJson(`${name}.api`, { apiNames, workspaceName: name }));\n\tmonoRepo.addModel(new ConfigYaml(WELL_KNOWN_FILES.CONFIG_YAML, \"config/config.yaml\", \"\"));\n\tmonoRepo.addModel(\n\t\tnew ConfigYaml(WELL_KNOWN_FILES.CONFIG_DEV_YAML, \"config/config.dev.yaml\", \"\"),\n\t);\n\tmonoRepo.addModel(new Gitignore());\n\tmonoRepo.addModel(new EnvFile());\n\tmonoRepo.addFile(new DevContainerHostScripts());\n\n\t// Biome formatter/linter config\n\tmonoRepo.addFile({\n\t\tfiles: () => [\n\t\t\t{\n\t\t\t\tfilePath: \"biome.json\",\n\t\t\t\tcontent: JSON.stringify(\n\t\t\t\t\t{\n\t\t\t\t\t\t$schema: \"https://biomejs.dev/schemas/2.0.0/schema.json\",\n\t\t\t\t\t\tfiles: {\n\t\t\t\t\t\t\tincludes: [\"**/*.ts\", \"**/*.js\", \"**/*.json\", \"**/*.yml\", \"**/*.yaml\"],\n\t\t\t\t\t\t},\n\t\t\t\t\t\tassist: { actions: { source: { organizeImports: \"on\" } } },\n\t\t\t\t\t\tvcs: { enabled: true, clientKind: \"git\", useIgnoreFile: true },\n\t\t\t\t\t\tformatter: {\n\t\t\t\t\t\t\tenabled: true,\n\t\t\t\t\t\t\tformatWithErrors: true,\n\t\t\t\t\t\t\tindentStyle: \"tab\",\n\t\t\t\t\t\t\tlineWidth: 95,\n\t\t\t\t\t\t},\n\t\t\t\t\t\tjavascript: { parser: { unsafeParameterDecoratorsEnabled: true } },\n\t\t\t\t\t\tlinter: {\n\t\t\t\t\t\t\trules: {\n\t\t\t\t\t\t\t\tstyle: {\n\t\t\t\t\t\t\t\t\tuseConsistentMemberAccessibility: {\n\t\t\t\t\t\t\t\t\t\tlevel: \"error\",\n\t\t\t\t\t\t\t\t\t\toptions: { accessibility: \"explicit\" },\n\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t\toverrides: [\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tincludes: [\"**/*.json\"],\n\t\t\t\t\t\t\t\tformatter: { indentStyle: \"space\", indentWidth: 2 },\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t],\n\t\t\t\t\t},\n\t\t\t\t\tnull,\n\t\t\t\t\t2,\n\t\t\t\t),\n\t\t\t},\n\t\t],\n\t});\n\n\tfor (const apiName of apiNames) {\n\t\taddApiProject(monoRepo, name, apiName);\n\t}\n\n\treturn monoRepo;\n}\n\nfunction createAddWorkspace(\n\ttargetDir: string,\n\tprojectName: string,\n\tapiNames: readonly string[],\n): MonoRepoScaffold {\n\tif (!isDecohereWorkspace(targetDir)) {\n\t\tthrow new CreateCliError(\n\t\t\t`Not a Decohere workspace: ${targetDir}. Scaffold one first with \\`npx @decohere/create webapi\\`.`,\n\t\t);\n\t}\n\n\tconst existing = listExistingApiNames(targetDir);\n\tfor (const apiName of apiNames) {\n\t\tif (existing.includes(apiName)) {\n\t\t\tthrow new CreateCliError(\n\t\t\t\t`API \"${apiName}\" already exists at ${webapiProjectDir(apiName)}.`,\n\t\t\t);\n\t\t}\n\t}\n\n\tconst monoRepo = new MonoRepoScaffold();\n\tmonoRepo.targetDir = targetDir;\n\tmonoRepo.setName(projectName);\n\tconst name = monoRepo.name;\n\n\tconst pkg = PackageJson.fromFile(join(targetDir, \"package.json\"));\n\tmonoRepo.addModel(pkg);\n\tmonoRepo.addModel(\n\t\texistsSync(join(targetDir, \".env\"))\n\t\t\t? EnvFile.fromFile(join(targetDir, \".env\"))\n\t\t\t: new EnvFile(),\n\t);\n\tmonoRepo.addModel(\n\t\texistsSync(join(targetDir, \"config/config.yaml\"))\n\t\t\t? ConfigYaml.fromFile(\n\t\t\t\t\tWELL_KNOWN_FILES.CONFIG_YAML,\n\t\t\t\t\t\"config/config.yaml\",\n\t\t\t\t\tjoin(targetDir, \"config/config.yaml\"),\n\t\t\t\t)\n\t\t\t: new ConfigYaml(WELL_KNOWN_FILES.CONFIG_YAML, \"config/config.yaml\", \"\"),\n\t);\n\tmonoRepo.addModel(\n\t\texistsSync(join(targetDir, \"config/config.dev.yaml\"))\n\t\t\t? ConfigYaml.fromFile(\n\t\t\t\t\tWELL_KNOWN_FILES.CONFIG_DEV_YAML,\n\t\t\t\t\t\"config/config.dev.yaml\",\n\t\t\t\t\tjoin(targetDir, \"config/config.dev.yaml\"),\n\t\t\t\t)\n\t\t\t: new ConfigYaml(WELL_KNOWN_FILES.CONFIG_DEV_YAML, \"config/config.dev.yaml\", \"\"),\n\t);\n\n\tfor (const [offset, apiName] of apiNames.entries()) {\n\t\tconst port = webapiPort(existing.length + offset);\n\t\tpkg.addScript(`start:${apiName}`, `node ${webapiReleaseEntry(apiName)}`);\n\t\tpkg.addScript(\n\t\t\t`dev:${apiName}`,\n\t\t\t`PORT=${port} flux serve --project ${webapiPackageName(name, apiName)}`,\n\t\t);\n\t\taddApiProject(monoRepo, name, apiName);\n\t}\n\tmonoRepo.addModel(new WebapiProductionDockerfile(apiNames, { namedOnly: true }));\n\n\treturn monoRepo;\n}\n\nfunction addApiProject(\n\tmonoRepo: MonoRepoScaffold,\n\tworkspaceName: string,\n\tapiName: string,\n): void {\n\tconst apiProject = new ProjectScaffold(webapiProjectDir(apiName));\n\tapiProject.addModel(new ApiPackageJson(workspaceName, apiName));\n\tapiProject.addModel(new MainSourceFile(`${workspaceName}.${apiName}`));\n\tapiProject.addModel(new ControllerSourceFile());\n\tapiProject.addFile(new SampleConfigModel());\n\tapiProject.addFile(new SampleServiceModel());\n\tmonoRepo.addProject(apiProject);\n}\n"],"names":["existsSync","basename","join","resolve","DockerCompose","ConfigYaml","WELL_KNOWN_FILES","DevContainer","commandHistory","EnvFile","Gitignore","LaunchJson","PackageJson","MonoRepoScaffold","ProjectScaffold","TsConfig","VitestConfig","VSCodeSettings","ScaffoldService","CreateCliError","isDecohereWorkspace","listExistingApiNames","parseApiNames","DEFAULT_WEBAPI_NAME","webapiPackageName","webapiPort","webapiProjectDir","webapiReleaseEntry","DevContainerHostScripts","AuthFeature","DatabaseFeature","FinalizeFeature","PostmanFeature","ApiPackageJson","ControllerSourceFile","GithubCiWorkflows","MainSourceFile","WebapiProductionDockerfile","SampleConfigModel","SampleServiceModel","WebapiDevContainer","WEBAPI_PROJECT_DIR","WEBAPI_RELEASE_ENTRY","features","scaffoldApi","cliOptions","targetDir","d","projectName","trim","process","env","DECOHERE_PROJECT_NAME","names","workspace","add","createAddWorkspace","createWorkspace","scaffold","apiNames","monoRepo","setName","name","compose","setProjectName","addHeaderComment","addNetwork","addService","build","volumes","volumeName","dir","env_file","environment","NPM_CONFIG_USERCONFIG","command","networks","addVolume","installCmd","devContainer","addExtension","setInitializeCommand","setPostCreateCommand","setUpdateContentCommand","setPostStartCommand","useCompose","index","apiName","entries","port","forwardPort","setPortAttributes","label","requireLocalPort","addModel","workspaceName","CONFIG_YAML","CONFIG_DEV_YAML","addFile","files","filePath","content","JSON","stringify","$schema","includes","assist","actions","source","organizeImports","vcs","enabled","clientKind","useIgnoreFile","formatter","formatWithErrors","indentStyle","lineWidth","javascript","parser","unsafeParameterDecoratorsEnabled","linter","rules","style","useConsistentMemberAccessibility","level","options","accessibility","overrides","indentWidth","addApiProject","existing","pkg","fromFile","offset","length","addScript","namedOnly","apiProject","addProject"],"mappings":"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"}

package/es6/src/webapi/devcontainer/codebase-rag-mcp.js

@@ -0,0 +1,156 @@
+import { chmodSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function isRecord(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function loadDotenv(path, env) {
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    } catch  {
+        return;
+    }
+    for (const line of raw.split(/\r?\n/)){
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#") || !trimmed.includes("=")) continue;
+        const eq = trimmed.indexOf("=");
+        const key = trimmed.slice(0, eq).trim();
+        const value = trimmed.slice(eq + 1).trim().replace(/^["']|["']$/g, "");
+        if (key && env[key] === undefined) env[key] = value;
+    }
+}
+function seedFromMcpJson(raw) {
+    let data;
+    try {
+        data = JSON.parse(raw);
+    } catch  {
+        return null;
+    }
+    if (!isRecord(data)) return null;
+    const servers = data.mcpServers;
+    if (!isRecord(servers)) return null;
+    const server = servers["codebase-rag"];
+    if (!isRecord(server)) return null;
+    const url = typeof server.url === "string" ? server.url.trim() : "";
+    const headers = isRecord(server.headers) ? server.headers : {};
+    const auth = typeof headers.Authorization === "string" ? headers.Authorization.trim() : "";
+    const token = auth.toLowerCase().startsWith("bearer ") ? auth.slice(7).trim() : "";
+    if (!url.startsWith("http") || token.length === 0) return null;
+    return {
+        url,
+        token
+    };
+}
+function mergeIntoMcpJson(input) {
+    const { mcpPath, url, token, hostRoot } = input;
+    if (!url || !token) {
+        return {
+            skipped: "no URL/token"
+        };
+    }
+    const xRoot = hostRoot || "${workspaceFolder}";
+    mkdirSync(dirname(mcpPath), {
+        recursive: true
+    });
+    let data = {
+        mcpServers: {}
+    };
+    try {
+        if (statSync(mcpPath).size > 0) {
+            const loaded = JSON.parse(readFileSync(mcpPath, "utf8"));
+            if (isRecord(loaded)) data = loaded;
+        }
+    } catch (err) {
+        const code = isRecord(err) && typeof err.code === "string" ? err.code : "";
+        if (code !== "ENOENT") {
+            console.log("codebase-rag MCP: existing mcp.json is invalid JSON; replacing rag entry only after backup");
+            renameSync(mcpPath, `${mcpPath}.bak`);
+        }
+    }
+    const servers = isRecord(data.mcpServers) ? data.mcpServers : {};
+    data.mcpServers = servers;
+    servers["codebase-rag"] = {
+        url,
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "X-Codebase-Root": xRoot
+        }
+    };
+    writeFileSync(mcpPath, `${JSON.stringify(data, null, 2)}\n`, "utf8");
+    try {
+        chmodSync(mcpPath, 0o600);
+    } catch  {
+    // memfs and some hosts omit chmod
+    }
+    return {
+        path: mcpPath,
+        root: xRoot
+    };
+}
+function workspaceRoot(env = process.env) {
+    const fromEnv = env.CODEBASE_RAG_WORKSPACE?.trim();
+    if (fromEnv) return fromEnv;
+    // Scaffolded copy lives at <repo>/.devcontainer/codebase-rag-mcp.ts
+    return dirname(dirname(fileURLToPath(import.meta.url)));
+}
+function mergeFromEnv(env = process.env) {
+    const root = workspaceRoot(env);
+    const cursorDir = join(root, ".cursor");
+    loadDotenv(join(cursorDir, "codebase-rag.env"), env);
+    const url = (env.CODEBASE_RAG_MCP_URL ?? "").trim();
+    const token = (env.CODEBASE_RAG_MCP_TOKEN ?? "").trim();
+    const hostRoot = (env.CODEBASE_RAG_MCP_ROOT ?? "").trim() || root;
+    const result = mergeIntoMcpJson({
+        mcpPath: join(cursorDir, "mcp.json"),
+        url,
+        token,
+        hostRoot
+    });
+    if (result.skipped != null) {
+        console.log(`codebase-rag MCP: skipped (${result.skipped})`);
+        return 0;
+    }
+    console.log(`codebase-rag MCP: wrote ${result.path} url=${url} root=${result.root}`);
+    return 0;
+}
+function seedPrint(mcpPath) {
+    let raw;
+    try {
+        raw = readFileSync(mcpPath, "utf8");
+    } catch  {
+        return 1;
+    }
+    const creds = seedFromMcpJson(raw);
+    if (creds == null) return 1;
+    console.log(creds.url);
+    console.log(creds.token);
+    return 0;
+}
+function main(argv = process.argv.slice(2)) {
+    const command = argv[0] ?? "merge";
+    if (command === "seed-print") {
+        const mcpPath = argv[1];
+        if (mcpPath == null || mcpPath.length === 0) return 1;
+        return seedPrint(mcpPath);
+    }
+    if (command === "merge") {
+        return mergeFromEnv();
+    }
+    console.error(`codebase-rag MCP: unknown command ${command}`);
+    return 1;
+}
+const invoked = (process.argv[1] ?? "").replaceAll("\\", "/");
+if (invoked.endsWith("/codebase-rag-mcp.ts") || invoked.endsWith("/codebase-rag-mcp.js")) {
+    process.exit(main());
+}
+export const codebaseRagMcp = {
+    loadDotenv,
+    seedFromMcpJson,
+    mergeIntoMcpJson,
+    mergeFromEnv,
+    seedPrint,
+    main
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/src/webapi/devcontainer/codebase-rag-mcp.ts"],"sourcesContent":["import {\n\tchmodSync,\n\tmkdirSync,\n\treadFileSync,\n\trenameSync,\n\tstatSync,\n\twriteFileSync,\n} from \"node:fs\";\nimport { dirname, join } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\n\nexport type CodebaseRagCredentials = {\n\turl: string;\n\ttoken: string;\n};\n\nexport type McpJson = {\n\tmcpServers?: Record<string, unknown>;\n\t[key: string]: unknown;\n};\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n\treturn value != null && typeof value === \"object\" && !Array.isArray(value);\n}\n\nfunction loadDotenv(path: string, env: NodeJS.ProcessEnv): void {\n\tlet raw: string;\n\ttry {\n\t\traw = readFileSync(path, \"utf8\");\n\t} catch {\n\t\treturn;\n\t}\n\tfor (const line of raw.split(/\\r?\\n/)) {\n\t\tconst trimmed = line.trim();\n\t\tif (!trimmed || trimmed.startsWith(\"#\") || !trimmed.includes(\"=\")) continue;\n\t\tconst eq = trimmed.indexOf(\"=\");\n\t\tconst key = trimmed.slice(0, eq).trim();\n\t\tconst value = trimmed\n\t\t\t.slice(eq + 1)\n\t\t\t.trim()\n\t\t\t.replace(/^[\"']|[\"']$/g, \"\");\n\t\tif (key && env[key] === undefined) env[key] = value;\n\t}\n}\n\nfunction seedFromMcpJson(raw: string): CodebaseRagCredentials | null {\n\tlet data: unknown;\n\ttry {\n\t\tdata = JSON.parse(raw);\n\t} catch {\n\t\treturn null;\n\t}\n\tif (!isRecord(data)) return null;\n\tconst servers = data.mcpServers;\n\tif (!isRecord(servers)) return null;\n\tconst server = servers[\"codebase-rag\"];\n\tif (!isRecord(server)) return null;\n\tconst url = typeof server.url === \"string\" ? server.url.trim() : \"\";\n\tconst headers = isRecord(server.headers) ? server.headers : {};\n\tconst auth = typeof headers.Authorization === \"string\" ? headers.Authorization.trim() : \"\";\n\tconst token = auth.toLowerCase().startsWith(\"bearer \") ? auth.slice(7).trim() : \"\";\n\tif (!url.startsWith(\"http\") || token.length === 0) return null;\n\treturn { url, token };\n}\n\nfunction mergeIntoMcpJson(input: {\n\tmcpPath: string;\n\turl: string;\n\ttoken: string;\n\thostRoot: string;\n}): { skipped?: string; path?: string; root?: string } {\n\tconst { mcpPath, url, token, hostRoot } = input;\n\tif (!url || !token) {\n\t\treturn { skipped: \"no URL/token\" };\n\t}\n\n\tconst xRoot = hostRoot || \"${workspaceFolder}\";\n\tmkdirSync(dirname(mcpPath), { recursive: true });\n\n\tlet data: McpJson = { mcpServers: {} };\n\ttry {\n\t\tif (statSync(mcpPath).size > 0) {\n\t\t\tconst loaded: unknown = JSON.parse(readFileSync(mcpPath, \"utf8\"));\n\t\t\tif (isRecord(loaded)) data = loaded as McpJson;\n\t\t}\n\t} catch (err) {\n\t\tconst code = isRecord(err) && typeof err.code === \"string\" ? err.code : \"\";\n\t\tif (code !== \"ENOENT\") {\n\t\t\tconsole.log(\n\t\t\t\t\"codebase-rag MCP: existing mcp.json is invalid JSON; replacing rag entry only after backup\",\n\t\t\t);\n\t\t\trenameSync(mcpPath, `${mcpPath}.bak`);\n\t\t}\n\t}\n\n\tconst servers = isRecord(data.mcpServers) ? data.mcpServers : {};\n\tdata.mcpServers = servers;\n\tservers[\"codebase-rag\"] = {\n\t\turl,\n\t\theaders: {\n\t\t\tAuthorization: `Bearer ${token}`,\n\t\t\t\"X-Codebase-Root\": xRoot,\n\t\t},\n\t};\n\twriteFileSync(mcpPath, `${JSON.stringify(data, null, 2)}\\n`, \"utf8\");\n\ttry {\n\t\tchmodSync(mcpPath, 0o600);\n\t} catch {\n\t\t// memfs and some hosts omit chmod\n\t}\n\treturn { path: mcpPath, root: xRoot };\n}\n\nfunction workspaceRoot(env: NodeJS.ProcessEnv = process.env): string {\n\tconst fromEnv = env.CODEBASE_RAG_WORKSPACE?.trim();\n\tif (fromEnv) return fromEnv;\n\t// Scaffolded copy lives at <repo>/.devcontainer/codebase-rag-mcp.ts\n\treturn dirname(dirname(fileURLToPath(import.meta.url)));\n}\n\nfunction mergeFromEnv(env: NodeJS.ProcessEnv = process.env): number {\n\tconst root = workspaceRoot(env);\n\tconst cursorDir = join(root, \".cursor\");\n\tloadDotenv(join(cursorDir, \"codebase-rag.env\"), env);\n\tconst url = (env.CODEBASE_RAG_MCP_URL ?? \"\").trim();\n\tconst token = (env.CODEBASE_RAG_MCP_TOKEN ?? \"\").trim();\n\tconst hostRoot = (env.CODEBASE_RAG_MCP_ROOT ?? \"\").trim() || root;\n\tconst result = mergeIntoMcpJson({\n\t\tmcpPath: join(cursorDir, \"mcp.json\"),\n\t\turl,\n\t\ttoken,\n\t\thostRoot,\n\t});\n\tif (result.skipped != null) {\n\t\tconsole.log(`codebase-rag MCP: skipped (${result.skipped})`);\n\t\treturn 0;\n\t}\n\tconsole.log(`codebase-rag MCP: wrote ${result.path} url=${url} root=${result.root}`);\n\treturn 0;\n}\n\nfunction seedPrint(mcpPath: string): number {\n\tlet raw: string;\n\ttry {\n\t\traw = readFileSync(mcpPath, \"utf8\");\n\t} catch {\n\t\treturn 1;\n\t}\n\tconst creds = seedFromMcpJson(raw);\n\tif (creds == null) return 1;\n\tconsole.log(creds.url);\n\tconsole.log(creds.token);\n\treturn 0;\n}\n\nfunction main(argv = process.argv.slice(2)): number {\n\tconst command = argv[0] ?? \"merge\";\n\tif (command === \"seed-print\") {\n\t\tconst mcpPath = argv[1];\n\t\tif (mcpPath == null || mcpPath.length === 0) return 1;\n\t\treturn seedPrint(mcpPath);\n\t}\n\tif (command === \"merge\") {\n\t\treturn mergeFromEnv();\n\t}\n\tconsole.error(`codebase-rag MCP: unknown command ${command}`);\n\treturn 1;\n}\n\nconst invoked = (process.argv[1] ?? \"\").replaceAll(\"\\\\\", \"/\");\nif (invoked.endsWith(\"/codebase-rag-mcp.ts\") || invoked.endsWith(\"/codebase-rag-mcp.js\")) {\n\tprocess.exit(main());\n}\n\nexport const codebaseRagMcp = {\n\tloadDotenv,\n\tseedFromMcpJson,\n\tmergeIntoMcpJson,\n\tmergeFromEnv,\n\tseedPrint,\n\tmain,\n};\n"],"names":["chmodSync","mkdirSync","readFileSync","renameSync","statSync","writeFileSync","dirname","join","fileURLToPath","isRecord","value","Array","isArray","loadDotenv","path","env","raw","line","split","trimmed","trim","startsWith","includes","eq","indexOf","key","slice","replace","undefined","seedFromMcpJson","data","JSON","parse","servers","mcpServers","server","url","headers","auth","Authorization","token","toLowerCase","length","mergeIntoMcpJson","input","mcpPath","hostRoot","skipped","xRoot","recursive","size","loaded","err","code","console","log","stringify","root","workspaceRoot","process","fromEnv","CODEBASE_RAG_WORKSPACE","mergeFromEnv","cursorDir","CODEBASE_RAG_MCP_URL","CODEBASE_RAG_MCP_TOKEN","CODEBASE_RAG_MCP_ROOT","result","seedPrint","creds","main","argv","command","error","invoked","replaceAll","endsWith","exit","codebaseRagMcp"],"mappings":"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"}