cocoindex-code 0.2.37__tar.gz → 0.2.38__tar.gz

{cocoindex_code-0.2.37 → cocoindex_code-0.2.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cocoindex-code
-Version: 0.2.37
+Version: 0.2.38
 Summary: MCP server for indexing and querying codebases using CocoIndex
 Project-URL: Homepage, https://github.com/cocoindex-io/cocoindex-code
 Project-URL: Repository, https://github.com/cocoindex-io/cocoindex-code
@@ -107,6 +107,8 @@ Next, set up your [coding agent integration](#coding-agent-integration) — or j
 
 ## Coding Agent Integration
 
+This repository is a **single plugin marketplace** (`.claude-plugin/marketplace.json`) consumed by both **Claude Code** and **Grok** — same plugin id `cocoindex-code`, same `ccc` skill. Grok optionally activates the bundled hooks and MCP server with `--trust`; Claude Code users can install the same marketplace and rely on the skill alone or load hooks/MCP from the plugin as needed.
+
 ### Skill (Recommended)
 
 Install the `ccc` skill so your coding agent automatically uses semantic search when needed:
@@ -126,11 +128,59 @@ Works with [Claude Code](https://docs.anthropic.com/en/docs/claude-code) and oth
 For Claude Code users, this repository is also a [plugin marketplace](https://code.claude.com/docs/en/plugin-marketplaces). Install the skill from inside Claude Code with:
 
 ```text
-/plugin marketplace add Roxabi/cocoindex-code
+/plugin marketplace add cocoindex-io/cocoindex-code
 /plugin install cocoindex-code@cocoindex-code
 ```
 
-This bundles the same `ccc` skill, with version pinning and `/plugin marketplace update` for updates.
+This bundles the same `ccc` skill, with version pinning and `/plugin marketplace update` for updates. The repository also ships `hooks/hooks.json` and `.mcp.json` for Grok (and Claude Code plugin installs that load those files); Claude users who want skill-only search can rely on the skill alone and add MCP manually in the [MCP Server](#mcp-server) section below instead of using the bundled `.mcp.json`.
+
+#### Grok plugin
+
+For [Grok](https://github.com/xai-org/grok) users, install via Grok's plugin system. The plugin bundles three components:
+
+| Component | Purpose |
+|-----------|---------|
+| **Skill** (`skills/ccc/`) | Agent runs `ccc search` / `ccc index` via the CLI (same as Claude Code above) |
+| **Hook** (`hooks/hooks.json`) | `SessionStart` → incremental `ccc index` when `.cocoindex_code/` exists |
+| **MCP** (`.mcp.json`) | `ccc mcp` stdio server — `search` tool with `refresh_index=true` by default |
+
+Grok does **not** import Claude's `enabledPlugins` or plugin cache; install separately even if you already use cocoindex in Claude Code.
+
+**Full install** (skill + hook + MCP):
+
+```bash
+grok plugin marketplace add cocoindex-io/cocoindex-code
+grok plugin install cocoindex-io/cocoindex-code --trust
+grok plugin enable cocoindex-code
+```
+
+Prefer the GitHub shorthand (`cocoindex-io/cocoindex-code`) for install — `grok plugin install cocoindex-code` can fail when no marketplace plugin matches that bare name.
+
+`--trust` is required so Grok activates the plugin's hooks and MCP server (skills load when the plugin is enabled).
+
+**Skill-only** (match Claude Code — no auto-index hook, no MCP tool):
+
+Install and enable as above, then disable the optional components:
+
+1. **Hooks** — open `/hooks`, select the `SessionStart` hook from `cocoindex-code`, press `Space` to disable.
+2. **MCP** — open `/mcps`, select `cocoindex-code`, press `Space` to disable; or persist in `~/.grok/config.toml`:
+
+```toml
+[mcp_servers.cocoindex-code]
+enabled = false
+```
+
+The agent still owns indexing via the `ccc` skill (`ccc index` / `ccc search --refresh` when stale), same as Claude Code.
+
+To avoid importing MCP servers from your Claude/Cursor user config (unrelated to this plugin):
+
+```toml
+[compat.claude]
+mcps = false
+
+[compat.cursor]
+mcps = false
+```
 
 ### MCP Server
 
@@ -178,6 +228,24 @@ Or use opencode.json:
 ```
 </details>
 
+<details>
+<summary>Kilo Code</summary>
+
+Add a local MCP server in `~/.config/kilo/kilo.jsonc`, `kilo.jsonc`, or `.kilo/kilo.jsonc`:
+
+```json
+{
+  "mcp": {
+    "cocoindex-code": {
+      "type": "local",
+      "command": ["ccc", "mcp"],
+      "enabled": true
+    }
+  }
+}
+```
+</details>
+
 Once configured, the agent automatically decides when semantic code search is helpful — finding code by description, exploring unfamiliar codebases, fuzzy/conceptual matches, or locating implementations without knowing exact names.
 
 > **Note:** The `cocoindex-code` command (without subcommand) still works as an MCP server for backward compatibility. It auto-creates settings from environment variables on first run.
@@ -215,7 +283,7 @@ ccc search "authentication logic"       # search!
 
 The background daemon starts automatically on first use.
 
-> **Tip:** `ccc index` auto-initializes if you haven't run `ccc init` yet, so you can skip straight to indexing.
+> **Tip:** You can skip `ccc init` and go straight to `ccc index` — it auto-initializes new projects with default settings. If global settings are missing too (first use on the machine), it walks you through the same model setup as `ccc init` when run interactively; non-interactive runs (scripts, hooks) still require a one-time `ccc init` first.
 
 ### CLI Reference
 
@@ -491,10 +559,15 @@ embedding:
 
 envs:                                                # extra environment variables for the daemon
   OPENAI_API_KEY: your-key                           # only needed if not already in your shell environment
+
+daemon:
+  idle_timeout_minutes: 180                          # optional: exit the daemon after this long without client activity (default 180, 0 = never)
 ```
 
 > **Note:** The daemon inherits your shell environment. If an API key (e.g. `OPENAI_API_KEY`) is already set as an environment variable, you don't need to duplicate it in `envs`. The `envs` field is only for values that aren't in your environment.
 
+> **Idle timeout:** the background daemon holds the embedding model in RAM, so it exits after `daemon.idle_timeout_minutes` without client activity and is restarted automatically on your next `ccc` command or MCP search. A live MCP session sends periodic heartbeats, so the daemon never idles out while your coding agent is connected. Set `0` to keep the daemon running forever.
+
 > **Custom location:** set `COCOINDEX_CODE_DIR` to place `global_settings.yml` somewhere other than `~/.cocoindex_code/` — useful if you want the file to live alongside your projects (e.g. on a synced folder).
 
 #### `indexing_params` / `query_params`
@@ -552,6 +625,14 @@ chunkers:
 
 > `.cocoindex_code/` is automatically added to `.gitignore` during init.
 
+After editing `include_patterns`, `exclude_patterns`, or `language_overrides`:
+
+- Run `ccc doctor` to preview which files match.
+- Run `ccc index` or `ccc search --refresh ...` to update the existing index.
+- You do not need to delete the index or restart the daemon for these file-matching changes.
+
+If you add or change custom `chunkers`, restart the daemon first so the chunker registry is reloaded, then run `ccc index`.
+
 Use `chunkers` when you want to control how a file type is split into chunks before indexing.
 
 `module: example_toml_chunker:toml_chunker` means:
@@ -750,6 +831,7 @@ embedding:
 | cpp | c++ | `.cpp`, `.cc`, `.cxx`, `.h`, `.hpp` |
 | csharp | csharp, cs | `.cs` |
 | css | | `.css`, `.scss` |
+| dart | | `.dart` |
 | dtd | | `.dtd` |
 | fortran | f, f90, f95, f03 | `.f`, `.f90`, `.f95`, `.f03` |
 | go | golang | `.go` |

{cocoindex_code-0.2.37 → cocoindex_code-0.2.38}/README.md

@@ -63,6 +63,8 @@ Next, set up your [coding agent integration](#coding-agent-integration) — or j
 
 ## Coding Agent Integration
 
+This repository is a **single plugin marketplace** (`.claude-plugin/marketplace.json`) consumed by both **Claude Code** and **Grok** — same plugin id `cocoindex-code`, same `ccc` skill. Grok optionally activates the bundled hooks and MCP server with `--trust`; Claude Code users can install the same marketplace and rely on the skill alone or load hooks/MCP from the plugin as needed.
+
 ### Skill (Recommended)
 
 Install the `ccc` skill so your coding agent automatically uses semantic search when needed:
@@ -82,11 +84,59 @@ Works with [Claude Code](https://docs.anthropic.com/en/docs/claude-code) and oth
 For Claude Code users, this repository is also a [plugin marketplace](https://code.claude.com/docs/en/plugin-marketplaces). Install the skill from inside Claude Code with:
 
 ```text
-/plugin marketplace add Roxabi/cocoindex-code
+/plugin marketplace add cocoindex-io/cocoindex-code
 /plugin install cocoindex-code@cocoindex-code
 ```
 
-This bundles the same `ccc` skill, with version pinning and `/plugin marketplace update` for updates.
+This bundles the same `ccc` skill, with version pinning and `/plugin marketplace update` for updates. The repository also ships `hooks/hooks.json` and `.mcp.json` for Grok (and Claude Code plugin installs that load those files); Claude users who want skill-only search can rely on the skill alone and add MCP manually in the [MCP Server](#mcp-server) section below instead of using the bundled `.mcp.json`.
+
+#### Grok plugin
+
+For [Grok](https://github.com/xai-org/grok) users, install via Grok's plugin system. The plugin bundles three components:
+
+| Component | Purpose |
+|-----------|---------|
+| **Skill** (`skills/ccc/`) | Agent runs `ccc search` / `ccc index` via the CLI (same as Claude Code above) |
+| **Hook** (`hooks/hooks.json`) | `SessionStart` → incremental `ccc index` when `.cocoindex_code/` exists |
+| **MCP** (`.mcp.json`) | `ccc mcp` stdio server — `search` tool with `refresh_index=true` by default |
+
+Grok does **not** import Claude's `enabledPlugins` or plugin cache; install separately even if you already use cocoindex in Claude Code.
+
+**Full install** (skill + hook + MCP):
+
+```bash
+grok plugin marketplace add cocoindex-io/cocoindex-code
+grok plugin install cocoindex-io/cocoindex-code --trust
+grok plugin enable cocoindex-code
+```
+
+Prefer the GitHub shorthand (`cocoindex-io/cocoindex-code`) for install — `grok plugin install cocoindex-code` can fail when no marketplace plugin matches that bare name.
+
+`--trust` is required so Grok activates the plugin's hooks and MCP server (skills load when the plugin is enabled).
+
+**Skill-only** (match Claude Code — no auto-index hook, no MCP tool):
+
+Install and enable as above, then disable the optional components:
+
+1. **Hooks** — open `/hooks`, select the `SessionStart` hook from `cocoindex-code`, press `Space` to disable.
+2. **MCP** — open `/mcps`, select `cocoindex-code`, press `Space` to disable; or persist in `~/.grok/config.toml`:
+
+```toml
+[mcp_servers.cocoindex-code]
+enabled = false
+```
+
+The agent still owns indexing via the `ccc` skill (`ccc index` / `ccc search --refresh` when stale), same as Claude Code.
+
+To avoid importing MCP servers from your Claude/Cursor user config (unrelated to this plugin):
+
+```toml
+[compat.claude]
+mcps = false
+
+[compat.cursor]
+mcps = false
+```
 
 ### MCP Server
 
@@ -134,6 +184,24 @@ Or use opencode.json:
 ```
 </details>
 
+<details>
+<summary>Kilo Code</summary>
+
+Add a local MCP server in `~/.config/kilo/kilo.jsonc`, `kilo.jsonc`, or `.kilo/kilo.jsonc`:
+
+```json
+{
+  "mcp": {
+    "cocoindex-code": {
+      "type": "local",
+      "command": ["ccc", "mcp"],
+      "enabled": true
+    }
+  }
+}
+```
+</details>
+
 Once configured, the agent automatically decides when semantic code search is helpful — finding code by description, exploring unfamiliar codebases, fuzzy/conceptual matches, or locating implementations without knowing exact names.
 
 > **Note:** The `cocoindex-code` command (without subcommand) still works as an MCP server for backward compatibility. It auto-creates settings from environment variables on first run.
@@ -171,7 +239,7 @@ ccc search "authentication logic"       # search!
 
 The background daemon starts automatically on first use.
 
-> **Tip:** `ccc index` auto-initializes if you haven't run `ccc init` yet, so you can skip straight to indexing.
+> **Tip:** You can skip `ccc init` and go straight to `ccc index` — it auto-initializes new projects with default settings. If global settings are missing too (first use on the machine), it walks you through the same model setup as `ccc init` when run interactively; non-interactive runs (scripts, hooks) still require a one-time `ccc init` first.
 
 ### CLI Reference
 
@@ -447,10 +515,15 @@ embedding:
 
 envs:                                                # extra environment variables for the daemon
   OPENAI_API_KEY: your-key                           # only needed if not already in your shell environment
+
+daemon:
+  idle_timeout_minutes: 180                          # optional: exit the daemon after this long without client activity (default 180, 0 = never)
 ```
 
 > **Note:** The daemon inherits your shell environment. If an API key (e.g. `OPENAI_API_KEY`) is already set as an environment variable, you don't need to duplicate it in `envs`. The `envs` field is only for values that aren't in your environment.
 
+> **Idle timeout:** the background daemon holds the embedding model in RAM, so it exits after `daemon.idle_timeout_minutes` without client activity and is restarted automatically on your next `ccc` command or MCP search. A live MCP session sends periodic heartbeats, so the daemon never idles out while your coding agent is connected. Set `0` to keep the daemon running forever.
+
 > **Custom location:** set `COCOINDEX_CODE_DIR` to place `global_settings.yml` somewhere other than `~/.cocoindex_code/` — useful if you want the file to live alongside your projects (e.g. on a synced folder).
 
 #### `indexing_params` / `query_params`
@@ -508,6 +581,14 @@ chunkers:
 
 > `.cocoindex_code/` is automatically added to `.gitignore` during init.
 
+After editing `include_patterns`, `exclude_patterns`, or `language_overrides`:
+
+- Run `ccc doctor` to preview which files match.
+- Run `ccc index` or `ccc search --refresh ...` to update the existing index.
+- You do not need to delete the index or restart the daemon for these file-matching changes.
+
+If you add or change custom `chunkers`, restart the daemon first so the chunker registry is reloaded, then run `ccc index`.
+
 Use `chunkers` when you want to control how a file type is split into chunks before indexing.
 
 `module: example_toml_chunker:toml_chunker` means:
@@ -706,6 +787,7 @@ embedding:
 | cpp | c++ | `.cpp`, `.cc`, `.cxx`, `.h`, `.hpp` |
 | csharp | csharp, cs | `.cs` |
 | css | | `.css`, `.scss` |
+| dart | | `.dart` |
 | dtd | | `.dtd` |
 | fortran | f, f90, f95, f03 | `.f`, `.f90`, `.f95`, `.f03` |
 | go | golang | `.go` |

{cocoindex_code-0.2.37 → cocoindex_code-0.2.38}/src/cocoindex_code/_daemon_paths.py

@@ -6,8 +6,11 @@ can import these without pulling in the full daemon stack.
 
 from __future__ import annotations
 
+import json
 import os
 import sys
+import time
+from dataclasses import dataclass
 from pathlib import Path
 
 from .settings import user_settings_dir
@@ -58,3 +61,50 @@ def daemon_pid_path() -> Path:
 def daemon_log_path() -> Path:
     """Return the path for the daemon's log file."""
     return daemon_runtime_dir() / "daemon.log"
+
+
+def daemon_last_exit_path() -> Path:
+    """Return the path for the daemon's graceful-exit marker file."""
+    return daemon_runtime_dir() / "last_exit"
+
+
+@dataclass
+class LastExitMarker:
+    """Record of the most recent *graceful* daemon exit.
+
+    Written by the daemon's graceful shutdown path (``StopRequest``,
+    SIGTERM/SIGINT) and removed again at the next daemon startup. A crashed
+    daemon (SIGKILL, OOM, segfault) never writes it — that absence is how the
+    client tells a crash from a graceful exit.
+    """
+
+    pid: int
+    reason: str
+    timestamp: float
+
+
+def write_last_exit_marker(pid: int, reason: str) -> None:
+    """Persist the graceful-exit marker. Best-effort — never raises."""
+    payload = json.dumps({"pid": pid, "reason": reason, "timestamp": time.time()})
+    try:
+        daemon_last_exit_path().write_text(payload)
+    except OSError:
+        pass
+
+
+def read_last_exit_marker() -> LastExitMarker | None:
+    """Read the graceful-exit marker, or None when absent/unreadable."""
+    try:
+        data = json.loads(daemon_last_exit_path().read_text())
+        return LastExitMarker(
+            pid=int(data["pid"]),
+            reason=str(data["reason"]),
+            timestamp=float(data["timestamp"]),
+        )
+    except (OSError, ValueError, KeyError, TypeError):
+        return None
+
+
+def clear_last_exit_marker() -> None:
+    """Remove the marker (daemon startup) so it always refers to the most recent exit."""
+    daemon_last_exit_path().unlink(missing_ok=True)

{cocoindex_code-0.2.37 → cocoindex_code-0.2.38}/src/cocoindex_code/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.37'
-__version_tuple__ = version_tuple = (0, 2, 37)
+__version__ = version = '0.2.38'
+__version_tuple__ = version_tuple = (0, 2, 38)
 
 __commit_id__ = commit_id = None

{cocoindex_code-0.2.37 → cocoindex_code-0.2.38}/src/cocoindex_code/cli.py

@@ -10,6 +10,7 @@ from collections.abc import Callable
 from pathlib import Path
 from typing import TYPE_CHECKING, TypeVar
 
+import msgspec as _msgspec
 import typer as _typer
 
 if TYPE_CHECKING:
@@ -76,22 +77,31 @@ def _apply_host_cwd() -> None:
 # ---------------------------------------------------------------------------
 
 
-def require_project_root() -> Path:
+def require_project_root(*, auto_init: bool = False) -> Path:
     """Find the project root by walking up from CWD.
 
     Checks global settings first (more fundamental), then project settings.
-    Exits with code 1 if either check fails.
+    With ``auto_init``, a missing project is initialized with default settings
+    instead of failing. Missing global settings run the same interactive model
+    setup as ``ccc init`` — but only on a TTY, since picking an embedding model
+    is a consequential choice; non-interactive runs (scripts, hooks, agents)
+    still exit with code 1 rather than silently committing to a default model.
     """
     gs_path = user_settings_path()
     if not gs_path.is_file():
-        _typer.echo(
-            f"Error: Global settings not found: {format_path_for_display(gs_path)}\n"
-            "Run `ccc init` to create it with default settings.",
-            err=True,
-        )
-        raise _typer.Exit(code=1)
+        if auto_init and sys.stdin.isatty():
+            _setup_user_settings_interactive(None)
+        else:
+            _typer.echo(
+                f"Error: Global settings not found: {format_path_for_display(gs_path)}\n"
+                "Run `ccc init` to create it with default settings.",
+                err=True,
+            )
+            raise _typer.Exit(code=1)
     root = find_project_root(Path.cwd())
     if root is None:
+        if auto_init:
+            return _auto_init_project(Path.cwd())
         _typer.echo(
             "Error: Not in an initialized project directory.\n"
             "Run `ccc init` in your project root to get started.",
@@ -101,6 +111,24 @@ def require_project_root() -> Path:
     return root
 
 
+def _auto_init_project(cwd: Path) -> Path:
+    """Create default project settings without an explicit ``ccc init``.
+
+    Anchors at the nearest parent git root when there is one, so running from
+    a repo subdirectory initializes the repo root rather than the subdirectory.
+    """
+    root = find_parent_with_marker(cwd) or cwd
+    _create_project_settings(root)
+    return root
+
+
+def _create_project_settings(root: Path) -> None:
+    """Write default project settings at *root* and gitignore the settings dir."""
+    save_project_settings(root, default_project_settings())
+    add_to_gitignore(root)
+    _typer.echo(f"Created project settings: {format_path_for_display(project_settings_path(root))}")
+
+
 _F = TypeVar("_F", bound=Callable[..., object])
 
 
@@ -599,12 +627,7 @@ def init(
             )
             raise _typer.Exit(code=1)
 
-    # Create project settings
-    save_project_settings(cwd, default_project_settings())
-    _typer.echo(f"Created project settings: {format_path_for_display(settings_file)}")
-
-    # Add to .gitignore
-    add_to_gitignore(cwd)
+    _create_project_settings(cwd)
 
     _typer.echo("You can edit the settings files to customize indexing behavior.")
     _typer.echo("Run `ccc index` to build the index.")
@@ -616,7 +639,7 @@ def index() -> None:
     """Create/update index for the codebase."""
     from . import client as _client
 
-    project_root = str(require_project_root())
+    project_root = str(require_project_root(auto_init=True))
     print_project_header(project_root)
     _run_index_with_progress(project_root)
     print_index_stats(_client.project_status(project_root))
@@ -631,6 +654,7 @@ def search(
     offset: int = _typer.Option(0, "--offset", help="Number of results to skip"),
     limit: int = _typer.Option(10, "--limit", help="Maximum results to return"),
     refresh: bool = _typer.Option(False, "--refresh", help="Refresh index before searching"),
+    json_output: bool = _typer.Option(False, "--json", help="Output results as JSON"),
 ) -> None:
     """Semantic search across the codebase."""
     project_root = str(require_project_root())
@@ -656,7 +680,14 @@ def search(
         limit=limit,
         offset=offset,
     )
-    print_search_results(resp)
+    if json_output:
+        sys.stdout.buffer.write(_msgspec.json.encode(resp))
+        sys.stdout.buffer.write(b"\n")
+        sys.stdout.buffer.flush()
+        if not resp.success:
+            raise _typer.Exit(code=1)
+    else:
+        print_search_results(resp)
 
 
 @app.command()
@@ -994,11 +1025,18 @@ def mcp() -> None:
     project_root = str(require_project_root())
 
     async def _run_mcp() -> None:
-        from .server import create_mcp_server
+        from .server import create_mcp_server, run_heartbeat_loop
 
         mcp_server = create_mcp_server(project_root)
-        asyncio.create_task(_bg_index(project_root))
-        await mcp_server.run_stdio_async()
+        background_tasks = {
+            asyncio.create_task(_bg_index(project_root)),
+            asyncio.create_task(run_heartbeat_loop()),
+        }
+        try:
+            await mcp_server.run_stdio_async()
+        finally:
+            for task in background_tasks:
+                task.cancel()
 
     asyncio.run(_run_mcp())
 
@@ -1028,6 +1066,8 @@ def daemon_status() -> None:
     resp = _client.daemon_status()
     _typer.echo(f"Daemon version: {resp.version}")
     _typer.echo(f"Uptime: {resp.uptime_seconds:.1f}s")
+    timeout_desc = f"{resp.idle_timeout_minutes}m" if resp.idle_timeout_minutes > 0 else "disabled"
+    _typer.echo(f"Idle: {resp.idle_seconds:.1f}s (timeout: {timeout_desc})")
     if resp.projects:
         _typer.echo("Projects:")
         for p in resp.projects:

{cocoindex_code-0.2.37 → cocoindex_code-0.2.38}/src/cocoindex_code/client.py

@@ -16,6 +16,7 @@ import time
 from collections.abc import Callable
 from multiprocessing.connection import Client, Connection
 from pathlib import Path
+from typing import NamedTuple
 
 from ._daemon_paths import (
     connection_family,
@@ -23,6 +24,7 @@ from ._daemon_paths import (
     daemon_pid_path,
     daemon_runtime_dir,
     daemon_socket_path,
+    read_last_exit_marker,
 )
 from ._version import __version__
 from .protocol import (
@@ -35,6 +37,8 @@ from .protocol import (
     ErrorResponse,
     HandshakeRequest,
     HandshakeResponse,
+    HeartbeatRequest,
+    HeartbeatResponse,
     IndexingProgress,
     IndexProgressUpdate,
     IndexRequest,
@@ -65,6 +69,19 @@ logger = logging.getLogger(__name__)
 
 _daemon_ensured = False
 
+# PID of the daemon we last completed a handshake with. Matched against the
+# graceful-exit marker when the daemon later vanishes, to tell an expected
+# exit (e.g. `ccc daemon stop`) from a crash.
+_ensured_daemon_pid: int | None = None
+
+# Consecutive crash-restarts in this process. Reset whenever the daemon
+# answers without needing a restart; at _MAX_CONSECUTIVE_CRASH_RESTARTS we
+# stop relaunching a crash-looping daemon and surface the failure instead.
+# In-process state: it matters for the long-lived MCP server, while one-shot
+# CLI invocations get at most one crash-restart each — which is fine.
+_consecutive_crash_restarts = 0
+_MAX_CONSECUTIVE_CRASH_RESTARTS = 3
+
 # Tracks which daemon-side handshake warnings have already been surfaced to
 # the user in this process. We print each distinct warning at most once per
 # `ccc` invocation — see `_print_handshake_warnings`.
@@ -111,33 +128,43 @@ def _connect_and_handshake() -> Connection:
 
     Returns the open connection for the caller to send exactly one request.
 
-    Automatically starts or restarts the daemon when it is absent or running
-    with stale global settings (e.g. a ``ccc init`` retry rewrote
-    ``global_settings.yml`` after the daemon loaded it). A genuine *version*
-    mismatch after we have already reached a matching daemon means the binary
-    was replaced under us mid-session — that fails fast instead of looping on
-    restarts.
+    Automatically starts or restarts the daemon when it is absent (first call,
+    or it exited since the last request) or running with
+    stale global settings (e.g. a ``ccc init`` retry rewrote
+    ``global_settings.yml`` after the daemon loaded it). An ensured daemon
+    that vanished *without* leaving a graceful-exit marker crashed — that is
+    restarted loudly, and given up on after a few consecutive crashes (see
+    ``_handle_vanished_daemon``). A genuine *version* mismatch after we have
+    already reached a matching daemon means the binary was replaced under us
+    mid-session — that fails fast instead of looping on restarts.
     """
-    global _daemon_ensured  # noqa: PLW0603
+    global _daemon_ensured, _ensured_daemon_pid, _consecutive_crash_restarts  # noqa: PLW0603
 
     try:
-        conn = _raw_connect_and_handshake()
+        result = _raw_connect_and_handshake()
         _daemon_ensured = True
-        return conn
+        _ensured_daemon_pid = result.resp.pid
+        # The daemon answered without needing a restart — any crash streak is over.
+        _consecutive_crash_restarts = 0
+        return result.conn
     except DaemonVersionError as e:
         # `resp.ok` is False only for a real version mismatch. Once we have
         # ensured a matching daemon, a fresh version mismatch means the binary
         # was swapped under us — fail fast. A settings-only restart request
         # (resp.ok True, but the loaded settings mtime moved) is expected;
-        # restart the daemon below so it reloads them.
+        # restart the daemon below so it reloads them. (stop_daemon sends a
+        # StopRequest, so this restart leaves a graceful-exit marker and the
+        # next connect stays silent.)
         if _daemon_ensured and not e.resp.ok:
             raise
         stop_daemon()
     except (ConnectionRefusedError, OSError):
-        # No daemon answered. Normal on the first call (start one below); if we
-        # had already ensured one it vanished mid-session — surface that.
+        # No daemon answered. Normal on the first call of this process (start
+        # one below). If we had already ensured one, decide crash vs graceful
+        # exit — a crash restarts loudly and is capped, a graceful exit (e.g.
+        # a manual stop) restarts silently.
         if _daemon_ensured:
-            raise
+            _handle_vanished_daemon()
 
     if _is_daemon_supervised():
         # Supervisor is responsible for (re)starting the daemon — just wait
@@ -150,16 +177,51 @@ def _connect_and_handshake() -> Connection:
     # Verify the fresh daemon is reachable
     for _attempt in range(10):
         try:
-            conn = _raw_connect_and_handshake()
+            result = _raw_connect_and_handshake()
             _daemon_ensured = True
-            return conn
+            _ensured_daemon_pid = result.resp.pid
+            return result.conn
         except (ConnectionRefusedError, OSError):
             time.sleep(0.5)
 
     raise RuntimeError("Failed to connect to daemon after starting it")
 
 
-def _raw_connect_and_handshake() -> Connection:
+def _handle_vanished_daemon() -> None:
+    """Decide how to react when an ensured daemon no longer answers.
+
+    A graceful exit (``ccc daemon stop``, SIGTERM) leaves a
+    last-exit marker carrying the exiting daemon's pid; when it matches the
+    pid we handshook with, the restart is expected and silent. No marker (or
+    a marker from a different process) means the daemon *crashed*: restart
+    it, but warn on stderr, and after ``_MAX_CONSECUTIVE_CRASH_RESTARTS``
+    consecutive crashes raise instead of relaunching a crash-looping daemon.
+    """
+    global _consecutive_crash_restarts  # noqa: PLW0603
+
+    marker = read_last_exit_marker()
+    if marker is not None and marker.pid == _ensured_daemon_pid:
+        return  # graceful exit — silent transparent restart
+
+    _consecutive_crash_restarts += 1
+    if _consecutive_crash_restarts >= _MAX_CONSECUTIVE_CRASH_RESTARTS:
+        raise RuntimeError(
+            f"cocoindex-code daemon crashed {_consecutive_crash_restarts} times in a row; "
+            f"not restarting it again. Check the daemon log ({daemon_log_path()}) "
+            "or run `ccc doctor`."
+        )
+    print_warning(
+        "cocoindex-code daemon exited unexpectedly; restarting. "
+        f"See {daemon_log_path()} for details."
+    )
+
+
+class _HandshakeResult(NamedTuple):
+    conn: Connection
+    resp: HandshakeResponse
+
+
+def _raw_connect_and_handshake() -> _HandshakeResult:
     """Low-level connect + handshake without auto-start logic."""
     sock = daemon_socket_path()
     if sys.platform != "win32" and not os.path.exists(sock):
@@ -187,7 +249,7 @@ def _raw_connect_and_handshake() -> Connection:
         conn.close()
         raise DaemonVersionError(resp)
     _print_handshake_warnings(resp)
-    return conn
+    return _HandshakeResult(conn=conn, resp=resp)
 
 
 class DaemonVersionError(RuntimeError):
@@ -354,6 +416,30 @@ def stop() -> StopResponse:
     return _send(StopRequest())  # type: ignore[return-value]
 
 
+def send_heartbeat() -> bool:
+    """Send one heartbeat so a running daemon counts an active MCP session as activity.
+
+    Uses the raw (non-auto-starting) connect path and returns False when no
+    compatible daemon answers: a heartbeat keeps an existing daemon warm but
+    must NEVER start or restart one — otherwise `ccc daemon stop` during an
+    MCP session would fight the heartbeat loop. The daemon still auto-starts
+    lazily on the next real search/index request.
+    """
+    try:
+        conn, _resp = _raw_connect_and_handshake()
+    except (ConnectionRefusedError, DaemonVersionError, OSError):
+        return False
+    try:
+        conn.send_bytes(encode_request(HeartbeatRequest()))
+        data = conn.recv_bytes()
+    except (EOFError, OSError):
+        return False
+    finally:
+        conn.close()
+    resp = decode_response(data)
+    return isinstance(resp, HeartbeatResponse) and resp.ok
+
+
 def daemon_env() -> DaemonEnvResponse:
     """Get environment variable names from the daemon."""
     return _send(DaemonEnvRequest())  # type: ignore[return-value]
@@ -500,8 +586,9 @@ def stop_daemon() -> None:
 
     Escalation: StopRequest → SIGTERM → SIGKILL.
     """
-    global _daemon_ensured  # noqa: PLW0603
+    global _daemon_ensured, _ensured_daemon_pid  # noqa: PLW0603
     _daemon_ensured = False
+    _ensured_daemon_pid = None
     _surfaced_warnings.clear()
     pid_path = daemon_pid_path()
 
@@ -515,7 +602,7 @@ def stop_daemon() -> None:
 
     # 1) Graceful StopRequest via socket (bypass auto-start)
     try:
-        conn = _raw_connect_and_handshake()
+        conn = _raw_connect_and_handshake().conn
         try:
             conn.send_bytes(encode_request(StopRequest()))
             conn.recv_bytes()

{cocoindex_code-0.2.37 → cocoindex_code-0.2.38}/src/cocoindex_code/daemon.py

@@ -12,16 +12,19 @@ import threading
 import time
 import traceback
 from collections.abc import AsyncIterator, Callable
-from multiprocessing.connection import Connection, Listener
+from datetime import timedelta
+from multiprocessing.connection import Client, Connection, Listener
 from pathlib import Path
 from typing import Any
 
 from ._daemon_paths import (
+    clear_last_exit_marker,
     connection_family,
     daemon_log_path,
     daemon_pid_path,
     daemon_runtime_dir,
     daemon_socket_path,
+    write_last_exit_marker,
 )
 from ._version import __version__
 from .chunking import ChunkerFn as _ChunkerFn
@@ -40,6 +43,8 @@ from .protocol import (
     ErrorResponse,
     HandshakeRequest,
     HandshakeResponse,
+    HeartbeatRequest,
+    HeartbeatResponse,
     IndexRequest,
     IndexStreamResponse,
     IndexWaitingNotice,
@@ -58,6 +63,7 @@ from .protocol import (
 )
 from .settings import (
     ChunkerMapping,
+    DaemonSettings,
     UserSettings,
     format_path_for_display,
     get_host_path_mappings,
@@ -194,6 +200,50 @@ class ProjectRegistry:
             for root, project in self._projects.items()
         ]
 
+    def any_indexing(self) -> bool:
+        """True when any loaded project currently holds its index lock."""
+        return any(project._index_lock.locked() for project in self._projects.values())
+
+
+# ---------------------------------------------------------------------------
+# Idle reaper
+# ---------------------------------------------------------------------------
+
+
+class IdleReaper:
+    """Tracks client activity and decides when the daemon should idle-exit.
+
+    ``last_activity`` is refreshed on every accepted connection and again when
+    each handler task finishes, so a long streaming request (e.g. an index run)
+    counts as activity up to its end.
+    """
+
+    def __init__(self, timeout: timedelta, *, supervised: bool) -> None:
+        self.timeout = timeout
+        self.supervised = supervised
+        self.last_activity = time.monotonic()
+
+    def record_activity(self) -> None:
+        self.last_activity = time.monotonic()
+
+    def idle_seconds(self, now: float | None = None) -> float:
+        return (time.monotonic() if now is None else now) - self.last_activity
+
+    def should_exit(self, *, now: float, active_handlers: int, indexing: bool) -> bool:
+        """Pure exit predicate — testable without an event loop.
+
+        Exit only when a timeout is configured, no external supervisor owns
+        the daemon lifecycle, no handler task is live, no project is indexing,
+        and the idle period exceeds the timeout.
+        """
+        if self.timeout <= timedelta(0):
+            return False
+        if self.supervised:
+            return False
+        if active_handlers > 0 or indexing:
+            return False
+        return now - self.last_activity > self.timeout.total_seconds()
+
 
 # ---------------------------------------------------------------------------
 # Connection handler
@@ -208,6 +258,7 @@ async def handle_connection(
     settings_mtime_us: int | None,
     settings_env_names: list[str],
     handshake_warnings: list[str],
+    reaper: IdleReaper,
 ) -> None:
     """Handle a single client connection (per-request model).
 
@@ -232,6 +283,7 @@ async def handle_connection(
                 HandshakeResponse(
                     ok=ok,
                     daemon_version=__version__,
+                    pid=os.getpid(),
                     global_settings_mtime_us=settings_mtime_us,
                     warnings=list(handshake_warnings),
                 )
@@ -244,7 +296,7 @@ async def handle_connection(
         data = await loop.run_in_executor(None, conn.recv_bytes)
         req = decode_request(data)
 
-        result = await _dispatch(req, registry, start_time, on_shutdown, settings_env_names)
+        result = await _dispatch(req, registry, start_time, on_shutdown, settings_env_names, reaper)
         if isinstance(result, AsyncIterator):
             try:
                 async for resp in result:
@@ -460,6 +512,7 @@ async def _dispatch(
     start_time: float,
     on_shutdown: Callable[[], None],
     settings_env_names: list[str],
+    reaper: IdleReaper,
 ) -> (
     Response
     | AsyncIterator[IndexStreamResponse]
@@ -503,10 +556,13 @@ async def _dispatch(
             return project.get_status()
 
         if isinstance(req, DaemonStatusRequest):
+            now = time.monotonic()
             return DaemonStatusResponse(
                 version=__version__,
-                uptime_seconds=time.monotonic() - start_time,
+                uptime_seconds=now - start_time,
                 projects=registry.list_projects(),
+                idle_seconds=reaper.idle_seconds(now),
+                idle_timeout_minutes=round(reaper.timeout / timedelta(minutes=1)),
             )
 
         if isinstance(req, RemoveProjectRequest):
@@ -517,6 +573,11 @@ async def _dispatch(
             on_shutdown()
             return StopResponse(ok=True)
 
+        if isinstance(req, HeartbeatRequest):
+            # A heartbeat's only effect is the connection itself, which the
+            # accept path already recorded as activity.
+            return HeartbeatResponse(ok=True)
+
         if isinstance(req, DaemonEnvRequest):
             from .protocol import DbPathMappingEntry
             from .settings import get_db_path_mappings
@@ -548,12 +609,21 @@ async def _dispatch(
 # ---------------------------------------------------------------------------
 
 
-def run_daemon() -> None:
+def run_daemon(
+    *,
+    idle_timeout: timedelta | None = None,
+    idle_check_interval: timedelta = timedelta(minutes=1),
+) -> None:
     """Main entry point for the daemon process (blocking).
 
     Sets up the listener, runs the asyncio event loop (``loop.run_forever``)
     to serve connections, and performs cleanup when shutdown is requested via
-    ``StopRequest`` or a signal (SIGTERM / SIGINT).
+    ``StopRequest``, a signal (SIGTERM / SIGINT), or the idle timeout.
+
+    ``idle_timeout`` and ``idle_check_interval`` exist so tests can run a
+    seconds-scale idle timeout in-process; production leaves them at their
+    defaults and the timeout comes from ``daemon.idle_timeout_minutes`` in
+    ``global_settings.yml`` (the dataclass default when the file is missing).
     """
     daemon_runtime_dir().mkdir(parents=True, exist_ok=True)
 
@@ -567,8 +637,10 @@ def run_daemon() -> None:
     indexing_params: dict[str, Any] = {}
     query_params: dict[str, Any] = {}
     handshake_warnings: list[str] = []
+    daemon_settings = DaemonSettings()
     if user_settings_path().is_file():
         user_settings = load_user_settings()
+        daemon_settings = user_settings.daemon
         settings_env_keys = list(user_settings.envs.keys())
         for key, value in user_settings.envs.items():
             os.environ[key] = value
@@ -590,9 +662,11 @@ def run_daemon() -> None:
         settings_env_keys = []
         embedder = None
 
-    # Write PID file
+    # Write PID file; drop the previous daemon's graceful-exit marker so the
+    # marker always refers to the most recent exit.
     pid_path = daemon_pid_path()
     pid_path.write_text(str(os.getpid()))
+    clear_last_exit_marker()
 
     # Set up logging to file
     log_path = daemon_log_path()
@@ -625,42 +699,101 @@ def run_daemon() -> None:
     loop = asyncio.new_event_loop()
     tasks: set[asyncio.Task[Any]] = set()
 
-    def _request_shutdown() -> None:
-        """Trigger daemon shutdown — called by StopRequest or signal handler."""
+    reaper = IdleReaper(
+        timeout=(
+            idle_timeout
+            if idle_timeout is not None
+            else timedelta(minutes=daemon_settings.idle_timeout_minutes)
+        ),
+        supervised=os.environ.get("COCOINDEX_CODE_DAEMON_SUPERVISED") == "1",
+    )
+
+    shutdown_reason: str | None = None
+
+    def _request_shutdown(reason: str) -> None:
+        """Trigger daemon shutdown — called by StopRequest, signal, or idle reaper.
+
+        Records *reason* (first one wins) for the graceful-exit marker written
+        during cleanup.
+        """
+        nonlocal shutdown_reason
+        if shutdown_reason is None:
+            shutdown_reason = reason
         loop.stop()
 
     def _spawn_handler(conn: Connection) -> None:
+        reaper.record_activity()
         task = loop.create_task(
             handle_connection(
                 conn,
                 registry,
                 start_time,
-                _request_shutdown,
+                lambda: _request_shutdown("stop_request"),
                 settings_mtime_us,
                 settings_env_keys,
                 handshake_warnings,
+                reaper,
             )
         )
         tasks.add(task)
-        task.add_done_callback(tasks.discard)
+
+        def _on_done(t: asyncio.Task[Any]) -> None:
+            tasks.discard(t)
+            # A finished handler is activity too — a long streaming request
+            # (e.g. an index run) counts up to its end, not just its start.
+            reaper.record_activity()
+
+        task.add_done_callback(_on_done)
+
+    async def _idle_reaper_loop() -> None:
+        """Periodically check the idle predicate; trigger shutdown when it fires."""
+        while True:
+            await asyncio.sleep(idle_check_interval.total_seconds())
+            if reaper.should_exit(
+                now=time.monotonic(),
+                active_handlers=len(tasks),
+                indexing=registry.any_indexing(),
+            ):
+                logger.info(
+                    "Idle for %.1fm (timeout %.1fm), shutting down",
+                    reaper.idle_seconds() / 60,
+                    reaper.timeout / timedelta(minutes=1),
+                )
+                _request_shutdown("idle_timeout")
+                return
+
+    reaper_task = loop.create_task(_idle_reaper_loop())
 
     # Handle signals for graceful shutdown
     try:
         for sig in (signal.SIGTERM, signal.SIGINT):
-            loop.add_signal_handler(sig, _request_shutdown)
+            loop.add_signal_handler(sig, _request_shutdown, "signal")
     except (RuntimeError, NotImplementedError):
         pass  # Not in main thread, or not supported on this platform (e.g. Windows)
 
     # Accept loop runs in a background thread; new connections are dispatched
-    # to the event loop via call_soon_threadsafe.  The loop exits when
-    # listener.close() (called during shutdown) causes accept() to raise.
+    # to the event loop via call_soon_threadsafe.  On POSIX the loop exits when
+    # listener.close() (called during shutdown) causes accept() to raise.  On
+    # Windows, PipeListener.close() does not cancel an in-flight
+    # ConnectNamedPipe wait, so shutdown additionally sets `shutting_down` and
+    # wakes accept() with a dummy client connection; the accepted connection
+    # (dummy or real) is dropped and the thread exits.
+    shutting_down = threading.Event()
+
     def _accept_loop() -> None:
         while True:
             try:
                 conn = listener.accept()
-                loop.call_soon_threadsafe(_spawn_handler, conn)
             except OSError:
                 break
+            if shutting_down.is_set():
+                conn.close()
+                break
+            try:
+                loop.call_soon_threadsafe(_spawn_handler, conn)
+            except RuntimeError:  # loop already closed — shutdown race
+                conn.close()
+                break
 
     accept_thread = threading.Thread(target=_accept_loop, daemon=True)
     accept_thread.start()
@@ -669,14 +802,34 @@ def run_daemon() -> None:
     try:
         loop.run_forever()
     finally:
-        # 1. Stop accepting new connections.
+        # 0. Record the graceful exit (idle timeout, StopRequest, signal).
+        #    Written first so a client that races the rest of the cleanup
+        #    already sees it. A crashed daemon never gets here — the marker's
+        #    absence is how the client detects a crash.
+        write_last_exit_marker(pid=os.getpid(), reason=shutdown_reason or "unknown")
+
+        # 1. Stop accepting new connections.  On Windows a blocked accept()
+        #    holds an open pipe instance that listener.close() can't release
+        #    (it only closes the queued next-instance handle), which would keep
+        #    the named pipe alive after exit — wake it with a dummy connection
+        #    so the accept thread closes it and exits.  POSIX doesn't need the
+        #    wake-up (listener.close() makes accept() raise), but it's harmless
+        #    there and keeps this path exercised on every platform rather than
+        #    only on Windows CI.
+        shutting_down.set()
+        try:
+            Client(sock_path, family=connection_family()).close()
+        except OSError:
+            pass
         listener.close()
+        accept_thread.join(timeout=5)
 
-        # 2. Cancel handler tasks (they may be blocked in run_in_executor).
-        for task in tasks:
+        # 2. Cancel handler tasks (they may be blocked in run_in_executor)
+        #    and the idle-reaper task.
+        pending = [*tasks, reaper_task]
+        for task in pending:
             task.cancel()
-        if tasks:
-            loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True))
+        loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
 
         # 3. Release project resources.
         registry.close_all()

{cocoindex_code-0.2.37 → cocoindex_code-0.2.38}/src/cocoindex_code/protocol.py

@@ -50,6 +50,16 @@ class DaemonEnvRequest(_msgspec.Struct, tag="daemon_env"):
     pass
 
 
+class HeartbeatRequest(_msgspec.Struct, tag="heartbeat"):
+    """Counts as client activity for the daemon's idle timeout.
+
+    Sent periodically by long-lived MCP servers so the daemon does not
+    idle-exit under an active session.
+    """
+
+    pass
+
+
 Request = (
     HandshakeRequest
     | IndexRequest
@@ -60,6 +70,7 @@ Request = (
     | StopRequest
     | DoctorRequest
     | DaemonEnvRequest
+    | HeartbeatRequest
 )
 
 # ---------------------------------------------------------------------------
@@ -70,6 +81,11 @@ Request = (
 class HandshakeResponse(_msgspec.Struct, tag="handshake"):
     ok: bool
     daemon_version: str
+    # The daemon's process id. The client remembers it so that, when the
+    # daemon later vanishes, the graceful-exit marker (written on shutdown
+    # with the same pid) can be matched race-free against the exact process
+    # the client was talking to — distinguishing a graceful exit from a crash.
+    pid: int
     global_settings_mtime_us: int | None = None
     # Non-fatal daemon-side warnings surfaced to the client on every handshake.
     # The client dedupes and prints them to stderr (see client._print_handshake_warnings).
@@ -139,6 +155,10 @@ class DaemonStatusResponse(_msgspec.Struct, tag="daemon_status"):
     version: str
     uptime_seconds: float
     projects: list[DaemonProjectInfo]
+    # Idle-timeout observability: seconds since the last client activity and
+    # the configured timeout (0 = never exit).
+    idle_seconds: float
+    idle_timeout_minutes: int
 
 
 class RemoveProjectResponse(_msgspec.Struct, tag="remove_project"):
@@ -149,6 +169,10 @@ class StopResponse(_msgspec.Struct, tag="stop"):
     ok: bool
 
 
+class HeartbeatResponse(_msgspec.Struct, tag="heartbeat"):
+    ok: bool
+
+
 class DoctorCheckResult(_msgspec.Struct):
     name: str
     ok: bool
@@ -193,6 +217,7 @@ Response = (
     | DaemonStatusResponse
     | RemoveProjectResponse
     | StopResponse
+    | HeartbeatResponse
     | DoctorResponse
     | DaemonEnvResponse
     | ErrorResponse

{cocoindex_code-0.2.37 → cocoindex_code-0.2.38}/src/cocoindex_code/server.py

@@ -17,6 +17,8 @@ from pathlib import Path
 from mcp.server.fastmcp import FastMCP
 from pydantic import BaseModel, Field
 
+from .settings import DaemonSettings, load_user_settings
+
 _MCP_INSTRUCTIONS = (
     "Code search and codebase understanding tools."
     "\n"
@@ -159,6 +161,45 @@ def create_mcp_server(project_root: str) -> FastMCP:
     return mcp
 
 
+# === Daemon heartbeat loop ===
+
+
+def heartbeat_interval_s(idle_timeout_minutes: int) -> int:
+    """Heartbeat period for a given idle timeout: a third of the timeout,
+    clamped to [30 s, 300 s] so several heartbeats always fit in one idle
+    window without hammering the daemon on very long timeouts.
+    """
+    return max(30, min(300, idle_timeout_minutes * 60 // 3))
+
+
+async def run_heartbeat_loop() -> None:
+    """Periodically heartbeat the daemon so it never idle-exits under this
+    live MCP session; when this process dies (even SIGKILL) the heartbeats
+    stop and the daemon exits on its normal idle timeout.
+
+    Reads the timeout from the same ``global_settings.yml`` the daemon reads
+    (dataclass default when the file is missing or invalid). Returns
+    immediately when the timeout is 0 (daemon never idle-exits). The
+    heartbeat itself never starts or restarts a daemon — see
+    ``client.send_heartbeat``.
+    """
+    from .client import send_heartbeat
+
+    try:
+        timeout_minutes = load_user_settings().daemon.idle_timeout_minutes
+    except (FileNotFoundError, ValueError):
+        timeout_minutes = DaemonSettings().idle_timeout_minutes
+    if timeout_minutes <= 0:
+        return
+
+    interval = heartbeat_interval_s(timeout_minutes)
+    loop = asyncio.get_event_loop()
+    while True:
+        await asyncio.sleep(interval)
+        # Client I/O is blocking — run off the event loop thread.
+        await loop.run_in_executor(None, send_heartbeat)
+
+
 # Keep the old `mcp` global for backward compatibility in __init__.py
 mcp: FastMCP | None = None
 
@@ -326,7 +367,14 @@ def main() -> None:
         async def _serve() -> None:
             from .cli import _bg_index
 
-            asyncio.create_task(_bg_index(str(project_root)))
-            await mcp_server.run_stdio_async()
+            background_tasks = {
+                asyncio.create_task(_bg_index(str(project_root))),
+                asyncio.create_task(run_heartbeat_loop()),
+            }
+            try:
+                await mcp_server.run_stdio_async()
+            finally:
+                for task in background_tasks:
+                    task.cancel()
 
         asyncio.run(_serve())

{cocoindex_code-0.2.37 → cocoindex_code-0.2.38}/src/cocoindex_code/settings.py

@@ -37,6 +37,7 @@ DEFAULT_INCLUDED_PATTERNS: list[str] = [
     "**/*.hxx",  # C++ headers
     "**/*.hh",  # C++ headers
     "**/*.cs",  # C#
+    "**/*.dart",  # Dart
     "**/*.sql",  # SQL
     "**/*.sh",  # Shell
     "**/*.bash",  # Bash
@@ -104,10 +105,18 @@ class EmbeddingSettings:
     query_params: dict[str, Any] | None = None
 
 
+@dataclass
+class DaemonSettings:
+    # Minutes without client activity before the daemon exits (0 = never exit).
+    # Clients auto-restart the daemon on the next request, so exiting is cheap.
+    idle_timeout_minutes: int = 180
+
+
 @dataclass
 class UserSettings:
     embedding: EmbeddingSettings
     envs: dict[str, str] = field(default_factory=dict)
+    daemon: DaemonSettings = field(default_factory=DaemonSettings)
 
 
 @dataclass
@@ -432,6 +441,8 @@ def _user_settings_to_dict(settings: UserSettings) -> dict[str, Any]:
     d: dict[str, Any] = {"embedding": _embedding_settings_to_dict(settings.embedding)}
     if settings.envs:
         d["envs"] = dict(settings.envs)
+    if settings.daemon != DaemonSettings():
+        d["daemon"] = {"idle_timeout_minutes": settings.daemon.idle_timeout_minutes}
     return d
 
 
@@ -456,7 +467,13 @@ def _user_settings_from_dict(d: dict[str, Any]) -> UserSettings:
         emb_kwargs["query_params"] = dict(emb_dict["query_params"] or {})
     embedding = EmbeddingSettings(**emb_kwargs)
     envs = d.get("envs", {})
-    return UserSettings(embedding=embedding, envs=envs)
+    # `daemon:` section is optional — missing keys use the dataclass defaults.
+    daemon_dict = d.get("daemon") or {}
+    daemon_kwargs: dict[str, Any] = {}
+    if "idle_timeout_minutes" in daemon_dict:
+        daemon_kwargs["idle_timeout_minutes"] = int(daemon_dict["idle_timeout_minutes"])
+    daemon = DaemonSettings(**daemon_kwargs)
+    return UserSettings(embedding=embedding, envs=envs, daemon=daemon)
 
 
 def _project_settings_to_dict(settings: ProjectSettings) -> dict[str, Any]: