pikiloom 0.4.15 → 0.4.16

package/dist/agent/mcp/extensions.js

@@ -17,6 +17,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { loadUserConfig, saveUserConfig } from '../../core/config/user-config.js';
+import { terminateProcessTree } from '../../core/process-control.js';
 import { getRecommendedMcpServers, } from './registry.js';
 import { hasValidMcpToken, injectOAuthHeaders } from './oauth.js';
 // ---------------------------------------------------------------------------
@@ -548,6 +549,7 @@ export async function checkMcpHealth(config, timeoutMs = 10_000) {
     return new Promise((resolve) => {
         const start = Date.now();
         let checkInterval = null;
+        let settled = false;
         const cleanup = () => {
             if (checkInterval) {
                 clearInterval(checkInterval);
@@ -555,20 +557,29 @@ export async function checkMcpHealth(config, timeoutMs = 10_000) {
             }
             clearTimeout(timer);
         };
+        const stopChildTree = () => {
+            terminateProcessTree(child, { signal: 'SIGTERM', forceSignal: 'SIGKILL', forceAfterMs: 1500 });
+        };
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(result);
+        };
         const child = spawn(config.command, config.args || [], {
             stdio: ['pipe', 'pipe', 'pipe'],
             env: { ...process.env, ...config.env },
+            detached: process.platform !== 'win32',
         });
         const timer = setTimeout(() => {
-            cleanup();
-            child.kill();
-            resolve({ ok: false, error: `timeout after ${timeoutMs}ms`, elapsedMs: Date.now() - start });
+            stopChildTree();
+            finish({ ok: false, error: `timeout after ${timeoutMs}ms`, elapsedMs: Date.now() - start });
         }, timeoutMs);
         let stdout = '';
         child.stdout?.on('data', (data) => { stdout += data.toString(); });
         child.on('error', (err) => {
-            cleanup();
-            resolve({ ok: false, error: err.message, elapsedMs: Date.now() - start });
+            finish({ ok: false, error: err.message, elapsedMs: Date.now() - start });
         });
         const initRequest = JSON.stringify({
             jsonrpc: '2.0',
@@ -585,8 +596,8 @@ export async function checkMcpHealth(config, timeoutMs = 10_000) {
             child.stdin?.write(header + initRequest);
         }
         catch {
-            cleanup();
-            resolve({ ok: false, error: 'failed to write to stdin', elapsedMs: Date.now() - start });
+            stopChildTree();
+            finish({ ok: false, error: 'failed to write to stdin', elapsedMs: Date.now() - start });
             return;
         }
         checkInterval = setInterval(() => {
@@ -606,7 +617,7 @@ export async function checkMcpHealth(config, timeoutMs = 10_000) {
             }
             catch { /* best-effort */ }
             setTimeout(() => {
-                child.kill();
+                stopChildTree();
                 const tools = [];
                 try {
                     const jsonMatches = stdout.match(/\{[^{}]*"tools"\s*:\s*\[[\s\S]*?\]\s*[^{}]*\}/g);
@@ -630,7 +641,7 @@ export async function checkMcpHealth(config, timeoutMs = 10_000) {
                     }
                 }
                 catch { /* best effort */ }
-                resolve({ ok: true, tools: tools.length ? tools : undefined, elapsedMs: Date.now() - start });
+                finish({ ok: true, tools: tools.length ? tools : undefined, elapsedMs: Date.now() - start });
             }, 1500);
         }, 100);
     });

package/dist/agent/stream.js

@@ -473,7 +473,7 @@ export async function doStream(opts) {
     // Start MCP bridge for IM tools (when sendFile is available) and/or supplemental servers (browser, etc.)
     let bridge = null;
     try {
-        const { startMcpBridge } = await import('./mcp/bridge.js');
+        const { startMcpBridge, redactMcpConfigForLog } = await import('./mcp/bridge.js');
         const sessionDir = path.dirname(session.workspacePath);
         bridge = await startMcpBridge({
             sessionDir,
@@ -498,7 +498,8 @@ export async function doStream(opts) {
             else
                 agentLog('[mcp] bridge registered with codex');
             try {
-                agentLog(`[mcp] config content:\n${fs.readFileSync(bridge.configPath, 'utf-8')}`);
+                if (bridge.configPath)
+                    agentLog(`[mcp] config content:\n${redactMcpConfigForLog(bridge.configPath)}`);
             }
             catch { }
             ;

package/dist/dashboard/routes/config.js

@@ -6,8 +6,9 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { spawn, spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
 import { loadUserConfig, saveUserConfig, applyUserConfig, hasUserConfigFile } from '../../core/config/user-config.js';
-import { expandTilde } from '../../core/platform.js';
+import { expandTilde, whichSync } from '../../core/platform.js';
 import { readGitStatus } from '../../core/git.js';
 import { isSetupReady } from '../../cli/onboarding.js';
 import { validateDingtalkConfig, validateDiscordConfig, validateFeishuConfig, validateSlackConfig, validateTelegramConfig, validateWecomConfig, validateWeixinConfig, } from '../../core/config/validation.js';
@@ -66,7 +67,96 @@ function runOpenCommand(command, args) {
         throw new Error(detail || `Failed to run ${command} ${args.join(' ')}`);
     }
 }
-function openPathWithTarget(filePath, target, isDirectory) {
+function stripOpenPathWrapping(value) {
+    let text = value.trim();
+    const pairs = [['`', '`'], ['"', '"'], ["'", "'"], ['<', '>']];
+    let changed = true;
+    while (changed && text.length >= 2) {
+        changed = false;
+        for (const [left, right] of pairs) {
+            if (text.startsWith(left) && text.endsWith(right)) {
+                text = text.slice(left.length, -right.length).trim();
+                changed = true;
+            }
+        }
+    }
+    return text;
+}
+function decodeOpenPathInput(raw) {
+    const text = stripOpenPathWrapping(raw);
+    if (text.startsWith('file://')) {
+        try {
+            return fileURLToPath(text);
+        }
+        catch {
+            return decodeURI(text.slice('file://'.length));
+        }
+    }
+    if (text.startsWith('vscode://file/')) {
+        return decodeURI(`/${text.slice('vscode://file/'.length)}`);
+    }
+    return text;
+}
+function resolveOpenBasePath(basePath) {
+    const base = typeof basePath === 'string' && basePath.trim()
+        ? basePath.trim()
+        : runtime.getRuntimeWorkdir(loadUserConfig());
+    return path.resolve(expandTilde(base || process.cwd()));
+}
+function splitExistingLineSuffix(candidate) {
+    const normalized = path.normalize(candidate);
+    if (fs.existsSync(normalized))
+        return { filePath: normalized, line: null, column: null };
+    const match = /^(.*?)(?::(\d+)(?::(\d+))?)$/.exec(normalized);
+    if (!match || !match[1])
+        return { filePath: normalized, line: null, column: null };
+    const filePath = path.normalize(match[1]);
+    if (!fs.existsSync(filePath))
+        return { filePath: normalized, line: null, column: null };
+    return {
+        filePath,
+        line: Number(match[2]),
+        column: match[3] ? Number(match[3]) : null,
+    };
+}
+export function resolveOpenPathLocator(rawPath, basePath) {
+    const decoded = decodeOpenPathInput(rawPath);
+    const expanded = expandTilde(decoded);
+    const absolute = path.isAbsolute(expanded)
+        ? path.resolve(expanded)
+        : path.resolve(resolveOpenBasePath(basePath), expanded);
+    return splitExistingLineSuffix(absolute);
+}
+function editorGotoArg(filePath, location) {
+    if (!location?.line)
+        return null;
+    return `${filePath}:${location.line}${location.column ? `:${location.column}` : ''}`;
+}
+function tryOpenCommand(command, args) {
+    if (!whichSync(command))
+        return false;
+    try {
+        runOpenCommand(command, args);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function tryOpenVSCodeUrl(filePath, location) {
+    if (!location?.line)
+        return false;
+    const suffix = `:${location.line}${location.column ? `:${location.column}` : ''}`;
+    try {
+        runOpenCommand('open', [`vscode://file${encodeURI(filePath)}${suffix}`]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function openPathWithTarget(filePath, target, isDirectory, location) {
+    const gotoArg = isDirectory ? null : editorGotoArg(filePath, location);
     if (process.platform === 'darwin') {
         switch (target) {
             case 'finder':
@@ -76,13 +166,21 @@ function openPathWithTarget(filePath, target, isDirectory) {
                 runOpenCommand('open', [filePath]);
                 return;
             case 'cursor':
+                if (gotoArg && tryOpenCommand('cursor', ['-g', gotoArg]))
+                    return;
                 runOpenCommand('open', ['-a', 'Cursor', filePath]);
                 return;
             case 'windsurf':
+                if (gotoArg && tryOpenCommand('windsurf', ['-g', gotoArg]))
+                    return;
                 runOpenCommand('open', ['-a', 'Windsurf', filePath]);
                 return;
             case 'vscode':
             default:
+                if (gotoArg && tryOpenCommand('code', ['-g', gotoArg]))
+                    return;
+                if (gotoArg && tryOpenVSCodeUrl(filePath, location))
+                    return;
                 runOpenCommand('open', ['-a', 'Visual Studio Code', filePath]);
                 return;
         }
@@ -90,10 +188,16 @@ function openPathWithTarget(filePath, target, isDirectory) {
     if (process.platform === 'win32') {
         switch (target) {
             case 'cursor':
-                runOpenCommand('cursor', [filePath]);
+                if (gotoArg)
+                    runOpenCommand('cursor', ['-g', gotoArg]);
+                else
+                    runOpenCommand('cursor', [filePath]);
                 return;
             case 'windsurf':
-                runOpenCommand('windsurf', [filePath]);
+                if (gotoArg)
+                    runOpenCommand('windsurf', ['-g', gotoArg]);
+                else
+                    runOpenCommand('windsurf', [filePath]);
                 return;
             case 'finder':
             case 'default':
@@ -101,16 +205,25 @@ function openPathWithTarget(filePath, target, isDirectory) {
                 return;
             case 'vscode':
             default:
-                runOpenCommand('code', [filePath]);
+                if (gotoArg)
+                    runOpenCommand('code', ['-g', gotoArg]);
+                else
+                    runOpenCommand('code', [filePath]);
                 return;
         }
     }
     switch (target) {
         case 'cursor':
-            runOpenCommand('cursor', [filePath]);
+            if (gotoArg)
+                runOpenCommand('cursor', ['-g', gotoArg]);
+            else
+                runOpenCommand('cursor', [filePath]);
             return;
         case 'windsurf':
-            runOpenCommand('windsurf', [filePath]);
+            if (gotoArg)
+                runOpenCommand('windsurf', ['-g', gotoArg]);
+            else
+                runOpenCommand('windsurf', [filePath]);
             return;
         case 'finder':
         case 'default':
@@ -118,7 +231,10 @@ function openPathWithTarget(filePath, target, isDirectory) {
             return;
         case 'vscode':
         default:
-            runOpenCommand('code', [filePath]);
+            if (gotoArg)
+                runOpenCommand('code', ['-g', gotoArg]);
+            else
+                runOpenCommand('code', [filePath]);
             return;
     }
 }
@@ -453,14 +569,20 @@ app.post('/api/open-in-editor', async (c) => {
     try {
         const body = await c.req.json();
         const filePath = typeof body?.filePath === 'string' ? body.filePath.trim() : '';
+        const basePath = typeof body?.basePath === 'string' && body.basePath.trim()
+            ? body.basePath.trim()
+            : typeof body?.workdir === 'string' && body.workdir.trim()
+                ? body.workdir.trim()
+                : null;
         const target = isOpenTarget(body?.target) ? body.target : 'vscode';
         if (!filePath)
             return c.json({ ok: false, error: 'filePath is required' }, 400);
-        if (!fs.existsSync(filePath))
+        const resolved = resolveOpenPathLocator(filePath, basePath);
+        if (!fs.existsSync(resolved.filePath))
             return c.json({ ok: false, error: 'Path not found' }, 404);
-        const stat = fs.statSync(filePath);
-        openPathWithTarget(filePath, target, stat.isDirectory());
-        return c.json({ ok: true });
+        const stat = fs.statSync(resolved.filePath);
+        openPathWithTarget(resolved.filePath, target, stat.isDirectory(), resolved);
+        return c.json({ ok: true, filePath: resolved.filePath, line: resolved.line, column: resolved.column });
     }
     catch (err) {
         const detail = err instanceof Error ? err.message : String(err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiloom",
-  "version": "0.4.15",
+  "version": "0.4.16",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {