devglide 0.1.1

package/src/packages/mcp-utils/src/index.ts

@@ -0,0 +1,171 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { randomUUID } from "crypto";
+
+/** Format a JSON-serializable value as an MCP text result. */
+export function jsonResult(data: unknown) {
+  return {
+    content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }],
+  };
+}
+
+/** Format an error message as an MCP error result. */
+export function errorResult(message: string) {
+  return {
+    content: [{ type: "text" as const, text: message }],
+    isError: true,
+  };
+}
+
+export function createDevglideMcpServer(
+  name: string,
+  version: string,
+  description?: string,
+  options?: { instructions?: string | string[] }
+): McpServer {
+  const serverOpts = options
+    ? {
+        ...options,
+        instructions: Array.isArray(options.instructions)
+          ? options.instructions.join('\n')
+          : options.instructions,
+      }
+    : undefined;
+  return new McpServer(
+    { name, version, ...(description && { description }) },
+    ...(serverOpts ? [serverOpts] : [])
+  );
+}
+
+function isInitializeRequest(body: unknown): boolean {
+  if (Array.isArray(body)) {
+    return body.some(
+      (msg) =>
+        typeof msg === "object" &&
+        msg !== null &&
+        (msg as Record<string, unknown>).method === "initialize"
+    );
+  }
+  return (
+    typeof body === "object" &&
+    body !== null &&
+    (body as Record<string, unknown>).method === "initialize"
+  );
+}
+
+interface McpSession {
+  transport: StreamableHTTPServerTransport;
+  server: McpServer;
+  lastAccessed: number;
+}
+
+/**
+ * Mount an MCP StreamableHTTP endpoint on an Express-compatible app.
+ * Each session gets its own McpServer instance via the factory function.
+ */
+export function mountMcpHttp(
+  app: {
+    post: (path: string, handler: (...args: any[]) => any) => void;
+    get: (path: string, handler: (...args: any[]) => any) => void;
+    delete: (path: string, handler: (...args: any[]) => any) => void;
+  },
+  serverFactory: () => McpServer,
+  path: string = "/mcp"
+): void {
+  const sessions = new Map<string, McpSession>();
+
+  // TTL cleanup: remove sessions not accessed in 30 minutes
+  const SESSION_TTL_MS = 30 * 60 * 1000;
+  const ttlTimer = setInterval(() => {
+    const cutoff = Date.now() - SESSION_TTL_MS;
+    for (const [id, session] of sessions) {
+      if (session.lastAccessed < cutoff) {
+        session.transport.close?.();
+        sessions.delete(id);
+      }
+    }
+  }, 5 * 60 * 1000);
+  ttlTimer.unref();
+
+  app.post(path, async (req: any, res: any) => {
+    const sessionId = req.headers["mcp-session-id"] as string | undefined;
+
+    if (sessionId && sessions.has(sessionId)) {
+      const session = sessions.get(sessionId)!;
+      session.lastAccessed = Date.now();
+      await session.transport.handleRequest(req, res, req.body);
+      return;
+    }
+
+    if (!sessionId && isInitializeRequest(req.body)) {
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID(),
+        onsessioninitialized: (id: string) => {
+          sessions.set(id, { transport, server, lastAccessed: Date.now() });
+        },
+      });
+      transport.onclose = () => {
+        if (transport.sessionId) sessions.delete(transport.sessionId);
+      };
+
+      const server = serverFactory();
+      await server.connect(transport);
+      await transport.handleRequest(req, res, req.body);
+      return;
+    }
+
+    res.writeHead(400, { "Content-Type": "application/json" });
+    res.end(
+      JSON.stringify({
+        jsonrpc: "2.0",
+        error: { code: -32000, message: "Bad Request: No valid session ID" },
+        id: null,
+      })
+    );
+  });
+
+  app.get(path, async (req: any, res: any) => {
+    const sessionId = req.headers["mcp-session-id"] as string | undefined;
+    if (!sessionId || !sessions.has(sessionId)) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          error: { code: -32000, message: "Bad Request: No valid session ID" },
+          id: null,
+        })
+      );
+      return;
+    }
+    const getSession = sessions.get(sessionId)!;
+    getSession.lastAccessed = Date.now();
+    await getSession.transport.handleRequest(req, res);
+  });
+
+  app.delete(path, async (req: any, res: any) => {
+    const sessionId = req.headers["mcp-session-id"] as string | undefined;
+    if (!sessionId || !sessions.has(sessionId)) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          error: { code: -32000, message: "Bad Request: No valid session ID" },
+          id: null,
+        })
+      );
+      return;
+    }
+    const delSession = sessions.get(sessionId)!;
+    delSession.lastAccessed = Date.now();
+    await delSession.transport.handleRequest(req, res);
+  });
+}
+
+/**
+ * Run an MCP server in stdio mode (for Claude Desktop / CLI usage).
+ */
+export async function runStdio(server: McpServer): Promise<void> {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}

