@cortexkit/opencode-magic-context 0.33.0 → 0.34.0

package/src/config/transform-mode.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "bun:test";
+
+import { RUST_COMPACTION_OFF_WARNING, resolveTransformMode } from "./transform-mode";
+
+describe("resolveTransformMode", () => {
+    it("falls back to ts and warns when rust lacks user-level subc", () => {
+        expect(
+            resolveTransformMode({
+                configured: "rust",
+                userTierHasSubc: false,
+                compactionEnabled: true,
+            }),
+        ).toEqual({
+            mode: "ts",
+            warnings: ["rust mode requires user-level subc configuration; running ts."],
+        });
+    });
+
+    it("keeps rust when trusted user-level subc is present", () => {
+        expect(
+            resolveTransformMode({
+                configured: "rust",
+                userTierHasSubc: true,
+                compactionEnabled: true,
+            }),
+        ).toEqual({ mode: "rust", warnings: [] });
+    });
+
+    it("keeps ts without warnings when ts is configured", () => {
+        expect(
+            resolveTransformMode({
+                configured: "ts",
+                userTierHasSubc: false,
+                compactionEnabled: true,
+            }),
+        ).toEqual({ mode: "ts", warnings: [] });
+    });
+
+    it("keeps rust in the default compaction-on mode without a warning", () => {
+        const result = resolveTransformMode({
+            configured: "rust",
+            userTierHasSubc: true,
+            compactionEnabled: true,
+        });
+
+        expect(result.mode).toBe("rust");
+        expect(result.warnings).toEqual([]);
+    });
+
+    it("downgrades rust to ts with one warning when compaction is off", () => {
+        expect(
+            resolveTransformMode({
+                configured: "rust",
+                userTierHasSubc: true,
+                compactionEnabled: false,
+            }),
+        ).toEqual({
+            mode: "ts",
+            warnings: [RUST_COMPACTION_OFF_WARNING],
+        });
+    });
+});

package/src/config/transform-mode.ts

@@ -0,0 +1,34 @@
+export type ResolvedTransformMode = "ts" | "rust";
+
+export interface ResolveTransformModeArgs {
+    configured: ResolvedTransformMode;
+    userTierHasSubc: boolean;
+    compactionEnabled: boolean;
+}
+
+export const RUST_COMPACTION_OFF_WARNING =
+    "compaction-off mode does not support rust transform mode; using the TypeScript transform.";
+
+const RUST_REQUIRES_USER_SUBC_WARNING =
+    "rust mode requires user-level subc configuration; running ts.";
+
+export function resolveTransformMode(args: ResolveTransformModeArgs): {
+    mode: ResolvedTransformMode;
+    warnings: string[];
+} {
+    if (args.configured === "rust" && !args.compactionEnabled) {
+        return {
+            mode: "ts",
+            warnings: [RUST_COMPACTION_OFF_WARNING],
+        };
+    }
+
+    if (args.configured === "rust" && !args.userTierHasSubc) {
+        return {
+            mode: "ts",
+            warnings: [RUST_REQUIRES_USER_SUBC_WARNING],
+        };
+    }
+
+    return { mode: args.configured, warnings: [] };
+}

package/src/config/variable.test.ts

