kontexted 0.1.5

package/dist/lib/proxy-server.js

@@ -0,0 +1,131 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { logError } from "../lib/logger.js";
+// Tools that modify data
+const WRITE_TOOLS = new Set(["createFolder", "createNote", "updateNote", "deleteNote", "deleteFolder"]);
+/**
+ * Convert JSON schema to Zod schema, removing workspaceSlug
+ */
+function jsonSchemaToZod(jsonSchema) {
+    if (!jsonSchema || typeof jsonSchema !== "object") {
+        return z.object({});
+    }
+    const properties = jsonSchema.properties ?? {};
+    const required = new Set(jsonSchema.required ?? []);
+    // Remove workspaceSlug as it's injected by the proxy
+    const { workspaceSlug, ...otherProperties } = properties;
+    const shape = {};
+    for (const [key, propSchema] of Object.entries(otherProperties)) {
+        const type = propSchema?.type;
+        if (type === "string") {
+            let zodType = z.string();
+            if (propSchema.minLength === 1) {
+                zodType = zodType.min(1);
+            }
+            shape[key] = zodType;
+        }
+        else if (type === "integer") {
+            let zodType = z.number().int();
+            if (propSchema.exclusiveMinimum === 0) {
+                zodType = zodType.positive();
+            }
+            if (propSchema.minimum !== undefined) {
+                zodType = zodType.min(propSchema.minimum);
+            }
+            if (propSchema.maximum !== undefined) {
+                zodType = zodType.max(propSchema.maximum);
+            }
+            shape[key] = zodType;
+        }
+        else if (type === "number") {
+            let zodType = z.number();
+            if (propSchema.minimum !== undefined) {
+                zodType = zodType.min(propSchema.minimum);
+            }
+            if (propSchema.maximum !== undefined) {
+                zodType = zodType.max(propSchema.maximum);
+            }
+            shape[key] = zodType;
+        }
+        else if (type === "boolean") {
+            shape[key] = z.boolean();
+        }
+        else if (type === "array") {
+            shape[key] = z.array(z.any());
+        }
+        else if (type === "object") {
+            shape[key] = z.record(z.any());
+        }
+        else {
+            shape[key] = z.any();
+        }
+        // Make optional if not in required list
+        if (!required.has(key)) {
+            shape[key] = shape[key].optional();
+        }
+    }
+    return z.object(shape);
+}
+/**
+ * Start the MCP proxy server that bridges stdio to HTTP
+ */
+export async function startProxyServer(options) {
+    const { client, workspaceSlug, tools, writeEnabled } = options;
+    const server = new McpServer({
+        name: "kontexted-proxy",
+        version: "0.1.0",
+    });
+    // Filter and register tools
+    const filteredTools = tools.filter((tool) => {
+        if (writeEnabled) {
+            return true;
+        }
+        return !WRITE_TOOLS.has(tool.name);
+    });
+    for (const tool of filteredTools) {
+        const inputSchema = jsonSchemaToZod(tool.inputSchema ?? {});
+        server.registerTool(tool.name, {
+            title: tool.title ?? tool.name,
+            description: tool.description ?? "",
+            inputSchema,
+        }, async (args) => {
+            // Inject workspaceSlug into arguments
+            const finalArgs = {
+                workspaceSlug,
+                ...(args ?? {}),
+            };
+            const result = await client.callTool({
+                name: tool.name,
+                arguments: finalArgs,
+            });
+            // Convert old format (toolResult) to new format (content) if needed
+            if ("toolResult" in result) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result.toolResult),
+                        },
+                    ],
+                    _meta: result._meta,
+                };
+            }
+            return result;
+        });
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    logError(`Proxy server started with ${filteredTools.length} tools (${writeEnabled ? "write enabled" : "read-only"})`);
+    // Handle graceful shutdown
+    process.on("SIGINT", async () => {
+        await client.close();
+        await server.close();
+        process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+        await client.close();
+        await server.close();
+        process.exit(0);
+    });
+}