package/src/packages/mcp-utils/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../tsconfig/node.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/src/packages/paths.ts

@@ -0,0 +1,18 @@
+/**
+ * Centralized path constants for ~/.devglide subdirectories.
+ * Single source of truth — all apps import from here.
+ */
+
+import { join } from 'path';
+import { homedir } from 'os';
+
+export const DEVGLIDE_DIR: string = join(homedir(), '.devglide');
+export const DATABASES_DIR: string = join(DEVGLIDE_DIR, 'databases');
+export const WORKFLOWS_DIR: string = join(DEVGLIDE_DIR, 'workflows');
+export const INSTRUCTIONS_DIR: string = join(DEVGLIDE_DIR, 'instructions');
+export const VOCABULARY_DIR: string = join(DEVGLIDE_DIR, 'vocabulary');
+export const VOICE_DIR: string = join(DEVGLIDE_DIR, 'voice');
+export const LOGS_DIR: string = join(DEVGLIDE_DIR, 'logs');
+export const PROJECTS_FILE: string = join(DEVGLIDE_DIR, 'projects.json');
+export const PROMPTS_DIR: string = join(DEVGLIDE_DIR, 'prompts');
+export const DOCS_DIR: string = join(DEVGLIDE_DIR, 'documentation');

package/src/packages/project-context/index.js

@@ -0,0 +1,55 @@
+/**
+ * Shared project context consumer — connects to Dashboard for active project tracking.
+ *
+ * Usage:
+ *   import { connectProjectContext } from '../../packages/project-context.js';
+ *
+ *   const projectCtx = connectProjectContext({ service: 'log' });
+ *   projectCtx.active;          // current project or null
+ *   projectCtx.onChange(cb);     // subscribe to project changes
+ *   projectCtx.disconnect();    // for shutdown
+ */
+
+import { io as ioClient } from 'socket.io-client';
+
+const DASHBOARD_URL = 'http://localhost:7000';
+
+/**
+ * Connect to Dashboard for project context.
+ * @param {{ service: string, port?: number }} opts
+ * @returns {{ active: object|null, onChange: (cb: function) => function, disconnect: () => void }}
+ */
+export function connectProjectContext({ service, port } = {}) {
+  const url = port ? `http://localhost:${port}` : DASHBOARD_URL;
+  const socket = ioClient(url, { reconnection: true });
+
+  let active = null;
+  const listeners = new Set();
+
+  socket.on('project:active', (project) => {
+    active = project;
+    for (const cb of listeners) cb(project);
+  });
+
+  socket.on('connect', () => {
+    if (service) console.log(`[${service}] Connected to Dashboard for project context`);
+  });
+
+  socket.on('connect_error', () => {
+    // Dashboard may not be running — silently retry
+  });
+
+  return {
+    get active() { return active; },
+
+    /** Subscribe to project changes. Returns an unsubscribe function. */
+    onChange(cb) {
+      listeners.add(cb);
+      return () => listeners.delete(cb);
+    },
+
+    disconnect() {
+      socket.disconnect();
+    },
+  };
+}

package/src/packages/project-context/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@devglide/project-context",
+  "version": "0.1.0",
+  "description": "Shared project context consumer for devglide apps",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js"
+  },
+  "dependencies": {
+    "socket.io-client": "^4.8.0"
+  }
+}

package/src/packages/project-store.ts

