@jungjaehoon/mama-core 2.4.1 → 4.0.0

package/dist/runtime/drivers/codex-auxiliary-tools.d.ts

@@ -0,0 +1,17 @@
+import type { HostToolBridge } from './types.js';
+export declare const CODEX_AUXILIARY_TOOL_NAMES: readonly ["Read", "Write", "Edit", "Bash", "Glob", "Grep"];
+export type CodexAuxiliaryToolName = (typeof CODEX_AUXILIARY_TOOL_NAMES)[number];
+export interface CodexAuxiliaryCommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface CodexAuxiliaryToolPolicy {
+    allowedTools: readonly CodexAuxiliaryToolName[];
+    roots: readonly string[];
+}
+export interface CodexAuxiliaryToolBridgeOptions extends CodexAuxiliaryToolPolicy {
+    executeCommand: (command: string, cwd: string, roots: readonly string[], signal?: AbortSignal) => Promise<CodexAuxiliaryCommandResult>;
+}
+export declare function createCodexAuxiliaryToolBridge(options: CodexAuxiliaryToolBridgeOptions): HostToolBridge;
+//# sourceMappingURL=codex-auxiliary-tools.d.ts.map

package/dist/runtime/drivers/codex-auxiliary-tools.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CODEX_AUXILIARY_TOOL_NAMES = void 0;
+exports.createCodexAuxiliaryToolBridge = createCodexAuxiliaryToolBridge;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const minimatch_1 = require("minimatch");
+exports.CODEX_AUXILIARY_TOOL_NAMES = [
+    'Read',
+    'Write',
+    'Edit',
+    'Bash',
+    'Glob',
+    'Grep',
+];
+const STRING = { type: 'string' };
+const DEFINITIONS = {
+    Read: definition('Read', 'Read one UTF-8 file inside the MAMA workspace.', {
+        path: STRING,
+    }, ['path']),
+    Write: definition('Write', 'Write one UTF-8 file inside the MAMA workspace.', {
+        path: STRING,
+        content: STRING,
+    }, ['path', 'content']),
+    Edit: definition('Edit', 'Replace one exact text occurrence inside a MAMA workspace file.', {
+        path: STRING,
+        old_string: STRING,
+        new_string: STRING,
+    }, ['path', 'old_string', 'new_string']),
+    Bash: definition('Bash', 'Run one command in the Codex sandbox inside the MAMA workspace.', {
+        command: STRING,
+        workdir: STRING,
+    }, ['command']),
+    Glob: definition('Glob', 'List workspace files matching a glob pattern.', {
+        pattern: STRING,
+        path: STRING,
+    }, ['pattern']),
+    Grep: definition('Grep', 'Search workspace text files with a regular expression.', {
+        pattern: STRING,
+        path: STRING,
+        glob: STRING,
+    }, ['pattern']),
+};
+const MAX_FILE_BYTES = 200_000;
+const MAX_COMMAND_STREAM_BYTES = 50_000;
+const MAX_WALK_ENTRIES = 5_000;
+const MAX_RESULTS = 500;
+function definition(name, description, properties, required) {
+    return {
+        type: 'function',
+        name,
+        description,
+        inputSchema: { type: 'object', properties, required, additionalProperties: false },
+    };
+}
+function requireString(input, name) {
+    const value = input[name];
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`${name} must be a non-empty string`);
+    }
+    return value;
+}
+function optionalString(input, name) {
+    const value = input[name];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`${name} must be a non-empty string when provided`);
+    }
+    return value;
+}
+function within(root, path) {
+    const rel = (0, node_path_1.relative)(root, path);
+    return rel === '' || (!rel.startsWith('..') && !(0, node_path_1.isAbsolute)(rel));
+}
+function normalizeRoots(roots) {
+    const normalized = [...new Set(roots.map((root) => (0, node_fs_1.realpathSync)((0, node_path_1.resolve)(root))))];
+    if (normalized.length === 0)
+        throw new Error('Codex auxiliary tools require at least one root');
+    return normalized;
+}
+function canonicalizeCandidate(path) {
+    let existing = path;
+    const missing = [];
+    while (!(0, node_fs_1.existsSync)(existing)) {
+        const parent = (0, node_path_1.dirname)(existing);
+        if (parent === existing)
+            throw new Error(`Cannot resolve path: ${path}`);
+        missing.unshift((0, node_path_1.basename)(existing));
+        existing = parent;
+    }
+    return (0, node_path_1.resolve)((0, node_fs_1.realpathSync)(existing), ...missing);
+}
+function assertNoSymlinkTraversal(path, root, allowMissingLeaf) {
+    const rel = (0, node_path_1.relative)(root, path);
+    const segments = rel === '' ? [] : rel.split('/');
+    let current = root;
+    for (let index = 0; index < segments.length; index += 1) {
+        current = (0, node_path_1.resolve)(current, segments[index]);
+        try {
+            if ((0, node_fs_1.lstatSync)(current).isSymbolicLink()) {
+                throw new Error(`Symlink traversal is not allowed: ${path}`);
+            }
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === 'ENOENT' && allowMissingLeaf)
+                return;
+            throw error;
+        }
+    }
+}
+function resolveScopedPath(rawPath, roots, options = {}) {
+    const candidate = canonicalizeCandidate((0, node_path_1.resolve)(options.base ?? roots[0], rawPath));
+    const root = roots.find((allowedRoot) => within(allowedRoot, candidate));
+    if (!root)
+        throw new Error(`Path is outside the MAMA auxiliary roots: ${rawPath}`);
+    assertNoSymlinkTraversal(candidate, root, options.allowMissingLeaf ?? false);
+    if (!(options.allowMissingLeaf ?? false)) {
+        const real = (0, node_fs_1.realpathSync)(candidate);
+        if (!within(root, real))
+            throw new Error(`Resolved path escaped the MAMA auxiliary root`);
+    }
+    return candidate;
+}
+function walkFiles(root) {
+    const files = [];
+    const pending = [root];
+    let visited = 0;
+    while (pending.length > 0) {
+        const directory = pending.pop();
+        if (!directory)
+            break;
+        for (const entry of (0, node_fs_1.readdirSync)(directory, { withFileTypes: true })) {
+            visited += 1;
+            if (visited > MAX_WALK_ENTRIES)
+                throw new Error('Workspace scan exceeded its entry limit');
+            if (entry.isSymbolicLink())
+                continue;
+            const path = (0, node_path_1.resolve)(directory, entry.name);
+            if (entry.isDirectory())
+                pending.push(path);
+            else if (entry.isFile())
+                files.push(path);
+        }
+    }
+    return files;
+}
+function content(result, isError = false) {
+    return { content: typeof result === 'string' ? result : JSON.stringify(result), isError };
+}
+function boundedCommandStream(value) {
+    const encoded = Buffer.from(value, 'utf8');
+    if (encoded.byteLength <= MAX_COMMAND_STREAM_BYTES) {
+        return { text: value, bytes: encoded.byteLength, truncated: false };
+    }
+    return {
+        text: encoded.subarray(0, MAX_COMMAND_STREAM_BYTES).toString('utf8'),
+        bytes: encoded.byteLength,
+        truncated: true,
+    };
+}
+function assertReadableFileSize(path) {
+    if ((0, node_fs_1.statSync)(path).size > MAX_FILE_BYTES) {
+        throw new Error('File exceeds read limit');
+    }
+}
+function createCodexAuxiliaryToolBridge(options) {
+    const roots = normalizeRoots(options.roots);
+    const allowed = [...new Set(options.allowedTools)];
+    const tools = allowed.map((name) => DEFINITIONS[name]);
+    return {
+        tools,
+        async execute(call) {
+            try {
+                if (!allowed.includes(call.name)) {
+                    throw new Error(`Codex auxiliary tool ${call.name} was not allowed`);
+                }
+                const name = call.name;
+                if (name === 'Read') {
+                    const path = resolveScopedPath(requireString(call.input, 'path'), roots);
+                    assertReadableFileSize(path);
+                    return content((0, node_fs_1.readFileSync)(path, 'utf8'));
+                }
+                if (name === 'Write') {
+                    const path = resolveScopedPath(requireString(call.input, 'path'), roots, {
+                        allowMissingLeaf: true,
+                    });
+                    const newContent = requireString(call.input, 'content');
+                    if (Buffer.byteLength(newContent) > MAX_FILE_BYTES) {
+                        throw new Error('File exceeds write limit');
+                    }
+                    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true });
+                    (0, node_fs_1.writeFileSync)(path, newContent, 'utf8');
+                    return content({ path, written: true });
+                }
+                if (name === 'Edit') {
+                    const path = resolveScopedPath(requireString(call.input, 'path'), roots);
+                    const oldText = requireString(call.input, 'old_string');
+                    const newText = requireString(call.input, 'new_string');
+                    assertReadableFileSize(path);
+                    const original = (0, node_fs_1.readFileSync)(path, 'utf8');
+                    const first = original.indexOf(oldText);
+                    if (first < 0)
+                        throw new Error('old_string was not found');
+                    if (original.indexOf(oldText, first + oldText.length) >= 0) {
+                        throw new Error('old_string matched more than once');
+                    }
+                    const edited = `${original.slice(0, first)}${newText}${original.slice(first + oldText.length)}`;
+                    if (Buffer.byteLength(edited) > MAX_FILE_BYTES) {
+                        throw new Error('File exceeds write limit');
+                    }
+                    (0, node_fs_1.writeFileSync)(path, edited, 'utf8');
+                    return content({ path, edited: true });
+                }
+                if (name === 'Bash') {
+                    const cwd = resolveScopedPath(optionalString(call.input, 'workdir') ?? roots[0], roots);
+                    const result = await options.executeCommand(requireString(call.input, 'command'), cwd, roots, call.signal);
+                    const stdout = boundedCommandStream(result.stdout);
+                    const stderr = boundedCommandStream(result.stderr);
+                    return content({
+                        exitCode: result.exitCode,
+                        stdout: stdout.text,
+                        stderr: stderr.text,
+                        stdoutBytes: stdout.bytes,
+                        stderrBytes: stderr.bytes,
+                        stdoutTruncated: stdout.truncated,
+                        stderrTruncated: stderr.truncated,
+                    }, result.exitCode !== 0);
+                }
+                const scanRoot = resolveScopedPath(optionalString(call.input, 'path') ?? roots[0], roots);
+                const files = walkFiles(scanRoot);
+                if (name === 'Glob') {
+                    const pattern = requireString(call.input, 'pattern');
+                    const matches = files
+                        .filter((path) => (0, minimatch_1.minimatch)((0, node_path_1.relative)(scanRoot, path), pattern, { dot: true }))
+                        .slice(0, MAX_RESULTS);
+                    return content(matches);
+                }
+                const regex = new RegExp(requireString(call.input, 'pattern'), 'g');
+                const glob = optionalString(call.input, 'glob');
+                const matches = [];
+                for (const path of files) {
+                    if (glob && !(0, minimatch_1.minimatch)((0, node_path_1.relative)(scanRoot, path), glob, { dot: true }))
+                        continue;
+                    const stat = (0, node_fs_1.lstatSync)(path);
+                    if (stat.size > MAX_FILE_BYTES)
+                        continue;
+                    const lines = (0, node_fs_1.readFileSync)(path, 'utf8').split(/\r?\n/);
+                    for (let index = 0; index < lines.length; index += 1) {
+                        regex.lastIndex = 0;
+                        if (regex.test(lines[index])) {
+                            matches.push({ path, line: index + 1, text: lines[index] });
+                            if (matches.length >= MAX_RESULTS)
+                                return content(matches);
+                        }
+                    }
+                }
+                return content(matches);
+            }
+            catch (error) {
+                return content(error instanceof Error ? error.message : String(error), true);
+            }
+        },
+    };
+}
+//# sourceMappingURL=codex-auxiliary-tools.js.map

