@thevinci/web 1.0.0

package/server/lib/quota/utils/transformers.js

@@ -0,0 +1,55 @@
+export const asObject = (value) => (value && typeof value === 'object' ? value : null);
+
+export const asNonEmptyString = (value) => {
+  if (typeof value !== 'string') return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+};
+
+export const toNumber = (value) => {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === 'string') {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+};
+
+export const toTimestamp = (value) => {
+  if (!value) return null;
+  if (typeof value === 'number') {
+    return value < 1_000_000_000_000 ? value * 1000 : value;
+  }
+  if (typeof value === 'string') {
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? null : parsed;
+  }
+  return null;
+};
+
+export const normalizeTimestamp = (value) => {
+  if (typeof value !== 'number') return null;
+  return value < 1_000_000_000_000 ? value * 1000 : value;
+};
+
+export const resolveWindowSeconds = (limit) => {
+  const ZAI_TOKEN_WINDOW_SECONDS = { 3: 3600 };
+  if (!limit || !limit.number) return null;
+  const unitSeconds = ZAI_TOKEN_WINDOW_SECONDS[limit.unit];
+  if (!unitSeconds) return null;
+  return unitSeconds * limit.number;
+};
+
+export const resolveWindowLabel = (windowSeconds) => {
+  if (!windowSeconds) return 'tokens';
+  if (windowSeconds % 86400 === 0) {
+    const days = windowSeconds / 86400;
+    return days === 7 ? 'weekly' : `${days}d`;
+  }
+  if (windowSeconds % 3600 === 0) {
+    return `${windowSeconds / 3600}h`;
+  }
+  return `${windowSeconds}s`;
+};

package/server/lib/scheduled-tasks/DOCUMENTATION.md

@@ -0,0 +1,44 @@
+# Scheduled Tasks module
+
+Server-owned scheduled task runtime and routes for Vinci-only automation.
+
+## Scope
+
+- Per-project scheduled task persistence is owned by `packages/web/server/lib/projects/project-config.js`.
+- Runtime orchestration and execution is owned by this module.
+- This module is Vinci feature logic; it is intentionally separate from OpenCode proxy/runtime internals.
+
+## Files
+
+- `packages/web/server/lib/scheduled-tasks/runtime.js`
+  - Next-run computation (daily/weekly/cron compatibility)
+  - Timer scheduling and queueing
+  - Concurrency controls
+  - Session create + prompt_async execution
+  - Emits Vinci task-run events
+
+- `packages/web/server/lib/scheduled-tasks/routes.js`
+  - Scheduled task CRUD endpoints
+  - Manual run endpoint
+  - Vinci events SSE stream endpoint
+
+## Public exports (runtime.js)
+
+- `createScheduledTasksRuntime(dependencies)`
+- Returned API:
+  - `start()`
+  - `stop()`
+  - `syncAllProjects()`
+  - `syncProject(projectId)`
+  - `runNow(projectId, taskId)`
+
+## Public exports (routes.js)
+
+- `registerScheduledTaskRoutes(app, dependencies)`
+- Registers:
+  - `GET /api/projects/:projectId/scheduled-tasks`
+  - `PUT /api/projects/:projectId/scheduled-tasks`
+  - `DELETE /api/projects/:projectId/scheduled-tasks/:taskId`
+  - `POST /api/projects/:projectId/scheduled-tasks/:taskId/run`
+  - `GET /api/vinci/scheduled-tasks/status`
+  - `GET /api/vinci/events`

package/server/lib/scheduled-tasks/routes.js

