@hailer/mcp 0.1.15 → 0.1.16

package/dist/mcp/tools/giuseppe-tools.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Giuseppe MCP Tools
+ *
+ * Bug-fixing tools for Giuseppe specialist daemon.
+ * These tools handle file operations, git, and build commands.
+ */
+import { Tool } from "../tool-registry";
+export declare const giuseppeFindAppTool: Tool;
+export declare const giuseppeListFilesTool: Tool;
+export declare const giuseppeReadFileTool: Tool;
+export declare const giuseppeWriteFileTool: Tool;
+export declare const giuseppeApplyFixTool: Tool;
+export declare const giuseppeRunBuildTool: Tool;
+export declare const giuseppeGitStatusTool: Tool;
+export declare const giuseppeGitPullTool: Tool;
+export declare const giuseppeGitCommitTool: Tool;
+export declare const giuseppeGitPushTool: Tool;
+export declare const giuseppeGitRevertTool: Tool;
+export declare const giuseppePublishAppTool: Tool;
+export declare const giuseppeTools: Tool[];
+//# sourceMappingURL=giuseppe-tools.d.ts.map

package/dist/mcp/tools/giuseppe-tools.js

@@ -0,0 +1,525 @@
+"use strict";
+/**
+ * Giuseppe MCP Tools
+ *
+ * Bug-fixing tools for Giuseppe specialist daemon.
+ * These tools handle file operations, git, and build commands.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.giuseppeTools = exports.giuseppePublishAppTool = exports.giuseppeGitRevertTool = exports.giuseppeGitPushTool = exports.giuseppeGitCommitTool = exports.giuseppeGitPullTool = exports.giuseppeGitStatusTool = exports.giuseppeRunBuildTool = exports.giuseppeApplyFixTool = exports.giuseppeWriteFileTool = exports.giuseppeReadFileTool = exports.giuseppeListFilesTool = exports.giuseppeFindAppTool = void 0;
+const zod_1 = require("zod");
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const tool_registry_1 = require("../tool-registry");
+const logger_1 = require("../../lib/logger");
+const config_1 = require("../../config");
+const logger = (0, logger_1.createLogger)({ component: "giuseppe-tools" });
+const appsBasePath = config_1.environment.DEV_APPS_PATH || process.cwd();
+// Helper to scan for apps
+async function scanApps() {
+    const apps = [];
+    try {
+        const entries = await fs.readdir(appsBasePath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory() && !entry.name.startsWith(".") && !["node_modules", "dist"].includes(entry.name)) {
+                const appPath = path.join(appsBasePath, entry.name);
+                // Check for manifest.json (Hailer app indicator)
+                try {
+                    await fs.access(path.join(appPath, "manifest.json"));
+                    apps.push({ name: entry.name, path: appPath });
+                }
+                catch {
+                    try {
+                        await fs.access(path.join(appPath, "public", "manifest.json"));
+                        apps.push({ name: entry.name, path: appPath });
+                    }
+                    catch {
+                        // Not a Hailer app
+                    }
+                }
+            }
+        }
+    }
+    catch (e) {
+        logger.warn("Failed to scan apps", { error: e });
+    }
+    return apps;
+}
+// Find App Tool
+exports.giuseppeFindAppTool = {
+    name: "giuseppe_find_app",
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: "Find a Hailer app project by name or from bug title",
+    schema: zod_1.z.object({
+        searchTerm: zod_1.z.string().describe("App name or bug title to search for").optional(),
+        name: zod_1.z.string().describe("Alias for searchTerm - app name to search for").optional()
+    }).refine(data => data.searchTerm || data.name, {
+        message: "Either searchTerm or name is required"
+    }),
+    async execute(args, _context) {
+        // Accept either searchTerm or name
+        const searchTerm = (args.searchTerm || args.name || '').toLowerCase();
+        const apps = await scanApps();
+        for (const app of apps) {
+            if (app.name.toLowerCase().includes(searchTerm) ||
+                searchTerm.includes(app.name.toLowerCase())) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({ found: true, name: app.name, path: app.path }) }]
+                };
+            }
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify({ found: false, availableApps: apps.map(a => a.name) }) }]
+        };
+    }
+};
+// List Files Tool
+exports.giuseppeListFilesTool = {
+    name: "giuseppe_list_files",
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: "List source files in a Hailer app project",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project")
+    }),
+    async execute(args, _context) {
+        const files = [];
+        const extensions = [".tsx", ".ts", ".jsx", ".js"];
+        const ignoreDirs = ["node_modules", "dist", "build", ".git"];
+        const scan = async (dir, depth = 0) => {
+            if (depth > 5)
+                return;
+            try {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    const relativePath = path.relative(args.appPath, fullPath);
+                    if (entry.isDirectory()) {
+                        if (!ignoreDirs.includes(entry.name) && !entry.name.startsWith(".")) {
+                            await scan(fullPath, depth + 1);
+                        }
+                    }
+                    else if (extensions.some(ext => entry.name.endsWith(ext))) {
+                        if (!entry.name.includes(".test.") && !entry.name.includes(".spec.")) {
+                            files.push(relativePath);
+                        }
+                    }
+                }
+            }
+            catch { /* skip */ }
+        };
+        await scan(args.appPath);
+        return {
+            content: [{ type: "text", text: JSON.stringify({ files: files.slice(0, 50), total: files.length }) }]
+        };
+    }
+};
+// Read File Tool
+exports.giuseppeReadFileTool = {
+    name: "giuseppe_read_file",
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: "Read a source file from the app",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project"),
+        filePath: zod_1.z.string().describe("Relative path to the file")
+    }),
+    async execute(args, _context) {
+        try {
+            const fullPath = path.join(args.appPath, args.filePath);
+            const content = await fs.readFile(fullPath, "utf-8");
+            return {
+                content: [{ type: "text", text: JSON.stringify({ content }) }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
+            };
+        }
+    }
+};
+// Write File Tool
+exports.giuseppeWriteFileTool = {
+    name: "giuseppe_write_file",
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: "Write/update a source file in the app",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project"),
+        filePath: zod_1.z.string().describe("Relative path to the file"),
+        content: zod_1.z.string().describe("New file content")
+    }),
+    async execute(args, _context) {
+        try {
+            const fullPath = path.join(args.appPath, args.filePath);
+            await fs.mkdir(path.dirname(fullPath), { recursive: true });
+            await fs.writeFile(fullPath, args.content, "utf-8");
+            logger.info("Giuseppe wrote file", { filePath: args.filePath });
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: true, path: args.filePath }) }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
+            };
+        }
+    }
+};
+// Apply Fix Tool (search/replace pattern - calls existing bot logic)
+const fixFileSchema = zod_1.z.object({
+    path: zod_1.z.string().describe("Relative file path (e.g., 'src/App.tsx')"),
+    action: zod_1.z.enum(["edit", "create", "delete"]).describe("Action: edit (search/replace), create (new file), delete"),
+    search: zod_1.z.string().optional().describe("For 'edit': the exact code snippet to find"),
+    replace: zod_1.z.string().optional().describe("For 'edit': the code to replace it with"),
+    content: zod_1.z.string().optional().describe("For 'create': the full file content")
+});
+exports.giuseppeApplyFixTool = {
+    name: "giuseppe_apply_fix",
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: `Apply code fixes using search/replace pattern. More token-efficient than rewriting entire files.
+
+**For 'edit' action:** Provide search (code to find) and replace (code to replace with).
+**For 'create' action:** Provide content (full file content).
+**For 'delete' action:** Just provide path.
+
+Example:
+\`\`\`json
+{
+  "appPath": "lineup-manager",
+  "fixes": [{
+    "path": "src/App.tsx",
+    "action": "edit",
+    "search": "const handleDragEnd = () => {\\n  // old code\\n}",
+    "replace": "const handleDragEnd = () => {\\n  // fixed code\\n}"
+  }]
+}
+\`\`\``,
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("App folder name or path (e.g., 'lineup-manager')"),
+        fixes: zod_1.z.array(fixFileSchema).describe("Array of file operations to apply")
+    }),
+    async execute(args, _context) {
+        try {
+            // Resolve app path
+            let appFullPath = args.appPath;
+            if (!path.isAbsolute(args.appPath)) {
+                appFullPath = path.join(appsBasePath, args.appPath);
+            }
+            // Check app exists
+            try {
+                await fs.access(appFullPath);
+            }
+            catch {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                success: false,
+                                error: `App not found at: ${appFullPath}`
+                            }) }]
+                };
+            }
+            const modifiedFiles = [];
+            const errors = [];
+            for (const fix of args.fixes) {
+                const filePath = path.join(appFullPath, fix.path);
+                try {
+                    if (fix.action === 'edit' && fix.search && fix.replace !== undefined) {
+                        // Read file
+                        const content = await fs.readFile(filePath, 'utf-8');
+                        // Try exact match first
+                        if (content.includes(fix.search)) {
+                            const newContent = content.replace(fix.search, fix.replace);
+                            await fs.writeFile(filePath, newContent, 'utf-8');
+                            modifiedFiles.push(fix.path);
+                            logger.info("Giuseppe applied fix (exact match)", { path: fix.path });
+                        }
+                        else {
+                            // Try normalized whitespace match
+                            const normalizeWs = (s) => s.replace(/\s+/g, ' ').trim();
+                            const normalizedContent = normalizeWs(content);
+                            const normalizedSearch = normalizeWs(fix.search);
+                            if (normalizedContent.includes(normalizedSearch)) {
+                                // Line-by-line search
+                                const searchLines = fix.search.split('\n').map((l) => l.trim()).filter((l) => l);
+                                const contentLines = content.split('\n');
+                                let found = false;
+                                for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
+                                    const candidateLines = contentLines.slice(i, i + searchLines.length);
+                                    if (candidateLines.every((line, j) => line.trim() === searchLines[j])) {
+                                        const before = contentLines.slice(0, i);
+                                        const after = contentLines.slice(i + searchLines.length);
+                                        const replaceLines = fix.replace.split('\n');
+                                        const newContent = [...before, ...replaceLines, ...after].join('\n');
+                                        await fs.writeFile(filePath, newContent, 'utf-8');
+                                        modifiedFiles.push(fix.path);
+                                        found = true;
+                                        logger.info("Giuseppe applied fix (normalized match)", { path: fix.path });
+                                        break;
+                                    }
+                                }
+                                if (!found) {
+                                    errors.push(`${fix.path}: Search string not found (whitespace mismatch)`);
+                                }
+                            }
+                            else {
+                                errors.push(`${fix.path}: Search string not found`);
+                            }
+                        }
+                    }
+                    else if (fix.action === 'create' && fix.content) {
+                        await fs.mkdir(path.dirname(filePath), { recursive: true });
+                        await fs.writeFile(filePath, fix.content, 'utf-8');
+                        modifiedFiles.push(fix.path);
+                        logger.info("Giuseppe created file", { path: fix.path });
+                    }
+                    else if (fix.action === 'delete') {
+                        await fs.unlink(filePath);
+                        modifiedFiles.push(fix.path);
+                        logger.info("Giuseppe deleted file", { path: fix.path });
+                    }
+                    else {
+                        errors.push(`${fix.path}: Invalid action or missing required fields`);
+                    }
+                }
+                catch (e) {
+                    errors.push(`${fix.path}: ${e.message}`);
+                }
+            }
+            if (errors.length > 0) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify({
+                                success: false,
+                                modifiedFiles,
+                                errors,
+                                hint: "Check that 'search' exactly matches the code in the file (including whitespace)"
+                            }) }]
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            success: true,
+                            modifiedFiles,
+                            message: `Applied ${modifiedFiles.length} fix(es). Run giuseppe_run_build to verify.`
+                        }) }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: false, error: e.message }) }]
+            };
+        }
+    }
+};
+// Run Build Tool
+exports.giuseppeRunBuildTool = {
+    name: "giuseppe_run_build",
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: "Run TypeScript build to check for errors",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project")
+    }),
+    async execute(args, _context) {
+        try {
+            const output = (0, child_process_1.execSync)("npm run build 2>&1", { cwd: args.appPath, encoding: "utf-8", timeout: 60000 });
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: true, output: output.slice(-2000) }) }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: false, error: (e.stdout || e.stderr || e.message).slice(-2000) }) }]
+            };
+        }
+    }
+};
+// Git Status Tool
+exports.giuseppeGitStatusTool = {
+    name: "giuseppe_git_status",
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: "Check git status - branch, changes, sync with remote",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project")
+    }),
+    async execute(args, _context) {
+        try {
+            const status = (0, child_process_1.execSync)("git status --short", { cwd: args.appPath, encoding: "utf-8" });
+            const branch = (0, child_process_1.execSync)("git branch --show-current", { cwd: args.appPath, encoding: "utf-8" }).trim();
+            let behind = 0, ahead = 0;
+            try {
+                const revList = (0, child_process_1.execSync)("git rev-list --left-right --count HEAD...@{upstream} 2>/dev/null", { cwd: args.appPath, encoding: "utf-8" }).trim().split(/\s+/);
+                ahead = parseInt(revList[0]) || 0;
+                behind = parseInt(revList[1]) || 0;
+            }
+            catch { /* no upstream */ }
+            return {
+                content: [{ type: "text", text: JSON.stringify({ branch, status: status || "clean", ahead, behind }) }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: e.message }) }]
+            };
+        }
+    }
+};
+// Git Pull Tool
+exports.giuseppeGitPullTool = {
+    name: "giuseppe_git_pull",
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: "Pull latest changes from remote",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project")
+    }),
+    async execute(args, _context) {
+        try {
+            const output = (0, child_process_1.execSync)("git pull", { cwd: args.appPath, encoding: "utf-8" });
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: true, output }) }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: false, error: e.stderr || e.message }) }]
+            };
+        }
+    }
+};
+// Git Commit Tool
+exports.giuseppeGitCommitTool = {
+    name: "giuseppe_git_commit",
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: "Stage all changes and commit",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project"),
+        message: zod_1.z.string().describe("Commit message")
+    }),
+    async execute(args, _context) {
+        try {
+            (0, child_process_1.execSync)("git add -A", { cwd: args.appPath });
+            (0, child_process_1.execSync)(`git commit -m "${args.message.replace(/"/g, '\\"')}"`, { cwd: args.appPath });
+            const hash = (0, child_process_1.execSync)("git rev-parse --short HEAD", { cwd: args.appPath, encoding: "utf-8" }).trim();
+            logger.info("Giuseppe committed", { hash, message: args.message });
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: true, hash }) }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: false, error: e.stderr || e.stdout || e.message }) }]
+            };
+        }
+    }
+};
+// Git Push Tool
+exports.giuseppeGitPushTool = {
+    name: "giuseppe_git_push",
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: "Push commits to remote",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project")
+    }),
+    async execute(args, _context) {
+        try {
+            (0, child_process_1.execSync)("git push", { cwd: args.appPath, encoding: "utf-8", stdio: "pipe" });
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: true }) }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: false, error: e.stderr || e.message }) }]
+            };
+        }
+    }
+};
+// Git Revert Tool
+exports.giuseppeGitRevertTool = {
+    name: "giuseppe_git_revert",
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: "Discard all uncommitted changes",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project")
+    }),
+    async execute(args, _context) {
+        try {
+            (0, child_process_1.execSync)("git checkout -- .", { cwd: args.appPath });
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: true }) }]
+            };
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: false, error: e.message }) }]
+            };
+        }
+    }
+};
+// Publish App Tool
+exports.giuseppePublishAppTool = {
+    name: "giuseppe_publish_app",
+    group: tool_registry_1.ToolGroup.PLAYGROUND,
+    description: "Publish app to Hailer production - ALWAYS ASK USER FIRST",
+    schema: zod_1.z.object({
+        appPath: zod_1.z.string().describe("Path to the app project")
+    }),
+    async execute(args, context) {
+        try {
+            const { publishHailerAppTool } = await Promise.resolve().then(() => __importStar(require("./app-scaffold")));
+            const result = await publishHailerAppTool.execute({ projectDirectory: args.appPath }, context);
+            return result;
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ success: false, error: e.message }) }]
+            };
+        }
+    }
+};
+// Export all tools
+exports.giuseppeTools = [
+    exports.giuseppeFindAppTool,
+    exports.giuseppeListFilesTool,
+    exports.giuseppeReadFileTool,
+    exports.giuseppeWriteFileTool,
+    exports.giuseppeApplyFixTool, // New: search/replace (preferred)
+    exports.giuseppeRunBuildTool,
+    exports.giuseppeGitStatusTool,
+    exports.giuseppeGitPullTool,
+    exports.giuseppeGitCommitTool,
+    exports.giuseppeGitPushTool,
+    exports.giuseppeGitRevertTool,
+    exports.giuseppePublishAppTool,
+];
+//# sourceMappingURL=giuseppe-tools.js.map

