gwanli 0.1.0 → 0.3.0

package/dist/auth-server.d.ts

@@ -0,0 +1,4 @@
+export declare function startAuthServer(): Promise<{
+    url: string;
+    tokenPromise: Promise<string>;
+}>;

package/dist/auth-server.js

@@ -0,0 +1,48 @@
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { serve } from "@hono/node-server";
+export async function startAuthServer() {
+    return new Promise((resolve, reject) => {
+        let server = null;
+        // Create promise that resolves when token received
+        const tokenPromise = new Promise((resolveToken, rejectToken) => {
+            const app = new Hono();
+            app.use("/*", cors());
+            app.post("/callback", async (c) => {
+                try {
+                    const { token } = await c.req.json();
+                    // Close server after a short delay to ensure response is sent
+                    setTimeout(() => {
+                        server?.close();
+                    }, 100);
+                    resolveToken(token); // Resolve with token!
+                    return c.json({ success: true });
+                }
+                catch (error) {
+                    setTimeout(() => {
+                        server?.close();
+                    }, 100);
+                    rejectToken(new Error("Invalid callback data"));
+                    return c.json({ error: "Invalid JSON" }, 400);
+                }
+            });
+            app.notFound((c) => c.text("Not Found", 404));
+            server = serve({
+                fetch: app.fetch,
+                port: 0,
+                hostname: "127.0.0.1"
+            }, (info) => {
+                const url = `http://127.0.0.1:${info.port}`;
+                // Set timeout to reject after 5 minutes
+                setTimeout(() => {
+                    server?.close();
+                    rejectToken(new Error("Authentication timeout after 5 minutes"));
+                }, 5 * 60 * 1000);
+                resolve({ url, tokenPromise });
+            });
+            server.on?.("error", (error) => {
+                rejectToken(error);
+            });
+        });
+    });
+}

package/dist/auth.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const auth: Command;

package/dist/auth.js

