kontexted 0.1.5

package/dist/commands/server/start.js

@@ -0,0 +1,44 @@
+import { isPlatformSupported, getPlatform, getBinaryPath, configExists, getServerStatus, startServer, } from '../../lib/server/index.js';
+const DOCKER_URL = 'https://hub.docker.com/r/rabbyte-tech/kontexted';
+function checkPrerequisites() {
+    if (!isPlatformSupported()) {
+        return { valid: false, error: `Platform not supported: ${getPlatform()}. Consider using Docker: ${DOCKER_URL}` };
+    }
+    if (!getBinaryPath()) {
+        return { valid: false, error: 'Server binary not found. Run `kontexted server install` first.' };
+    }
+    if (!configExists()) {
+        return { valid: false, error: 'Configuration not found. Run `kontexted server init` first.' };
+    }
+    const status = getServerStatus();
+    if (status.running && status.pid) {
+        return { valid: false, error: `Server is already running (PID: ${status.pid})` };
+    }
+    return { valid: true };
+}
+// ============ Yargs Command Module ============
+export const command = 'start';
+export const desc = 'Start the Kontexted server';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const builder = (yargs) => {
+    return yargs.option('foreground', {
+        alias: 'f',
+        type: 'boolean',
+        description: 'Run server in foreground (blocking)',
+    });
+};
+export const handler = async (argv) => {
+    const check = checkPrerequisites();
+    if (!check.valid) {
+        console.error('Error:', check.error);
+        process.exit(1);
+    }
+    try {
+        const pid = await startServer({ foreground: argv.foreground });
+        console.log(argv.foreground ? `Server running (PID: ${pid})` : `Server started (PID: ${pid})`);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+    }
+};

package/dist/commands/server/status.d.ts

@@ -0,0 +1,4 @@
+export declare const command = "status";
+export declare const desc = "Show server status";
+export declare const builder: (yargs: any) => any;
+export declare const handler: () => Promise<void>;

package/dist/commands/server/status.js

@@ -0,0 +1,23 @@
+import { getServerStatus, loadConfig } from '../../lib/server/index.js';
+import { CONFIG_FILE, LOG_FILE } from '../../lib/server/constants.js';
+// ============ Yargs Command Module ============
+export const command = 'status';
+export const desc = 'Show server status';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const builder = (yargs) => yargs;
+export const handler = async () => {
+    const status = getServerStatus();
+    if (!status.running) {
+        console.log('Server Status: Not running');
+        return;
+    }
+    const config = loadConfig();
+    console.log('Server Status: Running');
+    console.log(`  PID: ${status.pid}`);
+    if (config) {
+        console.log(`  Port: ${config.server.port}`);
+        console.log(`  Host: ${config.server.host}`);
+    }
+    console.log(`  Config: ${CONFIG_FILE}`);
+    console.log(`  Logs: ${LOG_FILE}`);
+};

package/dist/commands/server/stop.d.ts

@@ -0,0 +1,6 @@
+export declare const command = "stop";
+export declare const desc = "Stop the Kontexted server";
+export declare const builder: (yargs: any) => any;
+export declare const handler: (argv: {
+    force?: boolean;
+}) => Promise<void>;

package/dist/commands/server/stop.js