package/dist/lib/server/binary.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Gets the current platform identifier (e.g., "darwin-arm64")
+ */
+export declare function getPlatform(): string;
+/**
+ * Checks if the current platform is supported
+ */
+export declare function isPlatformSupported(): boolean;
+/**
+ * Gets the package name for the current platform
+ */
+export declare function getPlatformPackage(): string | null;
+/**
+ * Resolves the path to the server binary
+ * Returns null if the package is not installed or platform is unsupported
+ */
+export declare function getBinaryPath(): string | null;
+/**
+ * Resolves the path to the migration tool binary
+ * Returns null if the package is not installed or platform is unsupported
+ */
+export declare function getMigratePath(): string | null;
+/**
+ * Resolves the path to the migrations directory
+ * Returns null if the package is not installed or platform is unsupported
+ */
+export declare function getMigrationsDir(): string | null;
+/**
+ * Resolves the path to the public directory (frontend assets)
+ * Returns null if the package is not installed or platform is unsupported
+ */
+export declare function getPublicDir(): string | null;

package/dist/lib/server/binary.js

@@ -0,0 +1,127 @@
+import { createRequire } from 'module';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { PLATFORM_PACKAGES } from './constants.js';
+/**
+ * Gets the current platform identifier (e.g., "darwin-arm64")
+ */
+export function getPlatform() {
+    return `${process.platform}-${process.arch}`;
+}
+/**
+ * Checks if the current platform is supported
+ */
+export function isPlatformSupported() {
+    const platform = getPlatform();
+    return platform in PLATFORM_PACKAGES;
+}
+/**
+ * Gets the package name for the current platform
+ */
+export function getPlatformPackage() {
+    const platform = getPlatform();
+    return PLATFORM_PACKAGES[platform] || null;
+}
+/**
+ * Resolves the path to the server binary
+ * Returns null if the package is not installed or platform is unsupported
+ */
+export function getBinaryPath() {
+    if (!isPlatformSupported()) {
+        return null;
+    }
+    const pkg = getPlatformPackage();
+    if (!pkg) {
+        return null;
+    }
+    try {
+        // Use createRequire to resolve the package location
+        const require = createRequire(import.meta.url);
+        const packagePath = require.resolve(`${pkg}/package.json`);
+        const binaryName = process.platform === 'win32' ? 'kontexted.exe' : 'kontexted';
+        const binPath = join(packagePath, '..', 'bin', binaryName);
+        if (existsSync(binPath)) {
+            return binPath;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolves the path to the migration tool binary
+ * Returns null if the package is not installed or platform is unsupported
+ */
+export function getMigratePath() {
+    if (!isPlatformSupported()) {
+        return null;
+    }
+    const pkg = getPlatformPackage();
+    if (!pkg) {
+        return null;
+    }
+    try {
+        const require = createRequire(import.meta.url);
+        const packagePath = require.resolve(`${pkg}/package.json`);
+        const binaryName = process.platform === 'win32' ? 'kontexted-migrate.exe' : 'kontexted-migrate';
+        const migratePath = join(packagePath, '..', 'bin', binaryName);
+        if (existsSync(migratePath)) {
+            return migratePath;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolves the path to the migrations directory
+ * Returns null if the package is not installed or platform is unsupported
+ */
+export function getMigrationsDir() {
+    if (!isPlatformSupported()) {
+        return null;
+    }
+    const pkg = getPlatformPackage();
+    if (!pkg) {
+        return null;
+    }
+    try {
+        const require = createRequire(import.meta.url);
+        const packagePath = require.resolve(`${pkg}/package.json`);
+        const migrationsDir = join(packagePath, '..', 'migrations');
+        if (existsSync(migrationsDir)) {
+            return migrationsDir;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolves the path to the public directory (frontend assets)
+ * Returns null if the package is not installed or platform is unsupported
+ */
+export function getPublicDir() {
+    if (!isPlatformSupported()) {
+        return null;
+    }
+    const pkg = getPlatformPackage();
+    if (!pkg) {
+        return null;
+    }
+    try {
+        const require = createRequire(import.meta.url);
+        const packagePath = require.resolve(`${pkg}/package.json`);
+        const publicDir = join(packagePath, '..', 'public');
+        if (existsSync(publicDir)) {
+            return publicDir;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/server/config.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Server configuration interface
+ */
+export interface ServerConfig {
+    database: {
+        dialect: 'sqlite' | 'postgresql';
+        url: string;
+    };
+    server: {
+        port: number;
+        host: string;
+    };
+    logging: {
+        level: 'debug' | 'info' | 'warn' | 'error';
+    };
+    collab: {
+        tokenSecret: string;
+    };
+    auth: {
+        betterAuthSecret: string;
+        inviteCode: string;
+    };
+    paths?: {
+        publicDir?: string;
+        migrationsDir?: string;
+    };
+}
+/**
+ * Generates a secure random token secret (32 bytes as hex string)
+ */
+export declare function generateTokenSecret(): string;
+/**
+ * Generates a secure random auth secret (32 bytes as hex string)
+ */
+export declare function generateBetterAuthSecret(): string;
+/**
+ * Generates a readable invite code (16 alphanumeric chars, lowercase, no ambiguous chars)
+ */
+export declare function generateInviteCode(): string;
+/**
+ * Returns the default server configuration
+ */
+export declare function getDefaultConfig(): ServerConfig;
+/**
+ * Checks if the configuration file exists
+ */
+export declare function configExists(): boolean;
+/**
+ * Loads the server configuration from file
+ * Returns null if the config file doesn't exist or is invalid
+ */
+export declare function loadConfig(): ServerConfig | null;
+/**
+ * Saves the server configuration to file
+ * Creates the directory if it doesn't exist
+ */
+export declare function saveConfig(config: ServerConfig): void;

package/dist/lib/server/config.js

@@ -0,0 +1,136 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { randomBytes } from 'crypto';
+import { CONFIG_FILE, DATA_DIR, } from './constants.js';
+import { getMigrationsDir, getPublicDir } from './binary.js';
+/**
+ * Generates a secure random token secret (32 bytes as hex string)
+ */
+export function generateTokenSecret() {
+    return randomBytes(32).toString('hex');
+}
+/**
+ * Generates a secure random auth secret (32 bytes as hex string)
+ */
+export function generateBetterAuthSecret() {
+    return randomBytes(32).toString('hex');
+}
+/**
+ * Generates a readable invite code (16 alphanumeric chars, lowercase, no ambiguous chars)
+ */
+export function generateInviteCode() {
+    // Use lowercase letters and digits, excluding: 0, o, 1, l (ambiguous)
+    const chars = 'abcdefghijkmnpqrstuvwxyz23456789';
+    let code = '';
+    for (let i = 0; i < 16; i++) {
+        code += chars[randomBytes(1)[0] % chars.length];
+    }
+    return code;
+}
+/**
+ * Returns the default server configuration
+ */
+export function getDefaultConfig() {
+    const migrationsDir = getMigrationsDir();
+    const publicDir = getPublicDir();
+    const config = {
+        database: {
+            dialect: 'sqlite',
+            url: `${DATA_DIR}/kontexted.db`,
+        },
+        server: {
+            port: 3000,
+            host: '127.0.0.1',
+        },
+        logging: {
+            level: 'info',
+        },
+        collab: {
+            tokenSecret: generateTokenSecret(),
+        },
+        auth: {
+            betterAuthSecret: generateBetterAuthSecret(),
+            inviteCode: generateInviteCode(),
+        },
+    };
+    // Add paths if platform package is available
+    if (migrationsDir || publicDir) {
+        config.paths = {
+            migrationsDir: migrationsDir || undefined,
+            publicDir: publicDir || undefined,
+        };
+    }
+    return config;
+}
+/**
+ * Checks if the configuration file exists
+ */
+export function configExists() {
+    return existsSync(CONFIG_FILE);
+}
+/**
+ * Loads the server configuration from file
+ * Returns null if the config file doesn't exist or is invalid
+ */
+export function loadConfig() {
+    if (!configExists()) {
+        return null;
+    }
+    try {
+        const content = readFileSync(CONFIG_FILE, 'utf-8');
+        const parsed = JSON.parse(content);
+        // Basic validation
+        if (!parsed.server || !parsed.database) {
+            console.warn('Config file missing required fields, using defaults');
+            return null;
+        }
+        const tokenSecret = parsed.collab?.tokenSecret;
+        const betterAuthSecret = parsed.auth?.betterAuthSecret;
+        const inviteCode = parsed.auth?.inviteCode;
+        return {
+            database: {
+                dialect: parsed.database.dialect || 'sqlite',
+                url: parsed.database.url,
+            },
+            server: {
+                port: parsed.server.port || 3000,
+                host: parsed.server.host || '127.0.0.1',
+            },
+            logging: {
+                level: parsed.logging?.level || 'info',
+            },
+            collab: {
+                tokenSecret: tokenSecret || generateTokenSecret(),
+            },
+            auth: {
+                betterAuthSecret: betterAuthSecret || generateBetterAuthSecret(),
+                inviteCode: inviteCode || generateInviteCode(),
+            },
+            paths: {
+                publicDir: parsed.paths?.publicDir,
+                migrationsDir: parsed.paths?.migrationsDir,
+            },
+        };
+    }
+    catch (error) {
+        console.warn('Failed to load config file:', error instanceof Error ? error.message : 'Unknown error');
+        return null;
+    }
+}
+/**
+ * Saves the server configuration to file
+ * Creates the directory if it doesn't exist
+ */
+export function saveConfig(config) {
+    // Ensure the config directory exists
+    const configDir = dirname(CONFIG_FILE);
+    if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+    }
+    // Ensure the data directory exists
+    if (!existsSync(DATA_DIR)) {
+        mkdirSync(DATA_DIR, { recursive: true });
+    }
+    const content = JSON.stringify(config, null, 2);
+    writeFileSync(CONFIG_FILE, content, 'utf-8');
+}

package/dist/lib/server/constants.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Base Kontexted directory in user's home
+ */
+export declare const KONTEXTED_DIR: string;
+/**
+ * Path to the configuration file
+ */
+export declare const CONFIG_FILE: string;
+/**
+ * Directory for data storage (databases, etc.)
+ */
+export declare const DATA_DIR: string;
+/**
+ * Directory for log files
+ */
+export declare const LOGS_DIR: string;
+/**
+ * Main server log file path
+ */
+export declare const LOG_FILE: string;
+/**
+ * PID file for tracking the running server process
+ */
+export declare const PID_FILE: string;
+/**
+ * Platform-specific package mapping
+ * Maps platform identifiers to their corresponding npm packages
+ */
+export declare const PLATFORM_PACKAGES: Record<string, string>;

package/dist/lib/server/constants.js

@@ -0,0 +1,35 @@
+import { homedir } from 'os';
+import { join } from 'path';
+/**
+ * Base Kontexted directory in user's home
+ */
+export const KONTEXTED_DIR = join(homedir(), '.kontexted');
+/**
+ * Path to the configuration file
+ */
+export const CONFIG_FILE = join(KONTEXTED_DIR, 'config.json');
+/**
+ * Directory for data storage (databases, etc.)
+ */
+export const DATA_DIR = join(KONTEXTED_DIR, 'data');
+/**
+ * Directory for log files
+ */
+export const LOGS_DIR = join(KONTEXTED_DIR, 'logs');
+/**
+ * Main server log file path
+ */
+export const LOG_FILE = join(LOGS_DIR, 'server.log');
+/**
+ * PID file for tracking the running server process
+ */
+export const PID_FILE = join(KONTEXTED_DIR, 'server.pid');
+/**
+ * Platform-specific package mapping
+ * Maps platform identifiers to their corresponding npm packages
+ */
+export const PLATFORM_PACKAGES = {
+    'darwin-arm64': '@kontexted/darwin-arm64',
+    'linux-x64': '@kontexted/linux-x64',
+    'win32-x64': '@kontexted/windows-x64',
+};

package/dist/lib/server/daemon.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Reads the PID from the PID file
+ * Returns null if the file doesn't exist
+ */
+export declare function getPid(): number | null;
+/**
+ * Checks if a process with the given PID is running
+ * Uses signal 0 to check process existence without actually sending a signal
+ */
+export declare function isRunning(pid: number): boolean;
+/**
+ * Starts the server
+ * @param options.foreground - If true, runs in foreground (blocks). If false, runs as daemon
+ * @returns The PID of the started server
+ */
+export declare function startServer(options?: {
+    foreground?: boolean;
+}): Promise<number>;
+/**
+ * Stops the server
+ * @param options.force - If true, uses SIGKILL instead of SIGTERM
+ * @returns True if the server was stopped, false if it wasn't running
+ */
+export declare function stopServer(options?: {
+    force?: boolean;
+}): Promise<boolean>;
+/**
+ * Gets the current server status
+ */
+export declare function getServerStatus(): {
+    running: boolean;
+    pid?: number;
+    startedAt?: Date;
+};