qlogicagent 2.13.3 → 2.13.5

package/dist/cli/tool-bootstrap-core-registration.js

@@ -0,0 +1,555 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { execFile } from "node:child_process";
+import { createTaskTool } from "../skills/tools/task-tool.js";
+import { createAskUserTool } from "../skills/tools/ask-user-tool.js";
+import { createExecTool } from "../skills/tools/exec-tool.js";
+import { createReadTool } from "../skills/tools/read-tool.js";
+import { createWriteTool } from "../skills/tools/write-tool.js";
+import { createEditTool } from "../skills/tools/edit-tool.js";
+import { createPatchTool } from "../skills/tools/patch-tool.js";
+import { createSearchTool } from "../skills/tools/search-tool.js";
+import { createInstructionsTool } from "../skills/tools/instructions-tool.js";
+import { createWorktreeTool } from "../skills/tools/worktree-tool.js";
+import { createWorktreeBackend } from "../runtime/infra/worktree-backend.js";
+import { createNotebookEditTool } from "../skills/tools/notebook-edit-tool.js";
+import { createSleepTool } from "../skills/tools/sleep-tool.js";
+import { createToolSearchTool, searchToolCorpus } from "../skills/tools/tool-search-tool.js";
+import { defineToolRegistrationModule } from "../runtime/ports/index.js";
+import { isGroupSensitivePath } from "../skills/permissions/group-security-policy.js";
+import * as projectStore from "../runtime/infra/project-store.js";
+import { enforceAbsoluteFloors, resolveToolPath } from "./tool-bootstrap-paths.js";
+let groupSecurityMode = false;
+export function setGroupSecurityMode(enabled) {
+    groupSecurityMode = enabled;
+}
+export const localCoreToolRegistrationModule = defineToolRegistrationModule({
+    id: "local-core-tools",
+    kind: "core",
+    register: registerLocalCoreTools,
+});
+export function registerLocalCoreTools(context) {
+    const tools = context.tools;
+    tools.push(createTaskTool(undefined, {
+        onTaskCreated: (task) => context.taskToolHooks?.onTaskCreated?.(task),
+        onTaskCompleted: (task) => context.taskToolHooks?.onTaskCompleted?.(task),
+    }, {
+        getRuntime: () => context.backgroundTaskRuntime,
+    }));
+    tools.push(createAskUserTool({
+        askUser: async (questions) => context.askUserCallback?.(questions) ?? null,
+    }));
+    tools.push(createExecTool({
+        onProgress: context.onExecProgress,
+        validateCommand: async (command) => validateExecCommand(command, context.getCwd(), context.isGroupSecurityMode?.()),
+        resolveSandbox: () => context.resolveSandboxConfig(),
+        registerBackgroundTask: (info) => {
+            if (!context.backgroundTaskRuntime)
+                return false;
+            context.backgroundTaskRuntime.registerBashTask({
+                command: info.command,
+                cwd: info.cwd,
+                label: info.description,
+                pid: info.pid,
+                handle: info.handle,
+            });
+            return true;
+        },
+        interpretExitCode: (exitCode) => {
+            if (exitCode === 127)
+                return "command not found";
+            if (exitCode === 126)
+                return "permission denied";
+            if (exitCode === 137)
+                return "killed (SIGKILL / OOM)";
+            if (exitCode === 143)
+                return "terminated (SIGTERM)";
+            if (exitCode === 130)
+                return "interrupted (Ctrl+C)";
+            return undefined;
+        },
+    }));
+    tools.push(createReadTool(createReadDeps(context)));
+    tools.push(createWriteTool(createWriteDeps(context)));
+    tools.push(createEditTool(createEditDeps(context)));
+    tools.push(createPatchTool(createPatchDeps(context)));
+    tools.push(createSearchTool(createSearchDeps(context)));
+    tools.push(createInstructionsTool(createInstructionsDeps(context)));
+    tools.push(createWorktreeTool(createWorktreeBackend({ log: context.log ?? { info: () => { }, warn: () => { } } })));
+    tools.push(createNotebookEditTool());
+    tools.push(createSleepTool({
+        sleep: (durationMs, signal) => new Promise((resolve) => {
+            const start = Date.now();
+            const timer = setTimeout(() => {
+                resolve({ sleptSeconds: Math.round((Date.now() - start) / 1000), interrupted: false });
+            }, durationMs);
+            const onAbort = () => {
+                clearTimeout(timer);
+                resolve({ sleptSeconds: Math.round((Date.now() - start) / 1000), interrupted: true, interruptReason: "aborted" });
+            };
+            signal.addEventListener("abort", onAbort, { once: true });
+            if (signal.aborted) {
+                clearTimeout(timer);
+                onAbort();
+            }
+        }),
+    }));
+    tools.push(createToolSearchTool({
+        searchTools: async (query, options) => {
+            const maxResults = options?.maxResults ?? 5;
+            const corpus = context.listToolNames()
+                .map((name) => context.findRegisteredTool(name))
+                .filter((t) => !!t && t.shouldDefer === true && t.isEnabled?.() !== false)
+                .map((t) => ({ name: t.name, description: t.description, searchHint: t.searchHint }));
+            return searchToolCorpus(corpus, query, maxResults);
+        },
+        activateTool: async (name) => context.activateRegisteredTool(name),
+    }));
+}
+const FILE_READING_COMMANDS = new Set([
+    "cat", "head", "tail", "less", "more", "bat", "type",
+    "grep", "egrep", "fgrep", "rg", "ag", "ack",
+    "awk", "sed", "cut", "sort", "uniq", "strings", "xxd", "od", "hexdump",
+    "cp", "copy", "mv", "move", "scp", "rsync", "dd", "tar", "zip", "gzip", "base64",
+]);
+export function validateExecCommand(command, workdir, groupMode = groupSecurityMode) {
+    const tokenPatterns = [
+        /(?:>>?|[12]>)\s*(?:"([^"]+)"|'([^']+)'|(\S+))/g,
+        /(?:^|[\s;|&(])(?:"(\/[^"]+)"|'(\/[^']+)'|(\/[^\s;|&><)"']+))/g,
+    ];
+    for (const pattern of tokenPatterns) {
+        let m;
+        while ((m = pattern.exec(command)) !== null) {
+            const token = m[1] ?? m[2] ?? m[3];
+            if (!token)
+                continue;
+            const raw = token.replace(/\\/g, "/");
+            if (raw === "/dev/null")
+                continue;
+            if (raw.startsWith("/dev/") || raw.startsWith("/proc/") || raw.startsWith("/sys/")) {
+                return `Blocked: command references device/system path: ${token}`;
+            }
+        }
+    }
+    if (groupMode) {
+        const sensitive = collectGroupSensitiveExecPath(command, workdir);
+        if (sensitive) {
+            return `Blocked: command references group-sensitive file: ${sensitive}`;
+        }
+    }
+    return null;
+}
+function collectGroupSensitiveExecPath(command, workdir) {
+    const candidates = new Set();
+    const redir = /(?:>>?|[12]>)\s*(?:"([^"]+)"|'([^']+)'|([^\s;|&><)"']+))/g;
+    let m;
+    while ((m = redir.exec(command)) !== null) {
+        const t = m[1] ?? m[2] ?? m[3];
+        if (t)
+            candidates.add(t);
+    }
+    for (const segment of command.split(/[;|&]+|&&|\|\|/)) {
+        const tokens = segment.trim().match(/(?:"[^"]+"|'[^']+'|[^\s]+)/g);
+        if (!tokens || tokens.length === 0)
+            continue;
+        const cmd = tokens[0].replace(/^.*[\\/]/, "").toLowerCase();
+        if (!FILE_READING_COMMANDS.has(cmd))
+            continue;
+        for (const tok of tokens.slice(1)) {
+            if (tok.startsWith("-"))
+                continue;
+            const unquoted = tok.replace(/^["']|["']$/g, "");
+            if (unquoted)
+                candidates.add(unquoted);
+        }
+    }
+    for (const token of candidates) {
+        const resolved = resolveToolPath(token, workdir);
+        if (isGroupSensitivePath(resolved))
+            return token;
+    }
+    return null;
+}
+const IMAGE_EXTENSIONS = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg", ".ico"]);
+const BINARY_EXTENSIONS = new Set([".exe", ".dll", ".so", ".dylib", ".zip", ".tar", ".gz", ".7z", ".rar", ".wasm", ".class"]);
+const readFilePaths = new Set();
+function resolvePath(context, input) {
+    return resolveToolPath(input, context.getCwd());
+}
+function isGroupMode(context) {
+    return context.isGroupSecurityMode?.() ?? groupSecurityMode;
+}
+function createReadDeps(context) {
+    return {
+        resolvePath: (input) => resolvePath(context, input),
+        async readFile(filePath) {
+            const resolved = resolvePath(context, filePath);
+            const ext = path.extname(resolved).toLowerCase();
+            const floorError = enforceAbsoluteFloors(resolved);
+            if (floorError)
+                throw new Error(floorError);
+            if (BINARY_EXTENSIONS.has(ext)) {
+                return { type: "binary", mimeType: "application/octet-stream" };
+            }
+            if (IMAGE_EXTENSIONS.has(ext)) {
+                const mime = ext === ".png" ? "image/png"
+                    : ext === ".svg" ? "image/svg+xml"
+                        : ext === ".gif" ? "image/gif"
+                            : ext === ".webp" ? "image/webp"
+                                : "image/jpeg";
+                return { type: "image", localPath: resolved, mimeType: mime };
+            }
+            const content = await fs.promises.readFile(resolved, "utf8");
+            readFilePaths.add(resolved);
+            return { type: "text", text: content };
+        },
+        validatePath(filePath) {
+            const resolved = resolvePath(context, filePath);
+            const floorError = enforceAbsoluteFloors(resolved);
+            if (floorError)
+                return floorError;
+            if (isGroupMode(context) && isGroupSensitivePath(resolved)) {
+                return "Blocked: reading sensitive file in group chat mode";
+            }
+            return null;
+        },
+    };
+}
+function createWriteDeps(context) {
+    return {
+        resolvePath: (input) => resolvePath(context, input),
+        validatePath(filePath) {
+            const resolved = resolvePath(context, filePath);
+            const floorError = enforceAbsoluteFloors(resolved);
+            if (floorError)
+                return floorError;
+            if (isGroupMode(context) && isGroupSensitivePath(resolved)) {
+                return "Blocked: writing sensitive file in group chat mode";
+            }
+            return null;
+        },
+        checkReadBeforeWrite(filePath) {
+            try {
+                fs.accessSync(filePath, fs.constants.F_OK);
+            }
+            catch {
+                return null;
+            }
+            if (!readFilePaths.has(filePath)) {
+                return "File already exists but has not been read yet in this session. " +
+                    "Read it first with the read tool before overwriting, to avoid unintended data loss. " +
+                    "If you intend to completely replace the file, read it first to confirm.";
+            }
+            return null;
+        },
+        async writeFile(filePath, content) {
+            const resolved = resolvePath(context, filePath);
+            const floorError = enforceAbsoluteFloors(resolved);
+            if (floorError)
+                throw new Error(floorError);
+            await fs.promises.mkdir(path.dirname(resolved), { recursive: true });
+            await fs.promises.writeFile(resolved, content, "utf8");
+            readFilePaths.add(resolved);
+        },
+    };
+}
+function createEditDeps(context) {
+    return {
+        resolvePath: (input) => resolvePath(context, input),
+        async readFile(filePath) {
+            const resolved = resolvePath(context, filePath);
+            const floorError = enforceAbsoluteFloors(resolved);
+            if (floorError)
+                throw new Error(floorError);
+            return fs.promises.readFile(resolved, "utf8");
+        },
+        async writeFile(filePath, content) {
+            const resolved = resolvePath(context, filePath);
+            const floorError = enforceAbsoluteFloors(resolved);
+            if (floorError)
+                throw new Error(floorError);
+            await fs.promises.mkdir(path.dirname(resolved), { recursive: true });
+            await fs.promises.writeFile(resolved, content, "utf8");
+        },
+    };
+}
+function createPatchDeps(context) {
+    return {
+        resolvePath: (input) => resolvePath(context, input),
+        async readFile(filePath) {
+            const resolved = resolvePath(context, filePath);
+            const floorError = enforceAbsoluteFloors(resolved);
+            if (floorError)
+                throw new Error(floorError);
+            return fs.promises.readFile(resolved, "utf8");
+        },
+        async writeFile(filePath, content) {
+            const resolved = resolvePath(context, filePath);
+            const floorError = enforceAbsoluteFloors(resolved);
+            if (floorError)
+                throw new Error(floorError);
+            await fs.promises.mkdir(path.dirname(resolved), { recursive: true });
+            await fs.promises.writeFile(resolved, content, "utf8");
+        },
+        async deleteFile(filePath) {
+            const resolved = resolvePath(context, filePath);
+            const floorError = enforceAbsoluteFloors(resolved);
+            if (floorError)
+                throw new Error(floorError);
+            await fs.promises.unlink(resolved);
+        },
+        async fileExists(filePath) {
+            const resolved = resolvePath(context, filePath);
+            try {
+                await fs.promises.access(resolved);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+}
+function createSearchDeps(context) {
+    return {
+        resolvePath: (input) => resolvePath(context, input),
+        async glob(pattern, options) {
+            const cwd = options.cwd || context.getCwd();
+            const limit = options.limit || 1000;
+            const files = [];
+            let truncated = false;
+            const patternParts = pattern.replace(/\\/g, "/").split("/");
+            const isRecursive = patternParts.some(p => p === "**");
+            const filePattern = patternParts[patternParts.length - 1] ?? "*";
+            const regex = globToRegex(filePattern);
+            try {
+                await walkDir(cwd, async (relPath) => {
+                    if (files.length >= limit) {
+                        truncated = true;
+                        return false;
+                    }
+                    if (regex.test(path.basename(relPath)))
+                        files.push(relPath);
+                    return true;
+                }, isRecursive ? Infinity : 1);
+            }
+            catch {
+                // Directory inaccessible - return empty.
+            }
+            return { files, truncated };
+        },
+        async grep(pattern, options) {
+            const cwd = options.cwd || context.getCwd();
+            try {
+                return await grepWithRipgrep(pattern, cwd, options);
+            }
+            catch {
+                return await grepNative(pattern, cwd, options);
+            }
+        },
+    };
+}
+function globToRegex(pattern) {
+    let re = pattern
+        .replace(/[.+^$|()[\]\\]/g, "\\$&")
+        .replace(/\*/g, ".*")
+        .replace(/\?/g, ".");
+    re = re.replace(/\\\{([^}]+)\\\}/g, (_m, inner) => {
+        return `(${inner.replace(/,/g, "|")})`;
+    });
+    return new RegExp(`^${re}$`, "i");
+}
+const SKIP_DIRS = new Set([".git", ".svn", ".hg", "node_modules", "__pycache__", ".next", "dist", ".tox", ".venv"]);
+async function walkDir(dir, visitor, maxDepth, currentDepth = 0, prefix = "") {
+    if (currentDepth > maxDepth)
+        return;
+    let entries;
+    try {
+        entries = await fs.promises.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            if (SKIP_DIRS.has(entry.name))
+                continue;
+            await walkDir(path.join(dir, entry.name), visitor, maxDepth, currentDepth + 1, relPath);
+        }
+        else if (entry.isFile()) {
+            const cont = await visitor(relPath);
+            if (!cont)
+                return;
+        }
+    }
+}
+function grepWithRipgrep(pattern, cwd, options) {
+    return new Promise((resolve, reject) => {
+        const args = ["--json", "--no-heading", "--max-columns", "500"];
+        if (options.caseInsensitive)
+            args.push("-i");
+        if (options.contextLines)
+            args.push("-C", String(options.contextLines));
+        if (options.fileGlob)
+            args.push("-g", options.fileGlob);
+        args.push("--max-count", String(options.headLimit ?? 250));
+        args.push(pattern);
+        args.push(".");
+        execFile("rg", args, { cwd, maxBuffer: 10 * 1024 * 1024, timeout: 30_000 }, (err, stdout) => {
+            if (err && !("killed" in err && err.killed) && err.code !== 1) {
+                reject(err);
+                return;
+            }
+            const matches = [];
+            for (const line of stdout.split("\n")) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const obj = JSON.parse(line);
+                    if (obj.type === "match" && obj.data) {
+                        matches.push({
+                            path: obj.data.path?.text ?? "",
+                            line: obj.data.line_number ?? 0,
+                            text: (obj.data.lines?.text ?? "").trimEnd(),
+                        });
+                    }
+                }
+                catch {
+                    // Skip malformed JSON lines.
+                }
+            }
+            const limit = options.headLimit ?? 250;
+            const offset = options.offset ?? 0;
+            const sliced = matches.slice(offset, offset + limit);
+            resolve({ matches: sliced, truncated: matches.length > offset + limit });
+        });
+    });
+}
+async function grepNative(pattern, cwd, options) {
+    const regex = new RegExp(pattern, options.caseInsensitive ? "i" : "");
+    const limit = options.headLimit ?? 250;
+    const offset = options.offset ?? 0;
+    const fileGlobRegex = options.fileGlob ? globToRegex(options.fileGlob) : null;
+    const matches = [];
+    let truncated = false;
+    await walkDir(cwd, async (relPath) => {
+        if (matches.length >= offset + limit + 1) {
+            truncated = true;
+            return false;
+        }
+        if (fileGlobRegex && !fileGlobRegex.test(path.basename(relPath)))
+            return true;
+        if (BINARY_EXTENSIONS.has(path.extname(relPath).toLowerCase()))
+            return true;
+        try {
+            const content = await fs.promises.readFile(path.join(cwd, relPath), "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                if (regex.test(lines[i])) {
+                    matches.push({ path: relPath, line: i + 1, text: lines[i].slice(0, 500) });
+                    if (matches.length >= offset + limit + 1) {
+                        truncated = true;
+                        return false;
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip unreadable files.
+        }
+        return true;
+    }, Infinity);
+    return { matches: matches.slice(offset, offset + limit), truncated };
+}
+function createInstructionsDeps(context) {
+    function resolveInstructionProjectRoot(projectId) {
+        if (projectId === "default")
+            return context.activeProjectRoot();
+        const project = projectStore.getProjectById(projectId);
+        if (!project)
+            throw new Error(`Unknown project: ${projectId}`);
+        return project.workspaceDir;
+    }
+    function instrDir(projectId) {
+        const projectRoot = resolveInstructionProjectRoot(projectId);
+        return context.pathService?.getProjectRulesDir(projectRoot) ?? path.join(projectRoot, ".qlogicagent", "rules");
+    }
+    function resolveSafe(projectId, filename) {
+        if (!filename.endsWith(".md"))
+            throw new Error("Filename must end with .md");
+        if (filename.includes(".."))
+            throw new Error("Path traversal not allowed");
+        const dir = instrDir(projectId);
+        const resolved = path.resolve(dir, filename);
+        if (!resolved.startsWith(dir + path.sep) && resolved !== dir) {
+            throw new Error("Path traversal not allowed");
+        }
+        return resolved;
+    }
+    function walkMdFiles(dir, root) {
+        if (!fs.existsSync(dir))
+            return [];
+        const out = [];
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                out.push(...walkMdFiles(full, root));
+            }
+            else if (entry.isFile() && entry.name.endsWith(".md")) {
+                const stat = fs.statSync(full);
+                out.push({
+                    filename: path.relative(root, full).replace(/\\/g, "/"),
+                    path: full,
+                    size: stat.size,
+                    updatedAt: stat.mtime.toISOString(),
+                    content: fs.readFileSync(full, "utf-8"),
+                });
+            }
+        }
+        return out;
+    }
+    return {
+        list(projectId) {
+            const dir = instrDir(projectId);
+            return walkMdFiles(dir, dir).map(f => ({
+                filename: f.filename,
+                path: f.path,
+                size: f.size,
+                updatedAt: f.updatedAt,
+            }));
+        },
+        read(projectId, filename) {
+            try {
+                const filePath = resolveSafe(projectId, filename);
+                if (!fs.existsSync(filePath))
+                    return null;
+                const stat = fs.statSync(filePath);
+                const content = fs.readFileSync(filePath, "utf-8");
+                return { filename, path: filePath, size: stat.size, updatedAt: stat.mtime.toISOString(), content };
+            }
+            catch {
+                return null;
+            }
+        },
+        write(projectId, filename, content) {
+            const filePath = resolveSafe(projectId, filename);
+            fs.mkdirSync(path.dirname(filePath), { recursive: true });
+            fs.writeFileSync(filePath, content, "utf-8");
+            const stat = fs.statSync(filePath);
+            return { filename, path: filePath, size: stat.size, updatedAt: stat.mtime.toISOString(), content };
+        },
+        remove(projectId, filename) {
+            try {
+                const filePath = resolveSafe(projectId, filename);
+                if (!fs.existsSync(filePath))
+                    return false;
+                fs.unlinkSync(filePath);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+}

package/dist/cli/tool-bootstrap-media-registration.d.ts

@@ -0,0 +1,8 @@
+import type { PortableTool } from "../skills/portable-tool.js";
+export interface LocalMediaToolRegistrationContext {
+    tools: PortableTool<any>[];
+    getCwd(): string;
+    activeProjectRoot(): string;
+}
+export declare const localMediaToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<LocalMediaToolRegistrationContext>;
+export declare function registerLocalMediaTools(context: LocalMediaToolRegistrationContext): void;