feat: add multi-project support (#110)

* feat: Implement project management store with project path validation and synchronization

- Added `useProjectsStore` for managing projects, including adding, removing, renaming, and validating project paths.
- Implemented persistence for projects and active project ID using safe storage.
- Introduced synchronization from desktop settings to keep project data consistent.
- Enhanced session store to manage sessions by directory and added new methods for session management.
- Updated todo store to fetch session todos based on the directory context.
- Refactored server code to validate and resolve project directories for various API endpoints.
- Added project entry validation and sanitization to ensure data integrity.

* feat(settings): migrate legacy project settings and update settings loading logic

* feat: enhance project management with directory-aware settings and improved agent/command source handling

* feat: enhance session and project management with directory-aware settings and improved configuration refresh logic

* feat: enhance project management with worktree manager integration and project directory resolution

* feat: enhance agent groups store with project directory resolution and loading logic

* feat: add heartbeat management and global wrapping for SSE blocks in agent and chat providers

* feat: refactor command and project handling in useCommandsStore

- Replaced useDirectoryStore with useProjectsStore to manage project paths.
- Introduced getRequestDirectory function to determine the active project directory.
- Updated command fetching to respect project-level scoping.
- Enhanced error handling and logging for command configuration fetching.
- Improved command configuration saving and updating to utilize project directory context.

feat: enhance project path normalization in useProjectsStore

- Added resolveTildePath function to expand paths starting with ~.
- Updated normalizeProjectPath to utilize home directory for path expansion.

fix: update permission handling in useSessionStore

- Changed Permission type to PermissionRequest for clarity.
- Updated respondToPermission method to use requestId instead of permissionId.

refactor: improve permission utilities

- Introduced types for PermissionAction and PermissionRule.
- Enhanced getAgentDefinition and resolveConfigStore functions for better type safety.
- Added resolvePermissionAction to streamline permission resolution logic.

feat: add agent configuration retrieval endpoint

- Implemented new API endpoint to fetch agent configuration based on project directory.
- Enhanced getAgentPermissionSource to prioritize project-level permissions.

chore: update SDK version in package.json files

- Bumped @opencode-ai/sdk version to ^1.1.1 across all relevant package.json files.

refactor: streamline bridge message handling

- Updated handleBridgeMessage to accept directory parameter for agent and command requests.
- Improved local API request handling to extract directory from query parameters and headers.

feat: enhance project configuration management

- Added functions to retrieve and merge project configuration paths.
- Improved handling of existing project configuration files for agents and commands.

* feat: enhance VSCode integration and session management

- Added support for a sticky sidebar header background in light and dark themes.
- Introduced functions to read VSCode workspace directory and check if running in VSCode.
- Implemented detailed logging for session loading and creation processes.
- Enhanced session filtering based on directory structure and canonical paths.
- Added a new method to reorder projects and prevent modifications in VSCode workspace.
- Improved error handling and logging for app initialization and markdown file parsing.
- Updated API checks and health checks to ensure readiness before proceeding.
- Refactored code for better readability and maintainability across various modules.

* feat: improve agent and branch selection logic, enhance session management, and update multi-run creation response

* feat: add worktree management actions in agent group detail and sidebar, including delete and keep only options

* fix(ui): share IME guard and cover multi-run

* fix(session): reduce maximum visible sessions in group from 7 to 5

packages/vscode/src/AgentManagerPanelProvider.ts

@@ -15,6 +15,7 @@ export class AgentManagerPanelProvider {
   private _cachedError?: string;
   private _sseCounter = 0;
   private _sseStreams = new Map<string, AbortController>();
+  private _sseHeartbeats = new Map<string, ReturnType<typeof setInterval>>();
 
   constructor(
     private readonly _context: vscode.ExtensionContext,
@@ -58,6 +59,12 @@ export class AgentManagerPanelProvider {
         controller.abort();
       }
       this._sseStreams.clear();
+
+      for (const heartbeat of this._sseHeartbeats.values()) {
+        clearInterval(heartbeat);
+      }
+      this._sseHeartbeats.clear();
+
       this._panel = undefined;
     }, null, this._context.subscriptions);
 
@@ -162,12 +169,29 @@ export class AgentManagerPanelProvider {
     const targetUrl = new URL(normalizedPath.replace(/^\/+/, ''), base).toString();
 
     let response: Response;
+    let wrapAsGlobal = false;
+
+    const requestHeaders = this._buildSseHeaders(headers || {});
+
     try {
       response = await fetch(targetUrl, {
         method: 'GET',
-        headers: this._buildSseHeaders(headers || {}),
+        headers: requestHeaders,
         signal: controller.signal,
       });
+
+      // Fallback for OpenCode versions without /global/event.
+      if ((!response.ok || !response.body) && normalizedPath === '/global/event') {
+        const fallbackUrl = new URL('event', base).toString();
+        response = await fetch(fallbackUrl, {
+          method: 'GET',
+          headers: requestHeaders,
+          signal: controller.signal,
+        });
+        if (response.ok && response.body) {
+          wrapAsGlobal = true;
+        }
+      }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       return {
@@ -196,6 +220,21 @@ export class AgentManagerPanelProvider {
 
     this._sseStreams.set(streamId, controller);
 
+    const fallbackDirectory = this._openCodeManager?.getWorkingDirectory()
+      || vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
+      || 'global';
+
+    if (shouldInjectActivity) {
+      const heartbeatTimer = setInterval(() => {
+        if (controller.signal.aborted) {
+          return;
+        }
+        const heartbeatChunk = `${buildHeartbeatEventBlock()}\n\n`;
+        this._panel?.webview.postMessage({ type: 'api:sse:chunk', streamId, chunk: heartbeatChunk });
+      }, 30000);
+      this._sseHeartbeats.set(streamId, heartbeatTimer);
+    }
+
     (async () => {
       try {
         const reader = responseBody.getReader();
@@ -216,7 +255,10 @@ export class AgentManagerPanelProvider {
               const blocks = sseBuffer.split('\n\n');
               sseBuffer = blocks.pop() ?? '';
               if (blocks.length > 0) {
-                const outboundBlocks = shouldInjectActivity ? expandSseBlocksWithActivity(blocks) : blocks;
+                const routedBlocks = wrapAsGlobal
+                  ? wrapSseBlocksAsGlobal(blocks, fallbackDirectory)
+                  : blocks;
+                const outboundBlocks = shouldInjectActivity ? expandSseBlocksWithActivity(routedBlocks) : routedBlocks;
                 const joined = outboundBlocks.map((block: string) => `${block}\n\n`).join('');
                 this._panel?.webview.postMessage({ type: 'api:sse:chunk', streamId, chunk: joined });
               }
@@ -229,7 +271,10 @@ export class AgentManagerPanelProvider {
           }
           if (sseBuffer) {
             if (shouldInjectActivity) {
-              const outboundBlocks = expandSseBlocksWithActivity([sseBuffer]);
+              const baseBlocks = wrapAsGlobal
+                ? wrapSseBlocksAsGlobal([sseBuffer], fallbackDirectory)
+                : [sseBuffer];
+              const outboundBlocks = expandSseBlocksWithActivity(baseBlocks);
               const joined = outboundBlocks.map((block: string) => `${block}\n\n`).join('');
               this._panel?.webview.postMessage({ type: 'api:sse:chunk', streamId, chunk: joined });
             } else {
@@ -252,6 +297,11 @@ export class AgentManagerPanelProvider {
         }
       } finally {
         this._sseStreams.delete(streamId);
+        const heartbeat = this._sseHeartbeats.get(streamId);
+        if (heartbeat) {
+          clearInterval(heartbeat);
+          this._sseHeartbeats.delete(streamId);
+        }
       }
     })();
 
@@ -276,6 +326,12 @@ export class AgentManagerPanelProvider {
         controller.abort();
         this._sseStreams.delete(streamId);
       }
+
+      const heartbeat = this._sseHeartbeats.get(streamId);
+      if (heartbeat) {
+        clearInterval(heartbeat);
+        this._sseHeartbeats.delete(streamId);
+      }
     }
     return { id, type, success: true, data: { stopped: true } };
   }
@@ -396,6 +452,80 @@ const buildActivityEventBlock = (activity: SessionActivity): string => {
   })}`;
 };
 
+const buildHeartbeatEventBlock = (): string => {
+  return `data: ${JSON.stringify({ type: 'openchamber:heartbeat', timestamp: Date.now() })}`;
+};
+
+const parseSseBlockForGlobalWrap = (block: string): { id?: string; payload: Record<string, unknown> } | null => {
+  if (!block) {
+    return null;
+  }
+
+  const lines = block.split('\n');
+  const dataLines: string[] = [];
+  let eventId: string | undefined;
+
+  for (const line of lines) {
+    if (line.startsWith('data:')) {
+      dataLines.push(line.slice(5).replace(/^\s/, ''));
+      continue;
+    }
+    if (line.startsWith('id:')) {
+      const candidate = line.slice(3).trim();
+      if (candidate) {
+        eventId = candidate;
+      }
+    }
+  }
+
+  if (dataLines.length === 0) {
+    return null;
+  }
+
+  const payloadText = dataLines.join('\n').trim();
+  if (!payloadText) {
+    return null;
+  }
+
+  try {
+    const parsed = JSON.parse(payloadText) as unknown;
+    if (!parsed || typeof parsed !== 'object') {
+      return null;
+    }
+
+    const record = parsed as Record<string, unknown>;
+    const nestedPayload = record.payload;
+    const payload = nestedPayload && typeof nestedPayload === 'object'
+      ? (nestedPayload as Record<string, unknown>)
+      : record;
+
+    return eventId ? { id: eventId, payload } : { payload };
+  } catch {
+    return null;
+  }
+};
+
+const wrapSseBlocksAsGlobal = (blocks: string[], directory: string): string[] => {
+  const normalizedDirectory = typeof directory === 'string' && directory.trim().length > 0
+    ? directory.trim().replace(/\\/g, '/')
+    : 'global';
+
+  return blocks.map((block) => {
+    const parsed = parseSseBlockForGlobalWrap(block);
+    if (!parsed) {
+      return block;
+    }
+
+    const envelope = {
+      directory: normalizedDirectory,
+      payload: parsed.payload,
+    };
+
+    const idPrefix = parsed.id ? `id: ${parsed.id}\n` : '';
+    return `${idPrefix}data: ${JSON.stringify(envelope)}`;
+  });
+};
+
 const expandSseBlocksWithActivity = (blocks: string[]): string[] => {
   const expanded: string[] = [];
   for (const block of blocks) {