min-agent 0.5.0 → 0.6.0

package/dist/http-approvals.js

@@ -1,60 +0,0 @@
-export const APPROVAL_TIMEOUT_MS = 300_000;
-export function createApprovalGate(timeoutMs = APPROVAL_TIMEOUT_MS) {
-    const pending = new Map();
-    const clear = (id) => {
-        const item = pending.get(id);
-        if (!item)
-            return undefined;
-        clearTimeout(item.timer);
-        pending.delete(id);
-        return item;
-    };
-    return {
-        waitConfirm(id) {
-            return new Promise((resolve) => {
-                const timer = setTimeout(() => {
-                    pending.delete(id);
-                    resolve(false);
-                }, timeoutMs);
-                pending.set(id, { kind: "confirm", resolve, timer });
-            });
-        },
-        waitQuestion(id) {
-            return new Promise((resolve) => {
-                const timer = setTimeout(() => {
-                    pending.delete(id);
-                    resolve(null);
-                }, timeoutMs);
-                pending.set(id, { kind: "question", resolve, timer });
-            });
-        },
-        resolveConfirm(id, accepted) {
-            const item = pending.get(id);
-            if (!item || item.kind !== "confirm")
-                return false;
-            clear(id);
-            item.resolve(accepted);
-            return true;
-        },
-        resolveQuestion(id, answer) {
-            const item = pending.get(id);
-            if (!item || item.kind !== "question")
-                return false;
-            clear(id);
-            item.resolve(answer);
-            return true;
-        },
-        cancel(id) {
-            const item = clear(id);
-            if (!item)
-                return;
-            if (item.kind === "confirm")
-                item.resolve(false);
-            else
-                item.resolve(null);
-        },
-        has(id) {
-            return pending.has(id);
-        },
-    };
-}

package/dist/http.js

@@ -1,119 +0,0 @@
-import { lookup } from "dns/promises";
-import { isIP } from "net";
-function isPrivateIpv4(parts) {
-    if (parts.length !== 4 || parts.some((p) => Number.isNaN(p)))
-        return true;
-    const [a, b] = parts;
-    if (a === 0 || a === 10 || a === 127)
-        return true;
-    if (a === 169 && b === 254)
-        return true;
-    if (a === 172 && b >= 16 && b <= 31)
-        return true;
-    if (a === 192 && b === 168)
-        return true;
-    if (a === 100 && b >= 64 && b <= 127)
-        return true;
-    if (a === 198 && (b === 18 || b === 19))
-        return true;
-    return false;
-}
-/**
- * Decode the tail of an IPv4-mapped IPv6 address (`::ffff:7f00:1` or
- * `::ffff:127.0.0.1`) into IPv4 octets, or return null.
- */
-function mappedIpv4Bytes(ip) {
-    const tail = ip.slice(7);
-    if (tail.includes(".")) {
-        return tail.split(".").map(Number);
-    }
-    const groups = tail.split(":");
-    if (groups.length !== 2)
-        return null;
-    const hi = parseInt(groups[0], 16);
-    const lo = parseInt(groups[1], 16);
-    if (Number.isNaN(hi) || Number.isNaN(lo))
-        return null;
-    return [hi >> 8, hi & 0xff, lo >> 8, lo & 0xff];
-}
-/** Check whether an IP address belongs to a private / reserved / loopback range. */
-export function isPrivateAddress(ip) {
-    if (ip.startsWith("::ffff:")) {
-        const bytes = mappedIpv4Bytes(ip);
-        if (bytes)
-            return isPrivateIpv4(bytes);
-        return true;
-    }
-    if (isIP(ip) === 6) {
-        const lower = ip.toLowerCase();
-        if (lower === "::1" || lower.startsWith("::"))
-            return true;
-        if (lower.startsWith("fc") || lower.startsWith("fd"))
-            return true;
-        if (lower.startsWith("fe8") || lower.startsWith("fe9") || lower.startsWith("fea") || lower.startsWith("feb"))
-            return true;
-        if (lower.startsWith("2001:db8"))
-            return true;
-        return false;
-    }
-    return isPrivateIpv4(ip.split(".").map(Number));
-}
-/** Returns an error message if the URL is unsafe to fetch (SSRF protection), or null if safe. */
-export async function assertSafeUrl(raw) {
-    let parsed;
-    try {
-        parsed = new URL(raw);
-    }
-    catch {
-        return "Invalid URL";
-    }
-    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-        return "Only http/https URLs are allowed";
-    }
-    const host = parsed.hostname;
-    if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal")) {
-        return `Blocked: local hostname "${host}"`;
-    }
-    if (isIP(host)) {
-        return isPrivateAddress(host) ? `Blocked: private/internal IP "${host}"` : null;
-    }
-    try {
-        const addresses = await lookup(host, { all: true });
-        for (const addr of addresses) {
-            if (isPrivateAddress(addr.address)) {
-                return `Blocked: "${host}" resolves to private address "${addr.address}"`;
-            }
-        }
-    }
-    catch {
-        // DNS failure — let fetch surface the real error
-    }
-    return null;
-}
-/**
- * Read a response body up to maxBytes. Bytes beyond the limit are dropped and
- * the read is cancelled early so huge responses never fill memory.
- */
-export async function readBodyLimited(response, maxBytes) {
-    if (!response.body) {
-        return { text: "", truncated: false };
-    }
-    const reader = response.body.getReader();
-    const chunks = [];
-    let total = 0;
-    let truncated = false;
-    for (;;) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        total += value.byteLength;
-        if (total > maxBytes) {
-            chunks.push(Buffer.from(value.subarray(0, value.byteLength - (total - maxBytes))));
-            truncated = true;
-            await reader.cancel();
-            break;
-        }
-        chunks.push(Buffer.from(value));
-    }
-    return { text: Buffer.concat(chunks).toString("utf-8"), truncated };
-}

