edsger 0.71.0 → 0.72.1

package/dist/api/mcp-client.js

@@ -21,8 +21,15 @@ export async function callMcpEndpoint(method, params) {
     if (!mcpToken) {
         throw new Error('Not authenticated. Run `edsger login` or set EDSGER_MCP_TOKEN environment variable.');
     }
+    // The platform splits its JSON-RPC surface across two edge functions that
+    // share the same base URL and MCP-token auth:
+    //   - `/mcp`    — slash-notation methods (issues/list, github/org_repos, ...)
+    //   - `/agents` — dot-notation methods (agents.*, services.*, skills.*, ...)
+    // Route by the method's separator so callers don't have to care which
+    // function owns a given method.
+    const endpoint = method.includes('.') ? 'agents' : 'mcp';
     try {
-        const response = await fetch(`${mcpServerUrl}/mcp`, {
+        const response = await fetch(`${mcpServerUrl}/${endpoint}`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',

package/dist/commands/quality-benchmark/index.js

@@ -215,5 +215,5 @@ async function resolveRepositoryFullName(repositoryId) {
         .select('full_name')
         .eq('id', repositoryId)
         .maybeSingle();
-    return (data)?.full_name ?? null;
+    return data?.full_name ?? null;
 }

package/dist/commands/sync-terraform/index.js

@@ -29,9 +29,16 @@ export async function runSyncTerraform(teamId, options = {}) {
             repoFullName = result?.team?.terraform_repo_full_name ?? null;
         }
         catch {
-            // Fallback: read directly from supabase if MCP doesn't have the endpoint
+            // Fallback: the caller (e.g. the desktop app) may have already resolved
+            // the team's repo and injected it as EDSGER_TERRAFORM_REPO, so MCP isn't
+            // strictly required.
             logWarning('Could not fetch team via MCP, attempting to read terraform_repo_full_name from env');
         }
+        // Env fallback works whether or not MCP returned a repo — it lets the
+        // desktop app drive the sync without depending on the MCP team endpoint.
+        if (!repoFullName) {
+            repoFullName = process.env.EDSGER_TERRAFORM_REPO ?? null;
+        }
         if (!repoFullName) {
             logError('No Terraform repo configured for this team. ' +
                 'Go to Team Settings and set a Terraform repo, or use --dir to point at a local directory.');

package/dist/index.js

@@ -58,6 +58,7 @@ import { runWorkflow } from './commands/workflow/index.js';
 import { DEFAULT_MAX_FILES as FIND_ARCHITECTURE_DEFAULT_MAX_FILES } from './phases/find-architecture/index.js';
 import { DEFAULT_MAX_FILES as FIND_SMELLS_DEFAULT_MAX_FILES } from './phases/find-smells/index.js';
 import { SMELL_CATEGORIES, } from './phases/find-smells/types.js';
+import { deregisterSession, registerSession, } from './system/session-manager.js';
 import { logError, logInfo } from './utils/logger.js';
 // Get package.json version dynamically
 // eslint-disable-next-line @typescript-eslint/naming-convention -- ESM __filename/__dirname polyfill
@@ -77,6 +78,24 @@ program
     .name('edsger')
     .description('AI-powered workflow automation and code review CLI tool')
     .version(version);
+// When the desktop app spawns a streamed CLI it sets EDSGER_PROCESS_KEY (its
+// process-registry key with the `:output` marker stripped, e.g.
+// `sync-terraform` or `recipes:<productId>`). Open a cli_sessions row whose
+// `command` is that key so the originating tab can find the still-running
+// session and replay its logs across tab switches / restarts / devices.
+// registerSession is idempotent: commands that open their own (richer) session
+// just enrich the row started here (the process key stays in `command`), and
+// deregisterSession is a no-op once they've closed it.
+program.hook('preAction', async (_thisCommand, actionCommand) => {
+    if (process.env.EDSGER_PROCESS_KEY) {
+        await registerSession({ command: actionCommand.name() });
+    }
+});
+program.hook('postAction', async () => {
+    if (process.env.EDSGER_PROCESS_KEY) {
+        await deregisterSession();
+    }
+});
 // ============================================================
 // Subcommand: edsger login
 // ============================================================

package/dist/system/session-manager.d.ts

@@ -20,6 +20,14 @@ export interface CliSession {
 /**
  * Register this CLI session with the server.
  * Optionally accepts command name and product ID for filtering on detail pages.
+ *
+ * Idempotent: if a session is already active (e.g. registered by the top-level
+ * command hook), this enriches that row with the command/product instead of
+ * creating a second session, and returns the existing id.
+ *
+ * The stored `command` is the desktop process key when the CLI was spawned by
+ * the app (EDSGER_PROCESS_KEY), so a feature/tab can find this session; see
+ * `resolvedCommand`.
  */
 export declare function registerSession(options?: {
     command?: string;

package/dist/system/session-manager.js

@@ -25,13 +25,42 @@ function generateSessionId() {
     const random = Math.random().toString(36).substring(2, 8);
     return `cli-${timestamp}-${random}`;
 }
+/**
+ * The value stored in `cli_sessions.command`.
+ *
+ * When the desktop app spawns a streamed CLI it injects EDSGER_PROCESS_KEY --
+ * its process-registry key (`:output` channel marker already stripped), e.g.
+ * `sync-terraform`, `recipes:<productId>`, `pr-review:<prId>`. That key is what
+ * the originating tab looks up by, so it takes precedence over the bare command
+ * name; standalone runs fall back to the supplied command name.
+ */
+function resolvedCommand(options) {
+    return process.env.EDSGER_PROCESS_KEY || options?.command;
+}
 /**
  * Register this CLI session with the server.
  * Optionally accepts command name and product ID for filtering on detail pages.
+ *
+ * Idempotent: if a session is already active (e.g. registered by the top-level
+ * command hook), this enriches that row with the command/product instead of
+ * creating a second session, and returns the existing id.
+ *
+ * The stored `command` is the desktop process key when the CLI was spawned by
+ * the app (EDSGER_PROCESS_KEY), so a feature/tab can find this session; see
+ * `resolvedCommand`.
  */
 export async function registerSession(options) {
+    // Already in a session for this process — enrich, don't double-register.
+    if (currentSessionId) {
+        await enrichSession(options);
+        return currentSessionId;
+    }
     const sessionId = generateSessionId();
     currentSessionId = sessionId;
+    const command = resolvedCommand(options);
+    // Full invocation (subcommand + args) for readable run history. `command`
+    // stays the stable, entity-scoped lookup key; this carries the variable args.
+    const invocation = process.argv.slice(2).join(' ') || undefined;
     try {
         const userId = getUserId();
         if (hasSupabaseSession() && userId) {
@@ -44,8 +73,11 @@ export async function registerSession(options) {
                 started_at: new Date().toISOString(),
                 last_heartbeat: new Date().toISOString(),
             };
-            if (options?.command) {
-                row.command = options.command;
+            if (command) {
+                row.command = command;
+            }
+            if (invocation) {
+                row.invocation = invocation;
             }
             if (options?.productId) {
                 row.product_id = options.productId;
@@ -64,8 +96,11 @@ export async function registerSession(options) {
                 version: getVersion(),
                 status: 'running',
             };
-            if (options?.command) {
-                payload.command = options.command;
+            if (command) {
+                payload.command = command;
+            }
+            if (invocation) {
+                payload.invocation = invocation;
             }
             if (options?.productId) {
                 payload.product_id = options.productId;
@@ -82,6 +117,41 @@ export async function registerSession(options) {
     initLogSync(sessionId);
     return sessionId;
 }
+/**
+ * Best-effort enrichment of the already-active session row with command /
+ * product info (e.g. when a command registers itself after the top-level hook
+ * already opened the session). Direct-SDK path only; the MCP heartbeat path
+ * keeps whatever the initial register supplied.
+ */
+async function enrichSession(options) {
+    const command = resolvedCommand(options);
+    if (!currentSessionId || (!command && !options?.productId)) {
+        return;
+    }
+    try {
+        const userId = getUserId();
+        if (!hasSupabaseSession() || !userId) {
+            return;
+        }
+        const patch = {};
+        // With a desktop process key present, `command` resolves to that key, so
+        // a self-registering command can't clobber it with its bare name.
+        if (command) {
+            patch.command = command;
+        }
+        if (options?.productId) {
+            patch.product_id = options.productId;
+        }
+        await getSupabase()
+            .from('cli_sessions')
+            .update(patch)
+            .eq('session_id', currentSessionId)
+            .eq('user_id', userId);
+    }
+    catch {
+        // best-effort
+    }
+}
 /**
  * Send a heartbeat to keep the session alive and check for commands
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.71.0",
+  "version": "0.72.1",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"
@@ -50,8 +50,8 @@
     "commander": "^12.0.0",
     "cosmiconfig": "^9.0.0",
     "dotenv": "^16.4.5",
-    "edsger-contract": "0.7.0",
-    "edsger-tools": "0.9.0",
+    "edsger-contract": "0.9.1",
+    "edsger-tools": "0.9.1",
     "gray-matter": "^4.0.3",
     "zod": "^4.0.0"
   },