@@ -0,0 +1,127 @@
+import fs from 'fs';
+import path from 'path';
+import { randomUUID } from 'crypto';
+import { DEVGLIDE_DIR, PROJECTS_FILE } from './paths.js';
+
+const STORE_PATH = PROJECTS_FILE;
+
+export interface Project {
+  id: string;
+  name: string;
+  path: string;
+}
+
+export interface StoreData {
+  projects: Project[];
+  activeProjectId: string | null;
+}
+
+let _cache: StoreData | null = null;
+
+function ensureLoaded(): StoreData {
+  if (_cache) return _cache;
+  try {
+    _cache = JSON.parse(fs.readFileSync(STORE_PATH, 'utf8'));
+  } catch {
+    _cache = { projects: [], activeProjectId: null };
+  }
+  return _cache!;
+}
+
+function flushStore(): void {
+  fs.mkdirSync(DEVGLIDE_DIR, { recursive: true });
+  fs.writeFileSync(STORE_PATH, JSON.stringify(_cache, null, 2), 'utf8');
+}
+
+export function listProjects(): StoreData {
+  return ensureLoaded();
+}
+
+export function addProject(name: string, projectPath: string): Project {
+  if (!name || typeof name !== 'string') throw new Error('name is required');
+  if (!projectPath || typeof projectPath !== 'string') throw new Error('path is required');
+
+  const absPath = path.resolve(projectPath);
+  if (!fs.existsSync(absPath) || !fs.statSync(absPath).isDirectory()) {
+    throw new Error(`Path does not exist or is not a directory: ${absPath}`);
+  }
+
+  const store = ensureLoaded();
+  if (store.projects.some(p => p.path === absPath)) {
+    throw new Error(`Project with path "${absPath}" already exists`);
+  }
+
+  const project: Project = { id: randomUUID(), name: name.trim(), path: absPath };
+  store.projects.push(project);
+
+  if (!store.activeProjectId) store.activeProjectId = project.id;
+
+  flushStore();
+  return project;
+}
+
+export function removeProject(id: string): boolean {
+  const store = ensureLoaded();
+  const before = store.projects.length;
+  store.projects = store.projects.filter(p => p.id !== id);
+  if (store.projects.length === before) return false;
+
+  if (store.activeProjectId === id) {
+    store.activeProjectId = store.projects.length > 0 ? store.projects[0].id : null;
+  }
+  flushStore();
+  return true;
+}
+
+export function activateProject(id: string): Project | null {
+  const store = ensureLoaded();
+  const project = store.projects.find(p => p.id === id);
+  if (!project) return null;
+
+  store.activeProjectId = id;
+  flushStore();
+  return project;
+}
+
+export function updateProject(id: string, updates: { name?: string; path?: string }): Project {
+  const store = ensureLoaded();
+  const project = store.projects.find(p => p.id === id);
+  if (!project) throw new Error('Project not found');
+
+  if (updates.name !== undefined) {
+    if (!updates.name || typeof updates.name !== 'string') {
+      throw new Error('name must be a non-empty string');
+    }
+    project.name = updates.name.trim();
+  }
+
+  if (updates.path !== undefined) {
+    if (!updates.path || typeof updates.path !== 'string') {
+      throw new Error('path must be a non-empty string');
+    }
+    const absPath = path.resolve(updates.path);
+    if (!path.isAbsolute(absPath)) {
+      throw new Error(`Path must be absolute: ${updates.path}`);
+    }
+    if (!fs.existsSync(absPath) || !fs.statSync(absPath).isDirectory()) {
+      throw new Error(`Path does not exist or is not a directory: ${absPath}`);
+    }
+    if (store.projects.some(p => p.id !== id && p.path === absPath)) {
+      throw new Error(`Another project with path "${absPath}" already exists`);
+    }
+    project.path = absPath;
+  }
+
+  flushStore();
+  return project;
+}
+
+export function getActiveProject(): Project | null {
+  const store = ensureLoaded();
+  if (!store.activeProjectId) return null;
+  return store.projects.find(p => p.id === store.activeProjectId) || null;
+}
+
+export function readActiveProjectId(): string | null {
+  return ensureLoaded().activeProjectId;
+}

package/src/packages/server-sniffer.ts

