hsh19900502 1.0.24 → 2.0.1

package/CLAUDE.md

@@ -68,7 +68,7 @@ The CLI follows a modular command structure using Commander.js:
 - **ESM modules**: Uses ES module imports/exports throughout
 - **Async/await**: All shell operations are async with proper error handling
 - **Interactive CLI**: Extensive use of inquirer prompts with autocomplete
-- **Configuration-based**: IDE command uses `~/hsh.config.json` for project paths
+- **Configuration-based**: IDE command uses `~/.hsh/config.json` for project paths
 - **Monorepo aware**: Special handling for multi-repository workflows
 - **TypeScript strict mode**: Full type safety with comprehensive type checking
 
@@ -103,7 +103,7 @@ The CLI follows a modular command structure using Commander.js:
 
 ### IDE Configuration
 
-The `cursor` and `claude` commands require a configuration file at `~/hsh.config.json`:
+The `cursor` and `claude` commands require a configuration file at `~/.hsh/config.json`:
 
 ```json
 {

package/PRD.md

@@ -0,0 +1,147 @@
+# PRD: Window Management Command (`hsh window`)
+
+## Overview
+
+A macOS window and space management command that enables fast navigation across all open windows and virtual desktops (Spaces) using fuzzy search. Built on top of Hammerspoon for native macOS window control.
+
+## Problem Statement
+
+Navigating between windows and Spaces on macOS is cumbersome:
+- Mission Control requires mouse interaction or memorizing space positions
+- Cmd+Tab only cycles through apps, not individual windows
+- Finding a specific window among dozens requires visual scanning
+
+**Goal**: Enable instant window switching via fuzzy search from the terminal.
+
+## Terminology
+
+| Term | Definition |
+|------|------------|
+| **Space** | A macOS virtual desktop (also called "Desktop" in Mission Control). Each Space is an independent workspace that can contain multiple windows. Users can have multiple Spaces and switch between them. |
+| **Window** | An individual application window within a Space. One app can have multiple windows, potentially across different Spaces. Each window has a title (e.g., the filename in Cursor, the page title in Chrome). |
+| **Focus** | Making a window the active/selected window that receives keyboard input. |
+| **Raise** | Bringing a window to the front of the window stack so it's fully visible (not obscured by other windows). |
+| **Fullscreen Space** | A special Space type where a single app occupies the entire screen (entered via the green maximize button or Ctrl+Cmd+F). |
+
+## User Stories
+
+1. **As a developer**, I want to quickly jump to a specific Cursor window by searching its project name, so I can context-switch efficiently between projects.
+2. **As a power user**, I want to see all my windows/spaces in a searchable list, so I can find and focus any window without leaving the keyboard.
+
+## Feature Specification
+
+### Command: `hsh window search`
+
+Interactive fuzzy search across all macOS windows and Spaces.
+
+#### Behavior
+
+1. **List all spaces**: Query Hammerspoon for all Spaces across all screens (including fullscreen spaces without accessible windows)
+2. **Display format**: Show searchable list with:
+   - Space name (from Mission Control, e.g., "Desktop 1", "LLM", or app name for fullscreen)
+   - Space type (`[Desktop]` or `[Fullscreen]`)
+   - Main window info if available (app name and title, truncated if needed)
+3. **Fuzzy search**: Filter spaces as user types using inquirer autocomplete
+4. **Jump action**: Switch to the selected Space and focus its main window (if available)
+
+#### Example Output
+
+```
+? Select space/window to focus: (Use arrow keys or type to search)
+❯ Desktop 1 [Desktop] - Slack: awx-i18n-service (Channel)...
+  Desktop 2 [Desktop]
+  Cursor [Fullscreen] - Cursor: space_manager.sh — macos-manager
+  iTerm2 [Fullscreen]
+  LLM [Fullscreen]
+  Google Chrome [Fullscreen]
+  index.tsx — saas-pricing-webapp [Fullscreen]
+```
+
+> **Note**: Fullscreen spaces without accessible windows (e.g., "iTerm2", "LLM") are still listed and can be jumped to. The space name is preserved from Mission Control even if the original window was closed.
+
+#### Technical Requirements
+
+| Requirement | Details |
+|-------------|---------|
+| **Dependency** | Hammerspoon must be installed and running |
+| **API** | Uses `hs` CLI to execute Lua commands |
+| **Performance** | Window list retrieval should complete in <500ms |
+| **Error handling** | Graceful fallback if Hammerspoon unavailable |
+
+### Future Subcommands (Out of Scope for v1)
+
+| Command | Description |
+|---------|-------------|
+| `hsh window list` | List all windows/spaces without interactive search |
+| `hsh window goto <n>` | Jump directly to Space number n |
+| `hsh window close <keyword>` | Close windows matching keyword |
+
+## Technical Design
+
+### Architecture
+
+```
+src/commands/window.ts
+├── searchWindows()           # Main interactive search flow
+├── getAllSpacesAndWindows()  # Query all spaces and their main windows
+├── focusWindow()             # Switch to Space and focus window (if available)
+└── types                     # SpaceWindowInfo interface
+```
+
+### Data Structure
+
+```typescript
+interface SpaceWindowInfo {
+  spaceId: number;
+  spaceName: string;        // "Desktop 1", "LLM", or custom name from Mission Control
+  spaceType: 'user' | 'fullscreen';
+  spaceIndex: number;
+  screenIndex: number;
+  // Window info (may be empty for spaces without accessible windows)
+  appName: string;
+  windowTitle: string;
+  windowId: number | null;
+}
+```
+
+### Hammerspoon Integration
+
+Execute Lua scripts via `hs -c "<script>"` to:
+1. Query `hs.spaces.allSpaces()` for all spaces across all screens
+2. Query `hs.spaces.missionControlSpaceNames()` for space names
+3. Query `hs.window.allWindows()` and map to spaces via `spaces.windowSpaces()`
+4. Use `spaces.gotoSpace()` and `win:focus()` for navigation
+
+> **Design Note**: Follows the same logic as `space_manager.sh list_spaces()` to ensure consistent behavior.
+
+## Success Metrics
+
+- **Adoption**: Used 10+ times per day by active users
+- **Speed**: Average search-to-focus time under 2 seconds
+- **Reliability**: <1% failure rate on supported macOS versions
+
+## Dependencies
+
+| Dependency | Purpose | Installation |
+|------------|---------|--------------|
+| [Hammerspoon](https://www.hammerspoon.org/) | macOS automation API | `brew install hammerspoon` |
+| inquirer-autocomplete-prompt | Fuzzy search UI | Already in project |
+
+## Rollout Plan
+
+1. **Phase 1**: ✅ Implement `hsh window search` with basic functionality
+2. **Phase 2**: Add caching for faster subsequent queries
+3. **Phase 3**: Consider additional subcommands based on usage patterns
+
+## Open Questions (Resolved)
+
+- [x] Should we support filtering by app name only? (e.g., `hsh window search --app cursor`)
+  → No need, keyword fuzzy search is more generalized
+- [x] Should window focus also raise the window to front if partially obscured?
+  → Yes, always raise — `win:focus()` handles both focus and raise. For spaces without accessible windows, just switch to the space.
+- [x] Consider keyboard shortcut integration via Hammerspoon for even faster access?
+  → No need for v1
+
+---
+
+*Last updated: January 2026*

package/README.md

@@ -116,7 +116,7 @@ Projects updated:
 
 ### IDE Configuration
 
-Create `~/hsh.config.json` for IDE project management:
+Create `~/.hsh/config.json` for IDE project management:
 
 ```json
 {
@@ -164,3 +164,4 @@ yarn dev
 ## License
 
 MIT
+

package/dist/commands/claude.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Hook handler for UserPromptSubmit event
+ * Tracks task start time and git branch
+ */
+export declare function handleUserPromptSubmit(): Promise<void>;
+/**
+ * Hook handler for Stop event
+ * Calculates duration, sends notification for long tasks, marks for review
+ */
+export declare function handleStop(): Promise<void>;
+/**
+ * Interactive command to review completed long tasks
+ */
+export declare function reviewTasks(): Promise<void>;

package/dist/commands/claude.js

@@ -0,0 +1,267 @@
+import { $ } from 'zx';
+import { promises as fs } from 'fs';
+import { homedir } from 'os';
+import path from 'path';
+import inquirer from 'inquirer';
+import autocomplete from 'inquirer-autocomplete-prompt';
+import chalk from 'chalk';
+// Register autocomplete prompt
+inquirer.registerPrompt('autocomplete', autocomplete);
+const TASK_REGISTRY_PATH = path.join(homedir(), '.hsh', 'task-registry.json');
+const CONFIG_PATH = path.join(homedir(), '.hsh', 'config.json');
+const LONG_TASK_THRESHOLD_MS = 10 * 60 * 1000; // 10 minutes in milliseconds
+/**
+ * Load task registry from disk
+ */
+async function loadTaskRegistry() {
+    try {
+        const data = await fs.readFile(TASK_REGISTRY_PATH, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        // File doesn't exist or is invalid, return empty registry
+        return {};
+    }
+}
+/**
+ * Save task registry to disk
+ */
+async function saveTaskRegistry(registry) {
+    const dir = path.dirname(TASK_REGISTRY_PATH);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(TASK_REGISTRY_PATH, JSON.stringify(registry, null, 2), 'utf-8');
+}
+/**
+ * Get current git branch name
+ */
+async function getCurrentBranch() {
+    try {
+        const result = await $ `git rev-parse --abbrev-ref HEAD`;
+        return result.stdout.trim();
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/**
+ * Format duration in milliseconds to human-readable string
+ */
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) {
+        return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    }
+    else if (minutes > 0) {
+        return `${minutes}m ${seconds % 60}s`;
+    }
+    else {
+        return `${seconds}s`;
+    }
+}
+/**
+ * Format time ago (e.g., "2h 34m ago")
+ */
+function formatTimeAgo(timestamp) {
+    const ms = Date.now() - timestamp;
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0) {
+        return `${days}d ${hours % 24}h ago`;
+    }
+    else if (hours > 0) {
+        return `${hours}h ${minutes % 60}m ago`;
+    }
+    else if (minutes > 0) {
+        return `${minutes}m ago`;
+    }
+    else {
+        return `${seconds}s ago`;
+    }
+}
+/**
+ * Get WeChat webhook URL from environment variable or config file
+ */
+async function getWeChatWebhookUrl() {
+    // First try environment variable
+    const envUrl = process.env.WECHAT_WEBHOOK_URL;
+    if (envUrl) {
+        return envUrl;
+    }
+    // Then try config file
+    try {
+        const configData = await fs.readFile(CONFIG_PATH, 'utf-8');
+        const config = JSON.parse(configData);
+        return config.wechatWebhookUrl || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Send WeChat notification
+ */
+async function sendWeChatNotification(task) {
+    const webhookUrl = await getWeChatWebhookUrl();
+    if (!webhookUrl) {
+        console.error(chalk.yellow('⚠️  WeChat webhook URL not configured. Set WECHAT_WEBHOOK_URL env var or add wechatWebhookUrl to ~/.hsh/config.json'));
+        return;
+    }
+    const now = new Date().toLocaleString('zh-CN', {
+        timeZone: 'Asia/Shanghai',
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false,
+    });
+    const who = `${process.env.USER || 'unknown'}@${process.env.HOSTNAME || 'unknown'}`;
+    const durationStr = task.duration ? formatDuration(task.duration) : 'unknown';
+    const message = `Claude Code 任务完成 ✅
+项目路径: ${task.projectPath} (${task.branch})
+任务时长: ${durationStr}
+时间: ${now} +0800
+执行者: ${who}`;
+    const payload = {
+        msgtype: 'text',
+        text: {
+            content: message,
+        },
+    };
+    try {
+        const response = await fetch(webhookUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(payload),
+        });
+        const result = await response.json();
+        if (result.errcode !== 0) {
+            console.error(chalk.red(`WeChat webhook error: ${result.errmsg}`));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Failed to send WeChat notification: ${error}`));
+    }
+}
+/**
+ * Hook handler for UserPromptSubmit event
+ * Tracks task start time and git branch
+ */
+export async function handleUserPromptSubmit() {
+    const projectPath = process.cwd();
+    const branch = await getCurrentBranch();
+    const startTime = Date.now();
+    const registry = await loadTaskRegistry();
+    registry[projectPath] = {
+        projectPath,
+        branch,
+        startTime,
+    };
+    await saveTaskRegistry(registry);
+    // Silent operation - no console output
+}
+/**
+ * Hook handler for Stop event
+ * Calculates duration, sends notification for long tasks, marks for review
+ */
+export async function handleStop() {
+    const projectPath = process.cwd();
+    const registry = await loadTaskRegistry();
+    const task = registry[projectPath];
+    if (!task) {
+        // No task record found, nothing to do
+        return;
+    }
+    const endTime = Date.now();
+    const duration = endTime - task.startTime;
+    task.endTime = endTime;
+    task.duration = duration;
+    if (duration > LONG_TASK_THRESHOLD_MS) {
+        // Long task - send notification and mark for review
+        await sendWeChatNotification(task);
+        task.notified = true;
+        task.needsReview = true;
+        await saveTaskRegistry(registry);
+    }
+    else {
+        // Short task - remove from registry (immediate cleanup)
+        delete registry[projectPath];
+        await saveTaskRegistry(registry);
+    }
+    // Silent operation - no console output
+}
+/**
+ * Interactive command to review completed long tasks
+ */
+export async function reviewTasks() {
+    const registry = await loadTaskRegistry();
+    // Filter tasks that need review
+    const tasksNeedingReview = Object.values(registry).filter((task) => task.needsReview);
+    if (tasksNeedingReview.length === 0) {
+        console.log(chalk.green('✅ No completed tasks awaiting review!'));
+        return;
+    }
+    // Sort by completion time (most recent first)
+    tasksNeedingReview.sort((a, b) => (b.endTime || 0) - (a.endTime || 0));
+    console.log(chalk.bold('\n📋 Completed Long Tasks Awaiting Review:\n'));
+    // Display task list
+    tasksNeedingReview.forEach((task, index) => {
+        const timeAgo = task.endTime ? formatTimeAgo(task.endTime) : 'unknown';
+        const durationStr = task.duration ? formatDuration(task.duration) : 'unknown';
+        console.log(chalk.cyan(`${index + 1}. [${timeAgo}] ${task.projectPath} (${task.branch})`));
+        console.log(chalk.gray(`   Duration: ${durationStr}\n`));
+    });
+    // Create choices for inquirer
+    const choices = tasksNeedingReview.map((task) => {
+        const timeAgo = task.endTime ? formatTimeAgo(task.endTime) : 'unknown';
+        const durationStr = task.duration ? formatDuration(task.duration) : 'unknown';
+        return {
+            name: `[${timeAgo}] ${task.projectPath} (${task.branch}) - ${durationStr}`,
+            value: task.projectPath,
+        };
+    });
+    choices.push({ name: chalk.gray('Cancel'), value: '__cancel__' });
+    const { selectedPath } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'selectedPath',
+            message: 'Select task to review:',
+            choices,
+        },
+    ]);
+    if (selectedPath === '__cancel__') {
+        console.log(chalk.yellow('Review cancelled.'));
+        return;
+    }
+    const selectedTask = registry[selectedPath];
+    if (!selectedTask) {
+        console.error(chalk.red('❌ Task not found in registry.'));
+        return;
+    }
+    // Mark as reviewed (remove from registry)
+    delete registry[selectedPath];
+    await saveTaskRegistry(registry);
+    console.log(chalk.green(`\n✅ Task marked as reviewed and removed from queue.`));
+    console.log(chalk.cyan(`📂 Project: ${selectedTask.projectPath}`));
+    console.log(chalk.cyan(`🌿 Branch: ${selectedTask.branch}`));
+    // Output navigation command for shell wrapper to execute
+    // The shell wrapper should source this output to actually change directory
+    console.log(chalk.bold(`\n💡 To navigate to this project, run:`));
+    console.log(chalk.yellow(`cd "${selectedTask.projectPath}"`));
+    // Try to open in Cursor IDE if available
+    try {
+        process.chdir(selectedTask.projectPath);
+        await $ `cursor .`;
+        console.log(chalk.green('🚀 Opened project in Cursor IDE'));
+    }
+    catch {
+        console.log(chalk.gray('💡 Could not auto-open in Cursor. You can manually open the project or navigate with the cd command above.'));
+    }
+}

package/dist/commands/ide/index.d.ts

@@ -1,2 +1,3 @@
 import 'zx/globals';
 export declare const openIDE: (ideType: "cursor" | "claude", searchMode?: string) => Promise<void>;
+export declare const refreshIdeReposCache: () => Promise<void>;

package/dist/commands/ide/index.js

@@ -2,15 +2,48 @@ import inquirer from 'inquirer';
 import 'zx/globals';
 import chalk from 'chalk';
 import inquirerAutocomplete from 'inquirer-autocomplete-prompt';
-import { readConfig } from '../../util.js';
+import { readConfig, findGitRepositories, readIdeReposCache, writeIdeReposCache, } from '../../util.js';
 import { spawn } from 'child_process';
+import { existsSync } from 'fs';
 // Register autocomplete prompt
 inquirer.registerPrompt('autocomplete', inquirerAutocomplete);
 let reposConfig;
 let currentCategory;
-async function loadConfig() {
+let workingDirectory;
+let autoDiscoveredRepos = [];
+async function loadConfig(options) {
     const config = readConfig();
-    reposConfig = config.repos;
+    // Check if workingDirectory is configured
+    if (config.workingDirectory) {
+        workingDirectory = config.workingDirectory;
+        // Validate that workingDirectory exists
+        if (!existsSync(workingDirectory)) {
+            throw new Error(`Working directory does not exist: ${workingDirectory}`);
+        }
+        if (options?.refreshReposCache) {
+            // Force refresh: rescan and overwrite cache
+            autoDiscoveredRepos = findGitRepositories(workingDirectory);
+            writeIdeReposCache(workingDirectory, autoDiscoveredRepos);
+        }
+        else {
+            // Default: use cache if possible (fast path)
+            const cached = readIdeReposCache(workingDirectory);
+            if (cached) {
+                autoDiscoveredRepos = cached;
+            }
+            else {
+                // Warm the cache on first run
+                autoDiscoveredRepos = findGitRepositories(workingDirectory);
+                writeIdeReposCache(workingDirectory, autoDiscoveredRepos);
+            }
+        }
+        // Sort alphabetically by name for better UX
+        autoDiscoveredRepos.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    else {
+        // Use manual configuration (existing behavior)
+        reposConfig = config.repos;
+    }
 }
 async function searchCategories(_answers, input = '') {
     if (!reposConfig) {
@@ -46,6 +79,16 @@ async function searchProjects(_answers, input = '') {
 }
 // Flatten all projects with category context for fuzzy search
 function getAllProjects() {
+    // Auto-discovery mode: use discovered Git repos
+    if (workingDirectory) {
+        return autoDiscoveredRepos.map((repo) => ({
+            category: repo.topLevelFolder,
+            name: repo.name,
+            path: repo.path,
+            display: `${repo.name} (${repo.path})`,
+        }));
+    }
+    // Manual configuration mode
     if (!reposConfig)
         return [];
     return Object.entries(reposConfig).flatMap(([category, projects]) => Object.entries(projects).map(([name, path]) => ({
@@ -58,18 +101,60 @@ function getAllProjects() {
 // Single-keyword fuzzy search across all projects
 async function searchAllProjects(_answers, input = '') {
     const allProjects = getAllProjects();
-    if (!input) {
-        return allProjects.map((p) => ({ name: p.display, value: p }));
+    // Filter projects based on search input
+    let filteredProjects = allProjects;
+    if (input) {
+        const keywords = input.toLowerCase().trim().split(/\s+/);
+        filteredProjects = allProjects.filter((project) => {
+            const searchText = `${project.name} ${project.category} ${project.path}`.toLowerCase();
+            return keywords.every((keyword) => searchText.includes(keyword));
+        });
     }
-    // Split input by spaces and filter projects matching ALL keywords
-    const keywords = input.toLowerCase().trim().split(/\s+/);
-    return allProjects
-        .filter((project) => {
-        const searchText = `${project.name} ${project.category} ${project.path}`.toLowerCase();
-        // Check if all keywords are present in the search text
-        return keywords.every((keyword) => searchText.includes(keyword));
-    })
-        .map((p) => ({ name: p.display, value: p }));
+    // If auto-discovery mode, add category separators
+    if (workingDirectory) {
+        return formatProjectsWithSeparators(filteredProjects);
+    }
+    // Manual mode: simple display
+    return filteredProjects.map((p) => ({ name: p.display, value: p }));
+}
+// Format projects with top-level folder separators (for auto-discovery mode)
+function formatProjectsWithSeparators(projects) {
+    // Group projects by category (top-level folder)
+    const grouped = new Map();
+    projects.forEach((project) => {
+        const category = project.category;
+        if (!grouped.has(category)) {
+            grouped.set(category, []);
+        }
+        grouped.get(category).push(project);
+    });
+    // Sort categories alphabetically, but put root (/) last
+    const sortedCategories = Array.from(grouped.keys()).sort((a, b) => {
+        if (a === '/')
+            return 1;
+        if (b === '/')
+            return 1;
+        return a.localeCompare(b);
+    });
+    // Build result with separators
+    const result = [];
+    sortedCategories.forEach((category) => {
+        const categoryProjects = grouped.get(category);
+        // Add category separator
+        const categoryLabel = category === '/' ? '/ (root)' : category;
+        result.push({
+            name: `---------  ${categoryLabel}  ---------`,
+            disabled: 'separator',
+        });
+        // Add projects in this category
+        categoryProjects.forEach((p) => {
+            result.push({
+                name: `  ${p.display}`,
+                value: p,
+            });
+        });
+    });
+    return result;
 }
 // Select project using fuzzy search across all categories
 async function selectProjectWithFuzzySearch(searchMode) {
@@ -134,16 +219,22 @@ async function launchClaude(projectPath) {
         });
     });
 }
-// Launch Cursor or other IDE
+// Launch Cursor or other IDE, not include claude
 async function launchIDE(ideType, projectPath, projectName) {
-    await $ `${ideType} ${projectPath}`;
+    if (ideType === 'cursor') {
+        // it could ensure the cursor is brought to front in macos
+        await $ `open -a "Cursor" ${projectPath}`;
+    }
+    else {
+        await $ `${ideType} ${projectPath}`;
+    }
     console.log(chalk.green(`Opening ${projectName} in ${ideType}...`));
 }
 export const openIDE = async (ideType, searchMode) => {
     try {
         await loadConfig();
-        // Select project using appropriate method
-        const project = searchMode !== undefined
+        // In auto-discovery mode, always use fuzzy search (no categories)
+        const project = workingDirectory || searchMode !== undefined
             ? await selectProjectWithFuzzySearch(searchMode)
             : await selectProjectWithTwoStep();
         // Launch IDE based on type
@@ -158,3 +249,11 @@ export const openIDE = async (ideType, searchMode) => {
         console.error(chalk.red(`Error opening project in ${ideType}:`, error));
     }
 };
+export const refreshIdeReposCache = async () => {
+    await loadConfig({ refreshReposCache: true });
+    if (!workingDirectory) {
+        console.log(chalk.yellow('No workingDirectory configured; nothing to refresh.'));
+        return;
+    }
+    console.log(chalk.green('IDE repository cache refreshed.'));
+};

package/dist/commands/url.d.ts

@@ -1,3 +1,4 @@
 export declare function addUrl(name: string, url: string): Promise<void>;
 export declare function removeUrl(name?: string): Promise<void>;
-export declare function searchAndOpenUrl(): Promise<void>;
+export declare function searchAndOpenUrl(suppress?: boolean): Promise<void>;
+export declare function openUrlGroup(): Promise<void>;