@@ -0,0 +1,75 @@
+import { Command } from "commander";
+import open from "open";
+import { createInterface } from "readline";
+import { checkWorkspace, addWorkspace, cliLogger, OAUTH_BASE_URL } from "gwanli-core";
+async function promptUser(question) {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+async function runAuthFlow(workspace) {
+    cliLogger.console(`\nSetting up workspace: ${workspace}`);
+    // Build OAuth URL and open browser
+    const authUrl = `${OAUTH_BASE_URL}`;
+    cliLogger.console("\nOpening browser for authentication...");
+    await open(authUrl);
+    cliLogger.console("Please complete authentication in your browser and copy the token.");
+    // Ask user to paste token
+    const token = await promptUser("Paste your Notion API token here: ");
+    // Success
+    cliLogger.console("\nAuthentication successful!");
+    cliLogger.console(`Token: ${token.substring(0, 10)}...`);
+    // Check if workspace already exists
+    const workspaceExists = checkWorkspace(workspace);
+    if (workspaceExists) {
+        cliLogger.console(`\nWorkspace '${workspace}' already exists.`);
+        const shouldOverride = await promptUser("Do you want to override it? (y/n): ");
+        if (shouldOverride.toLowerCase() !== "y" && shouldOverride.toLowerCase() !== "yes") {
+            cliLogger.console("Operation cancelled. Workspace not updated.");
+            return;
+        }
+    }
+    // Add workspace to config
+    try {
+        addWorkspace(workspace, token);
+        cliLogger.console(`\n✓ Workspace '${workspace}' has been ${workspaceExists ? "updated" : "created"} successfully!`);
+        cliLogger.console("You can now use this workspace with gwanli commands.");
+        // Force exit after a short delay to ensure all async operations complete
+        setTimeout(() => {
+            process.exit(0);
+        }, 500);
+    }
+    catch (error) {
+        cliLogger.error(`Failed to save workspace configuration: ${error}`);
+        throw error;
+    }
+}
+function printHeader(title) {
+    cliLogger.console(`\n${title}`);
+    cliLogger.console("=".repeat(70));
+}
+function printFooter() {
+    cliLogger.console("=".repeat(70));
+}
+export const auth = new Command("auth")
+    .description("Generate a Notion API token and add workspace")
+    .option("--workspace <name>", "Workspace name to add after authentication (default: 'default')")
+    .action(async (options) => {
+    const { workspace = "default" } = options;
+    printHeader("Notion API Token Generator");
+    try {
+        await runAuthFlow(workspace);
+    }
+    catch (error) {
+        cliLogger.error(`\nAuthentication failed: ${error}`);
+        process.exit(1);
+    }
+    printFooter();
+});

package/dist/cli.js

@@ -1,15 +1,20 @@
 #!/usr/bin/env node
-import { Command } from 'commander';
-import { helloGwanli } from 'gwanli-core';
-const program = new Command('gwanli');
+import { Command } from "commander";
+import { auth } from "./auth.js";
+import { index } from "./index.js";
+import { ls } from "./ls.js";
+import { job } from "./job.js";
+const program = new Command("gwanli");
 program
-    .name('gwanli')
-    .description('Gwanli - Notion management CLI')
-    .version('0.1.0');
-program
-    .command('hello')
-    .description('Say hello from Gwanli')
-    .action(() => {
-    console.log(helloGwanli());
-});
+    .name("gwanli")
+    .description("Gwanli - Notion management CLI")
+    .version("0.2.0");
+// Add auth command
+program.addCommand(auth);
+// Add index command
+program.addCommand(index);
+// Add ls command
+program.addCommand(ls);
+// Add job command
+program.addCommand(job);
 program.parse();

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+declare const program: Command;
+export { program as index };

package/dist/index.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { loadConfig, checkWorkspace, indexNotionPages, JobTracker } from "gwanli-core";
+const program = new Command("index");
+program
+    .name("index")
+    .description("Index a Notion workspace")
+    .option("-w, --workspace <workspace>", "Workspace name to index", "default")
+    .action(async (options) => {
+    try {
+        const workspaceName = options.workspace;
+        // Check if workspace exists
+        if (!checkWorkspace(workspaceName)) {
+            console.error(`Workspace "${workspaceName}" not found. Use 'gwanli auth' to list available workspaces.`);
+            process.exit(1);
+        }
+        console.log(`Starting indexing for workspace: ${workspaceName}`);
+        const config = loadConfig();
+        const workspace = config.workspace[workspaceName];
+        if (!workspace) {
+            console.error(`Workspace configuration not found for: ${workspaceName}`);
+            process.exit(1);
+        }
+        // Create job tracker
+        const jobId = `cli-${Date.now()}`;
+        const jobTracker = new JobTracker(jobId);
+        console.log(`Job ID: ${jobId}`);
+        console.log(`Job directory: ${jobTracker.getJobDir()}`);
+        // Start indexing
+        await indexNotionPages(workspace.api_key, workspace.db_path, jobTracker);
+        console.log(`Indexing completed for workspace: ${workspaceName}`);
+        jobTracker.updateStatus("END");
+    }
+    catch (error) {
+        console.error(`Indexing failed:`, error);
+        process.exit(1);
+    }
+});
+export { program as index };

package/dist/job.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const job: Command;

package/dist/job.js

@@ -0,0 +1,73 @@
+import { Command } from "commander";
+import { cliLogger, getRecentJobs, getJobById } from "gwanli-core";
+function formatJobsList(jobs) {
+    if (jobs.length === 0) {
+        cliLogger.console("No jobs found.");
+        return;
+    }
+    cliLogger.console(`\nFound ${jobs.length} job(s):\n`);
+    jobs.forEach((job, index) => {
+        const statusText = job.state?.status ? ` (${job.state.status})` : "";
+        const timeStr = new Date(job.timestamp).toLocaleString();
+        cliLogger.console(`${index + 1}. ${job.jobId}${statusText}`);
+        cliLogger.console(`   ${job.prefix.toUpperCase()} job - ${timeStr}`);
+        if (index < jobs.length - 1) {
+            cliLogger.console("");
+        }
+    });
+}
+function formatJobDetails(job) {
+    cliLogger.console(`\nJob Details:`);
+    cliLogger.console("=".repeat(50));
+    cliLogger.console(`Job ID: ${job.jobId}`);
+    cliLogger.console(`Type: ${job.prefix.toUpperCase()}`);
+    cliLogger.console(`Timestamp: ${job.timestamp}`);
+    cliLogger.console(`Created: ${new Date(job.timestamp).toLocaleString()}`);
+    if (job.state) {
+        cliLogger.console(`\nStatus Information:`);
+        cliLogger.console(JSON.stringify(job.state, null, 2));
+    }
+    else {
+        cliLogger.console(`\nNo status file found`);
+    }
+    cliLogger.console("=".repeat(50));
+}
+export const job = new Command("job")
+    .description("Manage and check job status")
+    .option("-i, --id <jobId>", "Check specific job by ID")
+    .option("-n, --count <number>", "Number of recent jobs to show", "5")
+    .option("-p, --prefix <type>", "Filter by job prefix (mcp|cli)", "mcp")
+    .action(async (options) => {
+    try {
+        const { id, count, prefix } = options;
+        // Validate prefix
+        if (prefix && !['mcp', 'cli'].includes(prefix)) {
+            cliLogger.error("Invalid prefix. Use 'mcp' or 'cli'");
+            process.exit(1);
+        }
+        if (id) {
+            // Get specific job by ID
+            cliLogger.console(`Checking job: ${id}`);
+            const job = getJobById(id);
+            if (!job) {
+                cliLogger.error(`Job '${id}' not found.`);
+                process.exit(1);
+            }
+            formatJobDetails(job);
+        }
+        else {
+            // Get recent jobs
+            const jobCount = parseInt(count) || 5;
+            cliLogger.console(`Fetching ${jobCount} recent ${prefix.toUpperCase()} jobs...`);
+            const jobs = getRecentJobs(jobCount, prefix);
+            formatJobsList(jobs);
+            if (jobs.length > 0) {
+                cliLogger.console(`\nUse 'gwanli job --id <jobId>' to see detailed status.`);
+            }
+        }
+    }
+    catch (error) {
+        cliLogger.error(`Error checking jobs: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+});

package/dist/ls.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const ls: Command;

package/dist/ls.js

@@ -0,0 +1,26 @@
+import { Command } from "commander";
+import { listFiles, loadConfig, cliLogger } from "gwanli-core";
+export const ls = new Command("ls")
+    .description("List files from a workspace or database path")
+    .argument("[workspace]", "Workspace name or database path (defaults to 'default' workspace)")
+    .option("--prefix <prefix>", "Path prefix to filter results (default: '/')", "/")
+    .option("--depth <depth>", "Maximum depth to display (default: 2)", "2")
+    .action(async (workspace, options) => {
+    const { prefix, depth } = options;
+    const maxDepth = parseInt(depth, 10);
+    const config = loadConfig();
+    if (!config.default_search) {
+        return cliLogger.error("No default search configured");
+    }
+    let searchWorkspace = workspace ?? config.default_search;
+    cliLogger.console(`\nListing files from: ${searchWorkspace}`);
+    cliLogger.console(`Prefix: ${prefix}, Max Depth: ${maxDepth}\n`);
+    try {
+        const result = listFiles(searchWorkspace, prefix, maxDepth);
+        cliLogger.console(result);
+    }
+    catch (error) {
+        cliLogger.error(`Error listing files: ${error}`);
+        process.exit(1);
+    }
+});

package/dist/mcp.js

@@ -1,28 +1,417 @@
 #!/usr/bin/env node
-import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
+import { loadConfig, addWorkspace, updateWorkspace, deleteWorkspace, OAUTH_BASE_URL, checkWorkspace, indexNotionPages, JobTracker, listFiles, getRecentJobs, getJobById, } from "gwanli-core";
 // Create an MCP server
 const server = new McpServer({
-    name: "demo-server",
-    version: "1.0.0"
+    name: "gwanli-mcp",
+    version: "1.0.0",
+});
+// Register auth tool
+server.registerTool("auth", {
+    description: "Check authentication status and get OAuth URLs for workspace setup",
+    inputSchema: {},
+}, async () => {
+    try {
+        // Load current config to check existing workspaces
+        const config = loadConfig();
+        const existingWorkspaces = Object.keys(config.workspace);
+        const authUrl = `${OAUTH_BASE_URL}/`;
+        const message = existingWorkspaces.length > 0
+            ? `**Authenticated Workspaces:**\n${existingWorkspaces
+                .map((workspace) => `- ${workspace}${workspace === "default" ? " (default)" : ""}`)
+                .join("\n")}\n\n**Get a new token for any workspace:**\n${authUrl}\n\nVisit the URL above, complete OAuth, and you'll receive a token to add to your workspace configuration.`
+            : `**No authenticated workspaces found.**\n\nGenerate a token by visiting the URL above: ${authUrl}`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: message,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error checking authentication: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Register workspace management tool
+server.registerTool("workspace", {
+    description: "Manage workspace configurations - add, delete, or update workspaces",
+    inputSchema: {
+        type: z
+            .enum(["ADD", "DELETE", "UPDATE", "LIST"])
+            .describe("Type of workspace operation: ADD to create new workspace, DELETE to remove existing workspace, UPDATE to modify workspace details, LIST to show all workspaces"),
+        name: z
+            .string()
+            .optional()
+            .default("default")
+            .describe("Workspace name - defaults to 'default' if not provided. Used to identify which workspace to operate on"),
+        api_key: z
+            .string()
+            .optional()
+            .describe("API key/token for workspace authentication - required for ADD operations, optional for UPDATE to change the key"),
+        description: z
+            .string()
+            .optional()
+            .describe("Human-readable description of the workspace - required for UPDATE operations to set workspace description"),
+    },
+}, async (args) => {
+    try {
+        switch (args.type) {
+            case "ADD":
+                if (!args.api_key) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "API key is required for adding workspace.",
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const addName = args.name || "default";
+                addWorkspace(addName, args.api_key, {
+                    description: `Workspace: ${addName}`,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Successfully added workspace "${addName}" with API key.`,
+                        },
+                    ],
+                };
+            case "DELETE":
+                const deleteName = args.name || "default";
+                try {
+                    deleteWorkspace(deleteName);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Successfully deleted workspace "${deleteName}".`,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Workspace "${deleteName}" not found.`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            case "UPDATE":
+                if (!args.description) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "Description is required for updating workspace.",
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const updateName = args.name || "default";
+                try {
+                    updateWorkspace(updateName, {
+                        description: args.description,
+                        ...(args.api_key && { apiKey: args.api_key }),
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Successfully updated workspace "${updateName}".`,
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Workspace "${updateName}" not found.`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            case "LIST":
+                const config = loadConfig();
+                const workspaces = Object.entries(config.workspace);
+                if (workspaces.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "**No workspaces found.**\n\nUse the workspace tool with type 'ADD' to create a new workspace.",
+                            },
+                        ],
+                    };
+                }
+                const workspaceList = workspaces
+                    .map(([name, workspace]) => {
+                    const defaultLabel = name === "default" ? " (default)" : "";
+                    const description = workspace.description
+                        ? ` - ${workspace.description}`
+                        : "";
+                    return `- **${name}**${defaultLabel}${description}`;
+                })
+                    .join("\n");
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `**Available Workspaces:**\n\n${workspaceList}`,
+                        },
+                    ],
+                };
+            default:
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Invalid workspace operation type.",
+                        },
+                    ],
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error managing workspace: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Register index tool
+server.registerTool("index", {
+    description: "Start indexing a Notion workspace in the background",
+    inputSchema: {
+        workspace: z
+            .string()
+            .default("default")
+            .describe("Workspace name to index - defaults to 'default' if not provided"),
+    },
+}, async (args) => {
+    try {
+        const workspaceName = args.workspace || "default";
+        // Check if workspace exists
+        if (!checkWorkspace(workspaceName)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Workspace "${workspaceName}" not found. Use the workspace tool to list available workspaces or add a new one.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Run indexing directly in background
+        const config = loadConfig();
+        const workspace = config.workspace[workspaceName];
+        // Create job tracker
+        const jobId = `mcp-${Date.now()}`;
+        const jobTracker = new JobTracker(jobId);
+        // Start indexing asynchronously
+        indexNotionPages(workspace.api_key, workspace.db_path, jobTracker)
+            .then(() => {
+            jobTracker.updateStatus("END");
+            console.log(`Indexing completed for workspace: ${workspaceName}`);
+        })
+            .catch((error) => {
+            jobTracker.updateStatus("ERROR");
+            console.error(`Indexing failed for workspace ${workspaceName}:`, error);
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Indexing of Notion workspace has begun.\n\n**Job ID:** ${jobId}\n\nCheck back in a while to see its progress using the checkJob tool.`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error starting indexing: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Register ls tool
+server.registerTool("ls", {
+    description: "List files from a workspace or database path",
+    inputSchema: {
+        workspace: z
+            .string()
+            .optional()
+            .describe("Workspace name or database path - defaults to default_search from config if not provided"),
+        prefix: z
+            .string()
+            .default("/")
+            .describe("Path prefix to filter results - defaults to '/'"),
+        depth: z
+            .number()
+            .default(2)
+            .describe("Maximum depth to display - defaults to 2"),
+    },
+}, async (args) => {
+    try {
+        const config = loadConfig();
+        if (!config.default_search) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No default search configured",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const searchWorkspace = args.workspace ?? config.default_search;
+        const prefix = args.prefix ?? "/";
+        const maxDepth = args.depth ?? 2;
+        const result = listFiles(searchWorkspace, prefix, maxDepth);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `**Files from: ${searchWorkspace}**\nPrefix: ${prefix}, Max Depth: ${maxDepth}\n\n${result}`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error listing files: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Register checkJob tool
+server.registerTool("checkJob", {
+    description: "Check job status - either by specific ID or get recent jobs",
+    inputSchema: {
+        id: z
+            .string()
+            .optional()
+            .describe("Specific job ID to check (e.g., 'mcp-1755172514281')"),
+        count: z
+            .number()
+            .default(5)
+            .describe("Number of recent jobs to show when no ID is provided - defaults to 5"),
+        prefix: z
+            .enum(["mcp", "cli"])
+            .default("mcp")
+            .describe("Job prefix filter - defaults to 'mcp'"),
+    },
+}, async (args) => {
+    try {
+        if (args.id) {
+            // Get specific job by ID
+            const job = getJobById(args.id);
+            if (!job) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Job "${args.id}" not found.`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const stateText = job.state
+                ? `**Status:** \`\`\`json\n${JSON.stringify(job.state, null, 2)}\n\`\`\``
+                : "**Status:** No status file found";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Job ID:** ${job.jobId}\n**Prefix:** ${job.prefix}\n**Timestamp:** ${job.timestamp}\n\n${stateText}`,
+                    },
+                ],
+            };
+        }
+        else {
+            // Get recent jobs
+            const jobs = getRecentJobs(args.count, args.prefix);
+            if (jobs.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `No ${args.prefix} jobs found.`,
+                        },
+                    ],
+                };
+            }
+            const jobsList = jobs
+                .map((job) => {
+                const statusText = job.state?.status ? ` (${job.state.status})` : "";
+                const timeStr = new Date(job.timestamp).toLocaleString();
+                return `- **${job.jobId}**${statusText} - ${timeStr}`;
+            })
+                .join("\n");
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Recent ${args.prefix.toUpperCase()} Jobs (${jobs.length}):**\n\n${jobsList}\n\nUse checkJob with a specific ID to see detailed status.`,
+                    },
+                ],
+            };
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error checking job: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
 });
-// Add an addition tool
-server.registerTool("add", {
-    description: "Add two numbers",
-    inputSchema: { a: z.number(), b: z.number() }
-}, async ({ a, b }) => ({
-    content: [{ type: "text", text: String(a + b) }]
-}));
-// Add a dynamic greeting resource
-server.resource("greeting", new ResourceTemplate("greeting://{name}", { list: undefined }), {
-    description: "Dynamic greeting generator"
-}, async (uri, variables) => ({
-    contents: [{
-            uri: uri.href,
-            text: `Hello, ${variables.name}!`
-        }]
-}));
 // Start receiving messages on stdin and sending messages on stdout
 const transport = new StdioServerTransport();
 await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gwanli",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Notion management with AI capabilities - CLI and MCP server",
   "type": "module",
   "main": "dist/cli.js",
@@ -18,9 +18,12 @@
   "author": "Ivan Leo & Timothy Chen",
   "license": "MIT",
   "dependencies": {
+    "@hono/node-server": "^1.18.2",
     "commander": "^11.0.0",
-    "gwanli-core": "{\n  gwanli-core: 0.1.0\n}",
-    "gwanli-mcp": "{\n  gwanli-mcp: 0.1.0\n}"
+    "gwanli-core": "{\n  gwanli-core: 0.3.0\n}",
+    "gwanli-mcp": "{\n  gwanli-mcp: 0.3.0\n}",
+    "hono": "^4.9.1",
+    "open": "^10.2.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",