package/dist/runtime/drivers/codex-home.d.ts

@@ -0,0 +1,20 @@
+export interface CodexAppServerLaunchConfig {
+    args: string[];
+    env: Record<string, string | undefined>;
+    fingerprint: string;
+    /** Fingerprint of configured credential values; never persisted in thread policy. */
+    secretFingerprint: string;
+}
+export declare const CODEX_REASONING_EFFORTS: readonly ["low", "medium", "high", "xhigh", "max"];
+export type CodexReasoningEffort = (typeof CODEX_REASONING_EFFORTS)[number];
+export declare const DEFAULT_CODEX_REASONING_EFFORT: CodexReasoningEffort;
+export declare function buildMAMACodexAppServerConfig(effort?: string | null, hostNotes?: readonly string[], options?: {
+    shellTool?: boolean;
+    /** Enable live web search; disabled unless the consumer opts in. */
+    webSearch?: boolean;
+    shellEnvironment?: Record<string, string>;
+    deniedReadPaths?: string[];
+    allowLoginShell?: boolean;
+}): string;
+export declare function buildCodexAppServerLaunchConfig(mcpConfigPath: string | undefined, processEnv: Readonly<Record<string, string | undefined>>): CodexAppServerLaunchConfig;
+//# sourceMappingURL=codex-home.d.ts.map