@@ -0,0 +1,235 @@
+const asNonEmptyString = (value) => {
+  if (typeof value !== 'string') {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+};
+
+const parseProjectID = (req) => asNonEmptyString(req?.params?.projectId);
+const parseTaskID = (req) => asNonEmptyString(req?.params?.taskId);
+
+export const registerScheduledTaskRoutes = (app, dependencies) => {
+  const {
+    readSettingsFromDiskMigrated,
+    sanitizeProjects,
+    projectConfigRuntime,
+    scheduledTasksRuntime,
+    getVinciEventClients,
+    writeSseEvent,
+  } = dependencies;
+
+  const findProjectByID = async (projectID) => {
+    const settings = await readSettingsFromDiskMigrated();
+    const projects = sanitizeProjects(settings?.projects || []);
+    return projects.find((project) => project.id === projectID) || null;
+  };
+
+  app.get('/api/projects/:projectId/scheduled-tasks', async (req, res) => {
+    const projectID = parseProjectID(req);
+    if (!projectID) {
+      return res.status(400).json({ error: 'projectId is required' });
+    }
+
+    try {
+      const project = await findProjectByID(projectID);
+      if (!project) {
+        return res.status(404).json({ error: 'Project not found' });
+      }
+
+      const tasks = await projectConfigRuntime.listScheduledTasks(projectID);
+      return res.json({ tasks });
+    } catch (error) {
+      console.error('[ScheduledTasks] failed to load tasks:', error);
+      return res.status(500).json({ error: 'Failed to load scheduled tasks' });
+    }
+  });
+
+  app.put('/api/projects/:projectId/scheduled-tasks', async (req, res) => {
+    const projectID = parseProjectID(req);
+    if (!projectID) {
+      return res.status(400).json({ error: 'projectId is required' });
+    }
+
+    const taskInput = req.body && typeof req.body === 'object' ? req.body.task : null;
+    if (!taskInput || typeof taskInput !== 'object') {
+      return res.status(400).json({ error: 'task payload is required' });
+    }
+
+    try {
+      const project = await findProjectByID(projectID);
+      if (!project) {
+        return res.status(404).json({ error: 'Project not found' });
+      }
+
+      const upserted = await projectConfigRuntime.upsertScheduledTask(projectID, taskInput);
+      await scheduledTasksRuntime.syncProject(projectID);
+      const freshTasks = await projectConfigRuntime.listScheduledTasks(projectID);
+      const freshTask = freshTasks.find((task) => task.id === upserted.task.id) || upserted.task;
+
+      return res.json({
+        tasks: freshTasks,
+        task: freshTask,
+        created: upserted.created,
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Failed to save scheduled task';
+      const statusCode = message.toLowerCase().includes('required') || message.toLowerCase().includes('invalid')
+        ? 400
+        : 500;
+      if (statusCode === 500) {
+        console.error('[ScheduledTasks] failed to save task:', error);
+      }
+      return res.status(statusCode).json({ error: message });
+    }
+  });
+
+  app.delete('/api/projects/:projectId/scheduled-tasks/:taskId', async (req, res) => {
+    const projectID = parseProjectID(req);
+    const taskID = parseTaskID(req);
+    if (!projectID) {
+      return res.status(400).json({ error: 'projectId is required' });
+    }
+    if (!taskID) {
+      return res.status(400).json({ error: 'taskId is required' });
+    }
+
+    try {
+      const project = await findProjectByID(projectID);
+      if (!project) {
+        return res.status(404).json({ error: 'Project not found' });
+      }
+
+      const result = await projectConfigRuntime.deleteScheduledTask(projectID, taskID);
+      if (!result.deleted) {
+        return res.status(404).json({ error: 'Task not found' });
+      }
+      await scheduledTasksRuntime.syncProject(projectID);
+      const freshTasks = await projectConfigRuntime.listScheduledTasks(projectID);
+      return res.json({ tasks: freshTasks });
+    } catch (error) {
+      console.error('[ScheduledTasks] failed to delete task:', error);
+      return res.status(500).json({ error: 'Failed to delete scheduled task' });
+    }
+  });
+
+  app.post('/api/projects/:projectId/scheduled-tasks/:taskId/run', async (req, res) => {
+    const projectID = parseProjectID(req);
+    const taskID = parseTaskID(req);
+    if (!projectID) {
+      return res.status(400).json({ error: 'projectId is required' });
+    }
+    if (!taskID) {
+      return res.status(400).json({ error: 'taskId is required' });
+    }
+
+    try {
+      const project = await findProjectByID(projectID);
+      if (!project) {
+        return res.status(404).json({ error: 'Project not found' });
+      }
+
+      const result = await scheduledTasksRuntime.runNow(projectID, taskID);
+      if (result.running || result.queued) {
+        return res.status(409).json({ error: result.error || 'Task already running' });
+      }
+      if (result.skipped) {
+        return res.status(404).json({ error: 'Task not found or disabled' });
+      }
+      if (!result.ok) {
+        return res.status(500).json({
+          error: result.error || 'Task run failed',
+          task: result.task,
+        });
+      }
+
+      return res.json({
+        ok: true,
+        task: result.task,
+        sessionId: result.sessionID,
+      });
+    } catch (error) {
+      console.error('[ScheduledTasks] failed to run task:', error);
+      return res.status(500).json({ error: 'Failed to run scheduled task' });
+    }
+  });
+
+  app.get('/api/vinci/scheduled-tasks/status', async (_req, res) => {
+    try {
+      if (typeof scheduledTasksRuntime.getStatus === 'function') {
+        return res.json(scheduledTasksRuntime.getStatus());
+      }
+
+      const settings = await readSettingsFromDiskMigrated();
+      const projects = sanitizeProjects(settings?.projects || []);
+
+      let enabledCount = 0;
+      let runningCount = 0;
+
+      for (const project of projects) {
+        try {
+          const tasks = await projectConfigRuntime.listScheduledTasks(project.id);
+          for (const task of tasks) {
+            if (task?.enabled) {
+              enabledCount += 1;
+            }
+            if (task?.state?.lastStatus === 'running') {
+              runningCount += 1;
+            }
+          }
+        } catch {
+        }
+      }
+
+      return res.json({
+        hasEnabledScheduledTasks: enabledCount > 0,
+        hasRunningScheduledTasks: runningCount > 0,
+        enabledScheduledTasksCount: enabledCount,
+        runningScheduledTasksCount: runningCount,
+      });
+    } catch (error) {
+      console.error('[ScheduledTasks] failed to resolve scheduled task status:', error);
+      return res.status(500).json({ error: 'Failed to resolve scheduled task status' });
+    }
+  });
+
+  app.get('/api/vinci/events', (req, res) => {
+    res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+    res.flushHeaders?.();
+
+    const clients = getVinciEventClients();
+    clients.add(res);
+
+    try {
+      writeSseEvent(res, {
+        type: 'vinci:event-stream-ready',
+        properties: {
+          connectedAt: Date.now(),
+        },
+      });
+    } catch {
+    }
+
+    const heartbeat = setInterval(() => {
+      try {
+        writeSseEvent(res, {
+          type: 'vinci:heartbeat',
+          properties: {
+            timestamp: Date.now(),
+          },
+        });
+      } catch {
+        clearInterval(heartbeat);
+        clients.delete(res);
+      }
+    }, 25_000);
+
+    req.on('close', () => {
+      clearInterval(heartbeat);
+      clients.delete(res);
+    });
+  });
+};