package/dist/instructions.js

@@ -1,196 +0,0 @@
-import { AsyncLocalStorage } from "async_hooks";
-import { readFileSync, existsSync } from "fs";
-import path from "path";
-import os from "os";
-import { getRulesFile, loadConfig } from "./config.js";
-/**
- * Instruction/rules system.
- *
- * All config lives under ~/.min-agent/:
- *   ~/.min-agent/rules.md          — Global rules (always loaded)
- *   ~/.min-agent/config.json       — Can specify extra "instructions" paths/URLs
- *
- * Project-level rules (auto-discovered from cwd):
- *   ./AGENTS.md, ./RULES.md, ./.min-agent/AGENTS.md
- *
- * Context-aware (like opencode):
- *   When the agent reads a file, nearby AGENTS.md/RULES.md are auto-loaded.
- */
-const PROJECT_FILES = ["AGENTS.md", "RULES.md", "CLAUDE.md"];
-function isWithinDir(root, p) {
-    const rel = path.relative(root, p);
-    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
-}
-function walkUpDirs(startDir, minDir) {
-    const dirs = [];
-    let current = path.resolve(startDir);
-    while (current !== path.dirname(minDir) && isWithinDir(minDir, current)) {
-        dirs.push(current);
-        if (current === minDir)
-            break;
-        current = path.dirname(current);
-    }
-    return dirs;
-}
-/** Tracks which instruction files have already been loaded to avoid duplicates */
-export class InstructionTracker {
-    loaded = new Set();
-    isLoaded(filepath) {
-        return this.loaded.has(path.resolve(filepath));
-    }
-    markLoaded(filepath) {
-        this.loaded.add(path.resolve(filepath));
-    }
-    reset() {
-        this.loaded.clear();
-    }
-    /**
-     * Context-aware: when a file is read, walk up from its directory
-     * looking for AGENTS.md/RULES.md that haven't been loaded yet.
-     * Returns new instruction content to inject.
-     */
-    resolveForFile(filepath) {
-        const results = [];
-        const root = process.cwd();
-        for (const dir of walkUpDirs(path.dirname(path.resolve(filepath)), root)) {
-            for (const file of PROJECT_FILES) {
-                const candidate = path.join(dir, file);
-                if (existsSync(candidate) && !this.isLoaded(candidate)) {
-                    try {
-                        const content = readFileSync(candidate, "utf-8").trim();
-                        if (content) {
-                            this.markLoaded(candidate);
-                            results.push(`Instructions from: ${candidate}\n${content}`);
-                        }
-                    }
-                    catch { }
-                }
-            }
-            if (results.length > 0)
-                break;
-        }
-        return results;
-    }
-}
-const instructionStore = new AsyncLocalStorage();
-const fallbackInstructionTracker = new InstructionTracker();
-/** Per-run tracker so concurrent HTTP chats do not share loaded-file state. */
-export async function runWithInstructionTracker(fn) {
-    return instructionStore.run(new InstructionTracker(), fn);
-}
-export function getActiveInstructionTracker() {
-    return instructionStore.getStore() ?? fallbackInstructionTracker;
-}
-/** After compaction, nearby AGENTS.md must be allowed to re-inject. */
-export function resetActiveInstructionTracker() {
-    const current = instructionStore.getStore();
-    if (current)
-        current.reset();
-    else
-        fallbackInstructionTracker.reset();
-}
-export function findProjectInstructions() {
-    const results = [];
-    const root = path.parse(process.cwd()).root;
-    for (const dir of walkUpDirs(process.cwd(), root)) {
-        const dotDir = path.join(dir, ".min-agent", "AGENTS.md");
-        if (existsSync(dotDir)) {
-            results.push(dotDir);
-            break;
-        }
-        const found = PROJECT_FILES.find((file) => existsSync(path.join(dir, file)));
-        if (found) {
-            results.push(path.join(dir, found));
-            break;
-        }
-    }
-    return results;
-}
-function findGlobalRules() {
-    const results = [];
-    const rulesFile = getRulesFile();
-    if (existsSync(rulesFile))
-        results.push(rulesFile);
-    return results;
-}
-function resolveConfigInstructions() {
-    const config = loadConfig();
-    const instructions = config.instructions ?? [];
-    const results = [];
-    for (const item of instructions) {
-        if (item.startsWith("http://") || item.startsWith("https://"))
-            continue;
-        const resolved = item.startsWith("~/")
-            ? path.join(os.homedir(), item.slice(2))
-            : path.isAbsolute(item)
-                ? item
-                : path.resolve(process.cwd(), item);
-        if (existsSync(resolved))
-            results.push(resolved);
-    }
-    return results;
-}
-const REMOTE_CACHE_TTL_MS = 60_000;
-const remoteCache = new Map();
-async function fetchRemoteInstruction(url) {
-    const cached = remoteCache.get(url);
-    if (cached && Date.now() - cached.fetchedAt < REMOTE_CACHE_TTL_MS)
-        return cached.text;
-    try {
-        const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
-        if (response.ok) {
-            const text = await response.text();
-            if (text.trim()) {
-                remoteCache.set(url, { fetchedAt: Date.now(), text });
-                return text;
-            }
-        }
-    }
-    catch { }
-    return null;
-}
-export async function fetchRemoteInstructions(urls) {
-    const config = loadConfig();
-    const instructions = urls ?? config.instructions ?? [];
-    const results = await Promise.all(instructions
-        .filter((i) => i.startsWith("http://") || i.startsWith("https://"))
-        .map(async (url) => {
-        const text = await fetchRemoteInstruction(url);
-        return text ? `Instructions from: ${url}\n${text}` : "";
-    }));
-    return results.filter(Boolean);
-}
-export async function loadInstructions() {
-    const parts = [];
-    // Global rules from ~/.min-agent/rules.md
-    for (const filepath of findGlobalRules()) {
-        try {
-            const content = readFileSync(filepath, "utf-8").trim();
-            if (content)
-                parts.push(`Instructions from: ${filepath}\n${content}`);
-        }
-        catch { }
-    }
-    // Project-level instructions
-    for (const filepath of findProjectInstructions()) {
-        try {
-            const content = readFileSync(filepath, "utf-8").trim();
-            if (content)
-                parts.push(`Instructions from: ${filepath}\n${content}`);
-        }
-        catch { }
-    }
-    // Config-defined file instructions
-    for (const filepath of resolveConfigInstructions()) {
-        try {
-            const content = readFileSync(filepath, "utf-8").trim();
-            if (content)
-                parts.push(`Instructions from: ${filepath}\n${content}`);
-        }
-        catch { }
-    }
-    // Remote URL instructions
-    const remote = await fetchRemoteInstructions();
-    parts.push(...remote);
-    return parts;
-}

