@wjarka/cezarion 0.14.9-dev.898 → 0.14.9-dev.911

package/dist/server/server.js

@@ -17,9 +17,10 @@ import { serve } from '@hono/node-server';
 import { bodyLimit } from 'hono/body-limit';
 import { streamSSE } from 'hono/streaming';
 import { jsonZodValidator, paramZodValidator, queryZodValidator } from './validators.js';
+import { deliverOnce, TaskWebhooks } from '../runs/webhook.js';
 import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
 import { z } from 'zod';
-import { repoPullInputSchema, pinRunInputSchema, githubSearchQuerySchema, setWorkspaceUiStateInputSchema, } from '../contract/index.js';
+import { repoPullInputSchema, pinRunInputSchema, notifyRunInputSchema, githubSearchQuerySchema, setWorkspaceUiStateInputSchema, } from '../contract/index.js';
 // A contract VALUE, like `workspaceUiStateSchema` in workspace/migrations.ts — the request
 // schema this route validates with is the same one the client compiles against.
 import { MODEL_DISCOVERY_RUNNERS, attachmentInputSchema, attachmentFileParamSchema, modelDiscoveryRunnerSchema, openProjectInSchema, runnerDiscoversModels, updateProjectInputSchema, } from '../contract/index.js';
@@ -68,7 +69,7 @@ import { defaultAgentProfile, listAgentProfiles, profileDirState, resolveProfile
 import { PROFILE_CAPABLE_PROVIDERS, profileEnv, supportsProfiles } from '../core/agent-profiles.js';
 import { quoteExecutable, withEnvPrefix } from '../core/shell-env.js';
 import { resolveCursorExecutable } from '../core/cursor-model-catalog.js';
-import { allocateProjectSlug, listProjects, normalizeProjectTags, probeProjectStatus, registerProject, removeProject, shouldRegisterProject, } from '../workspace/projects.js';
+import { allocateProjectSlug, listProjects, normalizeProjectTags, probeProjectStatus, toProjectListEntry, registerProject, removeProject, shouldRegisterProject, } from '../workspace/projects.js';
 import { mergeWriteWorkspaceUiState, readWorkspaceUiState } from '../workspace/ui-state.js';
 import { checkoutRepo } from './checkout.js';
 import { ProjectContextError, ProjectContexts } from './project-context.js';
@@ -312,6 +313,8 @@ const startRunSchema = z
     todoId: z.string().min(1).max(200, 'must be at most 200 characters').optional(),
     // Idempotent start (#504): the same id and payload answer 200 with the existing run.
     clientRequestId: z.string().uuid().optional(),
+    // Task webhook opt-in (#589). Absent = off; not part of the idempotency hash.
+    notify: z.boolean().optional(),
 })
     .refine((b) => Boolean(b.workflow) !== Boolean(b.steps), {
     message: 'provide either "workflow" or "steps", not both',
@@ -822,6 +825,11 @@ export function createApp(deps) {
         automationStore: deps.automationStore ?? AutomationStore.open(bootDataDir),
         launchKey: ensureLaunchKey(bootDataDir), // bookmarklet auto-start secret (spec 011)
     };
+    // The task webhook (#589): attached before any recovery — the boot store by `index.ts`, lazy
+    // projects through `prepareManager` below. Attaching is idempotent, so the calls here only
+    // cover an app built without boot's wiring (tests, embedded servers).
+    const taskWebhooks = deps.taskWebhooks ?? new TaskWebhooks({ fetch: deps.taskWebhookFetch, origin: '' });
+    taskWebhooks.attach(bootContext);
     // Non-boot projects build lazily on first scoped request; their managers
     // count against the same workspace semaphore as the boot manager (step 2.5).
     const contexts = deps.contexts ?? new ProjectContexts({
@@ -832,7 +840,10 @@ export function createApp(deps) {
             return listProjects(selector);
         },
         semaphore: deps.semaphore,
-        prepareManager: project => deps.delegation?.attachProject(project),
+        prepareManager: (project) => {
+            taskWebhooks.attach(project);
+            return deps.delegation?.attachProject(project);
+        },
     });
     // Workspace-level SSE bus (step 2.8) — the registry mutators and the
     // checkout flow (Phase 4) emit here; /api/workspace/events relays.
@@ -856,6 +867,17 @@ export function createApp(deps) {
     }
     contexts.onStoreCreated((store) => providerRuntimeAuth.watch(store));
     contexts.onContextBuilt((ctx) => providerRuntimeAuth.watch(ctx.store));
+    // Injected contexts (tests) skip `prepareManager`; attach those when they are built.
+    for (const id of contexts.ids()) {
+        const ctx = contexts.peek(id);
+        if (ctx)
+            taskWebhooks.attach(ctx);
+    }
+    contexts.onContextBuilt((ctx) => taskWebhooks.attach(ctx));
+    const projectRegistryEntry = async (projectId) => {
+        const id = projectId === 'default' ? await resolveBootProject() : projectId;
+        return (await loadWorkspaceConfig()).projects.find((entry) => entry.id === id);
+    };
     const app = new Hono();
     // Reject oversized request bodies before they reach any handler (#429). GETs
     // and SSE carry no body, so this only ever gates the mutating routes.
@@ -2057,7 +2079,7 @@ export function createApp(deps) {
         const parsed = { data: c.req.valid('json') };
         // `default` is the boot alias the cockpit is allowed to use everywhere else.
         const id = raw === 'default' ? await resolveBootProject() : raw;
-        const { maxParallel, tags } = parsed.data;
+        const { maxParallel, tags, webhook } = parsed.data;
         // Read-first (mirroring DELETE, server.ts:1252-1258): a well-formed but
         // unknown id must 404 WITHOUT rewriting the config — otherwise it would both
         // do a needless full-config tmp+rename and, on a read-only home, surface the
@@ -2099,6 +2121,16 @@ export function createApp(deps) {
                     else
                         entry.tags = normalized;
                 }
+                if (webhook !== undefined) {
+                    // The token is write-only (#589): the form never has it back, so an omitted token
+                    // keeps the stored one and only `''` clears it.
+                    if (webhook === null)
+                        delete entry.webhook;
+                    else {
+                        const token = webhook.token === undefined ? entry.webhook?.token : webhook.token || undefined;
+                        entry.webhook = { url: webhook.url, ...(token ? { token } : {}) };
+                    }
+                }
                 updated = entry;
             });
         }