@@ -0,0 +1,323 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join, sep } from "node:path";
+
+import { substituteConfigVariables } from "./variable";
+
+describe("substituteConfigVariables", () => {
+    const ORIGINAL_ENV = { ...process.env };
+    let tmpDir: string;
+
+    beforeEach(() => {
+        tmpDir = mkdtempSync(join(tmpdir(), "mc-variable-test-"));
+    });
+
+    afterEach(() => {
+        try {
+            rmSync(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+        } catch {
+            /* Ignore EBUSY on Windows */
+        }
+        process.env = { ...ORIGINAL_ENV };
+    });
+
+    describe("env substitution", () => {
+        it("replaces {env:VAR} with process.env value", () => {
+            process.env.MC_TEST_KEY = "sk-real-value";
+            const input = `{ "api_key": "{env:MC_TEST_KEY}" }`;
+
+            const result = substituteConfigVariables({ text: input });
+
+            expect(result.text).toBe(`{ "api_key": "sk-real-value" }`);
+            expect(result.warnings).toHaveLength(0);
+        });
+
+        it("trims whitespace inside env token", () => {
+            process.env.MC_TEST_KEY = "trimmed-value";
+            const input = `{ "api_key": "{env: MC_TEST_KEY }" }`;
+
+            const result = substituteConfigVariables({ text: input });
+
+            expect(result.text).toBe(`{ "api_key": "trimmed-value" }`);
+            expect(result.warnings).toHaveLength(0);
+        });
+
+        it("JSON-escapes quotes in env values so JSONC parsing survives", () => {
+            process.env.MC_QUOTED = 'sk-"quoted"-value';
+            const input = `{ "api_key": "{env:MC_QUOTED}" }`;
+
+            const result = substituteConfigVariables({ text: input });
+
+            expect(result.text).toBe(`{ "api_key": "sk-\\"quoted\\"-value" }`);
+            expect(JSON.parse(result.text).api_key).toBe('sk-"quoted"-value');
+            expect(result.warnings).toHaveLength(0);
+        });
+
+        it("JSON-escapes newlines in env values so JSONC parsing survives", () => {
+            process.env.MC_MULTILINE = "line1\nline2";
+            const input = `{ "api_key": "{env:MC_MULTILINE}" }`;
+
+            const result = substituteConfigVariables({ text: input });
+
+            expect(result.text).toBe(`{ "api_key": "line1\\nline2" }`);
+            expect(JSON.parse(result.text).api_key).toBe("line1\nline2");
+            expect(result.warnings).toHaveLength(0);
+        });
+
+        it("prevents env values from injecting sibling JSON keys", () => {
+            process.env.MC_INJECT = 'abc", "provider": "off';
+            const input = `{ "api_key": "{env:MC_INJECT}" }`;
+
+            const result = substituteConfigVariables({ text: input });
+            const parsed = JSON.parse(result.text);
+
+            expect(parsed.api_key).toBe('abc", "provider": "off');
+            expect(parsed.provider).toBeUndefined();
+            expect(result.warnings).toHaveLength(0);
+        });
+
+        it("emits warning and empty string for missing env var", () => {
+            delete process.env.MC_MISSING_VAR;
+            const input = `{ "api_key": "{env:MC_MISSING_VAR}" }`;
+
+            const result = substituteConfigVariables({ text: input });
+
+            expect(result.text).toBe(`{ "api_key": "" }`);
+            expect(result.warnings).toHaveLength(1);
+            expect(result.warnings[0]).toContain("MC_MISSING_VAR");
+            expect(result.warnings[0]).toContain("not set");
+        });
+
+        it("emits warning for empty-string env var", () => {
+            process.env.MC_EMPTY = "";
+            const input = `{ "api_key": "{env:MC_EMPTY}" }`;
+
+            const result = substituteConfigVariables({ text: input });
+
+            expect(result.text).toBe(`{ "api_key": "" }`);
+            expect(result.warnings).toHaveLength(1);
+        });
+
+        it("passes {env:} literally through (matches OpenCode regex: at least one char required)", () => {
+            const input = `{ "api_key": "{env:}" }`;
+
+            const result = substituteConfigVariables({ text: input });
+
+            // The regex `{env:([^}]+)}` requires ≥1 char between the colon and
+            // brace. An empty `{env:}` is not a valid token and passes through
+            // to be parsed as literal JSONC text.
+            expect(result.text).toBe(input);
+            expect(result.warnings).toHaveLength(0);
+        });
+
+        it("handles multiple env tokens in one text", () => {
+            process.env.MC_A = "alpha";
+            process.env.MC_B = "beta";
+            const input = `{ "a": "{env:MC_A}", "b": "{env:MC_B}", "c": "{env:MC_MISSING}" }`;
+
+            const result = substituteConfigVariables({ text: input });
+
+            expect(result.text).toBe(`{ "a": "alpha", "b": "beta", "c": "" }`);
+            expect(result.warnings).toHaveLength(1);
+            expect(result.warnings[0]).toContain("MC_MISSING");
+        });
+    });
+
+    describe("file substitution", () => {
+        it("inlines file contents for absolute path", () => {
+            const keyFile = join(tmpDir, "key.txt");
+            writeFileSync(keyFile, "sk-from-file\n");
+            const input = `{ "api_key": "{file:${keyFile}}" }`;
+
+            const result = substituteConfigVariables({ text: input });
+
+            expect(result.text).toBe(`{ "api_key": "sk-from-file" }`);
+            expect(result.warnings).toHaveLength(0);
+        });
+
+        it("resolves relative path against configPath directory", () => {
+            const keyFile = join(tmpDir, "key.txt");
+            writeFileSync(keyFile, "relative-value");
+            const configPath = join(tmpDir, "magic-context.jsonc");
+
+            const input = `{ "api_key": "{file:./key.txt}" }`;
+            const result = substituteConfigVariables({ text: input, configPath });
+
+            expect(result.text).toBe(`{ "api_key": "relative-value" }`);
+            expect(result.warnings).toHaveLength(0);
+        });
+
+        it("resolves relative path without leading ./", () => {
+            const keyFile = join(tmpDir, "key.txt");
+            writeFileSync(keyFile, "no-dot-slash");
+            const configPath = join(tmpDir, "magic-context.jsonc");
+
+            const input = `{ "api_key": "{file:key.txt}" }`;
+            const result = substituteConfigVariables({ text: input, configPath });
+
+            expect(result.text).toBe(`{ "api_key": "no-dot-slash" }`);
+        });
+
+        it("expands ~/ to home directory", () => {
+            const input = `{ "marker": "{file:~/__mc-never-exists-${Date.now()}}" }`;
+
+            const result = substituteConfigVariables({ text: input });
+
+            // File doesn't exist, so warning fires — but warning must show it
+            // resolved under homedir, proving the ~ expansion happened.
+            expect(result.warnings).toHaveLength(1);
+            expect(result.warnings[0]).toContain(homedir() + sep);
+        });
+
+        it("JSON-escapes quotes and newlines in file contents", () => {
+            const keyFile = join(tmpDir, "multiline.txt");
+            writeFileSync(keyFile, 'line1 with "quote"\nline2');
+            const input = `{ "value": "{file:${keyFile}}" }`;
+
+            const result = substituteConfigVariables({ text: input });
+
+            // Escaped so the outer JSONC string still parses cleanly.
+            expect(result.text).toBe(`{ "value": "line1 with \\"quote\\"\\nline2" }`);
+            const parsed = JSON.parse(result.text);
+            expect(parsed.value).toBe('line1 with "quote"\nline2');
+        });
+
+        it("emits warning and empty string for missing file", () => {
+            const missing = join(tmpDir, "never-exists.txt");
+            const input = `{ "api_key": "{file:${missing}}" }`;
+
+            const result = substituteConfigVariables({ text: input });
+
+            expect(result.text).toBe(`{ "api_key": "" }`);
+            expect(result.warnings).toHaveLength(1);
+            expect(result.warnings[0]).toContain("not found");
+            expect(result.warnings[0]).toContain(missing);
+        });
+
+        it("passes {file:} literally through (matches OpenCode regex: at least one char required)", () => {
+            const input = `{ "api_key": "{file:}" }`;
+
+            const result = substituteConfigVariables({ text: input });
+
+            // Same reasoning as {env:} — empty token pattern doesn't match.
+            expect(result.text).toBe(input);
+            expect(result.warnings).toHaveLength(0);
+        });
+
+        it("suppresses {file:} expansion inside // line comments", () => {
+            const keyFile = join(tmpDir, "key.txt");
+            writeFileSync(keyFile, "should-not-appear");
+            const input = [
+                `{`,
+                `    // see docs: {file:${keyFile}}`,
+                `    "other": "value"`,
+                `}`,
+            ].join("\n");
+
+            const result = substituteConfigVariables({ text: input });
+
+            expect(result.text).not.toContain(`{file:${keyFile}}`);
+            expect(result.text).not.toContain("should-not-appear");
+            expect(result.warnings).toHaveLength(0);
+        });
+
+        it("suppresses {file:} expansion inside block comments", () => {
+            const keyFile = join(tmpDir, "key.txt");
+            writeFileSync(keyFile, "should-not-appear");
+            const input = [
+                `{`,
+                `    /* see docs: {file:${keyFile}} */`,
+                `    "other": "value"`,
+                `}`,
+            ].join("\n");
+
+            const result = substituteConfigVariables({ text: input });
+
+            expect(result.text).not.toContain(`{file:${keyFile}}`);
+            expect(result.text).not.toContain("should-not-appear");
+            expect(result.warnings).toHaveLength(0);
+        });
+
+        it("still expands {file:} tokens inside strings that contain URL comment markers", () => {
+            const keyFile = join(tmpDir, "key.txt");
+            writeFileSync(keyFile, "token-value");
+            const input = `{ "endpoint": "https://example.test/*literal*/{file:${keyFile}}" }`;
+
+            const result = substituteConfigVariables({ text: input });
+
+            expect(result.text).toBe(
+                `{ "endpoint": "https://example.test/*literal*/token-value" }`,
+            );
+            expect(JSON.parse(result.text).endpoint).toBe(
+                "https://example.test/*literal*/token-value",
+            );
+            expect(result.warnings).toHaveLength(0);
+        });
+    });
+
+    describe("combined substitution", () => {
+        it("handles env and file tokens together", () => {
+            process.env.MC_COMBINED = "env-val";
+            const keyFile = join(tmpDir, "combined.txt");
+            writeFileSync(keyFile, "file-val");
+
+            const input = `{ "e": "{env:MC_COMBINED}", "f": "{file:${keyFile}}" }`;
+            const result = substituteConfigVariables({ text: input });
+
+            expect(result.text).toBe(`{ "e": "env-val", "f": "file-val" }`);
+            expect(result.warnings).toHaveLength(0);
+        });
+
+        it("env tokens inside {file:} path expand before file read", () => {
+            // Tokens are substituted left-to-right in passes: env first, then
+            // file. So an env var naming a file path gets resolved during file
+            // substitution.
+            process.env.MC_FILE_DIR = tmpDir;
+            const keyFile = join(tmpDir, "indirect.txt");
+            writeFileSync(keyFile, "indirect-value");
+
+            const input = `{ "api_key": "{file:{env:MC_FILE_DIR}/indirect.txt}" }`;
+            const result = substituteConfigVariables({ text: input });
+
+            expect(result.text).toBe(`{ "api_key": "indirect-value" }`);
+        });
+    });
+
+    describe("no-op cases", () => {
+        it("returns text unchanged when no tokens present", () => {
+            const input = `{ "api_key": "literal-value", "provider": "openai-compatible" }`;
+
+            const result = substituteConfigVariables({ text: input });
+
+            expect(result.text).toBe(input);
+            expect(result.warnings).toHaveLength(0);
+        });
+
+        it("leaves partial patterns like {env alone", () => {
+            const input = `{ "note": "this {env is not a token" }`;
+
+            const result = substituteConfigVariables({ text: input });
+
+            expect(result.text).toBe(input);
+            expect(result.warnings).toHaveLength(0);
+        });
+    });
+
+    describe("sensitive-path warnings", () => {
+        it("warns when a user {file:} resolves into ~/.ssh", () => {
+            const input = `{ "key": "{file:~/.ssh/id_rsa}" }`;
+            const result = substituteConfigVariables({ text: input });
+            // Whether the file exists or not, the sensitive-path warning fires
+            // before the existence check.
+            expect(result.warnings.some((w) => w.includes("sensitive path"))).toBe(true);
+            expect(result.warnings.some((w) => w.includes("SSH keys"))).toBe(true);
+        });
+
+        it("does NOT warn for an ordinary {file:} path", () => {
+            const input = `{ "prompt": "{file:~/notes/context.md}" }`;
+            const result = substituteConfigVariables({ text: input });
+            expect(result.warnings.some((w) => w.includes("sensitive path"))).toBe(false);
+        });
+    });
+});

package/src/config/variable.ts

@@ -0,0 +1,192 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, resolve } from "node:path";
+
+import { stripJsonComments } from "../shared/jsonc-parser";
+
+export interface SubstituteInput {
+    /** Raw config text before JSONC parsing. */
+    text: string;
+    /**
+     * Path of the config file the text came from. Used to resolve relative
+     * `{file:...}` references and to emit useful warnings. Pass undefined for
+     * virtual/synthetic inputs (tests) — in that case `{file:}` tokens with
+     * relative paths resolve against `cwd`, which is rarely what callers want,
+     * so callers should prefer passing a real path when one exists.
+     */
+    configPath?: string;
+    /**
+     * Project-level config files are untrusted repository input. Do not expand
+     * secret-bearing tokens there; leave them literal and warn instead.
+     */
+    isProjectConfig?: boolean;
+}
+
+export interface SubstituteResult {
+    /** Config text with all `{env:X}` and `{file:path}` tokens replaced. */
+    text: string;
+    /**
+     * Human-readable warnings for missing env vars, unreadable files, and
+     * unresolved tokens that fell back to empty string. Safe to surface to the
+     * user via logger/toast/startup notification.
+     */
+    warnings: string[];
+}
+
+const ENV_PATTERN = /\{env:([^}]+)\}/g;
+const FILE_PATTERN = /\{file:([^}]+)\}/g;
+
+/**
+ * Directories that almost never belong in a config file's `{file:}` inline.
+ * Returns a short human label when `resolvedPath` sits inside one, else null.
+ * Used to WARN (not block) on user-level config — see the call site.
+ */
+function sensitiveFilePathReason(resolvedPath: string): string | null {
+    const home = homedir();
+    const sensitiveDirs: Array<{ dir: string; label: string }> = [
+        { dir: resolve(home, ".ssh"), label: "SSH keys" },
+        { dir: resolve(home, ".aws"), label: "AWS credentials" },
+        { dir: resolve(home, ".gnupg"), label: "GnuPG keyring" },
+        { dir: resolve(home, ".config", "gh"), label: "GitHub CLI auth" },
+    ];
+    for (const { dir, label } of sensitiveDirs) {
+        if (resolvedPath === dir || resolvedPath.startsWith(`${dir}/`)) {
+            return label;
+        }
+    }
+    return null;
+}
+
+/**
+ * Expand `{env:VAR}` and `{file:path}` tokens in raw config text.
+ *
+ * Mirrors OpenCode's `ConfigVariable.substitute` semantics so users can share
+ * the same patterns across `opencode.json(c)` and `magic-context.jsonc`:
+ *   - `{env:VAR}` → `process.env.VAR` (trimmed key), JSON-escaped for safe inlining, empty string when missing
+ *   - `{file:~/path}` → contents of `~/path`, JSON-escaped for safe inlining
+ *   - `{file:./rel}` or `{file:rel}` → resolved against the config file's dir
+ *   - `{file:/abs}` → resolved as absolute
+ *
+ * Unlike OpenCode we treat missing values as warnings rather than hard errors:
+ * magic-context config is less critical than the main OpenCode config, and a
+ * typo in an optional embedding key should not prevent the plugin from loading
+ * with other (valid) settings.
+ *
+ * File and env value substitution is JSON-escaped (wrapped then unwrapped
+ * through `JSON.stringify`) so line breaks, quotes, and backslashes survive
+ * the subsequent JSONC parse.
+ */
+export function substituteConfigVariables(input: SubstituteInput): SubstituteResult {
+    const warnings: string[] = [];
+    let text = input.text;
+
+    if (input.isProjectConfig) {
+        const hasEnvTokens = ENV_PATTERN.test(text);
+        const hasFileTokens = FILE_PATTERN.test(text);
+        ENV_PATTERN.lastIndex = 0;
+        FILE_PATTERN.lastIndex = 0;
+        if (hasEnvTokens || hasFileTokens) {
+            const tokenTypes = [
+                hasEnvTokens ? "{env:}" : undefined,
+                hasFileTokens ? "{file:}" : undefined,
+            ]
+                .filter(Boolean)
+                .join(" and ");
+            warnings.push(
+                `Project-level config no longer supports ${tokenTypes} tokens for security reasons; leaving tokens literal. Move secret expansion to user-level config.`,
+            );
+        }
+        return { text, warnings };
+    }
+
+    // Strip JSONC comments before substitution so tokens in comments cannot
+    // trigger env/file side effects. The shared parser helper is string-aware,
+    // so URL strings and literal comment markers inside strings are preserved.
+    text = stripJsonComments(text);
+
+    text = text.replace(ENV_PATTERN, (_, rawName: string) => {
+        const varName = rawName.trim();
+        const value = varName ? process.env[varName] : undefined;
+        if (value === undefined || value === "") {
+            warnings.push(
+                `Environment variable ${varName} is not set (referenced via {env:${varName}}); using empty string`,
+            );
+            return "";
+        }
+
+        return JSON.stringify(value).slice(1, -1);
+    });
+
+    const fileMatches = Array.from(text.matchAll(FILE_PATTERN));
+    if (fileMatches.length === 0) {
+        return { text, warnings };
+    }
+
+    const configDir = input.configPath ? dirname(input.configPath) : process.cwd();
+
+    let output = "";
+    let cursor = 0;
+
+    for (const match of fileMatches) {
+        const token = match[0];
+        const rawPath = match[1] ?? "";
+        const index = match.index ?? 0;
+
+        output += text.slice(cursor, index);
+        cursor = index + token.length;
+
+        // Skip tokens inside line comments: agents-only feature, matches OpenCode.
+        // We run before JSONC parsing so raw comments are still in the text.
+        const lineStart = text.lastIndexOf("\n", index - 1) + 1;
+        const prefix = text.slice(lineStart, index).trimStart();
+        if (prefix.startsWith("//")) {
+            output += token;
+            continue;
+        }
+
+        let filePath = rawPath.trim();
+        if (filePath.startsWith("~/")) {
+            filePath = resolve(homedir(), filePath.slice(2));
+        } else if (!isAbsolute(filePath)) {
+            filePath = resolve(configDir, filePath);
+        }
+
+        // Warn (don't block — this is user-level config, mirroring OpenCode's
+        // {file:} semantics) when a {file:} token resolves into a known-sensitive
+        // directory. A user pasting `{file:~/.ssh/id_rsa}` from a copied snippet
+        // would otherwise silently inline a private key into the prompt.
+        const sensitiveReason = sensitiveFilePathReason(filePath);
+        if (sensitiveReason) {
+            warnings.push(
+                `${token} resolves to a sensitive path (${sensitiveReason}: ${filePath}); ` +
+                    "inlining its contents into config — make sure this is intentional.",
+            );
+        }
+
+        if (!existsSync(filePath)) {
+            warnings.push(
+                `File not found for ${token} (resolved to ${filePath}); using empty string`,
+            );
+            continue;
+        }
+
+        let contents: string;
+        try {
+            contents = readFileSync(filePath, "utf-8").trim();
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            warnings.push(
+                `Failed to read file for ${token} (${filePath}): ${message}; using empty string`,
+            );
+            continue;
+        }
+
+        // JSON-escape so embedded quotes, newlines, and backslashes don't break
+        // the surrounding JSONC. Slice(1, -1) strips the outer quotes that
+        // JSON.stringify adds so the token stays inside the caller's own string.
+        output += JSON.stringify(contents).slice(1, -1);
+    }
+
+    output += text.slice(cursor);
+    return { text: output, warnings };
+}

package/src/features/magic-context/defaults.ts

@@ -0,0 +1 @@
+export const DEFAULT_PROTECTED_TAGS = 20;