@mndrk/agx 2.0.36 → 2.0.39

package/cloud-runtime/standalone/mcp/dist/db.js

@@ -0,0 +1,220 @@
+import { Pool } from "pg";
+import { config } from "dotenv";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+config({ path: resolve(__dirname, "../../.env") });
+const pool = new Pool({
+    connectionString: process.env.DATABASE_URL,
+});
+class QueryBuilder {
+    table;
+    operation = "select";
+    filters = [];
+    orderSpecs = [];
+    limitValue = null;
+    selectColumns = "*";
+    payload = null;
+    singleMode = "none";
+    returning = false;
+    constructor(table) {
+        this.table = table;
+    }
+    select(columns = "*") {
+        this.selectColumns = columns || "*";
+        if (this.operation !== "select")
+            this.returning = true;
+        return this;
+    }
+    insert(payload) {
+        this.operation = "insert";
+        this.payload = payload;
+        return this;
+    }
+    update(payload) {
+        this.operation = "update";
+        this.payload = payload;
+        return this;
+    }
+    delete() {
+        this.operation = "delete";
+        return this;
+    }
+    eq(column, value) {
+        this.filters.push({ op: "eq", column, value });
+        return this;
+    }
+    in(column, value) {
+        this.filters.push({ op: "in", column, value });
+        return this;
+    }
+    is(column, value) {
+        this.filters.push({ op: "is", column, value });
+        return this;
+    }
+    order(column, options) {
+        this.orderSpecs.push({ column, ...(options || {}) });
+        return this;
+    }
+    limit(limit) {
+        this.limitValue = limit;
+        return this;
+    }
+    single() {
+        this.singleMode = "single";
+        return this.execute();
+    }
+    maybeSingle() {
+        this.singleMode = "maybeSingle";
+        return this.execute();
+    }
+    then(resolve, reject) {
+        return this.execute().then(resolve, reject);
+    }
+    whereSql(params) {
+        const where = [];
+        for (const f of this.filters) {
+            if (f.op === "eq") {
+                params.push(f.value);
+                where.push(`${f.column} = $${params.length}`);
+            }
+            else if (f.op === "in") {
+                params.push(f.value);
+                where.push(`${f.column} = ANY($${params.length})`);
+            }
+            else if (f.op === "is") {
+                if (f.value === null)
+                    where.push(`${f.column} IS NULL`);
+                else {
+                    params.push(f.value);
+                    where.push(`${f.column} IS NOT DISTINCT FROM $${params.length}`);
+                }
+            }
+        }
+        return where;
+    }
+    normalizeColumns() {
+        if (!this.selectColumns || this.selectColumns.trim() === "*")
+            return "*";
+        return this.selectColumns;
+    }
+    async execute() {
+        try {
+            const params = [];
+            const where = this.whereSql(params);
+            let sql = "";
+            if (this.operation === "select") {
+                sql = `SELECT ${this.normalizeColumns()} FROM ${this.table}`;
+                if (where.length)
+                    sql += ` WHERE ${where.join(" AND ")}`;
+                if (this.orderSpecs.length) {
+                    sql +=
+                        " ORDER BY " +
+                            this.orderSpecs
+                                .map((o) => {
+                                const dir = o.ascending === false ? "DESC" : "ASC";
+                                const nulls = o.nullsFirst === true ? " NULLS FIRST" : o.nullsFirst === false ? " NULLS LAST" : "";
+                                return `${o.column} ${dir}${nulls}`;
+                            })
+                                .join(", ");
+                }
+                if (this.limitValue != null) {
+                    params.push(this.limitValue);
+                    sql += ` LIMIT $${params.length}`;
+                }
+            }
+            else if (this.operation === "insert") {
+                const rows = Array.isArray(this.payload) ? this.payload : [this.payload];
+                const cols = Object.keys(rows[0] || {});
+                const valuesSql = rows
+                    .map((row) => {
+                    const placeholders = cols.map((col) => {
+                        params.push(row[col]);
+                        return `$${params.length}`;
+                    });
+                    return `(${placeholders.join(", ")})`;
+                })
+                    .join(", ");
+                sql = `INSERT INTO ${this.table} (${cols.join(", ")}) VALUES ${valuesSql}`;
+                if (this.returning)
+                    sql += " RETURNING *";
+            }
+            else if (this.operation === "update") {
+                const cols = Object.keys(this.payload || {});
+                const setSql = cols
+                    .map((col) => {
+                    params.push(this.payload[col]);
+                    return `${col} = $${params.length}`;
+                })
+                    .join(", ");
+                sql = `UPDATE ${this.table} SET ${setSql}`;
+                if (where.length)
+                    sql += ` WHERE ${where.join(" AND ")}`;
+                if (this.returning)
+                    sql += " RETURNING *";
+            }
+            else {
+                sql = `DELETE FROM ${this.table}`;
+                if (where.length)
+                    sql += ` WHERE ${where.join(" AND ")}`;
+                if (this.returning)
+                    sql += " RETURNING *";
+            }
+            const res = await pool.query(sql, params);
+            const rows = res.rows;
+            if (this.singleMode === "single") {
+                if (!rows.length)
+                    return { data: null, error: { message: "No rows" } };
+                return { data: rows[0], error: null };
+            }
+            if (this.singleMode === "maybeSingle") {
+                return { data: rows[0] || null, error: null };
+            }
+            return { data: rows, error: null };
+        }
+        catch (error) {
+            return { data: null, error };
+        }
+    }
+}
+let db = null;
+export function getSupabase() {
+    if (db)
+        return db;
+    if (!process.env.DATABASE_URL) {
+        throw new Error("Missing DATABASE_URL for MCP server.");
+    }
+    db = {
+        from(table) {
+            return new QueryBuilder(table);
+        },
+    };
+    return db;
+}
+export async function fetchStageConfig(supabase, stage, userId) {
+    let stagePrompt = null;
+    let defaultPrompt = null;
+    const promises = [
+        supabase.from("stage_prompts").select("*").eq("stage", stage).eq("is_default", true).maybeSingle(),
+    ];
+    if (userId) {
+        promises.push(supabase.from("stage_prompts").select("*").eq("stage", stage).eq("user_id", userId).maybeSingle());
+    }
+    const results = await Promise.all(promises);
+    defaultPrompt = results[0].data;
+    if (userId) {
+        stagePrompt = results[1].data;
+    }
+    const resolvedPrompt = stagePrompt?.prompt || defaultPrompt?.prompt || null;
+    if (!resolvedPrompt) {
+        throw new Error(`No prompt found for stage "${stage}" in database (checked user and default).`);
+    }
+    return {
+        prompt: resolvedPrompt,
+        swarm: stagePrompt?.swarm ?? defaultPrompt?.swarm ?? false,
+        provider: stagePrompt?.provider || defaultPrompt?.provider,
+        model: stagePrompt?.model || defaultPrompt?.model,
+        swarm_models: stagePrompt?.swarm_models || defaultPrompt?.swarm_models,
+    };
+}
+//# sourceMappingURL=db.js.map