package/dist/mcp/utils/hailer-api-client.d.ts

@@ -17,6 +17,10 @@ export declare class HailerApiClient {
     private clients;
     private logger;
     constructor(clients: HailerClient);
+    /**
+     * Get the underlying HailerClient for direct access (e.g., SignalHandler)
+     */
+    getClient(): HailerClient;
     /**
      * Makes a socket API call - thin wrapper around clients.socket.request
      */
@@ -40,6 +44,7 @@ export declare class HailerApiClient {
         includeStats?: boolean;
         returnFlat?: boolean;
         filters?: any;
+        fields?: string[];
     }): Promise<any>;
     /**
      * Create activities - uses Socket API
@@ -63,8 +68,15 @@ export declare class HailerApiClient {
     fetchPreviousDiscussionMessages(oldestMessageId: string, batches?: number): Promise<any>;
     /**
      * Fetch activity by ID - uses Socket API
+     * WARNING: This uses activities.load which evaluates function fields and may fail
+     * For bot config, prefer fetchActivityByIdSafe()
      */
     fetchActivityById(activityId: string): Promise<any>;
+    /**
+     * Fetch activity by ID safely using v3.activity.list API
+     * This doesn't evaluate function fields so it works even when function fields are broken
+     */
+    fetchActivityByIdSafe(activityId: string, workflowId?: string, phaseId?: string): Promise<any>;
     /**
      * Send discussion message - uses Socket API
      */
