devglide 0.1.2 → 0.1.3

package/src/routers/coder.ts

@@ -0,0 +1,157 @@
+import { Router } from 'express';
+import fs from 'fs';
+import type { Dirent } from 'fs';
+import { open, readFile, writeFile, readdir, stat } from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { z } from 'zod';
+import { getActiveProject } from '../project-context.js';
+
+// ── Zod schema for HTTP input validation ─────────────────────────────────────
+
+const writeFileSchema = z.object({
+  root: z.string().optional(),
+  path: z.string().min(1, 'path is required'),
+  content: z.string().default(''),
+});
+
+export const router: Router = Router();
+
+const SKIP = new Set([
+  'node_modules', '.git', 'dist', '.next', '.turbo',
+  '__pycache__', '.pnpm-store', 'pnpm-store', '.cache',
+  'build', 'coverage', '.nyc_output', '.venv', 'venv',
+]);
+
+const MAX_TREE_ENTRIES = 5000;
+
+const MONOREPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+
+function safeRoot(reqRoot: string | undefined): string {
+  if (!reqRoot) return getActiveProject()?.path || MONOREPO_ROOT;
+  const resolved = path.resolve(reqRoot);
+  const allowed = getActiveProject()?.path || MONOREPO_ROOT;
+  if (resolved !== allowed && !resolved.startsWith(allowed + path.sep)) {
+    throw new Error('Root path outside allowed directory');
+  }
+  return resolved;
+}
+
+function safePath(reqPath: string | undefined, root: string): string {
+  const abs = path.resolve(root, (reqPath || '').replace(/^\/+/, ''));
+  if (!abs.startsWith(root + path.sep) && abs !== root) throw new Error('Path traversal denied');
+  return abs;
+}
+
+interface TreeEntry {
+  name: string;
+  path: string;
+  type: 'dir' | 'file';
+  children?: TreeEntry[];
+}
+
+async function buildTree(
+  dir: string,
+  depth: number = 0,
+  root: string,
+  counter: { count: number } = { count: 0 },
+): Promise<TreeEntry[]> {
+  if (depth > 8 || counter.count >= MAX_TREE_ENTRIES) return [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  const dirs: Dirent[] = [];
+  const files: Dirent[] = [];
+  for (const entry of entries) {
+    if (SKIP.has(entry.name)) continue;
+    if (entry.isDirectory()) dirs.push(entry);
+    else files.push(entry);
+  }
+  dirs.sort((a, b) => a.name.localeCompare(b.name));
+  files.sort((a, b) => a.name.localeCompare(b.name));
+
+  const result: TreeEntry[] = [];
+
+  // Process directories in parallel
+  const dirResults = await Promise.all(dirs.map(async (entry) => {
+    if (counter.count >= MAX_TREE_ENTRIES) return null;
+    const abs = path.join(dir, entry.name);
+    counter.count++;
+    return {
+      name: entry.name,
+      path: path.relative(root, abs),
+      type: 'dir' as const,
+      children: await buildTree(abs, depth + 1, root, counter),
+    };
+  }));
+  for (const d of dirResults) {
+    if (d) result.push(d);
+  }
+
+  // Process files
+  for (const entry of files) {
+    if (counter.count >= MAX_TREE_ENTRIES) break;
+    counter.count++;
+    result.push({ name: entry.name, path: path.relative(root, path.join(dir, entry.name)), type: 'file' });
+  }
+  return result;
+}
+
+async function isBinary(filePath: string): Promise<boolean> {
+  let fh;
+  try {
+    fh = await open(filePath, 'r');
+    const buf = Buffer.alloc(8192);
+    const { bytesRead } = await fh.read(buf, 0, 8192, 0);
+    for (let i = 0; i < bytesRead; i++) {
+      if (buf[i] === 0) return true;
+    }
+    return false;
+  } finally {
+    await fh?.close();
+  }
+}
+
+router.get('/tree', async (req, res) => {
+  try {
+    const root = safeRoot(req.query.root as string | undefined);
+    if (!fs.existsSync(root)) return res.status(400).json({ error: 'Root path does not exist' });
+    res.json(await buildTree(root, 0, root));
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    const status = message.includes('outside allowed') || message === 'Path traversal denied' ? 403 : 500;
+    res.status(status).json({ error: message });
+  }
+});
+
+router.get('/file', async (req, res) => {
+  try {
+    const root = safeRoot(req.query.root as string | undefined);
+    const abs = safePath(req.query.path as string | undefined, root);
+    const s = await stat(abs);
+    if (s.size > 2 * 1024 * 1024) return res.status(413).json({ error: 'File too large (>2MB)' });
+    if (await isBinary(abs)) return res.status(422).json({ error: 'Binary file cannot be displayed' });
+    const content = await readFile(abs, 'utf8');
+    res.json({ content });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    const status = message === 'Path traversal denied' ? 403 : 500;
+    res.status(status).json({ error: message });
+  }
+});
+
+router.put('/file', async (req, res) => {
+  try {
+    const parsed = writeFileSchema.safeParse(req.body);
+    if (!parsed.success) {
+      res.status(400).json({ error: parsed.error.issues[0]?.message ?? 'Invalid input' });
+      return;
+    }
+    const root = safeRoot(parsed.data.root);
+    const abs = safePath(parsed.data.path, root);
+    await writeFile(abs, parsed.data.content, 'utf8');
+    res.json({ ok: true });
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    const status = message === 'Path traversal denied' ? 403 : 500;
+    res.status(status).json({ error: message });
+  }
+});

package/src/routers/dashboard.ts

@@ -0,0 +1,158 @@
+import { Router } from 'express';
+import type { Namespace } from 'socket.io';
+import { readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import {
+  listProjects,
+  addProject,
+  removeProject,
+  updateProject,
+  activateProject,
+  getActiveProject,
+} from '../packages/project-store.js';
+import { setActiveProject } from '../project-context.js';
+
+export const router: Router = Router();
+
+let dashboardNsp: Namespace | null = null;
+
+// ── REST API: Project context ──────────────────────────────────────────────
+
+router.get('/projects', (_req, res) => {
+  res.json(listProjects());
+});
+
+router.post('/projects', (req, res) => {
+  try {
+    const project = addProject(req.body?.name, req.body?.path);
+    dashboardNsp?.emit('project:list', listProjects());
+    res.status(201).json(project);
+  } catch (err: unknown) {
+    res.status(400).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+router.delete('/projects/:id', (req, res) => {
+  const removed = removeProject(req.params.id);
+  if (!removed) return res.status(404).json({ error: 'Project not found' });
+  const store = listProjects();
+  dashboardNsp?.emit('project:list', store);
+  dashboardNsp?.emit('project:active', store.activeProjectId
+    ? store.projects.find((p) => p.id === store.activeProjectId) ?? null
+    : null);
+  const active = getActiveProject();
+  setActiveProject(active ? { id: active.id, name: active.name, path: active.path } : null);
+  res.json({ ok: true });
+});
+
+router.put('/projects/:id', (req, res) => {
+  try {
+    const project = updateProject(req.params.id, { name: req.body?.name, path: req.body?.path });
+    const store = listProjects();
+    dashboardNsp?.emit('project:list', store);
+    const active = getActiveProject();
+    if (active && active.id === req.params.id) {
+      dashboardNsp?.emit('project:active', project);
+      setActiveProject({ id: project.id, name: project.name, path: project.path });
+    }
+    res.json(project);
+  } catch (err: unknown) {
+    const status = (err instanceof Error ? err.message : String(err)) === 'Project not found' ? 404 : 400;
+    res.status(status).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+router.put('/projects/:id/activate', (req, res) => {
+  const project = activateProject(req.params.id);
+  if (!project) return res.status(404).json({ error: 'Project not found' });
+  dashboardNsp?.emit('project:active', project);
+  setActiveProject({ id: project.id, name: project.name, path: project.path });
+  res.json(project);
+});
+
+// ── REST API: Directory browsing ─────────────────────────────────────────────
+
+router.get('/browse', (req, res) => {
+  const raw = typeof req.query.path === 'string' ? req.query.path : '';
+  const target = resolve(raw || homedir());
+
+  try {
+    const stat = statSync(target);
+    if (!stat.isDirectory()) {
+      return res.status(400).json({ error: 'Not a directory' });
+    }
+  } catch {
+    return res.status(400).json({ error: 'Path does not exist' });
+  }
+
+  try {
+    const entries = readdirSync(target, { withFileTypes: true });
+    const dirs = entries
+      .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+      .map(e => e.name)
+      .sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' }));
+
+    res.json({ path: target, dirs });
+  } catch {
+    res.status(403).json({ error: 'Cannot read directory' });
+  }
+});
+
+// ── Socket.io namespace initializer ────────────────────────────────────────
+
+export function initDashboard(nsp: Namespace): void {
+  dashboardNsp = nsp;
+
+  nsp.on('connection', (socket) => {
+    socket.emit('project:active', getActiveProject());
+    socket.emit('project:list', listProjects());
+
+    socket.on('project:activate', ({ id }) => {
+      const project = activateProject(id);
+      if (project) {
+        nsp.emit('project:active', project);
+        setActiveProject({ id: project.id, name: project.name, path: project.path });
+      }
+    });
+
+    socket.on('project:add', ({ name, path: projectPath }, ack) => {
+      try {
+        const project = addProject(name, projectPath);
+        nsp.emit('project:list', listProjects());
+        if (typeof ack === 'function') ack({ ok: true, project });
+      } catch (err: unknown) {
+        if (typeof ack === 'function') ack({ ok: false, error: (err instanceof Error ? err.message : String(err)) });
+      }
+    });
+
+    socket.on('project:remove', ({ id }, ack) => {
+      const removed = removeProject(id);
+      if (removed) {
+        const store = listProjects();
+        nsp.emit('project:list', store);
+        nsp.emit('project:active', store.activeProjectId
+          ? store.projects.find((p) => p.id === store.activeProjectId) ?? null
+          : null);
+        const active = getActiveProject();
+        setActiveProject(active ? { id: active.id, name: active.name, path: active.path } : null);
+      }
+      if (typeof ack === 'function') ack({ ok: removed });
+    });
+
+    socket.on('project:update', ({ id, name, path: projectPath }, ack) => {
+      try {
+        const project = updateProject(id, { name, path: projectPath });
+        nsp.emit('project:list', listProjects());
+        const active = getActiveProject();
+        if (active && active.id === id) {
+          nsp.emit('project:active', project);
+          setActiveProject({ id: project.id, name: project.name, path: project.path });
+        }
+        if (typeof ack === 'function') ack({ ok: true, project });
+      } catch (err: unknown) {
+        if (typeof ack === 'function') ack({ ok: false, error: (err instanceof Error ? err.message : String(err)) });
+      }
+    });
+  });
+}

package/src/routers/kanban.ts

@@ -0,0 +1,38 @@
+import { Router } from 'express';
+import { featuresRouter } from '../apps/kanban/src/routes/features.js';
+import { issuesRouter } from '../apps/kanban/src/routes/issues.js';
+import { attachmentsRouter } from '../apps/kanban/src/routes/attachments.js';
+
+export { createKanbanMcpServer } from '../apps/kanban/src/mcp.js';
+
+declare global {
+  namespace Express {
+    interface Request {
+      projectId?: string;
+    }
+  }
+}
+
+function parseCookie(cookieHeader?: string): Record<string, string> {
+  if (!cookieHeader) return {};
+  return Object.fromEntries(cookieHeader.split(';').map(c => {
+    const [k, ...v] = c.trim().split('=');
+    return [k, decodeURIComponent(v.join('='))];
+  }));
+}
+
+export const router: Router = Router();
+
+// Project context middleware
+router.use((req, _res, next) => {
+  const fromHeader = req.headers['x-project-id'];
+  const cookies = parseCookie(req.headers.cookie);
+  const fromCookie = cookies['devglide-project-id'];
+  req.projectId = (typeof fromHeader === 'string' ? fromHeader : fromCookie) || undefined;
+  next();
+});
+
+// Mount sub-routers
+router.use('/features', featuresRouter);
+router.use('/issues', issuesRouter);
+router.use('/attachments', attachmentsRouter);

package/src/routers/log.ts

@@ -0,0 +1,42 @@
+import { Router } from 'express';
+import { logRouter } from '../apps/log/src/routes/log.js';
+import { statusRouter } from '../apps/log/src/routes/status.js';
+import { FileTailer } from '../apps/log/src/services/file-tailer.js';
+import { onProjectChange } from '../project-context.js';
+
+export { createLogMcpServer } from '../apps/log/src/mcp.js';
+
+export const router: Router = Router();
+
+// Mount sub-routers
+router.use('/', logRouter);
+router.use('/status', statusRouter);
+
+// ── File tailer lifecycle ────────────────────────────────────────────────────
+
+let fileTailer: FileTailer | null = null;
+let unsubscribe: (() => void) | null = null;
+
+export function initLog(): void {
+  fileTailer = new FileTailer();
+
+  unsubscribe = onProjectChange((project) => {
+    // Start/stop tailing based on active project
+    if (project?.path) {
+      fileTailer!.start(project.path);
+    } else {
+      fileTailer!.stop();
+    }
+  });
+}
+
+export function shutdownLog(): void {
+  if (fileTailer) {
+    fileTailer.stop();
+    fileTailer = null;
+  }
+  if (unsubscribe) {
+    unsubscribe();
+    unsubscribe = null;
+  }
+}

package/src/routers/prompts.ts

@@ -0,0 +1,134 @@
+import { Router } from 'express';
+import type { Request, Response } from 'express';
+import { z } from 'zod';
+import { PromptStore } from '../apps/prompts/services/prompt-store.js';
+
+// ── Zod schemas ───────────────────────────────────────────────────────────────
+
+const createPromptSchema = z.object({
+  title: z.string().min(1, 'title is required'),
+  content: z.string().min(1, 'content is required'),
+  description: z.string().optional(),
+  category: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  model: z.string().optional(),
+  temperature: z.number().min(0).max(2).optional(),
+  rating: z.number().int().min(1).max(5).optional(),
+  notes: z.string().optional(),
+});
+
+const updatePromptSchema = z.object({
+  title: z.string().optional(),
+  content: z.string().optional(),
+  description: z.string().nullable().optional(),
+  category: z.string().nullable().optional(),
+  tags: z.array(z.string()).nullable().optional(),
+  model: z.string().nullable().optional(),
+  temperature: z.number().min(0).max(2).nullable().optional(),
+  rating: z.number().int().min(1).max(5).nullable().optional(),
+  notes: z.string().nullable().optional(),
+});
+
+const renderSchema = z.object({
+  vars: z.record(z.string()).default({}),
+});
+
+export { createPromptsMcpServer } from '../apps/prompts/mcp.js';
+
+export const router: Router = Router();
+
+const store = PromptStore.getInstance();
+
+// GET /context — compiled markdown for LLM injection
+router.get('/context', async (_req: Request, res: Response) => {
+  try {
+    const markdown = await store.getCompiledContext();
+    res.type('text/markdown').send(markdown || 'No prompts defined.');
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// GET /entries — list prompts
+router.get('/entries', async (req: Request, res: Response) => {
+  try {
+    const category = req.query.category as string | undefined;
+    const tagsParam = req.query.tags as string | undefined;
+    const tags = tagsParam ? tagsParam.split(',').map((t) => t.trim()).filter(Boolean) : undefined;
+    const search = req.query.search as string | undefined;
+    const entries = await store.list({ category, tags, search });
+    res.json(entries);
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// GET /entries/:id — get 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: 'Prompt not found' }); return; }
+    res.json(entry);
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// POST /entries — create
+router.post('/entries', async (req: Request, res: Response) => {
+  try {
+    const parsed = createPromptSchema.safeParse(req.body);
+    if (!parsed.success) {
+      res.status(400).json({ error: parsed.error.issues[0]?.message ?? 'Invalid input' });
+      return;
+    }
+    const entry = await store.save(parsed.data);
+    res.status(201).json(entry);
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// PUT /entries/:id — update
+router.put('/entries/:id', async (req: Request, res: Response) => {
+  try {
+    const parsed = updatePromptSchema.safeParse(req.body);
+    if (!parsed.success) {
+      res.status(400).json({ error: parsed.error.issues[0]?.message ?? 'Invalid input' });
+      return;
+    }
+
+    const entry = await store.update(req.params.id, parsed.data);
+    if (!entry) { res.status(404).json({ error: 'Prompt not found' }); return; }
+    res.json(entry);
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// DELETE /entries/:id — delete
+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: 'Prompt not found' });
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});
+
+// POST /entries/:id/render — render with variable substitution
+router.post('/entries/:id/render', async (req: Request, res: Response) => {
+  try {
+    const parsed = renderSchema.safeParse(req.body);
+    if (!parsed.success) {
+      res.status(400).json({ error: parsed.error.issues[0]?.message ?? 'Invalid input' });
+      return;
+    }
+    const rendered = await store.render(req.params.id, parsed.data.vars);
+    if (rendered === null) { res.status(404).json({ error: 'Prompt not found' }); return; }
+    res.json({ rendered });
+  } catch (err: unknown) {
+    res.status(500).json({ error: (err instanceof Error ? err.message : String(err)) });
+  }
+});

package/src/routers/shell/index.ts

@@ -0,0 +1,47 @@
+import { createShellMcpServer } from '../../apps/shell/src/mcp.js';
+import { mountMcpHttp } from '../../packages/mcp-utils/src/index.js';
+import type { McpState } from '../../apps/shell/src/shell-types.js';
+import {
+  globalPtys,
+  dashboardState,
+  getShellNsp,
+  MAX_PANES,
+  nextPaneId,
+  paneActiveSocket,
+  socketDimensions,
+} from './shell-state.js';
+import { SHELL_CONFIGS } from './shell-config.js';
+import { killPty, spawnGlobalPty } from './pty-manager.js';
+
+export type { PtyEntry, PaneInfo, DashboardState, ShellConfig, McpState } from '../../apps/shell/src/shell-types.js';
+export { router } from './shell-routes.js';
+export { initShell } from './shell-socket.js';
+
+// ── MCP integration ─────────────────────────────────────────────────────────
+
+function getShellMcpState(): McpState {
+  return {
+    globalPtys,
+    dashboardState,
+    io: getShellNsp() as any,
+    spawnGlobalPty,
+    SHELL_CONFIGS,
+    MAX_PANES,
+    nextPaneId,
+    paneActiveSocket,
+    socketDimensions,
+  };
+}
+
+export function mountShellMcp(app: any, prefix: string): void {
+  mountMcpHttp(app, () => createShellMcpServer(getShellMcpState()), prefix);
+}
+
+// ── Shutdown ────────────────────────────────────────────────────────────────
+
+export function shutdownShell(): void {
+  for (const { ptyProcess } of globalPtys.values()) {
+    killPty(ptyProcess);
+  }
+  globalPtys.clear();
+}

package/src/routers/shell/pty-manager.ts

@@ -0,0 +1,107 @@
+import pty, { type IPty } from 'node-pty';
+import fs from 'fs';
+import type { PtyEntry, PaneInfo } from '../../apps/shell/src/shell-types.js';
+import {
+  globalPtys,
+  dashboardState,
+  getShellNsp,
+  SCROLLBACK_LIMIT,
+} from './shell-state.js';
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+/** Send SIGHUP, then SIGKILL after 2 s if still alive. */
+export function killPty(p: IPty): void {
+  try {
+    p.kill();
+  } catch {
+    return;
+  }
+  const { pid } = p;
+  setTimeout(() => {
+    try {
+      process.kill(pid, 0);
+      process.kill(pid, 'SIGKILL');
+    } catch { /* already exited */ }
+  }, 2000).unref();
+}
+
+export function readCwd(pid: number): Promise<string | null> {
+  return new Promise((resolve) => {
+    fs.readlink(`/proc/${pid}/cwd`, (err: NodeJS.ErrnoException | null, linkPath: string) => resolve(err ? null : linkPath));
+  });
+}
+
+function updatePaneCwd(id: string, cwd: string): void {
+  const pane = dashboardState.panes.find((p: PaneInfo) => p.id === id);
+  if (pane) pane.cwd = cwd;
+}
+
+// ── PTY lifecycle ───────────────────────────────────────────────────────────
+
+export function spawnGlobalPty(
+  id: string,
+  command: string,
+  args: string[],
+  env: Record<string, string>,
+  cols: number,
+  rows: number,
+  trackCwd: boolean,
+  oscOnly: boolean,
+  startCwd: string | null
+): IPty {
+  cols = Number.isInteger(cols) && cols >= 1 ? Math.min(cols, 500) : 80;
+  rows = Number.isInteger(rows) && rows >= 1 ? Math.min(rows, 500) : 24;
+
+  const ptyProcess: IPty = pty.spawn(command, args, {
+    name: 'xterm-256color',
+    cols,
+    rows,
+    cwd: startCwd || process.env.HOME || '/',
+    env
+  });
+
+  const entry: PtyEntry = { ptyProcess, chunks: [], totalLen: 0 };
+  globalPtys.set(id, entry);
+
+  let cwdTimer: ReturnType<typeof setTimeout> | null = null;
+
+  ptyProcess.onData((data: string) => {
+    entry.chunks.push(data);
+    entry.totalLen += data.length;
+    if (entry.totalLen > SCROLLBACK_LIMIT * 1.5) {
+      const joined = entry.chunks.join('').slice(-SCROLLBACK_LIMIT);
+      entry.chunks = [joined];
+      entry.totalLen = joined.length;
+    }
+
+    getShellNsp()!.to(`pane:${id}`).emit('terminal:data', { id, data });
+
+    if (trackCwd) {
+      const oscMatch = data.match(/\x1b\]7;([^\x07\x1b]+)\x07/);
+      if (oscMatch) {
+        const cwd = oscMatch[1];
+        updatePaneCwd(id, cwd);
+        getShellNsp()!.emit('terminal:cwd', { id, cwd });
+      } else if (!oscOnly) {
+        if (cwdTimer) clearTimeout(cwdTimer);
+        cwdTimer = setTimeout(async () => {
+          if (!globalPtys.has(id)) return;
+          const cwd = await readCwd(ptyProcess.pid);
+          if (cwd) {
+            updatePaneCwd(id, cwd);
+            getShellNsp()!.emit('terminal:cwd', { id, cwd });
+          }
+        }, 300);
+      }
+    }
+  });
+
+  ptyProcess.onExit(({ exitCode }: { exitCode: number }) => {
+    if (cwdTimer) clearTimeout(cwdTimer);
+    if (!globalPtys.delete(id)) return;
+    getShellNsp()!.emit('terminal:exit', { id, code: exitCode });
+  });
+
+  return ptyProcess;
+}