@@ -2114,7 +2146,41 @@ export function createApp(deps) {
         // `PUT /api/workspace/config` fires for a workspace-cap change.
         await deps.semaphore?.refresh();
         const body = {
-            project: { ...updated, ...(await probeProjectStatus(updated.root)) },
+            project: toProjectListEntry(updated, await probeProjectStatus(updated.root)),
+        };
+        return c.json(body);
+    })
+        // "Send test" (#589): one `task.test` delivery to the STORED webhook, now, with the timeout
+        // the real deliveries use and no retries — the settings page wants the answer, not a queue.
+        // Refused in single-project mode like every other registry edit route.
+        .post('/projects/:projectId/webhook/test', async (c) => {
+        if (capabilities().singleProject) {
+            return c.json(singleProjectRefusal('editing projects'), 409);
+        }
+        const raw = c.req.param('projectId');
+        if (!projectIdSchema.safeParse(raw).success) {
+            return c.json({ error: `unknown project: ${raw}` }, 404);
+        }
+        const entry = await projectRegistryEntry(raw).catch(() => undefined);
+        if (!entry)
+            return c.json({ error: `unknown project: ${raw}` }, 404);
+        if (!entry.webhook)
+            return c.json({ error: NO_WEBHOOK_ERROR }, 400);
+        const payload = {
+            event: 'task.test',
+            deliveryId: randomUUID(),
+            projectId: entry.id,
+            occurredAt: new Date().toISOString(),
+        };
+        if (process.env.CEZ_DRY_RUN === '1') {
+            const body = { ok: true, dryRun: true };
+            return c.json(body);
+        }
+        const result = await deliverOnce(entry.webhook, payload, { fetch: deps.taskWebhookFetch });
+        const body = {
+            ok: result.ok,
+            ...(result.status === undefined ? {} : { status: result.status }),
+            ...(result.error === undefined ? {} : { error: result.error }),
         };
         return c.json(body);
     })