@@ -100,8 +112,37 @@ export declare class HailerApiClient {
     }>;
     /**
      * Fetch workspace initialization data - uses Socket API
+     * @param include - What to include: 'users', 'network', 'networks', 'teams', etc.
+     */
+    fetchInit(include?: string[]): Promise<any>;
+    /**
+     * Update current user's profile info (firstname, lastname, etc.)
+     * Only works for the currently authenticated user
+     * @param key - Field to update: firstname, lastname, email, status, etc.
+     * @param value - New value as string
+     */
+    setUserInfo(key: 'firstname' | 'lastname' | 'email' | 'status' | 'default_company' | 'lastLocation' | 'preferredLanguages', value: string): Promise<void>;
+    /**
+     * Update current user's display name (firstname + lastname)
+     * Parses a full name into first/last parts
+     * @param fullName - Full display name like "HAL 9000"
+     */
+    setUserDisplayName(fullName: string): Promise<void>;
+    /**
+     * Find user by name - searches init data for firstname/lastname match
+     * @param name - Full name to search for (firstname lastname)
+     * @returns User ID if found, null otherwise
+     */
+    findUserByName(name: string): Promise<string | null>;
+    /**
+     * List all workflows in the workspace - extracts from init data
+     * @param workspaceId - Optional workspace ID to filter workflows (uses CID field)
+     */
+    listWorkflows(workspaceId?: string): Promise<any[]>;
+    /**
+     * Get workflow details including phases and fields
      */
-    fetchInit(): Promise<any>;
+    getWorkflow(workflowId: string): Promise<any>;
     /**
      * Global search across workspace - uses Socket API
      */