package/cloud-runtime/standalone/mcp/dist/index.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { runServer } from "./server.js";
+runServer().catch((error) => {
+    console.error("Failed to start server:", error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/cloud-runtime/standalone/mcp/dist/security.js

@@ -0,0 +1,18 @@
+import { createHmac } from "crypto";
+export function signTask(task, secret) {
+    const payload = JSON.stringify({
+        id: task.id,
+        user_id: task.user_id,
+        content: task.content,
+        stage: task.stage || "ideation",
+        engine: task.engine || "claude",
+        provider: task.provider || null,
+        model: task.model || null,
+        swarm: task.swarm || false,
+        swarm_models: task.swarm_models || null,
+        comments_digest: task.comments_digest ?? null,
+        created_at: task.created_at,
+    });
+    return createHmac("sha256", secret).update(payload).digest("hex");
+}
+//# sourceMappingURL=security.js.map

package/cloud-runtime/standalone/mcp/dist/server.js

@@ -0,0 +1,240 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+// Import tool handlers and schemas
+import { tasksListSchema, tasksList, tasksGetSchema, tasksGet, tasksCreateSchema, tasksCreate, tasksUpdateSchema, tasksUpdate, tasksLogSchema, tasksLog, } from "./tools/tasks.js";
+import { queuePullSchema, queuePull, queueCompleteSchema, queueComplete, queueFailSchema, queueFail, } from "./tools/queue.js";
+import { learningsAddSchema, learningsAdd, learningsListSchema, learningsList, learningsSearchSchema, learningsSearch, } from "./tools/learnings.js";
+import { auditLogSchema, auditLog, auditListSchema, auditList, } from "./tools/audit.js";
+// Convert Zod schema to JSON Schema (simplified)
+function zodToJsonSchema(zodSchema) {
+    // Get the shape from the Zod schema
+    let shape;
+    const def = zodSchema._def;
+    if (def.typeName === "ZodObject") {
+        shape = typeof def.shape === "function" ? def.shape() : def.shape;
+    }
+    else {
+        return { type: "object", properties: {} };
+    }
+    if (!shape)
+        return { type: "object", properties: {} };
+    const properties = {};
+    const required = [];
+    for (const [key, value] of Object.entries(shape)) {
+        let def = value._def;
+        let prop = {};
+        // Unwrap ZodOptional and ZodDefault
+        let isOptional = false;
+        while (def) {
+            if (def.typeName === "ZodOptional") {
+                isOptional = true;
+                def = def.innerType?._def;
+            }
+            else if (def.typeName === "ZodDefault") {
+                isOptional = true;
+                prop.default = typeof def.defaultValue === "function"
+                    ? def.defaultValue()
+                    : def.defaultValue;
+                def = def.innerType?._def;
+            }
+            else {
+                break;
+            }
+        }
+        if (!def) {
+            properties[key] = { type: "string" };
+            continue;
+        }
+        // Get description from the original or inner def
+        const origDef = value._def;
+        prop.description = def.description || origDef.description;
+        // Determine type
+        switch (def.typeName) {
+            case "ZodString":
+                prop.type = "string";
+                break;
+            case "ZodNumber":
+                prop.type = "number";
+                break;
+            case "ZodBoolean":
+                prop.type = "boolean";
+                break;
+            case "ZodEnum":
+                prop.type = "string";
+                prop.enum = def.values;
+                break;
+            case "ZodRecord":
+                prop.type = "object";
+                break;
+            case "ZodArray":
+                prop.type = "array";
+                break;
+            default:
+                prop.type = "string";
+        }
+        properties[key] = prop;
+        // Track required fields
+        if (!isOptional) {
+            required.push(key);
+        }
+    }
+    return {
+        type: "object",
+        properties,
+        required: required.length > 0 ? required : undefined,
+    };
+}
+// Tool definitions
+const tools = [
+    // Tasks
+    {
+        name: "tasks/list",
+        description: "List tasks with optional filters (status, stage, project, user)",
+        inputSchema: zodToJsonSchema(tasksListSchema),
+        handler: tasksList,
+        schema: tasksListSchema,
+    },
+    {
+        name: "tasks/get",
+        description: "Get a task by ID with full context and optionally its logs",
+        inputSchema: zodToJsonSchema(tasksGetSchema),
+        handler: tasksGet,
+        schema: tasksGetSchema,
+    },
+    {
+        name: "tasks/create",
+        description: "Create a new task with title, description, project, and priority",
+        inputSchema: zodToJsonSchema(tasksCreateSchema),
+        handler: tasksCreate,
+        schema: tasksCreateSchema,
+    },
+    {
+        name: "tasks/update",
+        description: "Update task fields (status, stage, priority, project)",
+        inputSchema: zodToJsonSchema(tasksUpdateSchema),
+        handler: tasksUpdate,
+        schema: tasksUpdateSchema,
+    },
+    {
+        name: "tasks/log",
+        description: "Append a log entry to a task",
+        inputSchema: zodToJsonSchema(tasksLogSchema),
+        handler: tasksLog,
+        schema: tasksLogSchema,
+    },
+    // Queue
+    {
+        name: "queue/pull",
+        description: "Get the next available task from the queue for a user. Marks it as in_progress.",
+        inputSchema: zodToJsonSchema(queuePullSchema),
+        handler: queuePull,
+        schema: queuePullSchema,
+    },
+    {
+        name: "queue/complete",
+        description: "Mark current task stage as complete and advance to next stage",
+        inputSchema: zodToJsonSchema(queueCompleteSchema),
+        handler: queueComplete,
+        schema: queueCompleteSchema,
+    },
+    {
+        name: "queue/fail",
+        description: "Mark a task as failed with an error message",
+        inputSchema: zodToJsonSchema(queueFailSchema),
+        handler: queueFail,
+        schema: queueFailSchema,
+    },
+    // Learnings
+    {
+        name: "learnings/add",
+        description: "Record a learning (task-level, project-level, or global)",
+        inputSchema: zodToJsonSchema(learningsAddSchema),
+        handler: learningsAdd,
+        schema: learningsAddSchema,
+    },
+    {
+        name: "learnings/list",
+        description: "List learnings with optional scope and user filters",
+        inputSchema: zodToJsonSchema(learningsListSchema),
+        handler: learningsList,
+        schema: learningsListSchema,
+    },
+    {
+        name: "learnings/search",
+        description: "Search learnings by text query",
+        inputSchema: zodToJsonSchema(learningsSearchSchema),
+        handler: learningsSearch,
+        schema: learningsSearchSchema,
+    },
+    // Audit
+    {
+        name: "audit/log",
+        description: "Record an audit event for a task action",
+        inputSchema: zodToJsonSchema(auditLogSchema),
+        handler: auditLog,
+        schema: auditLogSchema,
+    },
+    {
+        name: "audit/list",
+        description: "List audit events with filters",
+        inputSchema: zodToJsonSchema(auditListSchema),
+        handler: auditList,
+        schema: auditListSchema,
+    },
+];
+export async function createServer() {
+    const server = new Server({
+        name: "agx-mcp-server",
+        version: "1.0.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // List available tools
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: tools.map(t => ({
+                name: t.name,
+                description: t.description,
+                inputSchema: t.inputSchema,
+            })),
+        };
+    });
+    // Handle tool calls
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const tool = tools.find(t => t.name === name);
+        if (!tool) {
+            return {
+                content: [{ type: "text", text: `Unknown tool: ${name}` }],
+                isError: true,
+            };
+        }
+        try {
+            // Validate input
+            const validated = tool.schema.parse(args || {});
+            // Execute handler
+            const result = await tool.handler(validated);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+                isError: true,
+            };
+        }
+    });
+    return server;
+}
+export async function runServer() {
+    const server = await createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("AGX MCP Server running on stdio");
+}
+//# sourceMappingURL=server.js.map