@@ -2250,7 +2316,7 @@ export function createApp(deps) {
         let project;
         try {
             const entry = await registerProject(requested, source);
-            project = { ...entry, ...(await probeProjectStatus(entry.root)) };
+            project = toProjectListEntry(entry, await probeProjectStatus(entry.root));
         }
         catch (err) {
             // e.g. a read-only home — nothing was persisted (atomic tmp+rename).
@@ -3149,6 +3215,34 @@ export function createApp(deps) {
         const { store } = c.get('project');
         const run = store.setPinned(c.req.valid('param').id, c.req.valid('json').pinned !== false);
         return run ? c.json(run) : c.json({ error: 'not found' }, 404);
+    })
+        // Task webhook opt-in for one run (#589), valid in every state — handing a finished task to a
+        // bot for follow-up is a real case. Turning it on sends one `task.subscribed` delivery with
+        // the note; the note never reaches the agent session. Either direction leaves a durable
+        // `handoff` event so the thread shows when and why. Idempotent: repeating `true` with a
+        // new note is how "Send a note…" works.
+        .post('/runs/:id/notify', paramZodValidator(runIdParamSchema), jsonZodValidator(notifyRunInputSchema), async (c) => {
+        const project = c.get('project');
+        const { id } = c.req.valid('param');
+        const { notify, message } = c.req.valid('json');
+        if (!project.store.getRun(id))
+            return c.json({ error: 'not found' }, 404);
+        if (notify) {
+            const entry = await projectRegistryEntry(project.id).catch(() => undefined);
+            if (!entry?.webhook)
+                return c.json({ error: NO_WEBHOOK_ERROR }, 400);
+        }
+        const run = project.store.updateRun(id, { notify: notify ? true : undefined });
+        if (!run)
+            return c.json({ error: 'not found' }, 404);
+        project.store.appendEvent(id, {
+            type: 'handoff',
+            notify,
+            ...(message === undefined ? {} : { message }),
+        });
+        if (notify)
+            taskWebhooks.attach(project).subscribed(id, message);
+        return c.json(run);
     })
         // The per-task off switch for that resume (the workspace setting is Settings → Resources).
         // Idempotent: a run with nothing pending answers 200 too, because "this task will not
@@ -3225,9 +3319,15 @@ export function createApp(deps) {
             if ('error' in account)
                 return c.json({ error: account.error }, 400);
         }
+        // Task webhook (#589): an explicit `true` on a project with no webhook is refused, so a
+        // bot learns in one round trip. `cez task start`'s implicit default never sends it there.
+        if (parsed.data.notify === true && !(await projectRegistryEntry(c.get('project').id).catch(() => undefined))?.webhook) {
+            return c.json({ error: NO_WEBHOOK_ERROR }, 400);
+        }
         const images = parsed.data.images?.map(toPastedContent);
         const input = {
             task: parsed.data.task,
+            notify: parsed.data.notify,
             model: parsed.data.model,
             effort: parsed.data.effort,
             runner: parsed.data.runner,
@@ -5247,6 +5347,13 @@ export function createApp(deps) {
     routed.get('*', (c) => serveShell(c) ?? c.notFound());
     return routed;
 }
+/** The host a thread link names (#589): the bound one, or loopback for a wildcard bind. */
+function taskWebhookHost(bindHost) {
+    if (!bindHost || bindHost === '0.0.0.0' || bindHost === '::')
+        return '127.0.0.1';
+    return bindHost.includes(':') ? `[${bindHost}]` : bindHost;
+}
+const NO_WEBHOOK_ERROR = 'this project has no task webhook — set one in Settings → General → Task webhook, or start without notify';
 export function startServer(deps, port) {
     const workspaceEvents = deps.workspaceEvents ?? new WorkspaceEventBus();
     const skillsUpdate = deps.skillsUpdate ?? new SkillsUpdateService({ invalidateCatalog: refreshTeamSkills });
@@ -5256,11 +5363,15 @@ export function startServer(deps, port) {
     const automationCoordinator = new AutomationCoordinator({ listProjects });
     const bootProjectId = deps.bootProjectId ?? 'default';
     const bootAutomationStore = automationCoordinator.store(bootProjectId, deps.repoRoot);
+    const taskWebhooks = deps.taskWebhooks ?? new TaskWebhooks({ fetch: deps.taskWebhookFetch });
     const sharedContexts = deps.contexts ?? new ProjectContexts({
         listProjects,
         semaphore: deps.semaphore,
         automationStore: (projectId, root) => automationCoordinator.store(projectId, root),
-        prepareManager: project => deps.delegation?.attachProject(project),
+        prepareManager: (project) => {
+            taskWebhooks.attach(project);
+            return deps.delegation?.attachProject(project);
+        },
     });
     // #801: GitHub automations are opt-in. Off, the flag must remove the BEHAVIOR and not merely
     // the UI — no scheduler, no GitHub polling, no launched runs — so every entry point into the
@@ -5270,6 +5381,7 @@ export function startServer(deps, port) {
     let rescheduleAutomations = () => { };
     const app = createApp({
         ...deps,
+        taskWebhooks,
         contexts: sharedContexts,
         automationStore: bootAutomationStore,
         workspaceEvents,
@@ -5408,6 +5520,18 @@ export function startServer(deps, port) {
                 server.closeAllConnections();
         });
     };
+    // The task webhook's thread links name the port the listener BOUND (#594 review): `--port 0`
+    // asks for an ephemeral one, so the requested number is not an address. Deliveries queue
+    // behind this, so none goes out before it is set.
+    const setTaskWebhookOrigin = () => {
+        const address = server.address();
+        const bound = address && typeof address === 'object' ? address.port : port;
+        taskWebhooks.setOrigin(`http://${taskWebhookHost(deps.bindHost)}:${bound}`);
+    };
+    if (server.listening)
+        setTaskWebhookOrigin();
+    else
+        server.once('listening', setTaskWebhookOrigin);
     return Object.assign(server, { shutdownForRestart });
 }
 /**