@open-mercato/cezar 0.9.1-pr694.821 → 0.9.1-pr697.822

package/dist/server/server.js

@@ -1,11 +1,4 @@
 import { existsSync, readFileSync, statSync } from 'node:fs';
-import { randomUUID } from 'node:crypto';
-import { AutomationStore } from '../automations/store.js';
-import { AutomationCoordinator } from '../automations/coordinator.js';
-import { GithubPoller } from '../automations/github-poller.js';
-import { ProjectAutomationScheduler, WorkspaceAutomationScheduler } from '../automations/scheduler.js';
-import { launchAutomationRun, reconcileAutomationReceipts, validateAutomationPrompt } from '../automations/task-template.js';
-import { automationEventSchema, automationFiltersSchema, automationLogResultSchema, automationTaskSchema, } from '../automations/types.js';
 import { access, constants as fsConstants, mkdir, readFile, realpath, stat, unlink, writeFile } from 'node:fs/promises';
 import { basename, dirname, join, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -49,7 +42,7 @@ import { expandTilde } from '../paths.js';
 import { isLoopbackHostHeader, normalizeHostname, resolveCapabilities } from './capabilities.js';
 import { createSocketHub } from './ws.js';
 import { browseDirectory, isInsideBrowseRoot, isLexicallyInsideBrowseRoot, resolveBrowseRoot } from './fs-browse.js';
-import { parseRemote, resolveForge } from './forge/index.js';
+import { resolveForge } from './forge/index.js';
 import { fetchGithub, fetchGithubChecks, fetchGithubComments, fetchGithubPrDiff, GithubPrNotFoundError, GH_CHECKS_MAX } from './github.js';
 import { ensureLaunchKey } from './launch-key.js';
 import { openInTerminal } from './open-in-terminal.js';
@@ -71,39 +64,6 @@ const providerEnabledSchema = z.object({ enabled: z.boolean() }).strict();
 const providerRetrySchema = z.object({
     authFailureId: z.string().min(1).max(128),
 }).strict();
-const automationEditableSchema = z
-    .object({
-    name: z.string().trim().min(1).max(200),
-    description: z.string().max(2_000).optional(),
-    enabled: z.boolean().optional(),
-    events: z.array(automationEventSchema).min(1).max(4),
-    intervalSeconds: z.number().int().min(60).max(86_400),
-    filters: automationFiltersSchema,
-    task: automationTaskSchema,
-})
-    .strict();
-const automationCreateSchema = automationEditableSchema.extend({ enable: z.boolean().optional() });
-const automationUpdateSchema = automationEditableSchema.extend({ expectedRevision: z.number().int().positive() });
-const automationCheckSchema = z.object({ mode: z.enum(['preview', 'execute']) }).strict();
-const automationLogQuerySchema = z.object({
-    automationId: z.string().optional(),
-    result: automationLogResultSchema.optional(),
-    event: automationEventSchema.optional(),
-    since: z.string().datetime().optional(),
-    cursor: z.coerce.number().int().positive().optional(),
-    limit: z.coerce.number().int().min(1).max(100).default(100),
-});
-function editableAutomation(definition) {
-    return {
-        name: definition.name,
-        description: definition.description,
-        enabled: definition.enabled,
-        events: definition.events,
-        intervalSeconds: definition.intervalSeconds,
-        filters: definition.filters,
-        task: definition.task,
-    };
-}
 const SCOPED_PREFIX = '/api/p/:projectId';
 /**
  * The project-scoped route table of a `createApp()` app, derived from its
@@ -628,7 +588,6 @@ export function createApp(deps) {
         dataDir: bootDataDir,
         store: deps.store,
         manager: deps.manager,
-        automationStore: deps.automationStore ?? AutomationStore.open(bootDataDir),
         launchKey: ensureLaunchKey(bootDataDir), // bookmarklet auto-start secret (spec 011)
     };
     // Non-boot projects build lazily on first scoped request; their managers
@@ -645,13 +604,6 @@ export function createApp(deps) {
     // Workspace-level SSE bus (step 2.8) — the registry mutators and the
     // checkout flow (Phase 4) emit here; /api/workspace/events relays.
     const workspaceEvents = deps.workspaceEvents ?? new WorkspaceEventBus();
-    const emitAutomationChange = (project, automationId, revision, deleted = false) => workspaceEvents.emit('automation-change', {
-        project: project.id,
-        automationId,
-        revision,
-        ...(deleted ? { deleted: true } : {}),
-    });
-    const automationsChanged = () => deps.automationsChanged?.();
     const providerRuntimeAuth = deps.providerRuntimeAuth
         ?? new ProviderRuntimeAuthObserver(providerAuth, (status) => {
             workspaceEvents.emit('provider-status', status);
@@ -1879,215 +1831,6 @@ export function createApp(deps) {
             return c.json({ error: blocked }, 409);
         return c.json(await planChain(repoRoot, parsed.data.task));
     });
-    const manualChecks = new Map();
-    api.get('/automations', async (c) => {
-        const { root, automationStore } = c.get('project');
-        const forge = resolveForge(await getRepoInfo(root));
-        const availability = forge?.detectCached() ?? {
-            available: false,
-            reason: forge ? 'GitHub availability is still being checked' : 'No GitHub remote is configured',
-        };
-        const automations = automationStore.list().map((automation) => {
-            const logs = automationStore.logs({ automationId: automation.id, limit: 100 });
-            return {
-                ...automation,
-                state: automationStore.state(automation.id),
-                latestLog: logs[0],
-                counts: {
-                    matches: logs.filter((row) => row.result === 'launched' || row.result === 'duplicate').length,
-                    launched: logs.filter((row) => row.result === 'launched').length,
-                    duplicates: logs.filter((row) => row.result === 'duplicate').length,
-                    errors: logs.filter((row) => row.result === 'error' || row.result === 'rate-limited').length,
-                },
-            };
-        });
-        return c.json({
-            ...availability,
-            scheduler: {
-                state: automations.some((item) => item.enabled) ? 'scheduled' : 'idle',
-                nextDue: automations.map((item) => item.state?.nextCheckAt).filter(Boolean).sort()[0],
-            },
-            automations,
-        });
-    });
-    api.post('/automations', async (c) => {
-        const { automationStore } = c.get('project');
-        const parsed = automationCreateSchema.safeParse(await c.req.json().catch(() => null));
-        if (!parsed.success)
-            return c.json({ error: parsed.error.issues.map((issue) => issue.message).join('; ') }, 400);
-        const promptIssue = validateAutomationPrompt(parsed.data.task.prompt);
-        if (promptIssue)
-            return c.json({ error: promptIssue }, 400);
-        const { enable, ...input } = parsed.data;
-        try {
-            const automation = automationStore.create({ ...input, enabled: enable === true });
-            if (enable) {
-                const baselineAt = new Date().toISOString();
-                automationStore.setState(automation.id, {
-                    revision: automation.revision,
-                    baselineAt,
-                    cursor: { timestamp: baselineAt },
-                    nextCheckAt: new Date(Date.now() + automation.intervalSeconds * 1_000).toISOString(),
-                });
-            }
-            emitAutomationChange(c.get('project'), automation.id, automation.revision);
-            automationsChanged();
-            return c.json({ automation }, 201);
-        }
-        catch (error) {
-            return c.json({ error: error instanceof Error ? error.message : String(error) }, 400);
-        }
-    });
-    api.get('/automations/:id', (c) => {
-        const { automationStore } = c.get('project');
-        const automation = automationStore.get(c.req.param('id'));
-        return automation
-            ? c.json({ automation, state: automationStore.state(automation.id), latestLog: automationStore.logs({ automationId: automation.id, limit: 1 })[0] })
-            : c.json({ error: 'not found' }, 404);
-    });
-    api.put('/automations/:id', async (c) => {
-        const { automationStore } = c.get('project');
-        const parsed = automationUpdateSchema.safeParse(await c.req.json().catch(() => null));
-        if (!parsed.success)
-            return c.json({ error: parsed.error.issues.map((issue) => issue.message).join('; ') }, 400);
-        const promptIssue = validateAutomationPrompt(parsed.data.task.prompt);
-        if (promptIssue)
-            return c.json({ error: promptIssue }, 400);
-        const { expectedRevision, ...input } = parsed.data;
-        if (!automationStore.get(c.req.param('id')))
-            return c.json({ error: 'not found' }, 404);
-        try {
-            const automation = automationStore.update(c.req.param('id'), expectedRevision, { ...input, enabled: input.enabled ?? false });
-            emitAutomationChange(c.get('project'), automation.id, automation.revision);
-            automationsChanged();
-            return c.json({ automation });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            return c.json({ error: message }, message.includes('conflict') ? 409 : 400);
-        }
-    });
-    api.delete('/automations/:id', (c) => {
-        const id = c.req.param('id');
-        const store = c.get('project').automationStore;
-        const current = store.get(id);
-        if (!current || !store.delete(id))
-            return c.json({ error: 'not found' }, 404);
-        emitAutomationChange(c.get('project'), id, current.revision, true);
-        automationsChanged();
-        return c.body(null, 204);
-    });
-    api.post('/automations/:id/enable', (c) => {
-        const store = c.get('project').automationStore;
-        const current = store.get(c.req.param('id'));
-        if (!current)
-            return c.json({ error: 'not found' }, 404);
-        const automation = store.update(current.id, current.revision, { ...editableAutomation(current), enabled: true });
-        const baselineAt = new Date().toISOString();
-        store.setState(automation.id, {
-            ...store.state(automation.id),
-            revision: automation.revision,
-            baselineAt,
-            cursor: { timestamp: baselineAt },
-            nextCheckAt: new Date(Date.now() + automation.intervalSeconds * 1_000).toISOString(),
-        });
-        store.appendLog({ automationId: automation.id, revision: automation.revision, result: 'baseline', reason: 'Enabled from a current-time baseline; existing records were not launched.' });
-        emitAutomationChange(c.get('project'), automation.id, automation.revision);
-        automationsChanged();
-        return c.json({ automation });
-    });
-    api.post('/automations/:id/pause', (c) => {
-        const store = c.get('project').automationStore;
-        const current = store.get(c.req.param('id'));
-        if (!current)
-            return c.json({ error: 'not found' }, 404);
-        const automation = store.update(current.id, current.revision, { ...editableAutomation(current), enabled: false });
-        emitAutomationChange(c.get('project'), automation.id, automation.revision);
-        automationsChanged();
-        return c.json({ automation });
-    });
-    api.post('/automations/:id/check', async (c) => {
-        const project = c.get('project');
-        const store = project.automationStore;
-        const automation = store.get(c.req.param('id'));
-        if (!automation)
-            return c.json({ error: 'not found' }, 404);
-        const parsed = automationCheckSchema.safeParse(await c.req.json().catch(() => null));
-        if (!parsed.success)
-            return c.json({ error: parsed.error.issues.map((issue) => issue.message).join('; ') }, 400);
-        const id = randomUUID();
-        const check = { id, automationId: automation.id, mode: parsed.data.mode, status: 'queued', createdAt: new Date().toISOString() };
-        if (manualChecks.size >= 200)
-            manualChecks.delete(manualChecks.keys().next().value);
-        manualChecks.set(id, check);
-        void (async () => {
-            check.status = 'running';
-            try {
-                const remote = parseRemote((await getRepoInfo(project.root))?.remote ?? '');
-                if (!remote || remote.host !== 'github.com')
-                    throw new Error('No GitHub remote is configured');
-                const scheduler = new ProjectAutomationScheduler({
-                    projectId: project.id,
-                    owner: remote.owner,
-                    repo: remote.repo,
-                    store,
-                    poller: new GithubPoller(),
-                    launch: parsed.data.mode === 'execute'
-                        ? (definition, candidate, receiptId) => launchAutomationRun({ root: project.root, manager: project.manager, store: project.store, definition, candidate, receiptId })
-                        : undefined,
-                    onChange: (automationId, revision) => emitAutomationChange(project, automationId, revision),
-                });
-                const result = await scheduler.check(automation, parsed.data.mode);
-                Object.assign(check, { status: 'complete', completedAt: new Date().toISOString(), matches: result.candidates.length, truncated: result.truncated });
-            }
-            catch (error) {
-                Object.assign(check, { status: 'error', completedAt: new Date().toISOString(), error: error instanceof Error ? error.message : String(error) });
-            }
-        })();
-        return c.json({ checkId: id }, 202);
-    });
-    api.get('/automation-checks/:checkId', (c) => {
-        const check = manualChecks.get(c.req.param('checkId'));
-        return check ? c.json(check) : c.json({ error: 'not found' }, 404);
-    });
-    api.get('/automation-log', (c) => {
-        const parsed = automationLogQuerySchema.safeParse(c.req.query());
-        if (!parsed.success)
-            return c.json({ error: parsed.error.issues.map((issue) => issue.message).join('; ') }, 400);
-        return c.json({ records: c.get('project').automationStore.logs(parsed.data) });
-    });
-    api.post('/automation-log/:receiptId/retry', async (c) => {
-        const project = c.get('project');
-        const store = project.automationStore;
-        const receipt = [...store.latestReceipts().values()].find((row) => row.receiptId === c.req.param('receiptId'));
-        if (!receipt)
-            return c.json({ error: 'not found' }, 404);
-        if (receipt.status !== 'launch-error' || receipt.runId)
-            return c.json({ error: 'receipt is not retryable' }, 409);
-        if (!receipt.candidate)
-            return c.json({ error: 'receipt predates retry context and cannot be retried safely' }, 409);
-        const definition = store.get(receipt.automationId);
-        if (!definition)
-            return c.json({ error: 'automation not found' }, 404);
-        const lease = store.acquireLease();
-        if (!lease)
-            return c.json({ error: 'automation polling lease is held by another process' }, 409);
-        const reserved = { ...receipt, status: 'reserved', error: undefined, updatedAt: new Date().toISOString() };
-        store.appendReceipt(reserved);
-        try {
-            const launched = await launchAutomationRun({ root: project.root, manager: project.manager, store: project.store, definition, candidate: receipt.candidate, receiptId: receipt.receiptId });
-            store.appendReceipt({ ...reserved, status: 'launched', runId: launched.runId, updatedAt: new Date().toISOString() });
-            emitAutomationChange(project, definition.id, definition.revision);
-            return c.json({ receiptId: receipt.receiptId, runId: launched.runId }, 202);
-        }
-        catch (error) {
-            store.appendReceipt({ ...reserved, status: 'launch-error', error: error instanceof Error ? error.message : String(error), updatedAt: new Date().toISOString() });
-            return c.json({ error: error instanceof Error ? error.message : String(error) }, 409);
-        }
-        finally {
-            lease.release();
-        }
-    });
     // ---- runs ----------------------------------------------------------------
     // Additive `usage` field (#348): the latest CPU/RSS/proc-count sample of the
     // run's live process tree — absent for finished runs and when `ps` yields
@@ -3641,24 +3384,7 @@ export function startServer(deps, port) {
     // The subscription hub rides the same HTTP server (one port, zero config):
     // createApp registers the topics, the `upgrade` hook below owns the socket.
     const socketHub = deps.socketHub ?? createSocketHub();
-    const automationCoordinator = new AutomationCoordinator({ listProjects });
-    const bootProjectId = deps.bootProjectId ?? 'default';
-    const bootAutomationStore = automationCoordinator.store(bootProjectId, deps.repoRoot);
-    const sharedContexts = deps.contexts ?? new ProjectContexts({
-        listProjects,
-        semaphore: deps.semaphore,
-        automationStore: (projectId, root) => automationCoordinator.store(projectId, root),
-    });
-    let rescheduleAutomations = () => { };
-    const app = createApp({
-        ...deps,
-        contexts: sharedContexts,
-        automationStore: bootAutomationStore,
-        workspaceEvents,
-        skillsUpdate,
-        socketHub,
-        automationsChanged: () => rescheduleAutomations(),
-    });
+    const app = createApp({ ...deps, workspaceEvents, skillsUpdate, socketHub });
     // SECURITY: default to loopback. This server executes agents locally and its endpoints are
     // same-origin-trusted (only /api/health is CORS-open); binding to a non-loopback host would
     // expose an agent-executing box to the network. `bindHost` exists only for a deliberate
@@ -3670,60 +3396,17 @@ export function startServer(deps, port) {
         hostname: deps.bindHost ?? '127.0.0.1',
     });
     const coordinator = new SkillsUpdateCoordinator(skillsUpdate, async () => effectiveSkillsAutoUpdate(await loadWorkspaceConfig()));
-    const automationProjects = new Map();
-    const automationScheduler = new WorkspaceAutomationScheduler({
-        coordinator: automationCoordinator,
-        handle: (projectId, store) => {
-            const project = automationProjects.get(projectId);
-            if (!project)
-                return undefined;
-            return {
-                projectId,
-                owner: project.owner,
-                repo: project.repo,
-                store,
-                poller: new GithubPoller(),
-                onChange: (automationId, revision) => workspaceEvents.emit('automation-change', { project: projectId, automationId, revision }),
-                launch: async (definition, candidate, receiptId) => {
-                    const bootId = deps.bootProjectId ?? 'default';
-                    const context = projectId === bootId
-                        ? { root: deps.repoRoot, manager: deps.manager, store: deps.store }
-                        : await sharedContexts.context(projectId);
-                    return launchAutomationRun({
-                        root: context.root,
-                        manager: context.manager,
-                        store: context.store,
-                        definition,
-                        candidate,
-                        receiptId,
-                    });
-                },
-            };
-        },
-    });
-    rescheduleAutomations = () => { void automationScheduler.reschedule(); };
     const unsubscribe = workspaceEvents.on((event, data) => {
         if (event === 'project-added') {
             const project = data.project;
             if (project && typeof project.id === 'string' && typeof project.root === 'string' && project.status !== 'missing') {
                 coordinator.add(project.id, project.root);
-                void getRepoInfo(project.root).then((info) => {
-                    const parsed = parseRemote(info?.remote ?? '');
-                    if (parsed?.host === 'github.com')
-                        automationProjects.set(project.id, { root: project.root, owner: parsed.owner, repo: parsed.repo });
-                    return automationScheduler.reschedule();
-                });
             }
         }
         else if (event === 'project-removed') {
             const id = data.id;
             if (typeof id === 'string')
                 coordinator.remove(id);
-            if (typeof id === 'string') {
-                automationCoordinator.remove(id);
-                automationProjects.delete(id);
-                void automationScheduler.reschedule();
-            }
         }
     });
     server.once('listening', () => {
@@ -3731,20 +3414,9 @@ export function startServer(deps, port) {
             const all = projects.some((project) => project.root === deps.repoRoot)
                 ? projects : [{ id: deps.bootProjectId ?? 'default', root: deps.repoRoot, status: 'ok' }, ...projects];
             coordinator.start(all);
-            void Promise.all(all.map(async (project) => {
-                const parsed = parseRemote((await getRepoInfo(project.root))?.remote ?? '');
-                if (parsed?.host === 'github.com')
-                    automationProjects.set(project.id, { root: project.root, owner: parsed.owner, repo: parsed.repo });
-                const automationStore = automationCoordinator.store(project.id, project.root);
-                const runStore = project.id === (deps.bootProjectId ?? 'default')
-                    ? deps.store
-                    : sharedContexts.peek(project.id)?.store;
-                if (automationStore && runStore)
-                    reconcileAutomationReceipts(automationStore, runStore);
-            })).then(() => automationScheduler.start()).catch(() => undefined);
         }).catch(() => undefined);
     });
-    server.once('close', () => { unsubscribe(); coordinator.stop(); automationScheduler.stop(); });
+    server.once('close', () => { unsubscribe(); coordinator.stop(); });
     socketHub.attach(server, (req) => verifyWsUpgrade(req, deps.bindHost));
     return server;
 }