@exreve/exk 1.0.22 → 1.0.24

package/dist/agentSession.js

@@ -427,11 +427,15 @@ export class AgentSessionManager {
                         const mcpServer = this.buildMcpServer(sessionId);
                         if (mcpServer) {
                             const toolHint = getModuleToolHint(session.enabledModules || []);
+                            console.log(`[agentSession] MCP server created: name=${mcpServer.name}, hasHint=${!!toolHint}`);
+                            console.log(`[agentSession] MCP server keys:`, Object.keys(mcpServer));
+                            console.log(`[agentSession] MCP server type:`, mcpServer.type);
                             return {
-                                mcpServers: [mcpServer],
-                                ...(toolHint ? { systemPrompt: toolHint } : {})
+                                mcpServers: { [mcpServer.name]: mcpServer },
+                                ...(toolHint ? { systemPrompt: { type: 'preset', preset: 'claude_code', append: toolHint } } : {})
                             };
                         }
+                        console.log(`[agentSession] No MCP server created (enabledModules=${JSON.stringify(session.enabledModules)})`);
                         return {};
                     })(),
                     ...(pathToClaudeCodeExecutable ? { pathToClaudeCodeExecutable } : {}),

package/dist/index.js

@@ -202,8 +202,19 @@ function getCliVersion() {
 }
 const CURRENT_FILE = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(CURRENT_FILE);
