@exreve/exk 1.0.17 → 1.0.19

package/dist/agentSession.js

@@ -4,7 +4,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from '
 import { symlink as fsSymlink } from 'fs';
 import { getSkillContent } from './skills/index.js';
 import { isLocalModel, unwrapModelName, startOpenAIAdapter, getAdapterConfig } from './openaiAdapter.js';
-import { createModuleMcpServer } from './moduleMcpServer.js';
+import { createModuleMcpServer, getModuleToolHint } from './moduleMcpServer.js';
 import path from 'path';
 import os from 'os';
 import { createRequire } from 'module';
@@ -134,10 +134,11 @@ function loadAiConfig() {
         const apiKey = typeof config.authToken === 'string' ? config.authToken.trim() : '';
         const baseUrl = typeof config.baseUrl === 'string' ? config.baseUrl.trim() : '';
         const model = typeof config.model === 'string' && config.model.trim() ? config.model.trim() : DEFAULT_AI_MODEL;
-        return { apiKey, baseUrl, model };
+        const proxy = typeof config.proxy === 'string' ? config.proxy.trim() : '';
+        return { apiKey, baseUrl, model, proxy };
     }
     catch {
-        return { apiKey: '', baseUrl: '', model: DEFAULT_AI_MODEL };
+        return { apiKey: '', baseUrl: '', model: DEFAULT_AI_MODEL, proxy: '' };
     }
 }
 /** Create (or reuse) an empty directory to use as CLAUDE_CONFIG_DIR.
@@ -151,6 +152,17 @@ function getEmptyConfigDir() {
     }
     return configDir;
 }
+const PROXY_CONFIG_PATH = path.join(os.homedir(), '.talk-to-code', 'proxy.json');
+/** Read proxy toggle state from disk (synchronous) */
+function readProxyToggle() {
+    try {
+        const data = readFileSync(PROXY_CONFIG_PATH, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return { enabled: false };
+    }
+}
 /** Env for the Claude Code child: copy of host env with host ANTHROPIC_* stripped, then inject from ai-config only.
  *  If a local model is provided, override baseUrl to point to the anthropic-proxy adapter. */
 function envForClaudeCodeChild(localModel) {
@@ -160,11 +172,24 @@ function envForClaudeCodeChild(localModel) {
     delete env.ANTHROPIC_BASE_URL;
     delete env.ANTHROPIC_AUTH_TOKEN;
     // Inject from our ai-config.json only
-    const { apiKey, baseUrl } = loadAiConfig();
+    const { apiKey, baseUrl, proxy } = loadAiConfig();
     if (apiKey)
         env.ANTHROPIC_API_KEY = apiKey;
     if (baseUrl)
         env.ANTHROPIC_BASE_URL = baseUrl;
+    // Apply proxy if enabled
+    const proxyToggle = readProxyToggle();
+    if (proxyToggle.enabled && proxy) {
+        env.HTTPS_PROXY = proxy;
+        env.HTTP_PROXY = proxy;
+    }
+    else {
+        // Clear any inherited proxy env
+        delete env.HTTPS_PROXY;
+        delete env.HTTP_PROXY;
+        delete env.https_proxy;
+        delete env.http_proxy;
+    }
     // Prevent ~/.claude/settings.json env section from overriding our base URL.
     // This redirects the Claude config dir to an empty dir so that
     // ~/.claude/settings.json (which may have ANTHROPIC_BASE_URL set to z.ai)
@@ -418,7 +443,14 @@ export class AgentSessionManager {
                     // Create a fresh MCP server for each query call (SDK connects transport internally, cannot reuse)
                     ...(() => {
                         const mcpServer = this.buildMcpServer(sessionId);
-                        return mcpServer ? { mcpServers: [mcpServer] } : {};
+                        if (mcpServer) {
+                            const toolHint = getModuleToolHint(session.enabledModules || []);
+                            return {
+                                mcpServers: [mcpServer],
+                                ...(toolHint ? { systemPrompt: toolHint } : {})
+                            };
+                        }
+                        return {};
                     })(),
                     ...(pathToClaudeCodeExecutable ? { pathToClaudeCodeExecutable } : {}),
                     spawnClaudeCodeProcess: (spawnOptions) => {

package/dist/index.js

@@ -66,6 +66,33 @@ async function fetchAiConfig(authToken) {
     }
 }
 const AI_CONFIG_FILE = path.join(CONFIG_DIR, 'ai-config.json');
+const PROXY_CONFIG_FILE = path.join(CONFIG_DIR, 'proxy.json');
+/** Read proxy toggle state from disk */
+async function readProxyConfig() {
+    try {
+        const raw = await fs.readFile(PROXY_CONFIG_FILE, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return { enabled: false };
+    }
+}
+/** Write proxy toggle state to disk */
+async function writeProxyConfig(cfg) {
+    await fs.mkdir(CONFIG_DIR, { recursive: true });
+    await fs.writeFile(PROXY_CONFIG_FILE, JSON.stringify(cfg, null, 2));
+}
+/** Get the proxy URL from ai-config.json (saved from backend) */
+function getProxyUrl() {
+    try {
+        const raw = fsSync.readFileSync(AI_CONFIG_FILE, 'utf-8');
+        const j = JSON.parse(raw);
+        return typeof j.proxy === 'string' ? j.proxy.trim() : '';
+    }
+    catch {
+        return '';
+    }
+}
 /** True if ai-config.json has a model API key (not read from host ANTHROPIC_* env). */
 function hasAiCredentials() {
     try {
@@ -1796,6 +1823,39 @@ async function runDaemon(foreground = false, email) {
                 });
             });
             // Cloudflared handlers
+            // Proxy toggle handler
+            socket.on('proxy:toggle:request', async (data, callback) => {
+                try {
+                    const { enable } = data;
+                    const proxyUrl = getProxyUrl();
+                    if (enable && !proxyUrl) {
+                        callback?.({ success: false, enabled: false });
+                        return;
+                    }
+                    await writeProxyConfig({ enabled: enable });
+                    if (foreground) {
+                        console.log(`[CLI] Proxy ${enable ? 'enabled' : 'disabled'}${proxyUrl ? `: ${proxyUrl}` : ''}`);
+                    }
+                    else {
+                        console.log(`Proxy ${enable ? 'enabled' : 'disabled'}`);
+                    }
+                    callback?.({ success: true, enabled: enable, proxyUrl: enable ? proxyUrl : undefined });
+                }
+                catch (error) {
+                    callback?.({ success: false, enabled: false });
+                }
+            });
+            // Proxy status handler
+            socket.on('proxy:status:request', async (_data, callback) => {
+                try {
+                    const proxyConfig = await readProxyConfig();
+                    const proxyUrl = getProxyUrl();
+                    callback?.({ enabled: proxyConfig.enabled, proxyUrl: proxyConfig.enabled ? proxyUrl : undefined });
+                }
+                catch {
+                    callback?.({ enabled: false });
+                }
+            });
             socket.on('cloudflared:check:request', async () => {
                 try {
                     let installed = false;
@@ -2779,4 +2839,37 @@ program
         process.exit(1);
     });
 });
+// Enable proxy command
+program
+    .command('enable')
+    .description('Enable a feature (e.g. proxy)')
+    .argument('<feature>', 'Feature to enable (proxy)')
+    .action(async (feature) => {
+    if (feature !== 'proxy') {
+        console.error(`Unknown feature: ${feature}. Available: proxy`);
+        process.exit(1);
+    }
+    const proxyUrl = getProxyUrl();
+    if (!proxyUrl) {
+        console.log('No proxy URL configured. Run "exk daemon" first to sync config from server.');
+        process.exit(1);
+    }
+    await writeProxyConfig({ enabled: true });
+    console.log(`Proxy enabled: ${proxyUrl}`);
+    process.exit(0);
+});
+// Disable proxy command
+program
+    .command('disable')
+    .description('Disable a feature (e.g. proxy)')
+    .argument('<feature>', 'Feature to disable (proxy)')
+    .action(async (feature) => {
+    if (feature !== 'proxy') {
+        console.error(`Unknown feature: ${feature}. Available: proxy`);
+        process.exit(1);
+    }
+    await writeProxyConfig({ enabled: false });
+    console.log('Proxy disabled');
+    process.exit(0);
+});
 program.parse();

package/dist/moduleMcpServer.js

@@ -91,3 +91,20 @@ export function createModuleMcpServer(config) {
     });
     return server;
 }
+/**
+ * Get a system prompt hint describing available module tools.
+ * This ensures the model knows about custom MCP tools upfront without
+ * having to discover them through the MCP tool-listing mechanism.
+ */
+export function getModuleToolHint(enabledModules) {
+    if (enabledModules.length === 0)
+        return null;
+    const toolDescriptions = [];
+    if (enabledModules.includes('user-choice')) {
+        toolDescriptions.push('- user_choice_request: Request user input when making decisions. Presents a modal to the user with options and waits for their response. Use this when you need the user to choose between options or confirm an action.');
+    }
+    // Add more module tool descriptions here as they are implemented
+    if (toolDescriptions.length === 0)
+        return null;
+    return `You have access to the following custom MCP tools:\n${toolDescriptions.join('\n')}\n\nUse these tools proactively when they are relevant to the task.`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exreve/exk",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "exk - Control Claude CLI with voice and programmable interfaces",
   "type": "module",
   "bin": {