@@ -0,0 +1,32 @@
+import { getServerStatus, stopServer } from '../../lib/server/index.js';
+// ============ Yargs Command Module ============
+export const command = 'stop';
+export const desc = 'Stop the Kontexted server';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const builder = (yargs) => {
+    return yargs.option('force', {
+        type: 'boolean',
+        description: 'Force kill the server (SIGKILL)',
+    });
+};
+export const handler = async (argv) => {
+    const status = getServerStatus();
+    if (!status.running) {
+        console.log('Server is not running');
+        return;
+    }
+    try {
+        const stopped = await stopServer({ force: argv.force ?? false });
+        if (stopped) {
+            console.log('Server stopped');
+        }
+        else {
+            console.error('Error: Failed to stop server');
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+    }
+};

package/dist/commands/show-config.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from "commander";
+/**
+ * Register the show-config command
+ */
+export declare function registerShowConfigCommand(program: Command): void;

package/dist/commands/show-config.js

@@ -0,0 +1,19 @@
+import { readConfig, getConfigPath } from "../lib/config.js";
+/**
+ * Register the show-config command
+ */
+export function registerShowConfigCommand(program) {
+    program
+        .command("show-config")
+        .description("Display all stored profiles")
+        .action(async () => {
+        const config = await readConfig();
+        console.log(`Config file: ${getConfigPath()}`);
+        console.log("");
+        if (Object.keys(config.profiles).length === 0) {
+            console.log("No profiles configured.");
+            return;
+        }
+        console.log(JSON.stringify(config, null, 2));
+    });
+}

package/dist/commands/skill.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from "commander";
+/**
+ * Register the skill command and its subcommands
+ */
+export declare function registerSkillCommand(program: Command): void;

package/dist/commands/skill.js

@@ -0,0 +1,211 @@
+import * as readline from "readline";
+import { readConfig, writeConfig } from "../lib/config.js";
+import { getProfile } from "../lib/profile.js";
+import { ApiClient } from "../lib/api-client.js";
+import { ensureValidTokens } from "../lib/oauth.js";
+import { getProvider, allTemplates } from "../skill-init/index.js";
+import { initSkill } from "../skill-init/utils.js";
+/**
+ * Execute workspace-tree skill via the API
+ */
+async function executeWorkspaceTree(client, workspaceSlug) {
+    const response = await client.post("/api/skill/workspace-tree", { workspaceSlug });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Workspace tree skill failed: ${response.status} ${errorText}`);
+    }
+    return response.json();
+}
+/**
+ * Execute search-notes skill via the API
+ */
+async function executeSearchNotes(client, workspaceSlug, query, limit) {
+    const body = { workspaceSlug, query };
+    if (limit !== undefined) {
+        body.limit = limit;
+    }
+    const response = await client.post("/api/skill/search-notes", body);
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Search notes skill failed: ${response.status} ${errorText}`);
+    }
+    return response.json();
+}
+/**
+ * Execute note-by-id skill via the API
+ */
+async function executeNoteById(client, workspaceSlug, notePublicId) {
+    const response = await client.post("/api/skill/note-by-id", {
+        workspaceSlug,
+        notePublicId
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Note by ID skill failed: ${response.status} ${errorText}`);
+    }
+    return response.json();
+}
+/**
+ * Helper function to create an API client from a profile alias
+ */
+async function createApiClient(alias) {
+    const config = await readConfig();
+    const profile = getProfile(config, alias);
+    if (!profile) {
+        console.error(`Profile not found: ${alias}. Run 'kontexted login' first.`);
+        process.exit(1);
+    }
+    // Proactively refresh token if needed (non-interactive)
+    const tokensValid = await ensureValidTokens(profile.oauth, async () => writeConfig(config), profile.serverUrl);
+    if (!tokensValid) {
+        console.error(`Authentication expired. Run 'kontexted login --alias ${alias}' to re-authenticate.`);
+        process.exit(1);
+    }
+    return new ApiClient(profile.serverUrl, profile.oauth, async () => writeConfig(config));
+}
+/**
+ * Display results from a skill execution
+ */
+function displayResult(result) {
+    console.log(JSON.stringify(result, null, 2));
+}
+/**
+ * Register the skill command and its subcommands
+ */
+export function registerSkillCommand(program) {
+    const skillCommand = program
+        .command("skill")
+        .description("Invoke LLM skill via CLI");
+    skillCommand
+        .command("workspace-tree")
+        .description("Get the workspace tree structure")
+        .requiredOption("--alias <name>", "Profile alias to use")
+        .action(async (options) => {
+        try {
+            const client = await createApiClient(options.alias);
+            const config = await readConfig();
+            const profile = getProfile(config, options.alias);
+            if (!profile) {
+                console.error(`Profile not found: ${options.alias}. Run 'kontexted login' first.`);
+                process.exit(1);
+            }
+            const result = await executeWorkspaceTree(client, profile.workspace);
+            displayResult(result);
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    });
+    skillCommand
+        .command("search-notes")
+        .description("Search notes by query in a workspace")
+        .requiredOption("--alias <name>", "Profile alias to use")
+        .requiredOption("--query <text>", "Search query")
+        .option("--limit <number>", "Maximum number of results (default: 20, max: 50)", parseInt)
+        .action(async (options) => {
+        try {
+            const client = await createApiClient(options.alias);
+            const config = await readConfig();
+            const profile = getProfile(config, options.alias);
+            if (!profile) {
+                console.error(`Profile not found: ${options.alias}. Run 'kontexted login' first.`);
+                process.exit(1);
+            }
+            const result = await executeSearchNotes(client, profile.workspace, options.query, options.limit);
+            displayResult(result);
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    });
+    skillCommand
+        .command("note-by-id")
+        .description("Get a specific note by its public ID")
+        .requiredOption("--alias <name>", "Profile alias to use")
+        .requiredOption("--note-id <id>", "Public ID of the note")
+        .action(async (options) => {
+        try {
+            const client = await createApiClient(options.alias);
+            const config = await readConfig();
+            const profile = getProfile(config, options.alias);
+            if (!profile) {
+                console.error(`Profile not found: ${options.alias}. Run 'kontexted login' first.`);
+                process.exit(1);
+            }
+            const result = await executeNoteById(client, profile.workspace, options.noteId);
+            displayResult(result);
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    });
+    skillCommand
+        .command("init")
+        .description("Initialize AI agent skills for the current project")
+        .option("--provider <name>", "Provider to use (default: opencode)", "opencode")
+        .option("--all", "Generate all available skills without prompting", false)
+        .action(async (options) => {
+        try {
+            // Get the provider
+            let provider;
+            try {
+                provider = getProvider(options.provider);
+            }
+            catch {
+                console.error(`Unknown skill provider: ${options.provider}`);
+                console.error(`Available providers: ${["opencode"].join(", ")}`);
+                process.exit(1);
+            }
+            // Show what will be generated
+            console.log(`This will generate the following skills for ${provider.name}:`);
+            for (const template of allTemplates) {
+                const skillPath = provider.getSkillPath(template.name);
+                console.log(`  - ${template.name} → ${skillPath}`);
+            }
+            // Check if we should prompt for confirmation
+            if (!options.all) {
+                const rl = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                const answer = await new Promise((resolve) => {
+                    rl.question("\nContinue? (y/N) ", (response) => {
+                        rl.close();
+                        resolve(response);
+                    });
+                });
+                if (answer.toLowerCase() !== "y") {
+                    console.log("Aborted.");
+                    process.exit(0);
+                }
+            }
+            // Generate all skills
+            const results = [];
+            for (const template of allTemplates) {
+                console.log(`Generating skill: ${template.name}`);
+                const result = await initSkill({
+                    skill: template,
+                    provider,
+                });
+                const status = result.created ? "Created" : "Updated";
+                console.log(`✓ ${status} ${result.path}`);
+                results.push({
+                    name: result.name,
+                    path: result.path,
+                    created: result.created,
+                });
+            }
+            // Show summary
+            const created = results.filter((r) => r.created).length;
+            const updated = results.length - created;
+            console.log(`\nSummary: ${created} created, ${updated} updated`);
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { registerLoginCommand } from "./commands/login.js";
+import { registerLogoutCommand } from "./commands/logout.js";
+import { registerShowConfigCommand } from "./commands/show-config.js";
+import { registerMcpCommand } from "./commands/mcp.js";
+import { registerSkillCommand } from "./commands/skill.js";
+import { registerServerCommand } from "./commands/server/index.js";
+const program = new Command();
+program
+    .name("kontexted")
+    .description("CLI tool for Kontexted - MCP proxy and workspace management")
+    .version("0.1.0");
+// Register subcommands
+registerLoginCommand(program);
+registerLogoutCommand(program);
+registerShowConfigCommand(program);
+registerSkillCommand(program);
+registerMcpCommand(program);
+registerServerCommand(program);
+// Parse arguments
+program.parseAsync(process.argv).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/lib/api-client.d.ts

@@ -0,0 +1,36 @@
+import type { OAuthState } from "../types/index.js";
+/**
+ * API client for making authenticated HTTP requests with automatic token refresh
+ */
+export declare class ApiClient {
+    private serverUrl;
+    private oauth;
+    private persist;
+    constructor(serverUrl: string, oauth: OAuthState, persist: () => Promise<void>);
+    /**
+     * Make an authenticated HTTP request
+     * Automatically handles token refresh on 401 responses
+     */
+    request(path: string, options?: RequestInit): Promise<Response>;
+    /**
+     * Refresh the access token using the refresh token
+     * @returns true if refresh was successful, false otherwise
+     */
+    private refreshToken;
+    /**
+     * Make a GET request
+     */
+    get(path: string): Promise<Response>;
+    /**
+     * Make a POST request with a JSON body
+     */
+    post(path: string, body: unknown): Promise<Response>;
+    /**
+     * Make a PUT request with a JSON body
+     */
+    put(path: string, body: unknown): Promise<Response>;
+    /**
+     * Make a DELETE request
+     */
+    delete(path: string): Promise<Response>;
+}

package/dist/lib/api-client.js

@@ -0,0 +1,130 @@
+import { logDebug, logError } from "../lib/logger.js";
+/**
+ * API client for making authenticated HTTP requests with automatic token refresh
+ */
+export class ApiClient {
+    serverUrl;
+    oauth;
+    persist;
+    constructor(serverUrl, oauth, persist) {
+        this.serverUrl = serverUrl;
+        this.oauth = oauth;
+        this.persist = persist;
+    }
+    /**
+     * Make an authenticated HTTP request
+     * Automatically handles token refresh on 401 responses
+     */
+    async request(path, options = {}) {
+        const url = new URL(path, this.serverUrl);
+        // Prepare headers with Authorization
+        const headers = {
+            ...options.headers,
+            Authorization: `Bearer ${this.oauth.tokens?.access_token}`,
+        };
+        // Set Content-Type to application/json by default for methods that have a body
+        if (options.body !== undefined && !headers["Content-Type"]) {
+            headers["Content-Type"] = "application/json";
+        }
+        const requestOptions = {
+            ...options,
+            headers,
+        };
+        logDebug(`[API CLIENT] ${options.method ?? "GET"} ${path}`);
+        let response = await fetch(url.toString(), requestOptions);
+        logDebug(`[API CLIENT] Response status: ${response.status}`);
+        // Handle 401 Unauthorized - attempt to refresh token
+        if (response.status === 401 && this.oauth.tokens?.refresh_token) {
+            logDebug("[API CLIENT] Token expired, attempting to refresh...");
+            const refreshed = await this.refreshToken();
+            if (refreshed) {
+                logDebug("[API CLIENT] Token refreshed successfully, retrying request...");
+                // Update Authorization header with new token
+                headers.Authorization = `Bearer ${this.oauth.tokens?.access_token}`;
+                requestOptions.headers = headers;
+                // Retry the original request with new token
+                response = await fetch(url.toString(), requestOptions);
+                logDebug(`[API CLIENT] Retry response status: ${response.status}`);
+            }
+            else {
+                throw new Error("Failed to refresh access token. Please run 'kontexted login' to re-authenticate.");
+            }
+        }
+        // If still 401 after refresh attempt (or no refresh token available)
+        if (response.status === 401) {
+            throw new Error("Authentication failed. Please run 'kontexted login' to re-authenticate.");
+        }
+        return response;
+    }
+    /**
+     * Refresh the access token using the refresh token
+     * @returns true if refresh was successful, false otherwise
+     */
+    async refreshToken() {
+        if (!this.oauth.tokens?.refresh_token) {
+            logError("[API CLIENT] No refresh token available");
+            return false;
+        }
+        try {
+            const tokenUrl = new URL("/api/auth/oauth2/token", new URL(this.serverUrl).origin);
+            logDebug(`[API CLIENT] Refreshing token - URL: ${tokenUrl.toString()}`);
+            const response = await fetch(tokenUrl.toString(), {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+                body: new URLSearchParams({
+                    grant_type: "refresh_token",
+                    refresh_token: this.oauth.tokens.refresh_token,
+                    client_id: this.oauth.clientInformation?.client_id ?? "",
+                    client_secret: this.oauth.clientInformation?.client_secret ?? "",
+                }),
+            });
+            logDebug(`[API CLIENT] Token refresh response status: ${response.status}`);
+            if (!response.ok) {
+                const errorText = await response.text();
+                logError(`[API CLIENT] Failed to refresh access token - Status: ${response.status}, Error: ${errorText}`);
+                return false;
+            }
+            const tokens = (await response.json());
+            this.oauth.tokens = tokens;
+            await this.persist();
+            logDebug("[API CLIENT] Token refresh successful");
+            return true;
+        }
+        catch (error) {
+            logError("[API CLIENT] Error refreshing access token:", error);
+            return false;
+        }
+    }
+    /**
+     * Make a GET request
+     */
+    async get(path) {
+        return this.request(path, { method: "GET" });
+    }
+    /**
+     * Make a POST request with a JSON body
+     */
+    async post(path, body) {
+        return this.request(path, {
+            method: "POST",
+            body: JSON.stringify(body),
+        });
+    }
+    /**
+     * Make a PUT request with a JSON body
+     */
+    async put(path, body) {
+        return this.request(path, {
+            method: "PUT",
+            body: JSON.stringify(body),
+        });
+    }
+    /**
+     * Make a DELETE request
+     */
+    async delete(path) {
+        return this.request(path, { method: "DELETE" });
+    }
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,17 @@
+import type { Config } from "../types/index.js";
+/**
+ * Read the configuration file from disk
+ */
+export declare function readConfig(): Promise<Config>;
+/**
+ * Write configuration to disk
+ */
+export declare function writeConfig(config: Config): Promise<void>;
+/**
+ * Remove the entire config file
+ */
+export declare function removeConfig(): Promise<void>;
+/**
+ * Get the config file path (for display/debugging)
+ */
+export declare function getConfigPath(): string;

package/dist/lib/config.js

@@ -0,0 +1,46 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+const CONFIG_DIR = join(homedir(), ".kontexted");
+const CONFIG_PATH = join(CONFIG_DIR, "profile.json");
+/**
+ * Read the configuration file from disk
+ */
+export async function readConfig() {
+    try {
+        const raw = await readFile(CONFIG_PATH, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+            return { profiles: {} };
+        }
+        return parsed.profiles ? { profiles: parsed.profiles } : { profiles: {} };
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return { profiles: {} };
+        }
+        throw error;
+    }
+}
+/**
+ * Write configuration to disk
+ */
+export async function writeConfig(config) {
+    await mkdir(dirname(CONFIG_PATH), { recursive: true });
+    await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+/**
+ * Remove the entire config file
+ */
+export async function removeConfig() {
+    await rm(CONFIG_PATH, { force: true });
+}
+/**
+ * Get the config file path (for display/debugging)
+ */
+export function getConfigPath() {
+    return CONFIG_PATH;
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,6 @@
+export * from './api-client.js';
+export * from './config.js';
+export * from './oauth.js';
+export * from './mcp-client.js';
+export * from './proxy-server.js';
+export * from './server/index.js';

package/dist/lib/index.js

@@ -0,0 +1,6 @@
+export * from './api-client.js';
+export * from './config.js';
+export * from './oauth.js';
+export * from './mcp-client.js';
+export * from './proxy-server.js';
+export * from './server/index.js';

package/dist/lib/logger.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Set whether logging is enabled
+ */
+export declare function setLogEnabled(enabled: boolean): void;
+/**
+ * Log an info message (file only)
+ */
+export declare function logInfo(message: string, data?: unknown): void;
+/**
+ * Log a debug message (file only)
+ */
+export declare function logDebug(message: string, data?: unknown): void;
+/**
+ * Log a warning message (file only)
+ */
+export declare function logWarn(message: string, data?: unknown): void;
+/**
+ * Log an error message (file only)
+ */
+export declare function logError(message: string, data?: unknown): void;
+/**
+ * Get the log file path
+ */
+export declare function getLogFilePath(): string;