package/dist/logger.js

@@ -1,95 +0,0 @@
-import { mkdirSync, readdirSync, unlinkSync, writeFileSync } from "fs";
-import path from "path";
-import { getConfigDir } from "./config.js";
-const KEEP_DAYS = 7;
-function logsDir() {
-    return path.join(getConfigDir(), "logs");
-}
-function logFilePath(date) {
-    const y = date.getFullYear();
-    const m = String(date.getMonth() + 1).padStart(2, "0");
-    const d = String(date.getDate()).padStart(2, "0");
-    return path.join(logsDir(), `min-agent.${y}-${m}-${d}.log`);
-}
-export function initLogger() {
-    try {
-        mkdirSync(logsDir(), { recursive: true });
-        const cutoff = Date.now() - KEEP_DAYS * 24 * 60 * 60 * 1000;
-        for (const f of readdirSync(logsDir())) {
-            const m = f.match(/^min-agent\.(\d{4})-(\d{2})-(\d{2})\.log$/);
-            if (!m)
-                continue;
-            const ts = new Date(`${m[1]}-${m[2]}-${m[3]}T00:00:00`).getTime();
-            if (ts < cutoff) {
-                try {
-                    unlinkSync(path.join(logsDir(), f));
-                }
-                catch { }
-            }
-        }
-    }
-    catch { }
-}
-function writeLog(level, msg) {
-    try {
-        const now = new Date();
-        const time = `${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}`;
-        writeFileSync(logFilePath(now), `[${time}] [${level}]${runTag()} ${scrubSecrets(msg)}\n`, { flag: "a" });
-    }
-    catch { }
-}
-/**
- * Run context stamped onto every log line, so interleaved turns (and the passes
- * inside one turn) can be told apart when reading the file afterwards.
- */
-let runContext = null;
-function runTag() {
-    if (!runContext)
-        return "";
-    return ` [run=${runContext.runId} pass=${runContext.pass}]`;
-}
-/** Start a new run scope and return its id. */
-export function startRunLog() {
-    const runId = Math.random().toString(36).slice(2, 8);
-    runContext = { runId, pass: 0 };
-    return runId;
-}
-/** Mark the beginning of a model pass inside the current run. */
-export function nextRunPass() {
-    if (!runContext)
-        startRunLog();
-    runContext.pass++;
-    return runContext.pass;
-}
-export function endRunLog() {
-    runContext = null;
-}
-export function currentRunId() {
-    return runContext?.runId ?? null;
-}
-const SECRET_PATTERNS = [
-    /\b(Bearer\s+)[A-Za-z0-9._~+/-]{8,}/g,
-    /\b(api[_-]?key|apikey|token|secret|password|passwd)\s*[:=]\s*["']?[A-Za-z0-9._~+/-]{6,}["']?/gi,
-    /\b(sk-[A-Za-z0-9_-]{6,})/g,
-    /\b(gh[pousr]_[A-Za-z0-9]{20,})/g,
-];
-/** Mask obvious secrets before anything hits the log file. */
-function scrubSecrets(msg) {
-    let out = msg;
-    for (const re of SECRET_PATTERNS)
-        out = out.replace(re, "$1***");
-    return out;
-}
-export function log(level, msg) {
-    writeLog(level, msg);
-}
-function summarize(v, max = 200) {
-    const s = typeof v === "string" ? v : (JSON.stringify(v) ?? String(v));
-    return s.length > max ? s.slice(0, max) + "…" : s;
-}
-export function logToolCall(name, input) {
-    writeLog("info", `tool_call ${name} ${summarize(input)}`);
-}
-export function logToolResult(name, output) {
-    writeLog("info", `tool_result ${name} ${summarize(output)}`);
-}