devglide 0.1.2 → 0.1.4

package/src/routers/test.ts

@@ -0,0 +1,254 @@
+import path from 'path';
+import { Router } from 'express';
+import type { Request, Response } from 'express';
+import { z } from 'zod';
+import { ScenarioManager } from '../apps/test/src/services/scenario-manager.js';
+import { ScenarioStore } from '../apps/test/src/services/scenario-store.js';
+import { ScenarioBroadcaster } from '../apps/test/src/services/scenario-broadcaster.js';
+import { getActiveProject } from '../project-context.js';
+
+// ── Zod schemas for HTTP input validation ────────────────────────────────────
+
+const scenarioStepSchema = z.object({
+  command: z.string(),
+  selector: z.string().optional(),
+  text: z.string().optional(),
+  value: z.string().optional(),
+  timeout: z.number().optional(),
+  ms: z.number().optional(),
+  clear: z.boolean().optional(),
+  contains: z.boolean().optional(),
+  path: z.string().optional(),
+});
+
+const submitScenarioSchema = z.object({
+  name: z.string().optional(),
+  description: z.string().optional(),
+  steps: z.array(scenarioStepSchema).min(1, 'At least one step is required'),
+  target: z.string().optional(),
+});
+
+const saveScenarioSchema = z.object({
+  name: z.string().min(1, 'name is required'),
+  description: z.string().optional(),
+  steps: z.array(scenarioStepSchema).min(1, 'At least one step is required'),
+  target: z.string().min(1, 'target is required'),
+});
+
+const scenarioResultSchema = z.object({
+  status: z.enum(['passed', 'failed']),
+  failedStep: z.number().optional(),
+  error: z.string().optional(),
+  duration: z.number().optional(),
+});
+
+export { createTestMcpServer } from '../apps/test/src/mcp.js';
+
+export const router: Router = Router();
+
+const scenarioManager = ScenarioManager.getInstance();
+const scenarioStore = ScenarioStore.getInstance();
+const broadcaster = ScenarioBroadcaster.getInstance();
+
+// ── Trigger routes (mounted under /trigger) ──────────────────────────────────
+
+const triggerRouter = Router();
+
+/**
+ * GET /api/test/trigger/status — Return pending scenario count.
+ */
+triggerRouter.get('/status', (req: Request, res: Response) => {
+  const projectPath = (req.query.projectPath as string) || getActiveProject()?.path || null;
+  res.json({ pendingScenarios: scenarioManager.getPendingCountForProject(projectPath) });
+});
+
+/**
+ * GET /api/test/trigger/commands — Return the command catalog.
+ */
+triggerRouter.get('/commands', (_req: Request, res: Response) => {
+  res.json(scenarioManager.getCommandsCatalog());
+});
+
+/**
+ * POST /api/test/trigger/scenarios — Submit a scenario for browser execution.
+ */
+triggerRouter.post('/scenarios', (req: Request, res: Response) => {
+  const parsed = submitScenarioSchema.safeParse(req.body);
+  if (!parsed.success) {
+    res.status(400).json({ error: parsed.error.issues[0]?.message ?? 'Invalid input' });
+    return;
+  }
+
+  const saved = scenarioManager.submitScenario(parsed.data);
+  if (saved.target) {
+    broadcaster.broadcast(scenarioManager.resolveTargetKey(saved.target), saved);
+  }
+  res.status(201).json(saved);
+});
+
+/**
+ * GET /api/test/trigger/scenarios/results — List all recent results.
+ * Static paths must be registered before :id param routes to avoid ambiguity.
+ */
+triggerRouter.get('/scenarios/results', (req: Request, res: Response) => {
+  const projectPath = (req.query.projectPath as string) || getActiveProject()?.path || null;
+  res.json(scenarioManager.listResults(projectPath));
+});
+
+/**
+ * GET /api/test/trigger/scenarios/stream?target=... — SSE stream for scenario delivery.
+ */
+triggerRouter.get('/scenarios/stream', (req: Request, res: Response) => {
+  const target = (req.query.target as string) || '';
+
+  scenarioManager.registerTarget(target);
+
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+  res.flushHeaders();
+
+  const pending = scenarioManager.dequeueScenario(target);
+  if (pending) {
+    res.write(`data: ${JSON.stringify(pending)}\n\n`);
+  }
+
+  const key = scenarioManager.resolveTargetKey(target);
+  const removeClient = broadcaster.addClient(key, res);
+  req.on('close', removeClient);
+});
+
+/**
+ * GET /api/test/trigger/scenarios/poll?target=... — Check for a queued scenario.
+ */
+triggerRouter.get('/scenarios/poll', (req: Request, res: Response) => {
+  const target = (req.query.target as string) || '';
+
+  const queued = scenarioManager.dequeueScenario(target);
+  if (queued) {
+    res.status(200).json(queued);
+  } else {
+    res.status(204).end();
+  }
+});
+
+/**
+ * POST /api/test/trigger/scenarios/:id/result — Receive result from browser.
+ */
+triggerRouter.post('/scenarios/:id/result', (req: Request, res: Response) => {
+  const id = req.params.id as string;
+  const parsed = scenarioResultSchema.safeParse(req.body);
+  if (!parsed.success) {
+    res.status(400).json({ error: parsed.error.issues[0]?.message ?? 'Invalid input' });
+    return;
+  }
+
+  const result = scenarioManager.setResult(id, parsed.data);
+  res.status(201).json(result);
+});
+
+/**
+ * GET /api/test/trigger/scenarios/:id/result — Retrieve result for a scenario.
+ */
+triggerRouter.get('/scenarios/:id/result', (req: Request, res: Response) => {
+  const id = req.params.id as string;
+  const result = scenarioManager.getResult(id);
+  if (!result) {
+    res.status(404).end();
+    return;
+  }
+  res.json(result);
+});
+
+/**
+ * GET /api/test/trigger/scenarios/saved — List saved scenarios scoped to a target.
+ * Accepts ?target= (exact match) or ?projectPath= (matches exact path or basename).
+ * Returns empty array if neither is provided.
+ */
+triggerRouter.get('/scenarios/saved', async (req: Request, res: Response) => {
+  const target = req.query.target as string | undefined;
+  const projectPath = req.query.projectPath as string | undefined;
+
+  if (target) {
+    res.json(await scenarioStore.list(target));
+  } else if (projectPath) {
+    const basename = path.basename(projectPath);
+    const byPath = await scenarioStore.list(projectPath);
+    const byName = basename !== projectPath ? await scenarioStore.list(basename) : [];
+    // Dedupe in case both match the same scenarios
+    const seen = new Set(byPath.map((s) => s.id));
+    res.json([...byPath, ...byName.filter((s) => !seen.has(s.id))]);
+  } else {
+    res.json([]);
+  }
+});
+
+/**
+ * POST /api/test/trigger/scenarios/save — Save a new scenario.
+ */
+triggerRouter.post('/scenarios/save', async (req: Request, res: Response) => {
+  const parsed = saveScenarioSchema.safeParse(req.body);
+  if (!parsed.success) {
+    res.status(400).json({ error: parsed.error.issues[0]?.message ?? 'Invalid input' });
+    return;
+  }
+
+  const saved = await scenarioStore.save({
+    name: parsed.data.name,
+    description: parsed.data.description,
+    target: parsed.data.target,
+    steps: parsed.data.steps,
+  });
+  res.status(201).json(saved);
+});
+
+/**
+ * DELETE /api/test/trigger/scenarios/saved/:id — Delete a saved scenario by id.
+ */
+triggerRouter.delete('/scenarios/saved/:id', async (req: Request, res: Response) => {
+  const id = req.params.id as string;
+  const deleted = await scenarioStore.delete(id);
+  if (!deleted) {
+    res.status(404).end();
+    return;
+  }
+  res.status(204).end();
+});
+
+/**
+ * POST /api/test/trigger/scenarios/saved/:id/run — Re-run a saved scenario.
+ */
+triggerRouter.post('/scenarios/saved/:id/run', async (req: Request, res: Response) => {
+  const id = req.params.id as string;
+  const scenario = await scenarioStore.get(id);
+  if (!scenario) {
+    res.status(404).end();
+    return;
+  }
+
+  await scenarioStore.markRun(id);
+
+  const queued = scenarioManager.submitScenario({
+    name: scenario.name,
+    steps: scenario.steps,
+    target: scenario.target,
+  });
+  if (queued.target) {
+    broadcaster.broadcast(scenarioManager.resolveTargetKey(queued.target), queued);
+  }
+  res.status(201).json(queued);
+});
+
+router.use('/trigger', triggerRouter);
+
+// ── Lifecycle ────────────────────────────────────────────────────────────────
+
+export async function initTest(): Promise<void> {
+  scenarioManager.startCleanup();
+  await scenarioStore.load();
+}
+
+export function shutdownTest(): void {
+  scenarioManager.stopCleanup();
+  broadcaster.shutdown();
+}

