@grackle-ai/server 0.39.1 → 0.41.0

package/dist/grpc-service.js

@@ -12,17 +12,21 @@ import * as projectStore from "./project-store.js";
 import * as taskStore from "./task-store.js";
 import * as findingStore from "./finding-store.js";
 import * as personaStore from "./persona-store.js";
-import { broadcast, broadcastEnvironments } from "./ws-broadcast.js";
+import { emit } from "./event-bus.js";
 import { processEventStream } from "./event-processor.js";
 import * as processorRegistry from "./processor-registry.js";
 import { join } from "node:path";
-import { LOGS_DIR, DEFAULT_RUNTIME, DEFAULT_MODEL, DEFAULT_WEB_PORT, DEFAULT_MCP_PORT, MAX_TASK_DEPTH, SESSION_STATUS, TASK_STATUS, taskStatusToEnum, taskStatusToString, projectStatusToEnum, claudeProviderModeToEnum, providerToggleToEnum, } from "@grackle-ai/common";
+import { LOGS_DIR, DEFAULT_WEB_PORT, DEFAULT_MCP_PORT, MAX_TASK_DEPTH, SESSION_STATUS, TASK_STATUS, taskStatusToEnum, taskStatusToString, projectStatusToEnum, claudeProviderModeToEnum, providerToggleToEnum, } from "@grackle-ai/common";
+import { resolvePersona } from "./resolve-persona.js";
+import * as settingsStore from "./settings-store.js";
+import { isAllowedSettingKey } from "./settings-store.js";
 import { createScopedToken } from "@grackle-ai/mcp";
 import { grackleHome } from "./paths.js";
 import { safeParseJsonArray } from "./json-helpers.js";
 import { computeTaskStatus } from "./compute-task-status.js";
 import { loadOrCreateApiKey } from "./api-key.js";
 import { logger } from "./logger.js";
+import { reanimateAgent } from "./reanimate-agent.js";
 import { slugify } from "./utils/slugify.js";
 import { buildTaskSystemContext } from "./utils/system-context.js";
 import { importGitHubIssues as executeGitHubImport } from "./github-import.js";