+let cachedCliHash = null;
 function getCliHash() {
-    return createHash('sha256').update(fsSync.readFileSync(CURRENT_FILE)).digest('hex');
+    if (cachedCliHash)
+        return cachedCliHash;
+    try {
+        const hash = createHash('sha256').update(fsSync.readFileSync(CURRENT_FILE)).digest('hex');
+        cachedCliHash = hash;
+        return hash;
+    }
+    catch {
+        // File may be temporarily missing during update — return safe fallback
+        return 'updating';
+    }
 }
 async function checkForUpdate() {
     try {
@@ -221,48 +232,108 @@ async function checkForUpdate() {
         return null;
     }
 }
+let isUpdating = false;
 async function replaceSelf(tarballBuffer) {
+    isUpdating = true;
     const extractDir = path.join(os.tmpdir(), `ttc-update-${Date.now()}`);
-    await fs.mkdir(extractDir, { recursive: true });
-    const tarPath = path.join(extractDir, 'ttc-cli.tar.gz');
-    await fs.writeFile(tarPath, tarballBuffer);
-    execSync(`tar -xzf "${tarPath}" -C "${extractDir}"`);
-    await fs.unlink(tarPath);
-    // Preserve user config/token files (never overwrite on update)
-    const preserveFiles = ['device-config.json', 'device-id.json', 'config.json'];
-    const preserved = {};
-    for (const f of preserveFiles) {
+    const stagingDir = path.join(os.tmpdir(), `ttc-stage-${Date.now()}`);
+    try {
+        await fs.mkdir(extractDir, { recursive: true });
+        const tarPath = path.join(extractDir, 'ttc-cli.tar.gz');
+        await fs.writeFile(tarPath, tarballBuffer);
+        execSync(`tar -xzf "${tarPath}" -C "${extractDir}"`);
+        await fs.unlink(tarPath);
+        // Preserve user config/token files (never overwrite on update)
+        const preserveFiles = ['device-config.json', 'device-id.json', 'config.json'];
+        const preserved = {};
+        for (const f of preserveFiles) {
+            try {
+                preserved[f] = await fs.readFile(path.join(CONFIG_DIR, f));
+            }
+            catch {
+                /* file may not exist */
+            }
+        }
+        // Build the complete new state in a staging directory first.
+        // This ensures we never delete the running app until the replacement is
+        // fully prepared and verified — no window where files are missing.
+        const cliStaging = path.join(stagingDir, 'cli');
+        const sharedStaging = path.join(stagingDir, 'shared');
+        await fs.cp(path.join(extractDir, 'cli'), cliStaging, { recursive: true });
+        await fs.cp(path.join(extractDir, 'shared'), sharedStaging, { recursive: true });
+        await fs.copyFile(path.join(extractDir, 'package.json'), path.join(stagingDir, 'package.json'));
+        // Restore preserved config into staging
+        for (const f of preserveFiles) {
+            if (preserved[f])
+                await fs.writeFile(path.join(stagingDir, f), preserved[f]);
+        }
+        // Sanity check: staging must contain a valid dist/index.js
+        const indexJs = path.join(cliStaging, 'dist', 'index.js');
+        try {
+            const stat = await fs.stat(indexJs);
+            if (stat.size === 0)
+                throw new Error('Empty index.js');
+        }
+        catch (err) {
+            throw new Error(`Staged update is invalid (missing or empty dist/index.js): ${err.message}`);
+        }
+        // Atomic swap: rename staging dirs to final locations.
+        // rename() is atomic on the same filesystem. We move the old dirs out of
+        // the way first, then rename new ones in. If anything fails mid-swap we
+        // can attempt to roll back.
+        const cliDest = path.join(CONFIG_DIR, 'cli');
+        const sharedDest = path.join(CONFIG_DIR, 'shared');
+        const cliOld = cliDest + '.old';
+        const sharedOld = sharedDest + '.old';
+        // Move current dirs to .old (must exist for this to work)
+        await fs.rm(cliOld, { recursive: true, force: true });
+        await fs.rm(sharedOld, { recursive: true, force: true });
+        if (fsSync.existsSync(cliDest)) {
+            await fs.rename(cliDest, cliOld);
+        }
+        if (fsSync.existsSync(sharedDest)) {
+            await fs.rename(sharedDest, sharedOld);
+        }
+        // Move staged dirs into place
         try {
-            preserved[f] = await fs.readFile(path.join(CONFIG_DIR, f));
+            await fs.rename(cliStaging, cliDest);
+            await fs.rename(sharedStaging, sharedDest);
+            await fs.copyFile(path.join(stagingDir, 'package.json'), path.join(CONFIG_DIR, 'package.json'));
+        }
+        catch (swapErr) {
+            // Rollback: restore old dirs
+            console.error(`⚠ Swap failed: ${swapErr.message}, rolling back...`);
+            try {
+                if (fsSync.existsSync(cliOld))
+                    await fs.rename(cliOld, cliDest);
+                if (fsSync.existsSync(sharedOld))
+                    await fs.rename(sharedOld, sharedDest);
+            }
+            catch (rollbackErr) {
+                console.error(`⚠ Rollback also failed: ${rollbackErr.message}`);
+            }
+            throw swapErr;
+        }
+        // Clean up old dirs and temp dirs
+        await fs.rm(cliOld, { recursive: true, force: true }).catch(() => { });
+        await fs.rm(sharedOld, { recursive: true, force: true }).catch(() => { });
+        await fs.rm(extractDir, { recursive: true, force: true });
+        await fs.rm(stagingDir, { recursive: true, force: true }).catch(() => { });
+        // Invalidate cached hash since we just replaced the binary
+        cachedCliHash = null;
+        console.log('✓ CLI updated');
+        const npmPaths = [path.join(os.homedir(), '.nvm/versions/node/v22/bin/npm'), path.join(os.homedir(), '.nvm/versions/node/v20/bin/npm')];
+        const npmBin = npmPaths.find(p => fsSync.existsSync(p)) || 'npm';
+        try {
+            execSync(`"${npmBin}" install --omit=dev`, { cwd: CONFIG_DIR, stdio: 'inherit' });
+            console.log('✓ Dependencies updated');
         }
         catch {
-            /* file may not exist */
+            console.warn('⚠ npm install failed');
         }
     }
-    // Replace cli/ and shared/ in CONFIG_DIR
-    const cliDest = path.join(CONFIG_DIR, 'cli');
-    const sharedDest = path.join(CONFIG_DIR, 'shared');
-    await fs.rm(cliDest, { recursive: true, force: true });
-    await fs.rm(sharedDest, { recursive: true, force: true });
-    await fs.cp(path.join(extractDir, 'cli'), cliDest, { recursive: true });
-    await fs.cp(path.join(extractDir, 'shared'), sharedDest, { recursive: true });
-    // Update package.json and npm install
-    await fs.copyFile(path.join(extractDir, 'package.json'), path.join(CONFIG_DIR, 'package.json'));
-    await fs.rm(extractDir, { recursive: true, force: true });
-    // Restore preserved config
-    for (const f of preserveFiles) {
-        if (preserved[f])
-            await fs.writeFile(path.join(CONFIG_DIR, f), preserved[f]);
-    }
-    console.log('✓ CLI updated');
-    const npmPaths = [path.join(os.homedir(), '.nvm/versions/node/v22/bin/npm'), path.join(os.homedir(), '.nvm/versions/node/v20/bin/npm')];
-    const npmBin = npmPaths.find(p => fsSync.existsSync(p)) || 'npm';
-    try {
-        execSync(`"${npmBin}" install --omit=dev`, { cwd: CONFIG_DIR, stdio: 'inherit' });
-        console.log('✓ Dependencies updated');
-    }
-    catch {
-        console.warn('⚠ npm install failed');
+    finally {
+        isUpdating = false;
     }
 }
 async function selfUpdate(force = false) {
@@ -1716,6 +1787,10 @@ async function runDaemon(foreground = false, email) {
             // ========== Version & Update Handlers ==========
             // Respond with CLI version info
             socket.on('version:info', (_data, callback) => {
+                if (isUpdating) {
+                    callback({ success: false, error: 'Update in progress' });
+                    return;
+                }
                 callback({
                     success: true,
                     version: getCliVersion(),
@@ -1728,6 +1803,10 @@ async function runDaemon(foreground = false, email) {
             });
             // Force update: npm update -g @exreve/exk then restart PM2
             socket.on('force-update', (_data, callback) => {
+                if (isUpdating) {
+                    callback?.({ success: false, error: 'Update already in progress' });
+                    return;
+                }
                 if (foreground) {
                     console.log('[force-update] Received force update command from server');
                 }
@@ -1770,6 +1849,10 @@ async function runDaemon(foreground = false, email) {
             });
             // ========== update:start handler (legacy compatibility) ==========
             socket.on('update:start', (_data, callback) => {
+                if (isUpdating) {
+                    callback?.({ success: false, error: 'Update already in progress' });
+                    return;
+                }
                 // Use npm-based self-update
                 if (foreground) {
                     console.log('[update:start] Starting npm self-update...');

package/dist/moduleMcpServer.js

@@ -15,7 +15,7 @@ function createUserChoiceTool(onChoiceRequest) {
         options: z.array(z.object({ label: z.string(), value: z.string() })),
         timeout: z.number().optional()
     };
-    return tool('user_choice_request', 'Request user input when making decisions. Use this when you need the user to choose between options or provide input on a decision. This tool will present a modal to the user with your question and wait for their response.', schema, async (args, _extra) => {
+    return tool('user_choice_request', 'Present a choice modal to the user and wait for their selection. Use this whenever you need a decision, confirmation, or preference from the user. The AskUserQuestion tool is disabled — this is your only way to get interactive user input. Always use this before proceeding with ambiguous tasks or destructive actions.', schema, async (args, _extra) => {
         if (!onChoiceRequest) {
             return {
                 content: [
@@ -101,10 +101,15 @@ export function getModuleToolHint(enabledModules) {
         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.');
+        toolDescriptions.push(`- user_choice_request(question: str, options: [{label: str, value: str}], timeout?: int): Present a modal to the remote user with a question and clickable options. Returns the user's selection.
+  IMPORTANT: The built-in AskUserQuestion tool is DISABLED. Whenever you need user input, decisions, or confirmations, you MUST use user_choice_request instead.
+  Always call this tool when:
+  - There are multiple valid approaches and you need the user to pick one
+  - You need explicit confirmation before a destructive or significant action
+  - The user's preference matters for how to proceed`);
     }
     // 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.`;
+    return `You have access to the following custom MCP tools:\n${toolDescriptions.join('\n')}\n\nThese tools are your ONLY way to interact with the user (AskUserQuestion is disabled). Call them directly — do NOT ask the user to type responses in chat.`;
 }

package/package.json

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