package/src/routers/vocabulary.ts

@@ -0,0 +1,149 @@
+import { Router } from 'express';
+import type { Request, Response } from 'express';
+import { z } from 'zod';
+import { VocabularyStore } from '../apps/vocabulary/services/vocabulary-store.js';
+
+// ── Zod schemas for HTTP input validation ────────────────────────────────────
+
+const createEntrySchema = z.object({
+  term: z.string().min(1, 'term is required'),
+  definition: z.string().min(1, 'definition is required'),
+  aliases: z.array(z.string()).optional(),
+  category: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+});
+
+const updateEntrySchema = z.object({
+  term: z.string().optional(),
+  definition: z.string().optional(),
+  aliases: z.array(z.string()).optional(),
+  category: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+});
+
+export { createVocabularyMcpServer } from '../apps/vocabulary/mcp.js';
+
+export const router: Router = Router();
+
+const store = VocabularyStore.getInstance();
+
+// GET /entries — list all vocabulary entries
+router.get('/entries', async (req: Request, res: Response) => {
+  try {
+    const category = req.query.category as string | undefined;
+    const tag = req.query.tag as string | undefined;
+    const entries = await store.list({ category, tag });
+    res.json(entries);
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// GET /entries/lookup — lookup a term by name or alias
+router.get('/entries/lookup', async (req: Request, res: Response) => {
+  try {
+    const term = req.query.term as string;
+    if (!term) { res.status(400).json({ error: 'term query parameter is required' }); return; }
+
+    const entry = await store.lookup(term);
+    if (!entry) { res.status(404).json({ error: `Term "${term}" not found` }); return; }
+    res.json(entry);
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// GET /entries/:id — get a single entry by ID
+router.get('/entries/:id', async (req: Request, res: Response) => {
+  try {
+    const entry = await store.get(req.params.id);
+    if (!entry) { res.status(404).json({ error: 'Entry not found' }); return; }
+    res.json(entry);
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// POST /entries — create a new entry
+router.post('/entries', async (req: Request, res: Response) => {
+  try {
+    const parsed = createEntrySchema.safeParse(req.body);
+    if (!parsed.success) {
+      res.status(400).json({ error: parsed.error.issues[0]?.message ?? 'Invalid input' });
+      return;
+    }
+
+    const { term, definition, aliases, category, tags } = parsed.data;
+
+    const existing = await store.lookup(term);
+    if (existing) {
+      res.status(409).json({ error: `Term "${term}" already exists`, id: existing.id });
+      return;
+    }
+
+    const entry = await store.save({
+      term,
+      definition,
+      aliases,
+      category,
+      tags: tags ?? [],
+    });
+
+    res.status(201).json(entry);
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// PUT /entries/:id — update an existing entry
+router.put('/entries/:id', async (req: Request, res: Response) => {
+  try {
+    const existing = await store.get(req.params.id);
+    if (!existing) { res.status(404).json({ error: 'Entry not found' }); return; }
+
+    const parsed = updateEntrySchema.safeParse(req.body);
+    if (!parsed.success) {
+      res.status(400).json({ error: parsed.error.issues[0]?.message ?? 'Invalid input' });
+      return;
+    }
+
+    const { term, definition, aliases, category, tags } = parsed.data;
+
+    const entry = await store.save({
+      id: req.params.id,
+      term: term ?? existing.term,
+      definition: definition ?? existing.definition,
+      aliases: aliases ?? existing.aliases,
+      category: category ?? existing.category,
+      tags: tags ?? existing.tags,
+      projectId: existing.projectId,
+    });
+
+    res.json(entry);
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// DELETE /entries/:id — remove an entry
+router.delete('/entries/:id', async (req: Request, res: Response) => {
+  try {
+    const deleted = await store.delete(req.params.id);
+    if (deleted) { res.json({ ok: true }); return; }
+    res.status(404).json({ error: 'Entry not found' });
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// GET /context — get compiled vocabulary as markdown
+router.get('/context', async (req: Request, res: Response) => {
+  try {
+    const projectId = req.query.projectId as string | undefined;
+    const markdown = await store.getCompiledContext(projectId);
+    res.setHeader('Content-Type', 'text/markdown');
+    res.send(markdown || 'No vocabulary entries defined.');
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});

package/src/routers/voice.ts

@@ -0,0 +1,10 @@
+import { Router } from 'express';
+import { transcribeRouter } from '../apps/voice/src/routes/transcribe.js';
+import { configRouter } from '../apps/voice/src/routes/config.js';
+
+export const router: Router = Router();
+
+router.use('/transcribe', transcribeRouter);
+router.use('/config', configRouter);
+
+export { createVoiceMcpServer } from '../apps/voice/src/mcp.js';

package/src/routers/workflow.ts

@@ -0,0 +1,243 @@
+import { Router } from 'express';
+import type { Request, Response } from 'express';
+import { z } from 'zod';
+
+// Workflow imports
+import { WorkflowStore } from '../apps/workflow/services/workflow-store.js';
+import { RunManager } from '../apps/workflow/services/run-manager.js';
+import { getRegisteredTypes } from '../apps/workflow/engine/node-registry.js';
+import { registerAllExecutors } from '../apps/workflow/engine/executors/index.js';
+import { validateWorkflowGraph } from '../apps/workflow/services/workflow-validator.js';
+import { getActiveProject } from '../project-context.js';
+import type { WorkflowNode, WorkflowEdge, ExecutorServices } from '../apps/workflow/types.js';
+import { ScenarioManager } from '../apps/test/src/services/scenario-manager.js';
+import { ScenarioStore } from '../apps/test/src/services/scenario-store.js';
+
+// ── Zod schemas for HTTP input validation ────────────────────────────────────
+
+const createWorkflowSchema = z.object({
+  name: z.string().min(1, 'name is required'),
+  description: z.string().optional(),
+  nodes: z.array(z.object({ id: z.string(), type: z.string(), label: z.string(), config: z.record(z.unknown()), position: z.object({ x: z.number(), y: z.number() }) }).passthrough()),
+  edges: z.array(z.object({ id: z.string(), source: z.string(), target: z.string() }).passthrough()),
+  variables: z.array(z.unknown()).optional(),
+  tags: z.array(z.string()).optional(),
+  scope: z.enum(['project', 'global']).optional(),
+  enabled: z.boolean().optional(),
+  global: z.boolean().optional(),
+});
+
+export { createWorkflowMcpServer } from '../apps/workflow/mcp.js';
+
+export const router: Router = Router();
+
+// ── State ───────────────────────────────────────────────────────────────────
+
+const builderStore = WorkflowStore.getInstance();
+const runManager = RunManager.getInstance();
+
+// ── Routes ──────────────────────────────────────────────────────────────────
+
+// GET /workflows — returns saved graph workflows scoped to the active project
+router.get('/workflows', async (req: Request, res: Response) => {
+  try {
+    const projectId = (req.query.projectId as string | undefined) ?? getActiveProject()?.id;
+    const workflows = await builderStore.list(projectId).catch(() => []);
+    res.json(workflows);
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// GET /workflows/:id — get full graph workflow by ID
+router.get('/workflows/:id', async (req: Request, res: Response) => {
+  try {
+    const workflow = await builderStore.get(req.params.id);
+    if (!workflow) { res.status(404).json({ error: 'Workflow not found' }); return; }
+    res.json(workflow);
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// POST /workflows — create new graph workflow
+router.post('/workflows', async (req: Request, res: Response) => {
+  try {
+    const parsed = createWorkflowSchema.safeParse(req.body);
+    if (!parsed.success) {
+      res.status(400).json({ error: parsed.error.issues[0]?.message ?? 'Invalid input' });
+      return;
+    }
+
+    const { name, description, nodes, edges, variables, tags, scope, enabled, global: isGlobal } = parsed.data;
+
+    const workflow = await builderStore.save({
+      name,
+      description,
+      version: 1,
+      nodes: nodes as WorkflowNode[],
+      edges: edges as WorkflowEdge[],
+      variables: (variables ?? []) as any,
+      tags: tags ?? [],
+      scope,
+      enabled,
+      global: isGlobal,
+    });
+
+    res.status(201).json(workflow);
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// PUT /workflows/:id — update graph workflow
+router.put('/workflows/:id', async (req: Request, res: Response) => {
+  try {
+    const existing = await builderStore.get(req.params.id);
+    if (!existing) { res.status(404).json({ error: 'Workflow not found' }); return; }
+
+    const { name, description, nodes, edges, variables, tags, scope, enabled } = req.body;
+    const isGlobal: boolean | undefined = req.body.global;
+
+    const workflow = await builderStore.save({
+      id: req.params.id,
+      name: name ?? existing.name,
+      description: description ?? existing.description,
+      version: (existing.version ?? 0) + 1,
+      projectId: existing.projectId,
+      nodes: nodes ?? existing.nodes,
+      edges: edges ?? existing.edges,
+      variables: variables ?? existing.variables,
+      tags: tags ?? existing.tags,
+      scope,
+      enabled: enabled ?? existing.enabled,
+      global: isGlobal ?? existing.global,
+    });
+
+    res.json(workflow);
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// DELETE /workflows/:id — delete graph workflow
+router.delete('/workflows/:id', async (req: Request, res: Response) => {
+  try {
+    const deleted = await builderStore.delete(req.params.id);
+    if (deleted) { res.json({ ok: true }); return; }
+    res.status(404).json({ error: 'Workflow not found' });
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// GET /instructions — get compiled workflow instructions as markdown
+router.get('/instructions', async (req: Request, res: Response) => {
+  try {
+    const projectId = req.query.projectId as string | undefined;
+    const markdown = await builderStore.getCompiledInstructions(projectId);
+    res.setHeader('Content-Type', 'text/markdown');
+    res.send(markdown);
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// POST /workflows/:id/run — run a workflow
+router.post('/workflows/:id/run', async (req: Request, res: Response) => {
+  try {
+    const workflow = await builderStore.get(req.params.id);
+    if (!workflow) { res.status(404).json({ error: 'Workflow not found' }); return; }
+    const { triggerPayload } = req.body ?? {};
+    const runId = runManager.startRun(workflow, triggerPayload);
+    res.json({ runId });
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// GET /runs — list all runs
+router.get('/runs', (_req: Request, res: Response) => {
+  const runs = runManager.listRuns().map((r) => ({
+    id: r.id,
+    workflowId: r.workflowId,
+    workflowName: r.workflowName,
+    startedAt: r.startedAt,
+    status: r.status,
+  }));
+  res.json(runs);
+});
+
+// GET /runs/:id/stream — SSE stream for a run
+router.get('/runs/:id/stream', (req: Request, res: Response) => {
+  const run = runManager.getRun(req.params.id);
+  if (!run) { res.status(404).json({ error: 'Run not found' }); return; }
+
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+  res.flushHeaders();
+
+  res.write(`data: ${JSON.stringify({ type: 'snapshot', run: { id: run.id, workflowId: run.workflowId, workflowName: run.workflowName, startedAt: run.startedAt, status: run.status, events: run.events } })}\n\n`);
+
+  if (run.status !== 'running') { res.end(); return; }
+
+  runManager.addClient(req.params.id, res);
+  req.on('close', () => { runManager.removeClient(req.params.id, res); });
+});
+
+// POST /runs/:id/cancel — cancel a run
+router.post('/runs/:id/cancel', (req: Request, res: Response) => {
+  const cancelled = runManager.cancelRun(req.params.id);
+  if (!cancelled) { res.status(404).json({ error: 'Run not found' }); return; }
+  res.json({ ok: true });
+});
+
+// GET /node-types — registered node type names
+router.get('/node-types', (_req: Request, res: Response) => {
+  res.json(getRegisteredTypes());
+});
+
+// POST /validate — validate a workflow graph
+router.post('/validate', (req: Request, res: Response) => {
+  const { nodes, edges } = req.body as { nodes?: WorkflowNode[]; edges?: WorkflowEdge[] };
+
+  if (!nodes || !Array.isArray(nodes)) {
+    res.status(400).json({ valid: false, errors: ['nodes must be an array'] });
+    return;
+  }
+  if (!edges || !Array.isArray(edges)) {
+    res.status(400).json({ valid: false, errors: ['edges must be an array'] });
+    return;
+  }
+
+  res.json(validateWorkflowGraph(nodes, edges));
+});
+
+// ── Lifecycle ────────────────────────────────────────────────────────────────
+
+export function initWorkflow(): void {
+  registerAllExecutors();
+
+  // Wire concrete service implementations for executor dependency injection.
+  // This centralizes cross-app wiring in one place instead of having executors
+  // directly import singletons from other apps.
+  const services: ExecutorServices = {
+    test: {
+      submitScenario: (data) => ScenarioManager.getInstance().submitScenario(data),
+      getSavedScenario: (id) => ScenarioStore.getInstance().get(id),
+      markRun: (id) => ScenarioStore.getInstance().markRun(id),
+      saveScenario: (data) => ScenarioStore.getInstance().save(data),
+      listSaved: () => ScenarioStore.getInstance().list(),
+    },
+    workflow: {
+      getWorkflow: (id) => builderStore.get(id),
+    },
+  };
+  runManager.setServices(services);
+  runManager.startCleanup();
+}
+
+export function shutdownWorkflow(): void {
+  runManager.shutdown();
+}