@@ -0,0 +1,132 @@
+/**
+ * Server-side console sniffer for Devglide apps.
+ * Writes log entries directly to disk and forwards them to the Log service.
+ *
+ * Usage:
+ *   import { initServerSniffer } from '../../packages/server-sniffer.js';
+ *   initServerSniffer({ service: 'kanban', targetPath: '/abs/path/server.log' });
+ */
+
+import { writeFileSync, mkdirSync, createWriteStream } from 'fs';
+import { dirname } from 'path';
+
+
+export interface ServerSnifferOptions {
+  /** Service name (e.g. 'kanban', 'voice') */
+  service: string;
+  /** Absolute path to the JSONL log file */
+  targetPath: string;
+  /** Log service port (default: 7000) */
+  logPort?: number;
+}
+
+interface LogEntry {
+  type: string;
+  session: string;
+  seq: number;
+  ts: string;
+  message?: string;
+  url?: string;
+  ua?: string;
+  persistent?: boolean;
+  targetPath?: string;
+}
+
+let _initialized = false;
+
+export function initServerSniffer(opts: ServerSnifferOptions): void {
+  if (_initialized) return;
+  _initialized = true;
+
+  const { service, targetPath, logPort = 7000 } = opts;
+  const baseUrl = `http://localhost:${logPort}`;
+  const sessionId = `${service}-server`;
+
+  const origLog = console.log;
+  const origWarn = console.warn;
+  const origError = console.error;
+
+  let seq = 0;
+
+  // Ensure target directory exists
+  mkdirSync(dirname(targetPath), { recursive: true });
+
+  // Truncate log file and write SESSION_START directly (sync, runs once)
+  const sessionStart: LogEntry = {
+    type: 'SESSION_START',
+    session: sessionId,
+    seq: seq++,
+    ts: new Date().toISOString(),
+    url: `server://${service}`,
+    ua: `node/${process.version}`,
+    persistent: true,
+  };
+  writeFileSync(targetPath, JSON.stringify(sessionStart) + '\n');
+
+  // Open append stream AFTER truncation for non-blocking writes
+  const logStream = createWriteStream(targetPath, { flags: 'a' });
+  logStream.on('error', () => {});
+
+  function writeEntry(entry: LogEntry): void {
+    logStream.write(JSON.stringify(entry) + '\n');
+  }
+
+  function forward(entry: LogEntry): void {
+    fetch(`${baseUrl}/api/log`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(entry),
+      signal: AbortSignal.timeout(500),
+    }).catch(() => {});
+  }
+
+  forward({ ...sessionStart, targetPath });
+
+  function send(type: string, args: unknown[]): void {
+    const message = args
+      .map((a) => {
+        if (typeof a === 'string') return a;
+        try { return JSON.stringify(a); } catch { return String(a); }
+      })
+      .join(' ');
+
+    const entry: LogEntry = {
+      type,
+      session: sessionId,
+      seq: seq++,
+      ts: new Date().toISOString(),
+      message,
+      persistent: true,
+    };
+
+    writeEntry(entry);
+    forward({ ...entry, targetPath });
+  }
+
+  console.log = function (...args: unknown[]) {
+    origLog.apply(console, args);
+    send('SERVER_LOG', args);
+  };
+
+  console.warn = function (...args: unknown[]) {
+    origWarn.apply(console, args);
+    send('SERVER_WARN', args);
+  };
+
+  console.error = function (...args: unknown[]) {
+    origError.apply(console, args);
+    send('SERVER_ERROR', args);
+  };
+
+  process.on('uncaughtException', (err: Error) => {
+    send('SERVER_ERROR', [`Uncaught Exception: ${err.message}\n${err.stack || ''}`]);
+    setTimeout(() => process.exit(1), 1000).unref();
+  });
+
+  process.on('unhandledRejection', (reason: unknown) => {
+    const msg = reason instanceof Error
+      ? `Unhandled Rejection: ${reason.message}\n${reason.stack || ''}`
+      : `Unhandled Rejection: ${String(reason)}`;
+    send('SERVER_ERROR', [msg]);
+  });
+}

package/src/packages/shared-assets/favicon.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <rect width="32" height="32" fill="#1c2128"/>
+  <rect width="32" height="32" fill="none" stroke="#7ee787" stroke-width="1.5"/>
+  <path d="M8 10h6a6 6 0 0 1 0 12H8V10z" fill="#7ee787"/>
+  <rect x="18" y="10" width="6" height="4" fill="#7ee787" opacity="0.6"/>
+  <rect x="18" y="18" width="6" height="4" fill="#7ee787" opacity="0.6"/>
+</svg>