@@ -50,7 +54,6 @@ function envRowToProto(row) {
         displayName: row.displayName,
         adapterType: row.adapterType,
         adapterConfig: row.adapterConfig,
-        defaultRuntime: row.defaultRuntime,
         bootstrapped: row.bootstrapped,
         status: row.status,
         lastSeen: row.lastSeen || "",
@@ -89,6 +92,7 @@ function projectRowToProto(row) {
         updatedAt: row.updatedAt,
         useWorktrees: row.useWorktrees,
         worktreeBasePath: row.worktreeBasePath,
+        defaultPersonaId: row.defaultPersonaId,
     });
 }
 function taskRowToProto(row, childIds, computedStatus, latestSessionId) {
@@ -110,6 +114,7 @@ function taskRowToProto(row, childIds, computedStatus, latestSessionId) {
         depth: row.depth,
         childTaskIds: childIds ?? taskStore.getChildren(row.id).map((c) => c.id),
         canDecompose: row.canDecompose,
+        defaultPersonaId: row.defaultPersonaId,
     });
 }
 function findingRowToProto(row) {
@@ -173,8 +178,15 @@ function personaRowToProto(row) {
 }
 /** Convert persona MCP server configs to a JSON string for the PowerLine SpawnRequest. */
 function personaMcpServersToJson(row) {
-    const mcpServers = JSON.parse(row.mcpServers || "[]");
-    if (mcpServers.length === 0) {
+    let mcpServers;
+    try {
+        mcpServers = JSON.parse(row.mcpServers || "[]");
+    }
+    catch {
+        logger.warn({ personaId: row.id }, "Failed to parse persona mcpServers JSON; ignoring");
+        return "";
+    }
+    if (!Array.isArray(mcpServers) || mcpServers.length === 0) {
         return "";
     }
     return buildMcpServersJson(mcpServers);
@@ -202,9 +214,8 @@ export function registerGrackleRoutes(router) {
         },
         async addEnvironment(req) {
             const id = req.displayName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
-            const runtime = req.defaultRuntime || DEFAULT_RUNTIME;
-            envRegistry.addEnvironment(id, req.displayName, req.adapterType, req.adapterConfig, runtime);
-            broadcastEnvironments();
+            envRegistry.addEnvironment(id, req.displayName, req.adapterType, req.adapterConfig);
+            emit("environment.changed", {});
             const row = envRegistry.getEnvironment(id);
             return envRowToProto(row);
         },
@@ -226,11 +237,8 @@ export function registerGrackleRoutes(router) {
             // Delete sessions referencing this environment (FK constraint)
             sessionStore.deleteByEnvironment(req.id);
             envRegistry.removeEnvironment(req.id);
-            broadcastEnvironments();
-            broadcast({
-                type: "environment_removed",
-                payload: { environmentId: req.id },
-            });
+            emit("environment.changed", {});
+            emit("environment.removed", { environmentId: req.id });
             return create(grackle.EmptySchema, {});
         },
         async *provisionEnvironment(req) {
@@ -253,7 +261,7 @@ export function registerGrackleRoutes(router) {
                 return;
             }
             envRegistry.updateEnvironmentStatus(req.id, "connecting");
-            broadcastEnvironments();
+            emit("environment.changed", {});
             const config = JSON.parse(env.adapterConfig);
             const powerlineToken = env.powerlineToken;
             try {
@@ -268,7 +276,7 @@ export function registerGrackleRoutes(router) {
             catch (err) {
                 logger.error({ environmentId: req.id, err }, "Provision/bootstrap failed");
                 envRegistry.updateEnvironmentStatus(req.id, "error");
-                broadcastEnvironments();
+                emit("environment.changed", {});
                 yield create(grackle.ProvisionEventSchema, {
                     stage: "error",
                     message: `Provision failed: ${err instanceof Error ? err.message : String(err)}`,
@@ -283,7 +291,7 @@ export function registerGrackleRoutes(router) {
                 await tokenBroker.pushToEnv(req.id);
                 envRegistry.updateEnvironmentStatus(req.id, "connected");
                 envRegistry.markBootstrapped(req.id);
-                broadcastEnvironments();
+                emit("environment.changed", {});
                 yield create(grackle.ProvisionEventSchema, {
                     stage: "ready",
                     message: "Environment connected",
@@ -292,7 +300,7 @@ export function registerGrackleRoutes(router) {
             }
             catch (err) {
                 envRegistry.updateEnvironmentStatus(req.id, "error");
-                broadcastEnvironments();
+                emit("environment.changed", {});
                 yield create(grackle.ProvisionEventSchema, {
                     stage: "error",
                     message: `Connection failed: ${err instanceof Error ? err.message : String(err)}`,
@@ -311,7 +319,7 @@ export function registerGrackleRoutes(router) {
             }
             adapterManager.removeConnection(req.id);
             envRegistry.updateEnvironmentStatus(req.id, "disconnected");
-            broadcastEnvironments();
+            emit("environment.changed", {});
             return create(grackle.EmptySchema, {});
         },
         async destroyEnvironment(req) {
@@ -325,7 +333,7 @@ export function registerGrackleRoutes(router) {
             }
             adapterManager.removeConnection(req.id);
             envRegistry.updateEnvironmentStatus(req.id, "disconnected");
-            broadcastEnvironments();
+            emit("environment.changed", {});
             return create(grackle.EmptySchema, {});
         },
         async spawnAgent(req) {
@@ -337,37 +345,35 @@ export function registerGrackleRoutes(router) {
             if (!conn) {
                 throw new ConnectError(`Environment ${req.environmentId} not connected`, Code.FailedPrecondition);
             }
-            // Resolve persona if specified
-            const persona = req.personaId
-                ? personaStore.getPersona(req.personaId)
-                : undefined;
-            if (req.personaId && !persona) {
-                throw new ConnectError(`Persona not found: ${req.personaId}`, Code.NotFound);
+            // Resolve persona via cascade (request → app default)
+            let resolved;
+            try {
+                resolved = resolvePersona(req.personaId);
+            }
+            catch (err) {
+                throw new ConnectError(err.message, Code.FailedPrecondition);
             }
             const sessionId = uuid();
-            const runtime = req.runtime || persona?.runtime || env.defaultRuntime;
-            const model = req.model ||
-                persona?.model ||
-                process.env.GRACKLE_DEFAULT_MODEL ||
-                DEFAULT_MODEL;
+            const { runtime, model, systemPrompt, persona } = resolved;
+            const maxTurns = req.maxTurns || resolved.maxTurns;
             const logPath = join(grackleHome, LOGS_DIR, sessionId);
             let systemContext = req.systemContext || "";
-            if (persona) {
+            if (systemPrompt) {
                 systemContext =
-                    persona.systemPrompt + (systemContext ? "\n\n" + systemContext : "");
+                    systemPrompt + (systemContext ? "\n\n" + systemContext : "");
             }
             sessionStore.createSession(sessionId, req.environmentId, runtime, req.prompt, model, logPath);
-            const mcpServersJson = persona ? personaMcpServersToJson(persona) : "";
+            const mcpServersJson = personaMcpServersToJson(persona);
             const mcpPort = parseInt(process.env.GRACKLE_MCP_PORT || String(DEFAULT_MCP_PORT), 10);
             const mcpDialHost = toDialableHost(process.env.GRACKLE_HOST || "127.0.0.1");
             const mcpUrl = `http://${mcpDialHost}:${mcpPort}/mcp`;
-            const mcpToken = createScopedToken({ sub: sessionId, pid: "", per: req.personaId || "", sid: sessionId }, loadOrCreateApiKey());
+            const mcpToken = createScopedToken({ sub: sessionId, pid: "", per: resolved.personaId, sid: sessionId }, loadOrCreateApiKey());
             const powerlineReq = create(powerline.SpawnRequestSchema, {
                 sessionId,
                 runtime,
                 prompt: req.prompt,
                 model,
-                maxTurns: persona?.maxTurns || 0,
+                maxTurns,
                 branch: req.branch,
                 worktreeBasePath: req.branch
                     ? (req.worktreeBasePath.trim() || process.env.GRACKLE_WORKTREE_BASE || "/workspace")
@@ -388,37 +394,7 @@ export function registerGrackleRoutes(router) {
             return sessionRowToProto(row);
         },
         async resumeAgent(req) {
-            const session = sessionStore.getSession(req.sessionId);
-            if (!session) {
-                throw new ConnectError(`Session not found: ${req.sessionId}`, Code.NotFound);
-            }
-            const conn = adapterManager.getConnection(session.environmentId);
-            if (!conn) {
-                throw new ConnectError(`Environment ${session.environmentId} not connected`, Code.FailedPrecondition);
-            }
-            const powerlineReq = create(powerline.ResumeRequestSchema, {
-                sessionId: session.id,
-                runtimeSessionId: session.runtimeSessionId || "",
-                runtime: session.runtime,
-            });
-            const logPath = session.logPath || join(grackleHome, LOGS_DIR, session.id);
-            // Auto-bind task context from DB if session was previously associated with a task
-            let resumeProjectId;
-            let resumeTaskId;
-            if (session.taskId) {
-                const task = taskStore.getTask(session.taskId);
-                if (task) {
-                    resumeProjectId = task.projectId;
-                    resumeTaskId = task.id;
-                }
-            }
-            processEventStream(conn.client.resume(powerlineReq), {
-                sessionId: session.id,
-                logPath,
-                projectId: resumeProjectId,
-                taskId: resumeTaskId,
-            });
-            const row = sessionStore.getSession(session.id);
+            const row = reanimateAgent(req.sessionId);
             return sessionRowToProto(row);
         },
         async sendInput(req) {
@@ -465,7 +441,7 @@ export function registerGrackleRoutes(router) {
             if (session.taskId) {
                 const task = taskStore.getTask(session.taskId);
                 if (task) {
-                    broadcast({ type: "task_updated", payload: { taskId: task.id, projectId: task.projectId } });
+                    emit("task.updated", { taskId: task.id, projectId: task.projectId });
                 }
             }
             return create(grackle.EmptySchema, {});
@@ -555,10 +531,7 @@ export function registerGrackleRoutes(router) {
             const current = credentialProviders.getCredentialProviders();
             const updated = { ...current, [req.provider]: req.value };
             credentialProviders.setCredentialProviders(updated);
-            broadcast({
-                type: "credential_providers",
-                payload: updated,
-            });
+            emit("credential.providers_changed", updated);
             return create(grackle.CredentialProviderConfigSchema, {
                 claude: claudeProviderModeToEnum(updated.claude),
                 github: providerToggleToEnum(updated.github),
@@ -581,8 +554,8 @@ export function registerGrackleRoutes(router) {
             }
             // useWorktrees defaults to true when not specified
             const useWorktrees = req.useWorktrees ?? true;
-            projectStore.createProject(id, req.name, req.description, req.repoUrl, req.defaultEnvironmentId, useWorktrees, req.worktreeBasePath ?? "");
-            broadcast({ type: "project_created", payload: { projectId: id } });
+            projectStore.createProject(id, req.name, req.description, req.repoUrl, req.defaultEnvironmentId, useWorktrees, req.worktreeBasePath ?? "", req.defaultPersonaId ?? "");
+            emit("project.created", { projectId: id });
             const row = projectStore.getProject(id);
             return projectRowToProto(row);
         },
@@ -594,7 +567,7 @@ export function registerGrackleRoutes(router) {
         },
         async archiveProject(req) {
             projectStore.archiveProject(req.id);
-            broadcast({ type: "project_archived", payload: { projectId: req.id } });
+            emit("project.archived", { projectId: req.id });
             return create(grackle.EmptySchema, {});
         },
         async updateProject(req) {
@@ -615,11 +588,12 @@ export function registerGrackleRoutes(router) {
                 defaultEnvironmentId: req.defaultEnvironmentId,
                 useWorktrees: req.useWorktrees ?? undefined,
                 worktreeBasePath: req.worktreeBasePath,
+                defaultPersonaId: req.defaultPersonaId,
             });
             if (!row) {
                 throw new ConnectError(`Project not found after update: ${req.id}`, Code.NotFound);
             }
-            broadcast({ type: "project_updated", payload: { projectId: req.id } });
+            emit("project.updated", { projectId: req.id });
             return projectRowToProto(row);
         },
         // ─── Tasks ───────────────────────────────────────────────
@@ -666,12 +640,9 @@ export function registerGrackleRoutes(router) {
             taskStore.createTask(id, req.projectId, req.title, req.description, [...req.dependsOn], slugify(project.name), req.parentTaskId, 
             // Default to false (no decomposition rights) unless explicitly granted.
             // Orchestrator/root processes that need fork() must opt in.
-            req.canDecompose ?? false);
+            req.canDecompose ?? false, req.defaultPersonaId ?? "");
             const row = taskStore.getTask(id);
-            broadcast({
-                type: "task_created",
-                payload: { task: row ? { ...row } : null },
-            });
+            emit("task.created", { taskId: id, projectId: req.projectId });
             return taskRowToProto(row);
         },
         async getTask(req) {
@@ -696,7 +667,7 @@ export function registerGrackleRoutes(router) {
             }
             taskStore.updateTask(req.id, req.title !== "" ? req.title : existing.title, req.description !== "" ? req.description : existing.description, reqStatus, req.dependsOn.length > 0
                 ? [...req.dependsOn]
-                : safeParseJsonArray(existing.dependsOn));
+                : safeParseJsonArray(existing.dependsOn), req.defaultPersonaId);
             // Late-bind: associate an existing session with this task
             if (req.sessionId !== "") {
                 const session = sessionStore.getSession(req.sessionId);
@@ -713,10 +684,7 @@ export function registerGrackleRoutes(router) {
                 }
                 sessionStore.setSessionTask(req.sessionId, req.id);
                 processorRegistry.lateBind(req.sessionId, req.id, existing.projectId);
-                broadcast({
-                    type: "task_started",
-                    payload: { taskId: req.id, sessionId: req.sessionId, projectId: existing.projectId },
-                });
+                emit("task.started", { taskId: req.id, sessionId: req.sessionId, projectId: existing.projectId });
             }
             const row = taskStore.getTask(req.id);
             const taskSessions = sessionStore.listSessionsForTask(req.id);
@@ -747,39 +715,28 @@ export function registerGrackleRoutes(router) {
             const conn = adapterManager.getConnection(environmentId);
             if (!conn)
                 throw new ConnectError(`Environment ${environmentId} not connected`, Code.FailedPrecondition);
-            // Resolve persona from StartTaskRequest
-            const personaId = req.personaId || "";
-            const persona = personaId
-                ? personaStore.getPersona(personaId)
-                : undefined;
-            if (personaId && !persona) {
-                throw new ConnectError(`Persona not found: ${personaId}`, Code.NotFound);
+            // Resolve persona via cascade (request → task → project → app default)
+            let resolved;
+            try {
+                resolved = resolvePersona(req.personaId, task.defaultPersonaId, project.defaultPersonaId);
+            }
+            catch (err) {
+                throw new ConnectError(err.message, Code.FailedPrecondition);
             }
             const env = envRegistry.getEnvironment(environmentId);
             const sessionId = uuid();
-            const runtime = req.runtime ||
-                persona?.runtime ||
-                env?.defaultRuntime ||
-                DEFAULT_RUNTIME;
-            const model = req.model ||
-                persona?.model ||
-                process.env.GRACKLE_DEFAULT_MODEL ||
-                DEFAULT_MODEL;
-            const maxTurns = persona?.maxTurns || 0;
+            const { runtime, model, maxTurns, systemPrompt, persona } = resolved;
             const logPath = join(grackleHome, LOGS_DIR, sessionId);
             let systemContext = buildTaskSystemContext(task.title, task.description, req.notes || "", task.canDecompose);
-            if (persona) {
-                systemContext = persona.systemPrompt + "\n\n" + systemContext;
+            if (systemPrompt) {
+                systemContext = systemPrompt + "\n\n" + systemContext;
             }
-            sessionStore.createSession(sessionId, environmentId, runtime, task.title, model, logPath, task.id, personaId);
-            broadcast({
-                type: "task_started",
-                payload: { taskId: task.id, sessionId, projectId: task.projectId },
-            });
+            sessionStore.createSession(sessionId, environmentId, runtime, task.title, model, logPath, task.id, resolved.personaId);
+            emit("task.started", { taskId: task.id, sessionId, projectId: task.projectId });
             // Re-push stored tokens + provider credentials (scoped to runtime) so they're fresh for this session.
             // For local envs, skip file tokens — the PowerLine is on the same machine.
             await tokenBroker.refreshTokensForTask(environmentId, runtime, env?.adapterType === "local" ? { excludeFileTokens: true } : undefined);
-            const mcpServersJson = persona ? personaMcpServersToJson(persona) : "";
+            const mcpServersJson = personaMcpServersToJson(persona);
             // When useWorktrees is false, omit worktreeBasePath so PowerLine checks
             // out the branch in the main working tree instead of creating a worktree.
             // The branch field is still populated so the agent knows its branch name.
@@ -790,7 +747,7 @@ export function registerGrackleRoutes(router) {
             const taskMcpPort = parseInt(process.env.GRACKLE_MCP_PORT || String(DEFAULT_MCP_PORT), 10);
             const taskMcpDialHost = toDialableHost(process.env.GRACKLE_HOST || "127.0.0.1");
             const taskMcpUrl = `http://${taskMcpDialHost}:${taskMcpPort}/mcp`;
-            const taskMcpToken = createScopedToken({ sub: task.id, pid: task.projectId, per: personaId, sid: sessionId }, loadOrCreateApiKey());
+            const taskMcpToken = createScopedToken({ sub: task.id, pid: task.projectId, per: resolved.personaId, sid: sessionId }, loadOrCreateApiKey());
             const powerlineReq = create(powerline.SpawnRequestSchema, {
                 sessionId,
                 runtime,
@@ -837,10 +794,7 @@ export function registerGrackleRoutes(router) {
                     raw: "",
                 }));
             }
-            broadcast({
-                type: "task_completed",
-                payload: { taskId: task.id, projectId: task.projectId },
-            });
+            emit("task.completed", { taskId: task.id, projectId: task.projectId });
             const row = taskStore.getTask(task.id);
             const taskSessions = sessionStore.listSessionsForTask(task.id);
             const { status, latestSessionId } = computeTaskStatus(row.status, taskSessions);
@@ -876,10 +830,7 @@ export function registerGrackleRoutes(router) {
                 projectId: task.projectId,
                 taskId: task.id,
             });
-            broadcast({
-                type: "task_started",
-                payload: { taskId: task.id, sessionId: latestSession.id, projectId: task.projectId },
-            });
+            emit("task.started", { taskId: task.id, sessionId: latestSession.id, projectId: task.projectId });
             const row = sessionStore.getSession(latestSession.id);
             return sessionRowToProto(row);
         },
@@ -918,10 +869,7 @@ export function registerGrackleRoutes(router) {
                 logger.error({ taskId: req.id }, "deleteTask returned 0 changes despite task existing");
                 throw new ConnectError(`Failed to delete task ${req.id}: no rows affected`, Code.Internal);
             }
-            broadcast({
-                type: "task_deleted",
-                payload: { taskId: req.id, projectId: task.projectId },
-            });
+            emit("task.deleted", { taskId: req.id, projectId: task.projectId });
             return create(grackle.EmptySchema, {});
         },
         // ─── Personas ───────────────────────────────────────────────
@@ -955,7 +903,7 @@ export function registerGrackleRoutes(router) {
                 tools: [...s.tools],
             })));
             personaStore.createPersona(id, req.name, req.description, req.systemPrompt, toolConfigJson, req.runtime, req.model, req.maxTurns, mcpServersJson);
-            broadcast({ type: "persona_created", payload: { personaId: id } });
+            emit("persona.created", { personaId: id });
             const row = personaStore.getPersona(id);
             return personaRowToProto(row);
         },
@@ -1000,23 +948,52 @@ export function registerGrackleRoutes(router) {
             const model = req.model || existing.model;
             const maxTurns = req.maxTurns === 0 ? existing.maxTurns : req.maxTurns;
             personaStore.updatePersona(req.id, name, description, systemPrompt, toolConfigJson, runtime, model, maxTurns, mcpServersJson);
-            broadcast({ type: "persona_updated", payload: { personaId: req.id } });
+            emit("persona.updated", { personaId: req.id });
             const row = personaStore.getPersona(req.id);
             return personaRowToProto(row);
         },
         async deletePersona(req) {
             personaStore.deletePersona(req.id);
-            broadcast({ type: "persona_deleted", payload: { personaId: req.id } });
+            emit("persona.deleted", { personaId: req.id });
             return create(grackle.EmptySchema, {});
         },
+        // ─── Settings ─────────────────────────────────────────────
+        async getSetting(req) {
+            if (!isAllowedSettingKey(req.key)) {
+                throw new ConnectError(`Setting key not allowed: ${req.key}`, Code.InvalidArgument);
+            }
+            const value = settingsStore.getSetting(req.key);
+            return create(grackle.SettingResponseSchema, {
+                key: req.key,
+                value: value ?? "",
+            });
+        },
+        async setSetting(req) {
+            if (!isAllowedSettingKey(req.key)) {
+                throw new ConnectError(`Setting key not allowed: ${req.key}`, Code.InvalidArgument);
+            }
+            // Validate persona exists and has required fields when setting default_persona_id
+            if (req.key === "default_persona_id" && req.value) {
+                const persona = personaStore.getPersona(req.value);
+                if (!persona) {
+                    throw new ConnectError(`Persona not found: ${req.value}`, Code.NotFound);
+                }
+                if (!persona.runtime || !persona.model) {
+                    throw new ConnectError(`Persona "${persona.name}" must have runtime and model configured`, Code.FailedPrecondition);
+                }
+            }
+            settingsStore.setSetting(req.key, req.value);
+            emit("setting.changed", { key: req.key, value: req.value });
+            return create(grackle.SettingResponseSchema, {
+                key: req.key,
+                value: req.value,
+            });
+        },
         // ─── Findings ────────────────────────────────────────────
         async postFinding(req) {
             const id = uuid().slice(0, 8);
             findingStore.postFinding(id, req.projectId, req.taskId, req.sessionId, req.category, req.title, req.content, [...req.tags]);
-            broadcast({
-                type: "finding_posted",
-                payload: { projectId: req.projectId, findingId: id },
-            });
+            emit("finding.posted", { projectId: req.projectId, findingId: id });
             const rows = findingStore.queryFindings(req.projectId);
             const row = rows.find((r) => r.id === id);
             return findingRowToProto(row);